@remnic/core 1.0.0

package/dist/orchestrator-zTa-Qo-1.d.ts

@@ -0,0 +1,1104 @@
+import { SmartBuffer } from './buffer.js';
+import { S as SearchBackend, a as SearchQueryOptions, b as SearchExecutionOptions } from './port-C1GZFv8h.js';
+import { StorageManager } from './storage.js';
+import { TranscriptManager } from './transcript.js';
+import { HourlySummarizer } from './summarizer.js';
+import { LocalLlmClient } from './local-llm.js';
+import { ModelRegistry } from './model-registry.js';
+import { RelevanceStore } from './relevance.js';
+import { NegativeExampleStore } from './negative.js';
+import { LastRecallStore, TierMigrationStatusStore, GraphRecallExpandedEntry, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallSnapshot } from './recall-state.js';
+import { SessionObserverState } from './session-observer-state.js';
+import { EmbeddingFallback } from './embedding-fallback.js';
+import { PluginConfig, QmdSearchResult, BehaviorLoopPolicyState, BootstrapOptions, BootstrapResult, MemoryFile, DaySummaryResult, MemoryActionEvent, RecallPlanMode, MemoryIntent, ExtractionResult, MemoryFrontmatter, IdentityInjectionMode } from './types.js';
+import { SemanticConsolidationResult } from './semantic-consolidation.js';
+import { z } from 'zod';
+import { RuntimePolicyValues } from './policy-runtime.js';
+import { ProfilingCollector } from './profiling.js';
+
+type ReplaySource = "openclaw" | "claude" | "chatgpt";
+type ReplayRole = "user" | "assistant";
+interface ReplayTurn {
+    source: ReplaySource;
+    sessionKey: string;
+    role: ReplayRole;
+    content: string;
+    timestamp: string;
+    externalId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ReplayWarning {
+    code: string;
+    message: string;
+    index?: number;
+}
+
+type SummarizeFn = (text: string, targetTokens: number, aggressive: boolean) => Promise<string | null>;
+
+declare class LcmEngine {
+    private readonly summarizeFn;
+    private db;
+    private archive;
+    private dag;
+    private summarizer;
+    private observeQueue;
+    private closed;
+    private readonly config;
+    private readonly memoryDir;
+    private initPromise;
+    private readonly pendingObserveInitCounts;
+    private readonly pendingObserveInitWaiters;
+    private readonly pendingObserveInitIdleWaiters;
+    constructor(pluginConfig: PluginConfig, summarizeFn: SummarizeFn);
+    get enabled(): boolean;
+    /** Lazy init — open database on first use. */
+    ensureInitialized(): Promise<void>;
+    private doInit;
+    /**
+     * Enqueue messages from agent_end hook.
+     * The queue worker performs the archive append and incremental summarization.
+     */
+    observeMessages(sessionId: string, messages: Array<{
+        role: string;
+        content: string;
+    }>): Promise<void>;
+    /** Enqueue an observe job without waiting for worker completion. */
+    enqueueObserveMessages(sessionId: string, messages: Array<{
+        role: string;
+        content: string;
+    }>): void;
+    private processObserveMessages;
+    get observeQueueDepth(): number;
+    get observeQueueInFlightCount(): number;
+    waitForObserveQueueIdle(): Promise<void>;
+    waitForSessionObserveIdle(sessionId: string): Promise<void>;
+    private reservePendingObserveInit;
+    private releasePendingObserveInit;
+    private waitForPendingObserveInitIdle;
+    /** Build the compressed history recall section for a session. */
+    assembleRecall(sessionId: string, budgetChars: number): Promise<string>;
+    /** Flush pending summaries before compaction (called from before_compaction hook). */
+    preCompactionFlush(sessionId: string): Promise<void>;
+    /** Record a compaction event with real token counts (called from after_compaction hook). */
+    recordCompaction(sessionId: string, tokensBefore: number, tokensAfter: number): Promise<void>;
+    /** Verify archive coverage after compaction. */
+    verifyPostCompaction(sessionId: string): Promise<void>;
+    /** Search across all conversation history via FTS (snippet mode). */
+    searchContext(query: string, limit: number, sessionId?: string): Promise<Array<{
+        turn_index: number;
+        role: string;
+        snippet: string;
+        session_id: string;
+    }>>;
+    /** Search via FTS returning full message content (not snippets). */
+    searchContextFull(query: string, limit: number, sessionId?: string): Promise<Array<{
+        id: number;
+        turn_index: number;
+        role: string;
+        content: string;
+        session_id: string;
+        score: number;
+    }>>;
+    /** Get a compressed summary of a turn range. */
+    describeContext(sessionId: string, fromTurn: number, toTurn: number): Promise<{
+        summary: string;
+        turn_count: number;
+        depth: number;
+    } | null>;
+    /** Retrieve raw messages for a turn range (lossless expansion). */
+    expandContext(sessionId: string, fromTurn: number, toTurn: number, maxTokens: number): Promise<Array<{
+        turn_index: number;
+        role: string;
+        content: string;
+    }>>;
+    /** Get statistics about the LCM archive. */
+    getStats(sessionId?: string): Promise<{
+        totalMessages: number;
+        totalSummaryNodes: number;
+        maxDepth: number;
+    }>;
+    /** Prune old data beyond retention period. */
+    prune(): Promise<{
+        messagesPruned: number;
+        nodesPruned: number;
+    }>;
+    /** Close the database connection. */
+    close(): void;
+}
+
+interface ConversationIndexBackendInspection {
+    backend: "qmd" | "faiss";
+    status: "ok" | "degraded" | "disabled";
+    available: boolean;
+    indexPath: string;
+    supportsIncrementalUpdate: boolean;
+    message?: string;
+    metadata: {
+        chunkCount: number | null;
+        qmdAvailable?: boolean;
+        debugStatus?: string;
+        hasIndex?: boolean;
+        hasMetadata?: boolean;
+        hasManifest?: boolean;
+        manifest?: {
+            version: number;
+            modelId: string;
+            normalizedModelId: string;
+            dimension: number;
+            chunkCount: number;
+            updatedAt: string;
+            lastSuccessfulRebuildAt: string;
+        };
+    };
+}
+
+declare const SharedFeedbackEntrySchema: z.ZodObject<{
+    agent: z.ZodString;
+    decision: z.ZodEnum<["approved", "approved_with_feedback", "rejected"]>;
+    reason: z.ZodString;
+    date: z.ZodString;
+    learning: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    workflow: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    evidenceWindowStart: z.ZodOptional<z.ZodString>;
+    evidenceWindowEnd: z.ZodOptional<z.ZodString>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    decision: "rejected" | "approved" | "approved_with_feedback";
+    reason: string;
+    agent: string;
+    date: string;
+    confidence?: number | undefined;
+    tags?: string[] | undefined;
+    severity?: "low" | "medium" | "high" | undefined;
+    outcome?: string | undefined;
+    refs?: string[] | undefined;
+    workflow?: string | undefined;
+    learning?: string | undefined;
+    evidenceWindowStart?: string | undefined;
+    evidenceWindowEnd?: string | undefined;
+}, {
+    decision: "rejected" | "approved" | "approved_with_feedback";
+    reason: string;
+    agent: string;
+    date: string;
+    confidence?: number | undefined;
+    tags?: string[] | undefined;
+    severity?: "low" | "medium" | "high" | undefined;
+    outcome?: string | undefined;
+    refs?: string[] | undefined;
+    workflow?: string | undefined;
+    learning?: string | undefined;
+    evidenceWindowStart?: string | undefined;
+    evidenceWindowEnd?: string | undefined;
+}>;
+type SharedFeedbackEntry = z.infer<typeof SharedFeedbackEntrySchema>;
+interface SharedCrossSignalSource {
+    agent: string;
+    path: string;
+    title: string;
+    topics: string[];
+}
+interface SharedCrossSignalOverlap {
+    token: string;
+    agents: string[];
+    sourcePaths: string[];
+    agentCount: number;
+}
+interface SharedCrossSignalReport {
+    date: string;
+    generatedAt: string;
+    sourceCount: number;
+    feedbackCount: number;
+    feedbackByDecision: Record<"approved" | "approved_with_feedback" | "rejected", number>;
+    feedbackEntries: SharedFeedbackEntry[];
+    sources: SharedCrossSignalSource[];
+    overlaps: SharedCrossSignalOverlap[];
+    semantic: {
+        enabled: boolean;
+        applied: boolean;
+        timedOut: boolean;
+        candidateCount: number;
+        maxCandidates: number;
+        addedOverlapCount: number;
+    };
+}
+interface SharedCrossSignalSynthesisResult {
+    date: string;
+    crossSignalsPath: string;
+    crossSignalsMarkdownPath: string;
+    overlapCount: number;
+    report: SharedCrossSignalReport;
+}
+interface SharedDailyCurationResult {
+    date: string;
+    roundtablePath: string;
+    crossSignalsPath: string;
+    crossSignalsMarkdownPath: string;
+    overlapCount: number;
+}
+declare class SharedContextManager {
+    private readonly config;
+    readonly dir: string;
+    private readonly prioritiesPath;
+    private readonly prioritiesInboxPath;
+    private readonly outputsDir;
+    private readonly roundtableDir;
+    private readonly feedbackDir;
+    private readonly feedbackInboxPath;
+    private readonly crossSignalsDir;
+    constructor(config: PluginConfig);
+    ensureStructure(): Promise<void>;
+    private ensureFile;
+    readPriorities(): Promise<string>;
+    readLatestRoundtable(): Promise<string>;
+    readLatestCrossSignals(): Promise<string>;
+    writeAgentOutput(opts: {
+        agentId: string;
+        title: string;
+        content: string;
+        createdAt?: Date;
+    }): Promise<string>;
+    appendFeedback(entry: SharedFeedbackEntry): Promise<void>;
+    appendPrioritiesInbox(opts: {
+        agentId: string;
+        text: string;
+    }): Promise<void>;
+    synthesizeCrossSignals(opts: {
+        date?: string;
+        maxSummaryItems?: number;
+    }): Promise<SharedCrossSignalSynthesisResult>;
+    curateDaily(opts: {
+        date?: string;
+        maxChars?: number;
+    }): Promise<SharedDailyCurationResult>;
+}
+
+type MistakesFile = {
+    version?: number;
+    updatedAt: string;
+    patterns: string[];
+    registry?: MistakeRegistryEntry[];
+};
+type ActionOutcomeCounts = {
+    applied: number;
+    skipped: number;
+    failed: number;
+    unknown: number;
+};
+type ActionOutcomeSummary = {
+    action: string;
+    counts: ActionOutcomeCounts;
+    total: number;
+    weightedScore: number;
+    provenance: string[];
+};
+type PromotionCandidate = {
+    id: string;
+    sourceType: "action-outcome" | "mistake-pattern" | "rubric" | "causal-pattern";
+    subject: string;
+    category: "principle" | "rule";
+    content: string;
+    score: number;
+    rationale: string;
+    outcome: ActionOutcomeCounts | null;
+    provenance: string[];
+    agent: string | null;
+    workflow: string | null;
+};
+type CompoundingEntrySeverity = "low" | "medium" | "high";
+type EvidenceWindow = {
+    start: string | null;
+    end: string | null;
+};
+type MistakeRegistryEntry = {
+    id: string;
+    pattern: string;
+    category: "feedback" | "action";
+    status: "active" | "retired";
+    agent: string | null;
+    workflow: string | null;
+    tags: string[];
+    severity: CompoundingEntrySeverity | null;
+    confidence: number | null;
+    outcome: string | null;
+    provenance: string[];
+    firstSeenAt: string;
+    lastSeenAt: string;
+    recurrenceCount: number;
+    lastWeekId: string;
+    evidenceWindow: EvidenceWindow;
+    mergedFromIds?: string[];
+    retiredAt?: string | null;
+};
+type RubricSnapshotEntry = {
+    id: string;
+    kind: "agent" | "workflow";
+    subject: string;
+    observations: string[];
+    tags: string[];
+    provenance: string[];
+    observationEntries?: Array<{
+        note: string;
+        provenance: string[];
+    }>;
+    updatedAt: string;
+};
+type RubricSnapshot = {
+    updatedAt: string;
+    agents: RubricSnapshotEntry[];
+    workflows: RubricSnapshotEntry[];
+};
+type WeeklyCompoundingArtifact = {
+    version: number;
+    generatedAt: string;
+    weekId: string;
+    feedback: {
+        count: number;
+        byDecision: Record<"approved" | "approved_with_feedback" | "rejected", number>;
+        entries: Array<{
+            agent: string;
+            workflow: string | null;
+            decision: SharedFeedbackEntry["decision"];
+            reason: string;
+            learning: string | null;
+            outcome: string | null;
+            severity: CompoundingEntrySeverity | null;
+            confidence: number | null;
+            tags: string[];
+            provenance: string;
+            evidenceWindow: EvidenceWindow;
+        }>;
+    };
+    mistakes: {
+        count: number;
+        patterns: string[];
+        registry: MistakeRegistryEntry[];
+    };
+    rubrics: RubricSnapshot;
+    outcomes: ActionOutcomeSummary[];
+    promotionCandidates: PromotionCandidate[];
+    continuity: {
+        monthId: string;
+        weeklyPath: string | null;
+        monthlyPath: string | null;
+    };
+};
+interface CompoundingPromotionReport {
+    enabled: boolean;
+    dryRun: boolean;
+    weekId: string;
+    promoted: Array<{
+        id: string;
+        candidateId: string;
+        category: "principle" | "rule";
+        content: string;
+        confidence: number;
+        tags: string[];
+        lineage: string[];
+    }>;
+    skipped: Array<{
+        weekId: string;
+        candidateId?: string;
+        reason: "disabled" | "weekly-artifact-missing" | "candidate-not-found" | "duplicate-guidance";
+        existingMemoryId?: string;
+    }>;
+}
+type TierMigrationCycleTrigger = "extraction" | "maintenance";
+interface TierMigrationCycleBudget {
+    limit: number;
+    scanLimit: number;
+    minIntervalMs: number;
+}
+declare class CompoundingEngine {
+    private readonly config;
+    private readonly weeklyDir;
+    private readonly rubricsDir;
+    private readonly rubricsIndexPath;
+    private readonly rubricsAgentsDir;
+    private readonly rubricsWorkflowsDir;
+    private readonly rubricsPath;
+    private readonly mistakesPath;
+    private readonly feedbackInboxPath;
+    private readonly identityAnchorPath;
+    private readonly identityIncidentsDir;
+    private readonly identityAuditWeeklyDir;
+    private readonly identityAuditMonthlyDir;
+    private readonly identityImprovementLoopsPath;
+    private readonly memoryActionEventsPath;
+    constructor(config: PluginConfig);
+    ensureDirs(): Promise<void>;
+    synthesizeWeekly(opts?: {
+        weekId?: string;
+    }): Promise<{
+        weekId: string;
+        reportPath: string;
+        reportJsonPath: string;
+        mistakesCount: number;
+        rubricsPath: string;
+        rubricsIndexPath: string;
+        promotionCandidateCount: number;
+    }>;
+    promoteCandidate(opts: {
+        weekId: string;
+        candidateId: string;
+        dryRun?: boolean;
+        storage?: StorageManager;
+    }): Promise<CompoundingPromotionReport>;
+    synthesizeContinuityAudit(opts?: {
+        period?: "weekly" | "monthly";
+        key?: string;
+    }): Promise<{
+        period: "weekly" | "monthly";
+        key: string;
+        reportPath: string;
+    }>;
+    readMistakes(): Promise<MistakesFile | null>;
+    readRubrics(): Promise<RubricSnapshot | null>;
+    readWeeklyArtifact(weekId: string): Promise<WeeklyCompoundingArtifact | null>;
+    buildRecallSection(query: string, opts?: {
+        maxPatterns?: number;
+        maxRubrics?: number;
+    }): Promise<string | null>;
+    tierMigrationCycleBudget(trigger: TierMigrationCycleTrigger): TierMigrationCycleBudget;
+    private readFeedbackEntriesForWeek;
+    private buildActionFailurePatterns;
+    private readActionEventsForWeek;
+    private buildActionOutcomeSummary;
+    private derivePromotionCandidates;
+    private buildMistakes;
+    private formatWeeklyReport;
+    private buildRubricSnapshot;
+    private formatRubrics;
+    private syncRubricArtifacts;
+    private replaceRubricDirectory;
+    private scoreRubricForQuery;
+    private normalizeRubricEntry;
+    private getRubricObservationEntries;
+    private isSyntheticOutcomeRubricObservation;
+    private addRubricObservation;
+    private readNonEmptyFile;
+    private readOptionalFile;
+    private readContinuityIncidents;
+    private readContinuityAuditReferences;
+}
+
+interface GraphRecallSnapshot {
+    recordedAt: string;
+    mode: RecallPlanMode | string;
+    queryHash: string;
+    queryLength: number;
+    namespaces: string[];
+    seedCount: number;
+    expandedCount: number;
+    seeds: string[];
+    expanded: GraphRecallExpandedEntry[];
+    status?: "completed" | "skipped" | "aborted";
+    reason?: string;
+    shadowMode?: boolean;
+    queryIntent?: MemoryIntent;
+    seedResults?: GraphRecallRankedResult[];
+    finalResults?: GraphRecallRankedResult[];
+    shadowComparison?: GraphRecallShadowComparison;
+}
+interface GraphRecallRankedResult {
+    path: string;
+    score: number;
+    docid?: string;
+    sourceLabels: string[];
+}
+interface GraphRecallShadowComparison {
+    baselineCount: number;
+    graphCount: number;
+    overlapCount: number;
+    overlapRatio: number;
+    averageOverlapDelta: number;
+}
+interface IntentDebugSnapshot {
+    recordedAt: string;
+    promptHash: string;
+    promptLength: number;
+    retrievalQueryHash: string;
+    retrievalQueryLength: number;
+    plannerEnabled: boolean;
+    plannedMode: RecallPlanMode;
+    effectiveMode: RecallPlanMode;
+    recallResultLimit: number;
+    queryIntent: MemoryIntent;
+    graphExpandedIntentDetected: boolean;
+    graphDecision: {
+        status: "not_requested" | "skipped" | "completed" | "aborted";
+        reason?: string;
+        shadowMode: boolean;
+        qmdAvailable: boolean;
+        graphRecallEnabled: boolean;
+        multiGraphMemoryEnabled: boolean;
+    };
+}
+interface QmdRecallSnapshot {
+    recordedAt: string;
+    queryHash: string;
+    queryLength: number;
+    collection?: string;
+    namespaces: string[];
+    fetchLimit: number;
+    primaryResultCount: number;
+    hybridResultCount: number;
+    queryAwareSeedCount: number;
+    resultCount: number;
+    intentHint?: string;
+    explainEnabled: boolean;
+    hybridTopUpUsed: boolean;
+    hybridTopUpSkippedReason?: string;
+    results: QmdSearchResult[];
+}
+interface RecallModeDecision {
+    plannedMode: RecallPlanMode;
+    effectiveMode: RecallPlanMode;
+    graphExpandedIntentDetected: boolean;
+    graphReason?: string;
+}
+interface RecallInvocationOptions {
+    namespace?: string;
+    topK?: number;
+    mode?: RecallPlanMode;
+    abortSignal?: AbortSignal;
+}
+/** Default workspace directory when no per-agent or config workspace is available. */
+declare function defaultWorkspaceDir(): string;
+/**
+ * Produce a collision-resistant, filesystem-safe identifier from a session key.
+ *
+ * Session keys follow colon-delimited forms (e.g., `agent:gpucodebot:main`).
+ * A naive replace (`:` → `_`) is lossy: different keys like `agent:alpha` and
+ * `agent/alpha` would collide. Instead we append a short SHA-256 hash of the
+ * original key to the human-readable sanitized prefix, guaranteeing uniqueness
+ * while keeping filenames debuggable.
+ *
+ * Format: `<sanitized>-<12-char-hex-hash>`
+ * Example: `agent:gpucodebot:main` → `agent_gpucodebot_main-a1b2c3d4e5f6`
+ */
+declare function sanitizeSessionKeyForFilename(sessionKey: string): string;
+declare function isArtifactMemoryPath(filePath: string): boolean;
+declare function deriveTopicsFromExtraction(result: ExtractionResult): string[];
+declare function buildCompressionGuidelinesMarkdown(events: MemoryActionEvent[], generatedAtIso?: string): string;
+declare function formatCompressionGuidelinesForRecall(raw: string, maxLines?: number): string | null;
+declare function filterRecallCandidates(candidates: QmdSearchResult[], options: {
+    namespacesEnabled: boolean;
+    recallNamespaces: string[];
+    resolveNamespace: (path: string) => string;
+    limit: number;
+}): QmdSearchResult[];
+declare function shouldFilterLifecycleRecallCandidate(frontmatter: MemoryFrontmatter, options: {
+    lifecyclePolicyEnabled: boolean;
+    lifecycleFilterStaleEnabled: boolean;
+}): boolean;
+declare function lifecycleRecallScoreAdjustment(frontmatter: MemoryFrontmatter, options: {
+    lifecyclePolicyEnabled: boolean;
+}): number;
+declare function computeArtifactRecallLimit(recallMode: RecallPlanMode, recallResultLimit: number, verbatimArtifactsMaxRecall: number): number;
+declare function resolveEffectiveRecallMode(options: {
+    plannerEnabled: boolean;
+    graphRecallEnabled: boolean;
+    multiGraphMemoryEnabled: boolean;
+    graphExpandedIntentEnabled?: boolean;
+    prompt: string;
+}): RecallPlanMode;
+declare function resolveRecallModeDecision(options: {
+    plannerEnabled: boolean;
+    graphRecallEnabled: boolean;
+    multiGraphMemoryEnabled: boolean;
+    graphExpandedIntentEnabled?: boolean;
+    prompt: string;
+}): RecallModeDecision;
+declare function hasIdentityRecoveryIntent(prompt: string): boolean;
+declare function resolveEffectiveIdentityInjectionMode(options: {
+    configuredMode: IdentityInjectionMode;
+    recallMode: RecallPlanMode;
+    prompt: string;
+}): {
+    mode: IdentityInjectionMode;
+    shouldInject: boolean;
+};
+declare function computeArtifactCandidateFetchLimit(targetCount: number): number;
+declare function computeQmdHybridFetchLimit(recallFetchLimit: number, artifactsEnabled: boolean, maxArtifactRecall: number): number;
+declare function mergeGraphExpandedResults(primary: QmdSearchResult[], expanded: QmdSearchResult[]): QmdSearchResult[];
+declare function graphPathRelativeToStorage(storageDir: string, candidatePath: string): string | null;
+declare function blendGraphExpandedRecallScore(options: {
+    graphActivationScore: number;
+    seedRecallScore: number;
+    activationWeight: number;
+    blendMin: number;
+    blendMax: number;
+}): number;
+declare function summarizeGraphShadowComparison(baseline: QmdSearchResult[], merged: QmdSearchResult[], topN: number): {
+    baselineCount: number;
+    graphCount: number;
+    overlapCount: number;
+    overlapRatio: number;
+    averageOverlapDelta: number;
+};
+declare function mergeArtifactRecallCandidates(candidatesByNamespace: MemoryFile[][], limit: number): MemoryFile[];
+declare function resolveRecentThreadMemoryPaths(options: {
+    threadEpisodeIds: string[];
+    currentMemoryId: string;
+    allMemsForGraph: MemoryFile[] | null | undefined;
+    pathById?: Map<string, string>;
+    storageDir: string;
+    maxRecent: number;
+}): string[];
+declare function buildMemoryPathById(allMemsForGraph: MemoryFile[] | null | undefined, storageDir: string): Map<string, string>;
+declare function appendMemoryToGraphContext(options: {
+    allMemsForGraph: MemoryFile[] | null | undefined;
+    storageDir: string;
+    memoryRelPath: string;
+    memoryId: string;
+    category: MemoryFile["frontmatter"]["category"];
+    content: string;
+    entityRef: string | undefined;
+}): void;
+declare function resolvePersistedMemoryRelativePath(options: {
+    memoryId: string;
+    pathById: Map<string, string>;
+    category: string;
+}): string;
+declare class Orchestrator {
+    readonly storage: StorageManager;
+    private readonly storageRouter;
+    private readonly namespaceSearchRouter;
+    qmd: SearchBackend;
+    private readonly conversationQmd?;
+    private readonly conversationFaiss?;
+    private readonly conversationIndexBackend?;
+    readonly sharedContext?: SharedContextManager;
+    readonly compounding?: CompoundingEngine;
+    readonly buffer: SmartBuffer;
+    readonly transcript: TranscriptManager;
+    readonly sessionObserver: SessionObserverState;
+    readonly summarizer: HourlySummarizer;
+    readonly localLlm: LocalLlmClient;
+    readonly fastLlm: LocalLlmClient;
+    private readonly fastGatewayLlm;
+    readonly modelRegistry: ModelRegistry;
+    readonly relevance: RelevanceStore;
+    readonly negatives: NegativeExampleStore;
+    readonly lastRecall: LastRecallStore;
+    readonly tierMigrationStatus: TierMigrationStatusStore;
+    readonly embeddingFallback: EmbeddingFallback;
+    private readonly conversationIndexDir;
+    private readonly extraction;
+    readonly config: PluginConfig;
+    readonly profiler: ProfilingCollector;
+    private readonly threading;
+    /** v8.2: Per-namespace multi-graph memory indexes (entity/time/causal edges) */
+    private readonly graphIndexes;
+    /** Per-namespace BoxBuilders, keyed by the namespace root directory path. */
+    private readonly boxBuilders;
+    /** Temporal Memory Tree builder — builds hour/day/week/persona summary nodes. */
+    private readonly tmtBuilder;
+    /** Lossless Context Management engine — proactive session archive + DAG summarization. */
+    readonly lcmEngine: LcmEngine | null;
+    private readonly rerankCache;
+    /**
+     * Per-session workspace overrides keyed by sessionKey.
+     * Set by the before_agent_start hook so recall() uses the correct
+     * agent workspace for BOOT.md injection. Cleared after each recall.
+     * Using a Map prevents concurrent sessions from overwriting each other.
+     */
+    private _recallWorkspaceOverrides;
+    private routingRulesStore;
+    private contentHashIndex;
+    private readonly artifactSourceStatusCache;
+    private static readonly ARTIFACT_STATUS_CACHE_TTL_MS;
+    private accessTrackingBuffer;
+    private extractionQueue;
+    private queueProcessing;
+    private heartbeatObserverChains;
+    private recentExtractionFingerprints;
+    private nonZeroExtractionsSinceConsolidation;
+    private lastConsolidationRunAtMs;
+    private consolidationInFlight;
+    private qmdMaintenanceTimer;
+    private qmdMaintenancePending;
+    private qmdMaintenanceInFlight;
+    private lastQmdEmbedAtMs;
+    private lastQmdReprobeAtMs;
+    private tierMigrationInFlight;
+    private lastTierMigrationRunAtMs;
+    private readonly conversationIndexLastUpdateAtMs;
+    private lastFileHygieneRunAtMs;
+    private lastRecallFailureLogAtMs;
+    private lastRecallFailureAtMs;
+    private suppressedRecallFailures;
+    private readonly policyRuntime;
+    private runtimePolicyValues;
+    private utilityRuntimeValues;
+    private evalShadowWriteChain;
+    private initPromise;
+    private resolveInit;
+    /** Set per-session workspace for the next recall() call (compaction reset). @internal */
+    setRecallWorkspaceOverride(sessionKey: string, dir: string): void;
+    /** Remove a per-session workspace override (cleanup on error or early return). @internal */
+    clearRecallWorkspaceOverride(sessionKey: string): void;
+    resolvePrincipal(sessionKey?: string): string;
+    resolveSelfNamespace(sessionKey?: string): string;
+    getStorageForNamespace(namespace?: string): Promise<StorageManager>;
+    private configuredNamespaces;
+    private buildConfiguredQmdSearchOptions;
+    searchAcrossNamespaces(options: {
+        query: string;
+        namespaces?: string[];
+        maxResults?: number;
+        mode?: "search" | "hybrid" | "bm25" | "vector";
+        searchOptions?: SearchQueryOptions;
+        execution?: SearchExecutionOptions;
+    }): Promise<QmdSearchResult[]>;
+    private isSearchAvailableForNamespaceRouting;
+    constructor(config: PluginConfig);
+    /** Get or create a BoxBuilder for the given namespace storage root (namespace-isolated). */
+    private boxBuilderFor;
+    private effectiveRecencyWeight;
+    private effectiveCronRecallInstructionHeavyTokenCap;
+    private currentPolicyVersion;
+    private effectiveLifecycleThresholds;
+    private routeEngineOptions;
+    private getRoutingRulesStore;
+    private loadRoutingRules;
+    private resolveArtifactSourceStatuses;
+    /**
+     * Execute a fast-tier LLM chat completion.
+     * When gateway model source is active and fastGatewayAgentId is configured,
+     * routes through the gateway chain. Otherwise uses the local fast LLM.
+     */
+    private fastChatCompletion;
+    /**
+     * Get a fast-tier LLM client compatible with the rerank interface.
+     * When gateway model source is active, routes through the gateway fast chain.
+     * Otherwise returns the local fast LLM directly.
+     */
+    get fastLlmForRerank(): {
+        chatCompletion: (messages: Array<{
+            role: string;
+            content: string;
+        }>, options?: {
+            maxTokens?: number;
+            temperature?: number;
+            timeoutMs?: number;
+            operation?: string;
+            priority?: "recall-critical" | "background";
+        }) => Promise<{
+            content: string;
+        } | null>;
+    };
+    initialize(): Promise<void>;
+    /**
+     * Auto-register the engram-day-summary cron job in OpenClaw if it doesn't exist.
+     * Fire-and-forget — never blocks init or crashes on failure.
+     */
+    private autoRegisterDaySummaryCron;
+    private autoRegisterNightlyGovernanceCron;
+    applyBehaviorRuntimePolicy(state: BehaviorLoopPolicyState): Promise<{
+        applied: boolean;
+        rolledBack: boolean;
+        values: RuntimePolicyValues | null;
+        reason: string;
+    }>;
+    rollbackBehaviorRuntimePolicy(): Promise<boolean>;
+    maybeRunFileHygiene(): Promise<void>;
+    runBootstrap(options: BootstrapOptions): Promise<BootstrapResult>;
+    runConsolidationNow(): Promise<{
+        memoriesProcessed: number;
+        merged: number;
+        invalidated: number;
+    }>;
+    runSemanticConsolidationNow(options?: {
+        dryRun?: boolean;
+        thresholdOverride?: number;
+    }): Promise<SemanticConsolidationResult>;
+    private runSemanticConsolidation;
+    waitForExtractionIdle(timeoutMs?: number): Promise<boolean>;
+    waitForConsolidationIdle(timeoutMs?: number): Promise<boolean>;
+    getStorage(namespace?: string): Promise<StorageManager>;
+    generateDaySummary(memories: string | MemoryFile[]): Promise<DaySummaryResult | null>;
+    /**
+     * Auto-gather today's facts and hourly summaries from storage, then generate a day summary.
+     * Returns null if no facts are found for today.
+     */
+    generateDaySummaryAuto(namespace?: string): Promise<DaySummaryResult | null>;
+    /**
+     * Read today's facts and hourly summaries from storage, returning them
+     * as a formatted string suitable for generateDaySummary().
+     */
+    gatherTodayFacts(namespace?: string): Promise<string>;
+    previewMemoryActionEvent(event: Omit<MemoryActionEvent, "timestamp"> & {
+        timestamp?: string;
+    }): MemoryActionEvent;
+    appendMemoryActionEvent(event: Omit<MemoryActionEvent, "timestamp"> & {
+        timestamp?: string;
+    }): Promise<boolean>;
+    getLastGraphRecallSnapshot(namespace?: string): Promise<GraphRecallSnapshot | null>;
+    getLastIntentSnapshot(namespace?: string): Promise<IntentDebugSnapshot | null>;
+    getLastQmdRecallSnapshot(namespace?: string): Promise<QmdRecallSnapshot | null>;
+    explainLastGraphRecall(options?: {
+        namespace?: string;
+        maxExpanded?: number;
+    }): Promise<string>;
+    explainLastIntent(options?: {
+        namespace?: string;
+    }): Promise<string>;
+    explainLastQmdRecall(options?: {
+        namespace?: string;
+        maxResults?: number;
+    }): Promise<string>;
+    private searchConversationRecallResults;
+    private formatConversationRecallSection;
+    private countConversationChunkDocs;
+    private buildConversationIndexChunks;
+    getConversationIndexHealth(): Promise<{
+        enabled: boolean;
+        backend: "qmd" | "faiss";
+        status: "ok" | "degraded" | "disabled";
+        chunkDocCount: number;
+        lastUpdateAt: string | null;
+        qmdAvailable?: boolean;
+        faiss?: {
+            ok: boolean;
+            status: "ok" | "degraded" | "error";
+            indexPath: string;
+            message?: string;
+            manifest?: {
+                version: number;
+                modelId: string;
+                normalizedModelId: string;
+                dimension: number;
+                chunkCount: number;
+                updatedAt: string;
+                lastSuccessfulRebuildAt: string;
+            };
+        };
+    }>;
+    inspectConversationIndex(): Promise<ConversationIndexBackendInspection & {
+        enabled: boolean;
+        chunkDocCount: number;
+        lastUpdateAt: string | null;
+    }>;
+    getRecoverySummary(sessionKey?: string): Promise<{
+        generatedAt: string;
+        sessionKey?: string;
+        healthy: boolean;
+        issueCount: number;
+        incompleteTurns: number;
+        brokenChains: number;
+        checkpointHealthy: boolean;
+    }>;
+    updateConversationIndex(sessionKey: string, hours?: number, opts?: {
+        embed?: boolean;
+        enforceMinInterval?: boolean;
+    }): Promise<{
+        chunks: number;
+        skipped: boolean;
+        reason?: string;
+        retryAfterMs?: number;
+        embedded?: boolean;
+    }>;
+    rebuildConversationIndex(sessionKey?: string, hours?: number, opts?: {
+        embed?: boolean;
+    }): Promise<{
+        chunks: number;
+        skipped: boolean;
+        reason?: string;
+        embedded?: boolean;
+        rebuilt?: boolean;
+    }>;
+    /**
+     * Validate local LLM model availability and context window compatibility.
+     * Warns the user if there's a mismatch.
+     */
+    private validateLocalLlmModel;
+    recall(prompt: string, sessionKey?: string, options?: RecallInvocationOptions): Promise<string>;
+    private logRecallFailure;
+    private artifactTypeForCategory;
+    private truncateArtifactForRecall;
+    private fetchActiveArtifactsForNamespace;
+    private recallArtifactsAcrossNamespaces;
+    private scopeQueryAwarePaths;
+    private buildQueryAwarePrefilter;
+    private searchScopedMemoryCandidates;
+    private fetchQmdMemoryResultsWithArtifactTopUp;
+    private expandResultsViaGraph;
+    private recordLastGraphRecallSnapshot;
+    private recordLastIntentSnapshot;
+    private recordLastQmdRecallSnapshot;
+    private recordLastIntentSnapshotForNamespace;
+    private resolveStateDirForNamespace;
+    private buildGraphRecallRankedResults;
+    private getRecallSectionEntry;
+    private isRecallSectionEnabled;
+    private getRecallSectionMaxChars;
+    private getRecallSectionNumber;
+    private appendRecallSection;
+    private truncateRecallSectionToBudget;
+    private protectedRecallSectionIds;
+    private protectedRecallReservationChars;
+    private estimateReservedRecallBudget;
+    private getRecallBudgetChars;
+    private assembleRecallSections;
+    private recallInternal;
+    processTurn(role: "user" | "assistant", content: string, sessionKey?: string): Promise<void>;
+    ingestReplayBatch(turns: ReplayTurn[], options?: {
+        deadlineMs?: number;
+    }): Promise<void>;
+    observeSessionHeartbeat(sessionKey: string): Promise<void>;
+    private queueBufferedExtraction;
+    private shouldQueueExtraction;
+    /**
+     * Background serial queue processor.
+     * Processes extractions one at a time to avoid race conditions.
+     * Called automatically when items are queued.
+     */
+    private processQueue;
+    private runExtraction;
+    private runTierMigrationCycle;
+    getTierMigrationStatus(): Promise<TierMigrationStatusSnapshot>;
+    runTierMigrationNow(options?: {
+        dryRun?: boolean;
+        limit?: number;
+    }): Promise<TierMigrationCycleSummary>;
+    private maybeScheduleConsolidation;
+    private requestQmdMaintenance;
+    /**
+     * Public entrypoint for tool-driven QMD maintenance requests.
+     * Routes through existing debounced/singleflight maintenance controls.
+     */
+    requestQmdMaintenanceForTool(reason: string): void;
+    private runQmdMaintenance;
+    private persistExtraction;
+    private indexPersistedMemory;
+    /**
+     * Build a graph edge for a persisted memory (v8.2).
+     * Shared helper used by both the chunked and non-chunked write paths to avoid duplication.
+     * Fail-open: caller wraps in try/catch.
+     */
+    private buildGraphEdge;
+    private graphIndexFor;
+    /**
+     * Batch-update temporal and tag indexes after extraction (v8.1).
+     * Reads each persisted memory's path + frontmatter and adds them to
+     * state/index_time.json and state/index_tags.json.
+     * Fail-open: any error is logged but does not abort extraction.
+     */
+    private updateTemporalTagIndexes;
+    /** IDs of facts persisted in the last extraction */
+    private lastPersistedIds;
+    private runConsolidation;
+    optimizeCompressionGuidelines(options?: {
+        dryRun?: boolean;
+        eventLimit?: number;
+    }): Promise<{
+        enabled: boolean;
+        dryRun: boolean;
+        eventCount: number;
+        previousGuidelineVersion: number | null;
+        nextGuidelineVersion: number;
+        changedRules: number;
+        semanticRefinementApplied: boolean;
+        persisted: boolean;
+        draftContentHash: string | null;
+    }>;
+    activateCompressionGuidelineDraft(options?: {
+        expectedContentHash?: string;
+        expectedGuidelineVersion?: number;
+    }): Promise<{
+        enabled: boolean;
+        activated: boolean;
+        guidelineVersion: number | null;
+        reason?: "disabled" | "missing_draft" | "expected_revision_required" | "content_hash_mismatch" | "guideline_version_mismatch" | "draft_changed";
+    }>;
+    private runCompressionGuidelineLearningPass;
+    private buildCompressionGuidelineRecallSection;
+    private parseCompressionSemanticRefinement;
+    private actionOutcomePriorDelta;
+    private buildLifecycleActionPriors;
+    private runLifecyclePolicyPass;
+    /**
+     * Archive old, low-importance, rarely-accessed facts (v6.0).
+     * Moves eligible facts from facts/ to archive/YYYY-MM-DD/.
+     * Returns the number of archived facts.
+     */
+    private runFactArchival;
+    /**
+     * Run memory summarization if memory count exceeds threshold (Phase 4A).
+     */
+    private runSummarization;
+    /**
+     * Run topic extraction on all memories (Phase 4B).
+     */
+    private runTopicExtraction;
+    /** Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated */
+    private static readonly IDENTITY_CONSOLIDATE_THRESHOLD;
+    private autoConsolidateIdentity;
+    private formatQmdResults;
+    private formatObjectiveStateResults;
+    private formatCausalTrajectoryResults;
+    private formatTrustZoneResults;
+    private formatHarmonicRetrievalResults;
+    private formatWorkProductResults;
+    private formatVerifiedEpisodeResults;
+    private formatVerifiedSemanticRuleResults;
+    private summarizeIdentityText;
+    private formatOpenIncidentLine;
+    private trimIdentitySection;
+    private buildIdentityContinuitySection;
+    private emitTrace;
+    private queueEvalShadowRecall;
+    private publishRecallResults;
+    private buildLastRecallBudgetSummary;
+    private collectLastRecallSources;
+    private searchEmbeddingFallback;
+    /**
+     * Long-term fallback retrieval.
+     * Searches archived memories only, and is invoked only when hot recall returns zero hits.
+     */
+    private searchLongTermArchiveFallback;
+    private applyColdFallbackPipeline;
+    /**
+     * Record that memories were accessed (retrieved).
+     * Updates are batched in memory and flushed during consolidation.
+     */
+    trackMemoryAccess(memoryIds: string[]): void;
+    /**
+     * Flush access tracking buffer to disk.
+     * Called during consolidation or when buffer is full.
+     */
+    flushAccessTracking(): Promise<void>;
+    /**
+     * Apply recency, access count, and importance boosting to QMD search results.
+     * Returns re-ranked results.
+     */
+    private boostSearchResults;
+    /**
+     * Extract memory IDs from QMD search results for access tracking.
+     */
+    private extractMemoryIdsFromResults;
+    recordMemoryFeedback(memoryId: string, vote: "up" | "down", note?: string): Promise<void>;
+    recordNotUsefulMemories(memoryIds: string[], note?: string): Promise<void>;
+    getLastRecall(sessionKey: string): LastRecallSnapshot | null;
+    /**
+     * Check if a new memory contradicts an existing one.
+     * Uses QMD to find similar memories, then LLM to verify contradiction.
+     */
+    private checkForContradiction;
+    /**
+     * Suggest links for a new memory based on similar existing memories.
+     */
+    private suggestLinksForMemory;
+    private namespaceFromPath;
+    private namespaceFromStorageDir;
+    private readAllMemoriesForNamespaces;
+    private readArchivedMemoriesForNamespaces;
+}
+
+export { resolvePersistedMemoryRelativePath as A, resolveRecallModeDecision as B, type CompoundingPromotionReport as C, resolveRecentThreadMemoryPaths as D, shouldFilterLifecycleRecallCandidate as E, summarizeGraphShadowComparison as F, type GraphRecallSnapshot as G, type IntentDebugSnapshot as I, Orchestrator as O, type QmdRecallSnapshot as Q, type ReplaySource as R, type ReplayWarning as a, type ReplayTurn as b, type GraphRecallRankedResult as c, defaultWorkspaceDir as d, type GraphRecallShadowComparison as e, type RecallInvocationOptions as f, type RecallModeDecision as g, appendMemoryToGraphContext as h, blendGraphExpandedRecallScore as i, buildCompressionGuidelinesMarkdown as j, buildMemoryPathById as k, computeArtifactCandidateFetchLimit as l, computeArtifactRecallLimit as m, computeQmdHybridFetchLimit as n, deriveTopicsFromExtraction as o, filterRecallCandidates as p, formatCompressionGuidelinesForRecall as q, graphPathRelativeToStorage as r, sanitizeSessionKeyForFilename as s, hasIdentityRecoveryIntent as t, isArtifactMemoryPath as u, lifecycleRecallScoreAdjustment as v, mergeArtifactRecallCandidates as w, mergeGraphExpandedResults as x, resolveEffectiveIdentityInjectionMode as y, resolveEffectiveRecallMode as z };