import type { RetrievalResultMetadata } from './retrieval.js';
export type SemanticMemoryPredicate = 'use' | 'require' | 'prefer' | 'avoid' | 'version' | 'state';
export type PolicyFacet = 'formatting' | 'styling' | 'component_library' | 'framework' | 'package_manager' | 'dependency_installation' | 'testing' | 'build' | 'architecture' | 'api' | 'generated_files';
export interface SemanticMemoryRecord {
    subject: string;
    predicate: SemanticMemoryPredicate;
    value: string;
    polarity: 'positive' | 'negative' | 'neutral';
    entities: string[];
    facet: PolicyFacet | 'generic';
    scope: 'project' | 'skill' | 'session';
    semanticKey: string;
    facetKey: string;
}
export interface MemoryCapsule {
    narrative: string;
    sourceEvidenceIds: string[];
    /** Exact source text copied by the host to ground semantic extraction. */
    evidenceSpans?: string[];
    entities: string[];
    validFrom?: number;
    validUntil?: number;
    temporalStatus: 'current' | 'temporary' | 'historical';
    extractionVersion: string;
}
export interface MemoryProjection {
    subject: string;
    predicate: string;
    value: string;
    polarity: 'positive' | 'negative' | 'neutral';
    facet: PolicyFacet | 'generic';
}
export type MemoryRelationType = 'related_to' | 'supersedes' | 'references' | 'contradicts' | 'continues';
export interface UserPrefs {
    preferences: Record<string, unknown>;
    stack: string[];
}
export interface Convention {
    key: string;
    value: string;
    source: "manual" | "auto";
    confidence: number;
}
export interface ProjectContext {
    stack: string[];
    conventions: Convention[];
    metadata: Record<string, unknown>;
}
export interface SessionEntry {
    timestamp: number;
    action: string;
    summary: string;
    metadata?: Record<string, unknown>;
}
export interface SessionMemory {
    sessionId: string;
    task: string;
    entries: SessionEntry[];
    createdAt: number;
}
export interface MemoryCandidate {
    id: string;
    type: "project" | "global";
    content: Record<string, unknown>;
    confidence: number;
    source: string;
}
export interface MemoryEntryRecord {
    id: string;
    projectId: string;
    memoryNamespace: string;
    actorId: string;
    category: 'procedural' | 'semantic' | 'episodic' | 'failure_lesson' | 'project_knowledge' | 'mcp_correction';
    content: string;
    originalText?: string;
    source: 'auto' | 'manual' | 'distill' | 'explicit_intent' | 'rule_engine' | 'ai_extract' | 'claude_api' | 'l1_realtime' | 'l1_dialog' | 'l2_llm';
    status: 'pending' | 'approved' | 'rejected' | 'expired';
    confidence: number;
    scope: string;
    sessionId?: string;
    createdAt: number;
    approvedAt?: number;
}
export type MemoryEntryInput = Omit<MemoryEntryRecord, 'id' | 'createdAt' | 'status' | 'projectId' | 'memoryNamespace' | 'actorId' | 'sessionId'>;
export interface MemoryFilter {
    category?: string;
    status?: string;
    scope?: string;
    source?: string;
}
export interface MemorySemanticTaskDescriptor {
    contextHash: string;
    primaryIntent: string;
    primaryAction: RetrievalTaskAction;
    entities: string[];
    targetAnchors: string[];
    queryPolarity?: 'positive' | 'negative' | 'neutral';
}
export interface MemorySearchOptions {
    limit?: number;
    categories?: string[];
    scope?: string;
    purpose?: string;
    sessionId?: string;
    executionId?: string;
    requestId?: string;
    recordAccess?: boolean;
    maxPerFailureCategory?: number;
    action?: RetrievalTaskAction;
    requiredPolicyFacets?: PolicyFacet[];
    /** Immutable semantic fields resolved by semantic-engine. Retrieval text is never reclassified. */
    semanticTask?: MemorySemanticTaskDescriptor;
}
export type RetrievalTaskAction = 'analyze' | 'debug' | 'create' | 'modify' | 'format' | 'test' | 'build' | 'install' | 'release' | 'verify' | 'document' | 'unknown';
/** Read-model fields returned by ranked Memory search; separate from mutation records. */
export interface MemorySearchEntry {
    id: string;
    type: string;
    title: string;
    content: string;
    originalText?: string;
    source: string;
    status: string;
    confidence: number;
    strength: number;
    scope: string;
    sessionId?: string;
    createdAt: number;
    evidenceStatus: 'verified' | 'unverified';
}
export interface MemorySearchResult {
    entry: MemorySearchEntry;
    score: number;
    scoreDetails?: MemoryScoreDetails;
}
export interface MemoryScoreDetails {
    profileVersion: string;
    embeddingProfileHash?: string;
    embeddingGeneration?: number;
    channelRanks: Record<string, number>;
    lexicalScore: number;
    semanticScore: number;
    entityEvidence: string[];
    policyApplicability: number;
    qualityGate: string;
    finalScore: number;
}
export interface MemorySnapshotItem {
    id: string;
    type: string;
    title: string;
    content: string;
    source: string;
    scope: string;
    confidence: number;
    importance: number;
    score: number;
    createdAt: number;
    /** Durable storage is authoritative; vector indexing may complete asynchronously. */
    indexStatus?: 'pending' | 'indexed';
    durable?: boolean;
    lexicallyReady?: boolean;
    policyReady?: boolean;
    vectorStatus?: 'pending' | 'ready' | 'degraded';
    /** Why this item is applicable to the current task. */
    applicability?: string[];
    evidenceStatus?: 'verified' | 'unverified';
    scoreDetails?: MemoryScoreDetails;
    relatedMemoryIds?: string[];
    semanticDecision?: {
        status: import('./task-semantic-control.js').SemanticDecisionStatus;
        operations: import('./task-semantic-control.js').MemoryLifecycleOperation[];
        rejectedCount: number;
    };
}
export interface MemoryRetrievalDiagnostics {
    threshold: number;
    candidateCount: number;
    selectedCount: number;
    rejectedCount: number;
    rejectionCategories: Record<string, number>;
}
export interface GetMemoryOptions {
    query?: string;
    purpose?: string;
    budgetTokens?: number;
    scopes?: string[];
    /** Internal caller cap; not exposed by the MCP tool schema. */
    limit?: number;
    /** Canonical retrieval identity used for truthful benefit attribution. */
    requestId?: string;
    executionId?: string;
    sessionId?: string;
    action?: RetrievalTaskAction;
    requiredPolicyFacets?: PolicyFacet[];
    semanticTask?: MemorySemanticTaskDescriptor;
}
export type PreferenceConflictKind = 'exclusive_choice' | 'entity_polarity' | 'version_choice';
export interface PreferenceFacet {
    kind: PreferenceConflictKind;
    family: string;
    entity: string;
    value?: string;
    polarity: 'positive' | 'negative';
    confidence: 'high' | 'ambiguous';
}
export interface MemoryConflictDiagnostic {
    id: string;
    kind: PreferenceConflictKind;
    family: string;
    entity: string;
    memoryIds: string[];
    status: 'withheld' | 'resolved';
    summary?: string;
}
export interface GetMemoryResult {
    memories: MemorySnapshotItem[];
    budgetTokens: number;
    tokenCount: number;
    truncatedCount: number;
    purpose?: string;
    project: ProjectContext;
    user: UserPrefs;
    /** Preferences withheld from automatic injection because no safe winner exists. */
    conflicts?: MemoryConflictDiagnostic[];
    retrieval?: MemoryRetrievalDiagnostics;
}
export interface CanonicalGetMemoryResult extends GetMemoryResult, RetrievalResultMetadata {
}
/** Kinds of events that flow into the memory pipeline */
export declare const MEMORY_EVENT_KINDS: readonly ["mcp_call", "file_read", "file_write", "bash_command", "bash_error", "subagent", "web_search", "web_fetch", "tool_use"];
export type MemoryEventKind = (typeof MEMORY_EVENT_KINDS)[number];
/** Structured payload carried by memory events. Fields vary by kind. */
export interface MemoryEventPayload {
    [key: string]: unknown;
    mcpTool?: string | null;
    query?: string | null;
    resultCount?: number | null;
    resultSizeBytes?: number | null;
    filePath?: string | null;
    fileContentSize?: number | null;
    command?: string | null;
    exitCode?: number | null;
    stderr?: string | null;
    subagentType?: string | null;
    description?: string | null;
    failureSource?: string;
    durationMs?: number | null;
}
export interface SessionEventInput {
    id: string;
    sessionId: string;
    tool: string;
    createdAt: number;
    kind: MemoryEventKind;
    payload: MemoryEventPayload;
}
export declare function isSessionEventInput(value: unknown): value is SessionEventInput;
//# sourceMappingURL=memory.d.ts.map