@remnic/core 9.69.55 → 9.69.57

package/dist/orchestrator-iexgVLow.d.ts

@@ -1,2701 +0,0 @@
-import { TierMigrationStatusStore, TierMigrationStatusSnapshot, TierMigrationCycleSummary, RecallHandleHistoryStore, LastRecallBudgetSummary, GraphRecallExpandedEntry, LastRecallStore, LastRecallSnapshot, DrainPendingImpressionsResult } from './recall-state.js';
-import { BriefingFollowupGenerator } from './briefing.js';
-import { SmartBuffer } from './buffer.js';
-import { FaithfulnessGateCounters } from './extraction-faithfulness.js';
-import { SearchBackend, SearchQueryOptions, SearchExecutionOptions } from './search/port.js';
-import { S as StorageManager } from './storage-CMm-3aD3.js';
-import { TranscriptManager } from './transcript.js';
-import { HourlySummarizer } from './summarizer.js';
-import { L as LocalLlmClient } from './local-llm-BkkEK9rn.js';
-import { FallbackLlmClient } from './fallback-llm.js';
-import { M as MaintenanceScheduler } from './maintenance-CLBIvVxg.js';
-import { CompoundingEngine } from './compounding/engine.js';
-import { P as PluginConfig, M as MemoryFile, an as MemoryActionEvent, Q as QmdSearchResult, R as RecallPlanMode, I as IdentityInjectionMode, bw as RecallSectionConfig, bp as MemoryLink, ac as ExtractionResult, k as BufferTurn, C as CodingContext, aC as MemoryIntent, p as SourceConnectorProvenance, m as MemoryFrontmatter, t as BehaviorLoopPolicyState, bx as BootstrapOptions, by as BootstrapResult, bz as ConsolidationObservation, aU as DaySummaryResult, af as ImportTurn } from './types-Du6VdoAg.js';
-import { UtilityRuntimeValues } from './utility-runtime.js';
-import { CompressionGuidelineCoordinator } from './orchestration/compression-guideline-coordinator.js';
-import { S as SemanticConsolidationResult } from './semantic-consolidation-D--qe0eE.js';
-import { EmbeddingFallback } from './embedding-fallback.js';
-import { ExtractionEngine } from './extraction.js';
-import { ObjectiveStateSearchResult } from './objective-state.js';
-import { CausalTrajectorySearchResult } from './causal-trajectory.js';
-import { TrustZoneSearchResult } from './trust-zones.js';
-import { HarmonicRetrievalResult } from './harmonic-retrieval.js';
-import { VerifiedEpisodeResult } from './verified-recall.js';
-import { VerifiedSemanticRuleResult } from './semantic-rule-verifier.js';
-import { WorkProductLedgerSearchResult } from './work-product-ledger.js';
-import { TrustStageResultItem } from './trust-score-stage.js';
-import { ContinuityIncidentRecord } from './types-continuity.js';
-import { ConversationChunk } from './conversation-index/chunker.js';
-import { ConversationIndexBackend, ConversationIndexBackendInspection } from './conversation-index/backend.js';
-import { C as ConversationSearchResult } from './faiss-adapter-BHecI1fF.js';
-import { CapabilitySet, GraphConstructionCapabilitySet, MemoryLifecycleCapabilitySet } from './capabilities.js';
-import { IncludedMemory } from './included-memories.js';
-import { D as DependencyPropagationDeliveryPort } from './dependency-propagation-delivery-BrhPjAHQ.js';
-import { BoxBuilder } from './boxes.js';
-import { NamespaceStorageRouter } from './namespaces/storage.js';
-import { ThreadingManager } from './threading.js';
-import { R as ResolvedScopeProfilePlan } from './scope-profiles-BN1Dgfha.js';
-import { c as GraphIndex } from './graph-DRkl22KE.js';
-import { RecallXrayServedBy, RecallXraySnapshot } from './recall-xray.js';
-import { RecallContextComposition } from './recall-context-composition.js';
-import './generic-recall-paths-C0J1Oxb7.js';
-import { LiveConnectorsRunSummary } from './live-connectors-runner.js';
-import { ModelRegistry } from './model-registry.js';
-import { RelevanceStore } from './relevance.js';
-import { NegativeExampleStore } from './negative.js';
-import { SessionObserverState } from './session-observer-state.js';
-import { S as SemanticDedupHit } from './semantic-BalR6EXU.js';
-import { ReplayTurn } from './replay/types.js';
-import { W as WearablesService, M as MeetingsService } from './service-VealHeqO.js';
-import { LcmEngine } from './lcm/engine.js';
-import { N as NamespaceKind, a as NamespaceCatalog } from './catalog-BuMyYPUn.js';
-import { NamespaceSearchHealth } from './namespaces/search.js';
-import { SharedContextManager } from './shared-context/manager.js';
-import { RuntimePolicyValues } from './policy-runtime.js';
-import { ProfilingCollector } from './profiling.js';
-
-/**
- * Pattern-reinforcement maintenance job (issue #687 PR 2/4).
- *
- * Reads all memories via `StorageManager.readAllMemories()`, clusters
- * non-procedural memories by normalized content, and reinforces the
- * most-recent member of each large-enough cluster:
- *
- *   1. Cluster across active AND already-superseded members.  This is
- *      load-bearing: after the first reinforcement pass, older
- *      duplicates are marked `superseded`, so on the next pass the
- *      "active count" alone would be just `canonical + N-new`.  By
- *      keeping superseded members in the cluster for the threshold
- *      check, an established canonical (count >= minCount) keeps
- *      growing as soon as a single new duplicate arrives.
- *      `forgotten` / `archived` / `quarantined` / `pending_review` /
- *      `rejected` stay excluded per CLAUDE.md rule 53.
- *   2. Pick the most-recent ACTIVE member of each cluster as the
- *      canonical.  Stamp it with `reinforcement_count` (total cluster
- *      size including superseded members) and `last_reinforced_at`.
- *      Record provenance: `derived_from = [...source-ids...]` and
- *      `derived_via = "pattern-reinforcement"`.
- *   3. Mark any still-active duplicates with `status: "superseded"`
- *      and point `supersededBy` at the canonical id.
- *
- * The job is idempotent: re-running on the same corpus does not
- * double-bump `reinforcement_count` (the bump-only-on-change guard
- * compares cluster size to the canonical's previous counter), and
- * already-superseded duplicates simply pass through.
- *
- * Recall integration (boost from `reinforcement_count`) and the CLI
- * surface ship in PR 3/4 and PR 4/4 respectively — this PR only wires
- * the maintenance job and storage plumbing.
- */
-
-interface PatternReinforcementClusterResult {
-    /** Memory id of the canonical (most-recent) member. */
-    canonicalId: string;
-    /** Cluster size at run time (mirrors `reinforcement_count`). */
-    count: number;
-    /** IDs of the source memories that contributed (canonical + duplicates). */
-    sourceIds: readonly string[];
-    /** IDs of the older duplicates that were marked superseded. */
-    supersededIds: readonly string[];
-    /**
-     * `true` when the canonical's `reinforcement_count` actually
-     * changed during this run.  False when the job converged
-     * idempotently (same cluster size as the previous run).
-     */
-    reinforcementBumped: boolean;
-}
-interface PatternReinforcementResult {
-    /** Number of clusters that met the `minCount` threshold. */
-    clustersFound: number;
-    /** Number of canonical memories whose reinforcement counter changed. */
-    canonicalsUpdated: number;
-    /** Total duplicate memories newly marked `status: "superseded"`. */
-    duplicatesSuperseded: number;
-    /** Per-cluster details for tests / observability. */
-    clusters: PatternReinforcementClusterResult[];
-}
-
-/**
- * Conversation index coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the conversation-index subsystem: semantic recall over past
- * conversations, plus the build / update / rebuild / inspect / health
- * lifecycle of the on-disk chunk store and its pluggable search backend
- * (qmd or faiss). Behavior-preserving move from orchestrator.ts — no logic
- * changes; the orchestrator constructs one instance and keeps thin
- * delegating methods so existing call sites and tests that exercise the
- * private API continue to work.
- *
- * The backend and transcript are read through getters (not captured at
- * construction) so that post-construction reassignment of the orchestrator's
- * live fields — exercised by the conversation-index integration tests and by
- * backend swap-in at deferred-init time — is honored. This mirrors the
- * TierMigrationCoordinator accessor pattern.
- */
-
-/**
- * Coordinator for the conversation-index subsystem.
- *
- * Holds the per-session last-update timestamps (previously an orchestrator
- * field) and delegates chunk building / persistence / embedding to the
- * configured backend.
- */
-declare class ConversationIndexCoordinator {
-    private readonly config;
-    private readonly originAuthorityEnabled;
-    private readonly getTranscript;
-    private readonly getBackend;
-    private readonly indexDir;
-    private readonly lastUpdateAtMs;
-    constructor(options: {
-        config: PluginConfig;
-        getTranscript: () => TranscriptManager;
-        getBackend: () => ConversationIndexBackend | undefined;
-        indexDir: string;
-    });
-    /** Semantic recall over past-conversation chunks (fail-open: empty on miss). */
-    search(retrievalQuery: string, topK: number): Promise<ConversationSearchResult[]>;
-    /** Render conversation-recall search hits as a budgeted markdown section. */
-    formatRecallSection(results: ConversationSearchResult[], maxChars: number): string | null;
-    /** Recursively count `.md` chunk documents under a directory. */
-    countChunkDocs(dir: string): Promise<number>;
-    /** Read recent transcript entries and chunk them for indexing. */
-    buildChunks(sessionKey?: string, hours?: number): Promise<ConversationChunk[]>;
-    getHealth(): 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;
-            };
-        };
-    }>;
-    inspect(): Promise<ConversationIndexBackendInspection & {
-        enabled: boolean;
-        chunkDocCount: number;
-        lastUpdateAt: string | null;
-    }>;
-    update(sessionKey: string, hours?: number, opts?: {
-        embed?: boolean;
-        enforceMinInterval?: boolean;
-    }): Promise<{
-        chunks: number;
-        skipped: boolean;
-        reason?: string;
-        retryAfterMs?: number;
-        embedded?: boolean;
-    }>;
-    rebuild(sessionKey?: string, hours?: number, opts?: {
-        embed?: boolean;
-    }): Promise<{
-        chunks: number;
-        skipped: boolean;
-        reason?: string;
-        embedded?: boolean;
-        rebuilt?: boolean;
-    }>;
-}
-
-/**
- * Tier migration coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the hot/cold tier-migration lifecycle for a single cycle:
- *   - gating (config flags, in-flight guard, min-interval throttle)
- *   - budget selection (compounding override or config default)
- *   - candidate scanning across hot + cold storage
- *   - promotion/demotion execution via TierMigrationExecutor
- *   - status recording through TierMigrationStatusStore
- *
- * The orchestrator constructs one instance and exposes it as the public
- * `tierMigrationCoordinator` field. CLI commands and maintenance paths call
- * `getStatus`/`runCycle` directly; the orchestrator keeps a private
- * `runTierMigrationCycle` wrapper for the extraction-run dependency.
- * Storage is passed per-call so extraction (which writes to a namespace-
- * scoped storage) and maintenance/manual (which use the default storage)
- * share one coordinator.
- */
-
-/** Dependencies injected by the orchestrator. All stable references or live
- *  accessors (the orchestrator reassigns `qmd` to NoopSearchBackend and
- *  `utilityRuntimeValues` after async init, so those arrive as getters). */
-interface TierMigrationCoordinatorDeps {
-    config: PluginConfig;
-    /** Live accessor — the orchestrator reassigns this.qmd to NoopSearchBackend
-     *  after construction when the collection is missing. */
-    getQmd: () => SearchBackend;
-    tierMigrationStatus: TierMigrationStatusStore;
-    /** Live accessor — loaded asynchronously during init, null before that. */
-    getUtilityRuntimeValues: () => UtilityRuntimeValues | null;
-    /** Live accessor — undefined when compounding is disabled. */
-    getCompounding: () => CompoundingEngine | undefined;
-    /** Constructs the cold-tier StorageManager for a given parent memory dir.
-     *  Injected so this module owns no direct storage.ts import (#1533). */
-    createColdStorage: (parentDir: string) => StorageManager;
-}
-/**
- * Coordinates a single tier-migration cycle. Owns the in-flight guard and
- * last-run timestamp that previously lived as private orchestrator fields.
- */
-declare class TierMigrationCoordinator {
-    private readonly deps;
-    private inFlight;
-    private lastRunAtMs;
-    constructor(deps: TierMigrationCoordinatorDeps);
-    /** Whether a migration cycle is currently executing (diagnostics). */
-    isInFlight(): boolean;
-    /** Latest status snapshot (delegates to the status store). */
-    getStatus(): TierMigrationStatusSnapshot;
-    /**
-     * Run one tier-migration cycle. Behavior-preserving move of the
-     * orchestrator's former `runTierMigrationCycle`.
-     */
-    runCycle(storage: StorageManager, trigger: "extraction" | "maintenance" | "manual", options?: {
-        dryRun?: boolean;
-        limitOverride?: number;
-        force?: boolean;
-    }): Promise<TierMigrationCycleSummary>;
-}
-
-/**
- * Extraction queue coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the background serial queue that drains extraction tasks one at a
- * time to avoid races between concurrent flush/heartbeat/bulk-import
- * triggers:
- *   - queue state (`extractionQueue` + `queueProcessing`)
- *   - the scheduling trigger (start the drain when the first task lands and
- *     the processor is idle)
- *   - the serial drain loop itself (`processQueue`)
- *   - failure classification (`logExtractionQueueFailure`) — issue #549:
- *     AbortError from session transitions logs at debug, real failures at
- *     error
- *   - the idle wait (`waitForIdle`) used by bootstrap and tests
- *
- * Does NOT own the WHAT — `runExtraction`, the dedupe fingerprint check,
- * the deadline timer, and the buffer-clear policy remain on the
- * orchestrator (they need the full extraction dependency surface). The
- * orchestrator builds each task closure and hands it to `enqueue`; the
- * coordinator owns only the queue mechanics.
- *
- * Behavior-preserving move from orchestrator.ts. No logic changes — the
- * orchestrator keeps a thin delegating `waitForExtractionIdle` and the
- * `queueBufferedExtraction` builder delegates push+scheduling here.
- */
-/**
- * Coordinates the background serial extraction queue. Owns the in-flight
- * guard + queue array that previously lived as private orchestrator fields.
- */
-declare class ExtractionQueueCoordinator {
-    /**
-     * Background serial queue for extractions (agent_end optimization).
-     * Queue stores tasks that resolve when extraction should run.
-     */
-    private readonly queue;
-    /** Whether the serial drain loop is currently running. */
-    private processing;
-    private accepting;
-    /** Current queue depth (idle-wait + test seam). */
-    get length(): number;
-    /** Whether the serial drain loop is currently running (idle-wait + test seam). */
-    get isProcessing(): boolean;
-    /**
-     * Enqueue a task and start the serial processor if it is idle. This is
-     * the production entry point — the orchestrator's `queueBufferedExtraction`
-     * builds each task closure and hands it here.
-     */
-    enqueue(task: () => Promise<void>): boolean;
-    /** Stop new producers from entering the queue. */
-    stopAccepting(): void;
-    /** Resume producer acceptance after an orchestrator re-initializes. */
-    resumeAccepting(): void;
-    /** Stop new producers and wait for all accepted work to finish. */
-    pauseAndDrain(timeoutMs?: number): Promise<boolean>;
-    /**
-     * Background serial queue processor.
-     * Processes extractions one at a time to avoid race conditions.
-     * Called automatically when items are queued via `enqueue`; also exposed
-     * for the characterization tests that push raw tasks and assert drain
-     * semantics directly.
-     */
-    processQueue(): Promise<void>;
-    /**
-     * Classify + log a failure from either the per-task catch inside
-     * `processQueue()` or the outer `processQueue().catch(...)` in
-     * `enqueue()`.  Issue #549: `throwIfRecallAborted`
-     * (used throughout `runExtraction`) raises an Error whose `name` is
-     * `"AbortError"`.  That path fires when `before_reset` aborts a
-     * queued task to avoid duplicate extraction — it is intentional
-     * cancellation, not a failure.  Downgrading the log to debug
-     * prevents spurious `error`-level lines that routinely appear
-     * right next to a successful `persisted: N facts, M entities` log
-     * and that confuse operators into thinking extraction is broken.
-     * Genuine extraction failures (network, parse, I/O) still log at
-     * `error`.
-     *
-     * Source differentiates the two call sites so the log message
-     * names the right layer (`task` vs `processor`).
-     */
-    logExtractionQueueFailure(err: unknown, source: "task" | "processor"): void;
-    /**
-     * Wait until the extraction queue is fully drained (no tasks queued, no
-     * drain in flight) or `timeoutMs` elapses. Used by bootstrap (after a
-     * dry-run import) and by tests that need to assert extraction settled.
-     * Returns false on timeout, true once idle.
-     */
-    waitForIdle(timeoutMs?: number): Promise<boolean>;
-    /**
-     * Push a raw task WITHOUT auto-starting the processor, matching the
-     * pre-extraction `this.extractionQueue.push(...)` used by the
-     * characterization tests that drive the drain manually via `processQueue`.
-     */
-    pushRaw(task: () => Promise<void>): void;
-    /** Remove + return the front task (test seam for the flush deadline tests). */
-    shift(): (() => Promise<void>) | undefined;
-    /**
-     * Force the processor-busy flag so `enqueue` does not auto-start the
-     * drain — used by the flush deadline test to simulate a busy queue and
-     * assert a queued task's deadline expires while it waits.
-     */
-    setProcessingForTest(value: boolean): void;
-}
-
-/**
- * Semantic-consolidation coordinator — extracted from the orchestrator
- * (issue #1526, seam 5).
- *
- * Owns the semantic-consolidation lifecycle: discovering clusters of
- * similar memories, synthesizing a canonical memory per cluster via the
- * LLM (operator-aware or legacy), archiving the superseded sources, and
- * firing post-consolidation hooks (Codex materialize, peer-profile
- * reasoner).
- *
- * The orchestrator constructs one instance and delegates the internal
- * entrypoint (`runSemanticConsolidation`) to it. The public wrappers
- * (`runSemanticConsolidationNow`, `runSemanticConsolidationFanout`)
- * remain on the orchestrator as thin pass-throughs. Storage is the
- * orchestrator's stable `this.storage` (or a per-namespace override
- * passed via options); the fast-tier LLM, content-hash removal, and
- * index save arrive as callbacks so the orchestrator keeps ownership of
- * gateway routing and cross-subsystem persistence.
- *
- * Behavior-preserving move from orchestrator.ts. No logic changes — the
- * orchestrator keeps a thin delegating method so existing call sites
- * and tests that exercise the public API continue to work.
- */
-
-/** Dependencies injected by the orchestrator. All stable references or
- *  live accessors. */
-interface SemanticConsolidationCoordinatorDeps {
-    config: PluginConfig;
-    /** Live accessor: the orchestrator's storage manager (stable post-ctor). */
-    getStorage: () => StorageManager;
-    /** Live accessor for the fast-tier local LLM client (falls back to main
-     *  local LLM when localLlmFastEnabled is false — orchestrator ctor handles
-     *  this). Injected as an accessor so tests that overwrite orchestrator.fastLlm
-     *  after construction still take effect. */
-    getFastLlm: () => LocalLlmClient;
-    /** The embedding-fallback manager used for index cleanup on archival. */
-    embeddingFallback: EmbeddingFallback;
-    /** Remove a memory's content-hash entry from the storage-scoped index.
-     *  Delegated to the orchestrator which owns the per-storage index map. */
-    removeContentHashForMemory: (targetStorage: StorageManager, memory: MemoryFile, context: string) => Promise<void>;
-    /** Persist all dirty content-hash indexes to disk. */
-    saveContentHashIndexes: () => Promise<void>;
-}
-/**
- * Coordinates semantic consolidation. Holds no mutable state of its own —
- * all persistence flows through the injected storage managers and
- * callbacks.
- */
-declare class SemanticConsolidationCoordinator {
-    private readonly deps;
-    constructor(deps: SemanticConsolidationCoordinatorDeps);
-    private get config();
-    runSemanticConsolidation(options?: {
-        dryRun?: boolean;
-        thresholdOverride?: number;
-        force?: boolean;
-        storage?: StorageManager;
-    }): Promise<SemanticConsolidationResult>;
-}
-
-/**
- * Lifecycle-policy coordinator — extracted from the orchestrator
- * (issue #1526, seam 6).
- *
- * Owns the deterministic memory-lifecycle pipeline: heat/decay scoring
- * (`runLifecyclePolicyPass`), fact archival (`runFactArchival`),
- * summarization (`runSummarization`), and topic extraction
- * (`runTopicExtraction`). Also owns the action-outcome prior builder
- * (`buildLifecycleActionPriors` / `actionOutcomePriorDelta`) that feeds
- * the lifecycle transition decider.
- *
- * The orchestrator constructs one instance and delegates the internal
- * entrypoints to it. The public wrapper (`runLifecyclePolicyNow`)
- * remains on the orchestrator as a thin pass-through. Storage is the
- * orchestrator's stable `this.storage` (or a per-namespace override
- * passed via options); the extraction engine, embedding-fallback, and
- * content-hash callbacks arrive as deps so the orchestrator keeps
- * ownership of gateway routing and cross-subsystem persistence.
- *
- * Behavior-preserving move from orchestrator.ts. No logic changes — the
- * orchestrator keeps thin delegating methods so existing call sites
- * and tests that exercise the public API continue to work.
- */
-
-/** Dependencies injected by the orchestrator. All stable references or
- *  live accessors. */
-interface LifecyclePolicyCoordinatorDeps {
-    config: PluginConfig;
-    /** Live accessor: the orchestrator's storage manager (stable post-ctor). */
-    getStorage: () => StorageManager;
-    /** The extraction engine — used for summarization. */
-    extraction: ExtractionEngine;
-    /** The embedding-fallback manager used for index cleanup on archival. */
-    embeddingFallback: EmbeddingFallback;
-    /** Effective lifecycle thresholds (promote/stale/archive). Delegated to
-     *  the orchestrator which owns runtime-policy-values overlay. */
-    getEffectiveLifecycleThresholds: () => {
-        promoteHeatThreshold: number;
-        staleDecayThreshold: number;
-        archiveDecayThreshold: number;
-    };
-    /** Remove a memory's content-hash entry from the storage-scoped index.
-     *  Delegated to the orchestrator which owns the per-storage index map. */
-    removeContentHashForMemory: (targetStorage: StorageManager, memory: MemoryFile, context: string) => Promise<void>;
-    /** Persist all dirty content-hash indexes to disk. */
-    saveContentHashIndexes: () => Promise<void>;
-    /** Recall-handle ring used to suppress quoted-back echo during seed graduation. */
-    getHandleHistory?: () => RecallHandleHistoryStore;
-}
-/**
- * Coordinates the memory-lifecycle policy pipeline. Holds no mutable
- * state of its own — all persistence flows through the injected storage
- * managers and callbacks.
- */
-declare class LifecyclePolicyCoordinator {
-    private readonly deps;
-    constructor(deps: LifecyclePolicyCoordinatorDeps);
-    private get config();
-    actionOutcomePriorDelta(event: MemoryActionEvent): number;
-    buildLifecycleActionPriors(storage?: StorageManager): Promise<Map<string, number>>;
-    runLifecyclePolicyPass(allMemories: MemoryFile[], storage?: StorageManager): Promise<number>;
-    /**
-     * 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.
-     */
-    runFactArchival(allMemories: MemoryFile[]): Promise<number>;
-    /**
-     * Run memory summarization if memory count exceeds threshold (Phase 4A).
-     */
-    runSummarization(allMemories: MemoryFile[]): Promise<void>;
-    /**
-     * Run topic extraction on all memories (Phase 4B).
-     */
-    runTopicExtraction(allMemories: MemoryFile[]): Promise<void>;
-}
-
-/**
- * Entity synthesis coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the entity-synthesis lifecycle: processing the queued entities whose
- * evidence has changed since their last synthesis, gathering timeline +
- * structured-section evidence, deduplicating it, batch-feeding it through the
- * fast-tier LLM to produce a compact "current truth" synthesis, and persisting
- * the result with drift/bookkeeping metadata.
- *
- * Moved here (behavior-preserving):
- *   - module-level helpers `dedupeEntitySynthesisEvidenceEntries`,
- *     `flattenStructuredSectionEvidence`, `fingerprintEntitySynthesisEvidence`
- *   - the queue-processing method, now owned by this coordinator as
- *     `processQueue` (originally the orchestrator's `processEntitySynthesisQueue`)
- *
- * The orchestrator constructs one instance and exposes it as
- * `orchestrator.entitySynthesisCoordinator`; call sites invoke `processQueue`
- * directly (issue #1800 removed the orchestrator's forwarding delegate once
- * every caller migrated). Storage is resolved per-call via the injected
- * accessor so namespace-scoped and default-namespace calls share one
- * coordinator.
- */
-
-/** Dependencies injected by the orchestrator. */
-interface EntitySynthesisCoordinatorDeps {
-    config: PluginConfig;
-    /** Resolve the storage manager for a namespace (or the default). */
-    getStorage: (namespace?: string) => Promise<StorageManager>;
-    /** Fast-tier LLM completion (same signature as Orchestrator.fastChatCompletion). */
-    fastChatCompletion: (messages: Array<{
-        role: string;
-        content: string;
-    }>, options: {
-        temperature?: number;
-        maxTokens?: number;
-        timeoutMs?: number;
-        operation?: string;
-        priority?: "background" | "recall-critical";
-    }) => Promise<{
-        content: string;
-    } | null>;
-}
-/**
- * Coordinates entity synthesis refresh for queued entities. Owns the
- * evidence-gathering, dedup, batched-LLM-synthesis, and persistence logic
- * that previously lived inline in the orchestrator.
- */
-declare class EntitySynthesisCoordinator {
-    private readonly deps;
-    constructor(deps: EntitySynthesisCoordinatorDeps);
-    /**
-     * Process up to `maxEntities` entities from the synthesis queue for the
-     * given namespace. Returns the number of entities whose synthesis was
-     * successfully refreshed.
-     */
-    processQueue(namespace?: string, maxEntities?: number): Promise<number>;
-}
-
-/**
- * Recall result formatter — extracted from the orchestrator (issue #1526).
- *
- * Owns the formatting of recall search results into display sections, plus the
- * identity-continuity section assembly:
- *   - QMD result formatting (with memory handles + epistemic hedge rendering)
- *   - Specialized recall result formatters (objective-state, causal-trajectory,
- *     trust-zone, harmonic-retrieval, work-product, verified-episode,
- *     verified-semantic-rule)
- *   - Identity continuity helpers (summarizeIdentityText, formatOpenIncidentLine,
- *     trimIdentitySection) and the full buildIdentityContinuitySection builder
- *   - Module-level helpers hasIdentityRecoveryIntent and
- *     resolveEffectiveIdentityInjectionMode (only consumed here)
- *
- * Behavior-preserving move from orchestrator.ts. No logic changes — the
- * orchestrator constructs one instance and keeps thin delegating methods so
- * existing call sites and tests that exercise the private API continue to work.
- */
-
-declare function hasIdentityRecoveryIntent(prompt: string): boolean;
-declare function resolveEffectiveIdentityInjectionMode(options: {
-    configuredMode: IdentityInjectionMode;
-    recallMode: RecallPlanMode;
-    prompt: string;
-}): {
-    mode: IdentityInjectionMode;
-    shouldInject: boolean;
-};
-/**
- * Formats recall search results into display sections and assembles the
- * identity-continuity section. Holds a reference to config for feature-gated
- * rendering (memory handles, epistemic hedges, identity injection mode).
- */
-declare class RecallResultFormatter {
-    private readonly config;
-    private readonly originAuthorityEnabled;
-    constructor(config: PluginConfig);
-    formatQmdResultEntries(title: string, results: QmdSearchResult[], sessionKey?: string, trustByPath?: Map<string, TrustStageResultItem> | null): {
-        heading: string;
-        entries: string[];
-    };
-    formatQmdResults(title: string, results: QmdSearchResult[], sessionKey?: string, trustByPath?: Map<string, TrustStageResultItem> | null): string;
-    formatObjectiveStateResults(results: ObjectiveStateSearchResult[]): string;
-    formatCausalTrajectoryResults(results: CausalTrajectorySearchResult[]): string;
-    formatTrustZoneResults(results: TrustZoneSearchResult[]): string;
-    formatHarmonicRetrievalResults(results: HarmonicRetrievalResult[]): string;
-    /**
-     * Render grouped raw-turn episodes for the top recalled facts (issue #2331).
-     * Returns `null` for zero episodes so the section is omitted entirely —
-     * never an empty header.
-     */
-    formatEpisodicContext(episodes: ReadonlyArray<{
-        sessionKey: string;
-        fromTurn: number;
-        toTurn: number;
-        memoryIds: readonly string[];
-        turns: ReadonlyArray<{
-            role: string;
-            content: string;
-        }>;
-    }>): string | null;
-    formatWorkProductResults(results: WorkProductLedgerSearchResult[]): string;
-    formatVerifiedEpisodeResults(results: VerifiedEpisodeResult[]): string;
-    formatVerifiedSemanticRuleResults(results: VerifiedSemanticRuleResult[]): string;
-    summarizeIdentityText(raw: string, maxLines: number, maxChars: number): string;
-    formatOpenIncidentLine(incident: ContinuityIncidentRecord, includeDetails: boolean): string;
-    trimIdentitySection(content: string, maxChars: number): {
-        text: string;
-        truncated: boolean;
-    };
-    buildIdentityContinuitySection(options: {
-        storage: StorageManager;
-        recallMode: RecallPlanMode;
-        prompt: string;
-    }): Promise<{
-        section: string;
-        mode: IdentityInjectionMode;
-        injectedChars: number;
-        truncated: boolean;
-    } | null>;
-}
-
-/**
- * Recall rerank coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the post-retrieval result-ranking subsystem: Memory-Worth reranking,
- * TrustScore scoring + quarantine, reasoning-trace boost, and MMR
- * diversification/limiting. Behavior-preserving move from orchestrator.ts —
- * no logic changes; the orchestrator constructs one instance and keeps thin
- * delegating methods so existing call sites (recallInternal,
- * applyColdFallbackPipeline) continue to work.
- *
- * Config, storage, and the QMD-result memory reader are accessed through
- * getter callbacks (not captured at construction) so that post-construction
- * reassignment of the orchestrator's live fields is honored. This mirrors
- * the ConversationIndexCoordinator / TierMigrationCoordinator accessor
- * pattern.
- */
-
-interface RecallResultPartition {
-    appliedResults: QmdSearchResult[];
-    headroomResults: QmdSearchResult[];
-}
-/**
- * Coordinator for the recall-result reranking subsystem.
- *
- * Holds the per-namespace caches for memory-worth counters and trust signals
- * (previously orchestrator fields) so the reranking stages don't trigger a
- * full `readAllMemories` scan per query.
- */
-declare class RecallRerankCoordinator {
-    private readonly getConfig;
-    private readonly getStorage;
-    private readonly readQmdResultMemory;
-    private readonly memoryWorthCounterCache;
-    private readonly trustSignalCache;
-    /**
-     * Cap on distinct namespaces retained in the corpus-fallback caches. Each
-     * entry holds a derived per-namespace map; on high-cardinality namespace
-     * workloads an unbounded map would grow without limit (#1905, Cursor). Map
-     * preserves insertion order, so overflow evicts the oldest namespace.
-     */
-    private static readonly CORPUS_FALLBACK_CACHE_MAX_NAMESPACES;
-    /** Insert-ordered bounded set: evict the oldest namespace on overflow. */
-    private static capCache;
-    constructor(options: {
-        getConfig: () => PluginConfig;
-        getStorage: (namespace: string) => Promise<StorageManager>;
-        readQmdResultMemory: (resultPath: string, fallbackStorage: StorageManager, recallNamespaces: readonly string[], preferredNamespace?: string) => Promise<MemoryFile | null>;
-    });
-    applyMemoryWorthRerank(results: QmdSearchResult[], namespaces: string[], preloadedFrontmatter?: ReadonlyMap<string, MemoryFile>, abortSignal?: AbortSignal): Promise<QmdSearchResult[]>;
-    /**
-     * Issue #1577 — unified TrustScore recall stage. Thin wiring over the pure
-     * {@link applyTrustScoreStage} scorer + the {@link buildTrustSignalsForRerank}
-     * signal builder. The stage subsumes the Memory Worth multiplier — the
-     * orchestrator runs exactly one of the two (mutual exclusion, rule 39; the
-     * double-multiplier test in trust-score-stage.test.ts pins it structurally).
-     *
-     * Returns the admitted results AND the per-path trust map (including
-     * quarantined items) so the caller can: (a) render epistemic hedges, (b)
-     * surface quarantined items in X-ray with a reason (rule 34), and (c) filter
-     * quarantined paths from fallback recall branches. The trust map is a
-     * per-recall local — never instance state — so concurrent recalls cannot
-     * race on it (review: shared-trust-map concurrency).
-     */
-    applyTrustScoreRerank(results: QmdSearchResult[], namespaces: string[], preloadedFrontmatter?: ReadonlyMap<string, MemoryFile>, abortSignal?: AbortSignal): Promise<{
-        results: QmdSearchResult[];
-        trustByPath: Map<string, TrustStageResultItem> | null;
-    }>;
-    /**
-     * Issue #1577 — apply the TrustScore stage (or, when trust is off, the Memory
-     * Worth multiplier fallback) to ONE recall branch's results, returning the
-     * scored results + the per-path trust map. Thin wiring over
-     * {@link applyTrustScoreRerank} so every recall path — hot QMD, embedding
-     * fallback, recent scan — applies the SAME multiplier gate (rule 41: a
-     * feature gate must apply across ALL parallel recall paths). TrustScore
-     * subsumes Memory Worth; exactly one runs (rule 39). Fail-open on lookup
-     * errors so a storage hiccup never breaks a fallback path.
-     */
-    applyTrustScoreToBranch(results: QmdSearchResult[], namespaces: string[], caps: CapabilitySet, label: string, preloadedFrontmatter?: ReadonlyMap<string, MemoryFile>, abortSignal?: AbortSignal): Promise<{
-        results: QmdSearchResult[];
-        trustByPath: Map<string, TrustStageResultItem> | null;
-    }>;
-    /**
-     * Issue #2371 — stale-preference damping + injection annotation.
-     *
-     * Runs immediately after the trust/Memory-Worth stage on EVERY recall branch
-     * (hot QMD, embedding fallback, recent scan, cold fallback), so the feature
-     * gate applies uniformly and fallback parity holds (§27, AGENTS.md retrieval
-     * guardrails). Fully inert on the default config: when neither damping nor
-     * annotation is active the input array is returned untouched and NO
-     * frontmatter is read, so recall ordering and injected text stay
-     * byte-identical to pre-#2371.
-     *
-     * Fail-open: any lookup error leaves the branch's results unchanged.
-     */
-    applyPreferenceDriftStage(results: QmdSearchResult[], namespaces: string[], preloadedFrontmatter?: ReadonlyMap<string, MemoryFile>, abortSignal?: AbortSignal): Promise<QmdSearchResult[]>;
-    diversifyRecallResultsWithHeadroom(sectionId: string, results: QmdSearchResult[], limit: number, retrievalQuery?: string, caps?: CapabilitySet, 
-    /**
-     * #2859 — state-view packet semantics. When true, superseded rows are
-     * reconciled against their successors BEFORE MMR (orphan removal can
-     * never underfill), and the cap counts complete evidence packets: a
-     * predecessor admitted alongside its successor consumes ONE slot and
-     * the slice never splits the pair at the boundary. Absent/false keeps
-     * the legacy slice byte-identical.
-     */
-    stateViewActive?: boolean): RecallResultPartition;
-    diversifyAndLimitRecallResults(sectionId: string, results: QmdSearchResult[], limit: number, retrievalQuery?: string, caps?: CapabilitySet, 
-    /** #2859 — see diversifyRecallResultsWithHeadroom. */
-    stateViewActive?: boolean): QmdSearchResult[];
-    /**
-     * Apply Maximal Marginal Relevance to a section's ordered candidate list.
-     *
-     * Operates per-section so one redundant cluster cannot dominate a section,
-     * and so one section's MMR pass cannot starve other sections. Returns the
-     * input unchanged when disabled, when there are fewer than 2 candidates, or
-     * when no budget information is available.
-     */
-    applyMmrToQmdResults(sectionId: string, results: QmdSearchResult[], caps?: CapabilitySet): QmdSearchResult[];
-}
-
-/**
- * Recall section coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the recall-output section-budgeting subsystem: section enablement
- * lookups, per-section maxChars/number resolution, section bucket appends,
- * budget-aware section truncation, and final ordered assembly of recall
- * sections within the configured character budget. Also builds the
- * LastRecallBudgetSummary and collects the sources used for X-ray tracing.
- *
- * Behavior-preserving move from orchestrator.ts — no logic changes; the
- * orchestrator constructs one instance and keeps thin delegating methods so
- * existing call sites (recallInternal, consolidation) continue to work.
- *
- * Config is accessed through a getter callback (not captured at construction)
- * so that post-construction reassignment of the orchestrator's live
- * `config` field is honored. This mirrors the ConversationIndexCoordinator /
- * TierMigrationCoordinator accessor pattern.
- */
-
-interface RecallSectionAppendOptions {
-    atomic?: boolean;
-    memoryId?: string;
-    memoryPath?: string;
-    memoryNamespace?: string;
-    /**
-     * #2928 — state-view packet key (canonical `stateViewPacketKeys` root).
-     * Atomic chunks sharing a packetKey are ONE evidence packet: the final
-     * budget admits or drops them together, so a historical row can never
-     * render without its linked successor. Absent on non-state rows.
-     */
-    packetKey?: string;
-}
-interface RecallSectionChunk {
-    content: string;
-    atomic?: boolean;
-    memoryId?: string;
-    memoryPath?: string;
-    memoryNamespace?: string;
-    packetKey?: string;
-}
-type RecallSectionBuckets = Map<string, Array<string | RecallSectionChunk>>;
-/**
- * Coordinator for the recall section budgeting + assembly subsystem.
- *
- * All methods are pure with respect to the coordinator's own state — they
- * read config via the getter and operate on the caller-provided section
- * buckets. No caches are held because the config-derived values are cheap
- * to recompute and the buckets are transient (per-recall-call).
- */
-declare class RecallSectionCoordinator {
-    private readonly getConfig;
-    private readonly resolveSectionEnabled;
-    constructor(options: {
-        getConfig: () => PluginConfig;
-        resolveSectionEnabled?: (sectionId: string, defaultEnabled: boolean) => boolean;
-    });
-    getRecallSectionEntry(sectionId: string): RecallSectionConfig | undefined;
-    isRecallSectionEnabled(sectionId: string, defaultEnabled?: boolean): boolean;
-    isSpecializedRecallSectionEnabled(sectionId: string, topLevelEnabled: boolean): boolean;
-    getRecallSectionMaxChars(sectionId: string): number | null | undefined;
-    getRecallSectionNumber(sectionId: string, key: keyof RecallSectionConfig): number | undefined;
-    appendRecallSection(sectionBuckets: RecallSectionBuckets, sectionId: string, content: string, options?: RecallSectionAppendOptions): boolean;
-    truncateProfileToBoundary(content: string, maxChars: number): string;
-    truncateRecallSectionToBudget(content: string, maxChars: number, maxTokens?: number): string;
-    getRecallBudgetChars(override?: number): number;
-    assembleRecallSections(sectionBuckets: RecallSectionBuckets, budgetOverride?: number): {
-        sections: string[];
-        includedIds: string[];
-        omittedIds: string[];
-        truncated: boolean;
-        finalChars: number;
-        includedMemories: IncludedMemory[];
-        includedMemoryIds: string[];
-        includedMemoryPaths: string[];
-        includedMemoryNamespaces: Array<string | undefined>;
-        omittedMemoryIds: string[];
-    };
-    buildLastRecallBudgetSummary(options: {
-        requestedTopK?: number;
-        recallResultLimit: number;
-        qmdFetchLimit: number;
-        qmdHybridFetchLimit: number;
-        finalContextChars?: number;
-        truncated?: boolean;
-        includedSections?: string[];
-        omittedMemoryIds?: string[];
-        omittedSections?: string[];
-    }): LastRecallBudgetSummary;
-    collectLastRecallSources(sectionBuckets: RecallSectionBuckets, recallSource: "none" | "hot_qmd" | "hot_embedding" | "cold_fallback" | "recent_scan"): string[];
-}
-
-/**
- * QMD result resolver — extracted from the orchestrator (issue #1526 seam 11).
- *
- * Owns the subsystem that resolves a QMD search-result path back to the
- * concrete `MemoryFile` (and its owning namespace/storage). Three concerns
- * live here:
- *
- *   - `readQmdResultMemory` — resolve a result path to a `MemoryFile`,
- *     handling cold-tier collections, namespace-prefixed collections, and
- *     absolute vs relative paths.
- *   - `resolveColdQmdResultForRecall` — wrap a result with its owner
- *     namespace so the recall pipeline can scope-filter candidates.
- *   - `storageForAbsoluteQmdResultPath` — find the `StorageManager` whose
- *     directory tree contains an absolute result path.
- *
- * Behavior-preserving move from orchestrator.ts — no logic changes. The
- * orchestrator constructs one instance and keeps thin delegating methods so
- * existing call sites (recallInternal, applyColdFallbackPipeline,
- * loadSearchResultMemoryMap, suggestLinksForMemory, and the
- * RecallRerankCoordinator callback) continue to work.
- *
- * Config, the storage router, and the orchestrator's namespace-resolution
- * helpers are accessed through getter callbacks (not captured at
- * construction) so that post-construction reassignment of the
- * orchestrator's live fields is honored. This mirrors the
- * RecallRerankCoordinator / ConversationIndexCoordinator accessor pattern.
- */
-
-/**
- * Coordinator for resolving QMD search-result paths to concrete memory
- * files and their owning namespace/storage.
- */
-declare class QmdResultResolver {
-    private readonly getConfig;
-    private readonly storageFor;
-    private readonly storageDirNamespace;
-    private readonly qmdCollectionNamespaceFromPrefix;
-    private readonly namespaceFromPath;
-    constructor(options: {
-        getConfig: () => PluginConfig;
-        storageFor: (namespace: string) => Promise<StorageManager>;
-        storageDirNamespace: (storageDir: string) => string;
-        qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
-        namespaceFromPath: (p: string) => string;
-    });
-    readQmdResultMemory(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[], preferredNamespace?: string): Promise<MemoryFile | null>;
-    filterPrivateSearchResults(results: QmdSearchResult[], fallbackStorage: StorageManager, namespaces?: readonly string[], preserveUnresolved?: boolean, visibilityCache?: Map<string, boolean>): Promise<QmdSearchResult[]>;
-    private isVisibleSearchResult;
-    resolveColdQmdResultForRecall(result: QmdSearchResult, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
-        namespace: string;
-        result: QmdSearchResult;
-    } | null>;
-    storageForAbsoluteQmdResultPath(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
-        storage: StorageManager;
-        dir: string;
-        namespace: string;
-    } | null>;
-}
-
-/**
- * Contradiction-linking coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the write-path semantic-analysis subsystem: contradiction detection
- * (QMD similarity search + LLM verification), deferred contradiction
- * auto-resolve (#1645 — retires superseded memories only after the new write's
- * tombstone status is known), and memory link suggestion. The orchestrator
- * constructs one instance and keeps thin delegating methods so existing call
- * sites (writeMemory fact-write branches) continue to work.
- *
- * Config, storage, search, namespace resolution, and the extraction engine are
- * accessed through getter callbacks (not captured at construction) so that
- * post-construction reassignment of the orchestrator's live fields is honored.
- * This mirrors the RecallRerankCoordinator / ConversationIndexCoordinator
- * accessor pattern.
- */
-
-/** Result type of {@link ContradictionLinkingCoordinator.checkForContradiction}. */
-interface ContradictionResult {
-    supersededId: string;
-    confidence: number;
-    reason: string;
-    supersededPath: string;
-    supersededCreated: string;
-    supersededTags: string[];
-}
-/** Outcome of the post-write contradiction retirement attempt. */
-type ContradictionResolveOutcome = "not_attempted" | "blocked" | "resolved" | "lost_race" | "supersede_failed" | "supersedes_clear_failed";
-/**
- * Subset of {@link ContradictionResult} used by
- * {@link ContradictionLinkingCoordinator.applyDeferredContradictionResolve}.
- * The deferred resolve runs AFTER writeMemory and only needs the supersede
- * target fields (not confidence, which the caller already consumed).
- */
-interface ContradictionResolveTarget {
-    supersededId: string;
-    reason: string;
-    supersededPath: string;
-    supersededCreated: string;
-    supersededTags: string[];
-}
-/**
- * Coordinator for the contradiction-detection + memory-linking subsystem.
- *
- * The three methods mirror the orchestrator's former private methods
- * `checkForContradiction`, `applyDeferredContradictionResolve`, and
- * `suggestLinksForMemory` byte-for-byte in logic.
- */
-declare class ContradictionLinkingCoordinator {
-    private readonly getConfig;
-    private readonly isSearchAvailable;
-    private readonly searchAcrossNamespaces;
-    private readonly extractMemoryIdsFromResults;
-    private readonly namespaceFromPath;
-    private readonly storageForNamespace;
-    private readonly getExtraction;
-    private readonly storageDirNamespace;
-    private readonly getDependencyPropagationDelivery;
-    constructor(options: {
-        getConfig: () => PluginConfig;
-        isSearchAvailable: () => boolean;
-        searchAcrossNamespaces: (options: {
-            query: string;
-            namespaces?: string[];
-            maxResults?: number;
-            mode?: "search" | "hybrid" | "bm25" | "vector";
-        }) => Promise<QmdSearchResult[]>;
-        extractMemoryIdsFromResults: (results: QmdSearchResult[]) => string[];
-        namespaceFromPath: (p: string) => string;
-        storageForNamespace: (namespace: string) => Promise<StorageManager>;
-        getExtraction: () => ExtractionEngine;
-        storageDirNamespace?: (storageDir: string) => string;
-        getDependencyPropagationDelivery?: () => DependencyPropagationDeliveryPort;
-    });
-    /**
-     * Check if a new memory contradicts an existing one.
-     * Uses QMD to find similar memories, then LLM to verify contradiction.
-     */
-    checkForContradiction(content: string, category: string, namespaceScope: string, anchor?: {
-        entityRef?: string;
-        structuredAttributes?: Record<string, string>;
-        attributes?: Record<string, string>;
-        storageSnapshot?: MemoryFile[];
-    }): Promise<ContradictionResult | null>;
-    /**
-     * #1645: Complete the deferred contradiction auto-resolve after writeMemory
-     * returns and the new write's tombstone status is known. Retires the old
-     * memory + deindexes it ONLY when the new write is genuinely active (not
-     * tombstone-blocked / pending_review). A blocked write must not retire the
-     * only active copy — deferring here closes the "contradictionAutoResolve
-     * supersedes before tombstone status is known" defect class.
-     */
-    applyDeferredContradictionResolve(contradiction: ContradictionResolveTarget | null | undefined, storage: StorageManager, newMemoryId: string, postWriteGuard: boolean): Promise<ContradictionResolveOutcome>;
-    /**
-     * Suggest links for a new memory based on similar existing memories.
-     */
-    suggestLinksForMemory(content: string, category: string, namespaceScope: string): Promise<MemoryLink[]>;
-}
-
-/**
- * Derive issue #1955 origin metadata at the extraction boundary.
- */
-
-interface ExtractionSourceContext {
-    sessionKey?: string;
-    principal?: string;
-    validAt?: string;
-    sourceConnector?: string;
-    turnRole?: "user" | "assistant" | "tool" | string;
-    importAdapter?: string;
-    originConflict?: boolean;
-}
-
-declare function deriveTopicsFromExtraction(result: ExtractionResult): string[];
-interface ExtractionResilienceStatus {
-    breaker: {
-        state: "closed" | "open" | "half_open";
-        openUntilMs: number;
-        consecutiveFailures: number;
-        lastReason: string;
-    };
-    backoffFingerprintCount: number;
-}
-
-/**
- * Extraction-run coordinator — extracted from the orchestrator
- * (issue #1526, seam 15).
- *
- * Owns the buffer→extract→persist pipeline orchestration:
- *   - `runExtraction` — the main extraction pipeline coordinator
- *     (normalize → threshold gate → namespace resolve → dedupe
- *     fingerprint → extract → validate → persist → post-write hooks)
- *   - dedupe support: `shouldQueueExtraction`,
- *     `buildExtractionFingerprint`, `normalizeExtractionFingerprintTurns`
- *   - `recordProcessedExtractionFingerprint` — meta recording
- *
- * The orchestrator constructs one instance and delegates the extraction
- * run to it. `persistExtraction`, `maybeCapturePassiveCorrections`, and
- * all post-write side-effect helpers arrive as injectable delegates so
- * the orchestrator keeps ownership of cross-subsystem routing and the
- * behavior-critical chokepoints it hosts.
- *
- * Behavior-preserving move from orchestrator.ts. No logic changes — the
- * orchestrator keeps thin delegating methods so existing call sites
- * and tests that exercise the public API continue to work.
- */
-
-interface ExtractionRunResult {
-    status: "completed" | "skipped";
-    reason?: string;
-    persistedCount: number;
-    durableOutputCount: number;
-    postPersistMetadataFailed?: boolean;
-}
-/** Dependencies injected by the orchestrator. All stable references or
- *  live accessors — lazy getters for anything tests reassign
- *  post-construction (buffer, extraction, storageRouter, threading). */
-interface ExtractionRunCoordinatorDeps {
-    config: PluginConfig;
-    getBuffer: () => SmartBuffer;
-    getExtraction: () => Pick<ExtractionEngine, "extract">;
-    getStorageRouter: () => Pick<NamespaceStorageRouter, "storageFor">;
-    getThreading: () => Pick<ThreadingManager, "processTurn" | "updateThreadTitle">;
-    persistExtraction: (result: ExtractionResult, storage: StorageManager, threadIdForExtraction?: string | null, sourceContext?: ExtractionSourceContext, baseNamespace?: string, scopeProfileWritePlan?: ResolvedScopeProfilePlan | null, sourceText?: string, graphCaps?: GraphConstructionCapabilitySet, lifecycleCaps?: MemoryLifecycleCapabilitySet) => Promise<{
-        persistedIds: string[];
-        memoryPathById: Map<string, string>;
-    }>;
-    maybeCapturePassiveCorrections: (turns: readonly BufferTurn[], opts: {
-        sessionKey: string;
-        principal?: string;
-        namespace: string;
-        bufferKey: string;
-        isLiveSession: boolean;
-        abortSignal?: AbortSignal;
-    }) => Promise<void>;
-    resolveSelfNamespace: (sessionKey?: string) => string;
-    getCodingContextForSession: (sessionKey: string) => CodingContext | null;
-    applyCodingNamespaceOverlay: (sessionKey: string, namespace: string) => string;
-    boxBuilderFor: (storage: StorageManager) => Pick<BoxBuilder, "onExtraction">;
-    appendPersistedThreadEpisodes: (threadId: string, ids: string[]) => Promise<void>;
-    maybeScheduleConsolidation: (nonZero: boolean) => void;
-    requestQmdMaintenance: () => void;
-    runTierMigrationCycle: (storage: StorageManager, trigger: "extraction" | "maintenance" | "manual", options?: {
-        dryRun?: boolean;
-        limitOverride?: number;
-        force?: boolean;
-    }) => Promise<TierMigrationCycleSummary>;
-    getLastPersistExtractionDeferredCount: () => number;
-    recordProcessedExtractionFingerprint: (storage: StorageManager, fingerprint: string, preloadedMeta?: Awaited<ReturnType<StorageManager["loadMeta"]>>) => Promise<void>;
-}
-
-/**
- * Coordinates the extraction run pipeline. Holds the dedupe fingerprint
- * cache (`recentExtractionFingerprints`) and delegates all side effects
- * to injected orchestrator methods.
- */
-declare class ExtractionRunCoordinator {
-    private readonly deps;
-    private readonly recentExtractionFingerprints;
-    private readonly extractionRetryState;
-    private readonly hydratedRetryNamespaces;
-    private providerBreaker;
-    constructor(deps: ExtractionRunCoordinatorDeps);
-    private get config();
-    private latestSourceValidAtFromTurns;
-    normalizeExtractionFingerprintTurns(turns: BufferTurn[]): string[];
-    buildExtractionFingerprint(turns: BufferTurn[], bufferKey: string): string | null;
-    shouldQueueExtraction(turns: BufferTurn[], options?: {
-        commit?: boolean;
-        bufferKey?: string;
-    }): boolean;
-    recordProcessedExtractionFingerprint(storage: StorageManager, fingerprint: string, preloadedMeta?: Awaited<ReturnType<StorageManager["loadMeta"]>>): Promise<void>;
-    /** Lazily hydrate the in-memory retry-state mirror for a namespace from meta.
-     *  One-time per namespace per coordinator; the hot path is then a Map lookup.
-     *  Cross-process coherence: a fresh coordinator hydrates from the shared
-     *  meta.json, so a failure persisted by another process is honored here. */
-    private hydrateRetryStateFromMeta;
-    private logBreakerTransition;
-    /** True while the breaker suppresses non-forced attempts. Flips an expired
-     *  `open` breaker to `half_open`, which allows exactly one probe (the next
-     *  non-forced attempt) because the extraction queue is a serial drain. */
-    private isProviderBreakerOpen;
-    private onProviderFailure;
-    private resetProviderBreakerOnSuccess;
-    /** Rebuild `meta.extractionRetryState` from the in-memory namespace mirror,
-     *  bounded to the newest entries, and prune the mirror to match. */
-    private persistRetryStateToMeta;
-    /** Record an extraction failure into per-fingerprint backoff state + breaker,
-     *  persisting to namespace meta. Fail-open: never throws upward. */
-    private recordExtractionFailure;
-    /** Delete a fingerprint's retry entry from the mirror + meta. Returns whether
-     *  meta changed (so the caller can decide to persist). Does not touch the
-     *  breaker — callers pair this with `resetProviderBreakerOnSuccess`. */
-    private clearExtractionRetryEntry;
-    /** Live in-process resilience snapshot (breaker + backoff population). */
-    getExtractionResilienceStatus(): ExtractionResilienceStatus;
-    runExtraction(turns: BufferTurn[], options?: {
-        clearBufferAfterExtraction?: boolean;
-        clearMatchingTurns?: boolean;
-        skipCharThreshold?: boolean;
-        skipUserTurnThreshold?: boolean;
-        deadlineMs?: number;
-        bufferKey?: string;
-        abortSignal?: AbortSignal;
-        failOnExtractionFailure?: boolean;
-        /**
-         * Called immediately after durable extraction persistence returns, before
-         * any metadata, retention, or helper work. Lifecycle callers use this
-         * as the write-rate-limit commit boundary.
-         */
-        onDurableCommit?: () => void;
-        /**
-         * Explicit namespace override for the write path (#460).  When set, this
-         * is the namespace where extraction writes go instead of the one derived
-         * from `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))`.
-         * The resolved `principal` is still threaded into memory metadata for
-         * provenance; only the storage target is overridden.
-         */
-        writeNamespaceOverride?: string;
-        /**
-         * Pin the provenance principal instead of deriving it from
-         * `resolvePrincipal(sessionKey)`. When set, this is the identity an
-         * access surface already authenticated; used so observed-turn provenance
-         * is correct even though `turn.sessionKey` is the original key.
-         */
-        principalOverride?: string;
-        /**
-         * Access scope resolution may already have selected a profile while the
-         * session context remains intentionally unbound. Reuse that plan for
-         * persistence instead of deriving it from shared session state.
-         */
-        scopeProfileWritePlan?: ResolvedScopeProfilePlan | null;
-        /**
-         * Force the extractor call, bypassing the retry-backoff / circuit-breaker
-         * gate (extraction hot-loop hardening). Set by explicit flush paths.
-         */
-        forceExtractionAttempt?: boolean;
-    }): Promise<ExtractionRunResult>;
-}
-
-/**
- * Graph-recall coordinator — extracted from the orchestrator (issue #1526).
- *
- * Owns the graph-expansion subsystem in recall: spreading-activation
- * traversal from seed memories, seed-path resolution relative to
- * per-namespace storage, and the last-graph-recall snapshot persistence.
- * Behavior-preserving move from orchestrator.ts with bounded graph-state
- * lookups and optional path scoring. The orchestrator constructs one instance
- * and keeps thin delegating methods so existing call sites (recallInternal,
- * cold-fallback pipeline) continue to work.
- *
- * Config, storage, graph index, namespace resolution, and QMD result
- * resolution are accessed through getter callbacks (not captured at
- * construction) so that post-construction reassignment of the orchestrator's
- * live fields is honored. This mirrors the RecallRerankCoordinator /
- * ContradictionLinkingCoordinator accessor pattern.
- */
-
-interface GraphRecallRankedResult {
-    path: string;
-    score: number;
-    docid?: string;
-    sourceLabels: string[];
-}
-interface GraphRecallShadowComparison {
-    baselineCount: number;
-    graphCount: number;
-    overlapCount: number;
-    overlapRatio: number;
-    averageOverlapDelta: number;
-}
-interface GraphRecallExpansionOptions {
-    memoryResults: QmdSearchResult[];
-    recallNamespaces: string[];
-    recallResultLimit: number;
-    /** Query-time instant used for graph-path invalidity checks. */
-    asOf?: string;
-    asOfMs?: number;
-    deadlineAtMs?: number | null;
-    /** Issue #681 — when true, bypass graphTraversalConfidenceFloor. */
-    includeLowConfidence?: boolean;
-}
-interface GraphRecallExpansionResult {
-    merged: QmdSearchResult[];
-    seedPaths: string[];
-    expandedPaths: GraphRecallExpandedEntry[];
-    seedResults: QmdSearchResult[];
-}
-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 class GraphRecallCoordinator {
-    private readonly getConfig;
-    private readonly getStorage;
-    private readonly storageFor;
-    private readonly graphIndexFor;
-    private readonly namespaceFromPath;
-    private readonly resolveColdQmdResultForRecall;
-    private readonly storageForAbsoluteQmdResultPath;
-    private readonly readQmdResultMemory;
-    private readonly graphPathStateLoader;
-    constructor(options: {
-        getConfig: () => PluginConfig;
-        getStorage: () => StorageManager;
-        storageFor: (namespace: string) => Promise<StorageManager>;
-        graphIndexFor: (storage: StorageManager) => GraphIndex;
-        namespaceFromPath: (p: string) => string;
-        resolveColdQmdResultForRecall: (result: QmdSearchResult, fallbackStorage: StorageManager, recallNamespaces: readonly string[]) => Promise<{
-            namespace: string;
-            result: QmdSearchResult;
-        } | null>;
-        storageForAbsoluteQmdResultPath: (resultPath: string, fallbackStorage: StorageManager, recallNamespaces: readonly string[]) => Promise<{
-            storage: StorageManager;
-            dir: string;
-            namespace: string;
-        } | null>;
-        readQmdResultMemory: (resultPath: string, fallbackStorage: StorageManager, recallNamespaces: readonly string[], preferredNamespace?: string) => Promise<MemoryFile | null>;
-    });
-    expandResultsViaGraph(options: GraphRecallExpansionOptions): Promise<GraphRecallExpansionResult>;
-    recordLastGraphRecallSnapshot(options: {
-        storage: StorageManager;
-        prompt: string;
-        recallMode: RecallPlanMode;
-        recallNamespaces: string[];
-        seedPaths: string[];
-        expandedPaths: GraphRecallExpandedEntry[];
-        status: "completed" | "skipped" | "aborted";
-        reason?: string;
-        shadowMode?: boolean;
-        queryIntent: MemoryIntent;
-        seedResults?: GraphRecallRankedResult[];
-        finalResults?: GraphRecallRankedResult[];
-        shadowComparison?: GraphRecallShadowComparison;
-    }): Promise<void>;
-    private graphSeedPathRelativeToStorage;
-    private graphSeedPathsWithinDeadline;
-}
-
-/**
- * Turn-ingestion coordinator — extracted from the orchestrator
- * (issue #1526, seam 20).
- *
- * Owns the buffer-side entry points that feed the extraction pipeline:
- *   - processTurn (per-turn buffering + trigger-mode flush decisions)
- *   - observeSessionHeartbeat (heartbeat-driven extraction observer)
- *   - queueBufferedExtraction (dedupe-gated extraction queueing)
- *   - ingestReplayBatch / ingestBulkImportBatch (batch ingestion)
- *   - maybeCapturePassiveCorrections (passive correction capture)
- *
- * Behavior-preserving move from orchestrator.ts. The orchestrator keeps
- * thin delegating methods; every member the moved code consults flows
- * back through TurnIngestionDeps live accessors/arrows so prototype-call
- * tests (Orchestrator.prototype.processTurn.call(fake, …)) and instance
- * stubs keep working (same late-binding rule as seams 18/19).
- */
-
-/**
- * Options for {@link TurnIngestionCoordinator.processTurn}.
- * Extends {@link SourceConnectorProvenance} to thread trusted connector identity.
- */
-interface TurnIngestionOptions extends SourceConnectorProvenance {
-    bufferKey?: string;
-    logicalSessionKey?: string;
-    providerThreadId?: string | null;
-    turnFingerprint?: string;
-}
-
-/**
- * Recall-introspection coordinator — extracted from the orchestrator
- * (issue #1526, seam 21).
- *
- * Owns the recall observability surfaces:
- *   - last-intent / last-graph-recall / last-QMD-recall snapshot
- *     recording, reading, and explain rendering
- *   - console faithfulness distribution
- *   - background direct-answer tier annotation (observation mode, #518)
- *
- * Behavior-preserving move from orchestrator.ts. The orchestrator keeps
- * thin delegating methods; all member access flows back through
- * RecallIntrospectionDeps live accessors/arrows (late-binding rule,
- * seams 18–20).
- */
-
-interface RecallIntrospectionDeps {
-    annotateDirectAnswerTier(prompt: string, sessionKey: string, namespaces: string[], expectedIdentity: {
-        writeNonce?: string;
-        traceId?: string;
-        recordedAt?: string;
-    } | undefined, caps: CapabilitySet, _parentAbortSignal?: AbortSignal): Promise<void>;
-    readonly config: PluginConfig;
-    directAnswerObservationChain: Promise<void>;
-    effectiveCronRecallInstructionHeavyTokenCap(): number;
-    readonly faithfulnessCounters: FaithfulnessGateCounters;
-    getCodingContextForSession(sessionKey: string | undefined): CodingContext | null;
-    getStorage(namespace?: string): Promise<StorageManager>;
-    readonly graphRecallCoordinator: GraphRecallCoordinator;
-    readonly lastRecall: LastRecallStore;
-    trackRecallBackgroundWrite(promise: Promise<void>, label: string): void;
-    resolveStateDirForNamespace(namespace: string): Promise<string>;
-    readonly storageRouter: NamespaceStorageRouter;
-}
-declare class RecallIntrospectionCoordinator {
-    private readonly deps;
-    constructor(deps: RecallIntrospectionDeps);
-    /**
-     * Faithfulness gate verdict distribution (issue #1576). Consumed by the
-     * console-state aggregator so `remnic doctor` can render how the gate is
-     * performing. Returns a fresh object so callers cannot mutate the
-     * internal counters. Returns `undefined` when the gate is off so the
-     * console-state snapshot omits the faithfulness block entirely (cursor
-     * review: an all-zero block would otherwise always be truthy and leak
-     * into snapshots that document it as absent-when-off).
-     */
-    getConsoleFaithfulnessDistribution(): FaithfulnessGateCounters | undefined;
-    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>;
-    /**
-     * Await the in-flight observation-mode direct-answer annotation chain.
-     * Resolves to true when settled, false on timeout.
-     */
-    waitForDirectAnswerObservationIdle(timeoutMs?: number): Promise<boolean>;
-    enqueueDirectAnswerObservation(prompt: string, sessionKey: string, namespaceOverride: string | undefined, principalOverride: string | undefined, caps: CapabilitySet, namespacesEnabled: boolean): void;
-    annotateDirectAnswerTier(prompt: string, sessionKey: string, namespaces: string[], expectedIdentity: {
-        writeNonce?: string;
-        traceId?: string;
-        recordedAt?: string;
-    } | undefined, caps: CapabilitySet, _parentAbortSignal?: AbortSignal): Promise<void>;
-    recordLastGraphRecallSnapshot(options: {
-        storage: StorageManager;
-        prompt: string;
-        recallMode: RecallPlanMode;
-        recallNamespaces: string[];
-        seedPaths: string[];
-        expandedPaths: GraphRecallExpandedEntry[];
-        status: "completed" | "skipped" | "aborted";
-        reason?: string;
-        shadowMode?: boolean;
-        queryIntent: MemoryIntent;
-        seedResults?: GraphRecallRankedResult[];
-        finalResults?: GraphRecallRankedResult[];
-        shadowComparison?: GraphRecallShadowComparison;
-    }): Promise<void>;
-    recordLastIntentSnapshot(options: {
-        storage: StorageManager;
-        snapshot: IntentDebugSnapshot;
-    }): Promise<void>;
-    recordLastQmdRecallSnapshot(options: {
-        storage: StorageManager;
-        snapshot: QmdRecallSnapshot;
-    }): Promise<void>;
-    recordLastIntentSnapshotForNamespace(options: {
-        namespace: string;
-        snapshot: IntentDebugSnapshot;
-    }): Promise<void>;
-}
-
-/**
- * Session-context coordinator — extracted from the orchestrator
- * (issue #1526, seam 28).
- *
- * Owns per-session binding surfaces and session-facing service glue:
- *   - peer-id and coding-context bindings (incl. namespace overlay)
- *   - LCM read-namespace resolution for a session
- *   - session flush, passive-correction service construction
- *   - day-summary generation and deep-sleep governance triggers
- *
- * Behavior-preserving move (late-binding selfDeps wiring, seams 18–27).
- */
-
-interface SessionFlushOptions {
-    reason: string;
-    abortSignal?: AbortSignal;
-    bufferKey?: string;
-    clearMatchingTurns?: boolean;
-    extractionDeadlineMs?: number;
-    writeNamespaceOverride?: string;
-    /** Called at the first durable extraction commit in this flush. */
-    onCommitted?: () => void;
-    failOnExtractionFailure?: boolean;
-    /** Resolved profile plan from access scope resolution; avoids recomputing from shared session context. */
-    scopeProfileWritePlan?: ResolvedScopeProfilePlan | null;
-    principalOverride?: string;
-}
-
-/**
- * Orchestrator module-level helpers — relocated from orchestrator.ts
- * (issue #1526, seam 25).
- *
- * Pure functions, types, and constants that previously lived at module
- * level in orchestrator.ts: recall-mode planning, recall snapshots and
- * parsers, abort/race helpers, artifact recall limits, replay
- * source-time slicing, day-summary date utilities, and QMD startup
- * checks. orchestrator.ts re-exports the previously-public names so
- * every existing importer (coordinators, tests, root shims) keeps
- * working unchanged.
- *
- * Behavior-preserving move — no logic changes.
- */
-
-interface BulkImportBatchIngestResult {
-    attemptedTurnCount: number;
-    extractionCount: number;
-    persistedCount: number;
-    durableOutputCount: number;
-    skippedCount: number;
-    failedCount: number;
-    postPersistMetadataFailureCount: number;
-    processedTurnCount: number;
-}
-declare class BulkImportBatchPartialFailureError extends Error {
-    readonly partialResult: BulkImportBatchIngestResult;
-    readonly originalError: unknown;
-    constructor(message: string, partialResult: BulkImportBatchIngestResult, originalError: unknown);
-}
-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 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;
-    /**
-     * Where `plannedMode` came from (issue #1367 / Option C). `"heuristic"` for
-     * the regex planner; `"llm"` when the LLM planner classified it; and
-     * `"heuristic-fallback"` when the LLM was enabled but errored/timed out and we
-     * fell back. Absent on the synchronous heuristic-only path.
-     */
-    plannerSource?: "heuristic" | "llm" | "heuristic-fallback";
-    /** Short rationale from the planner (for telemetry / x-ray). */
-    plannerReason?: string;
-    /** Wall-clock spent in the LLM planner call, when one was made. */
-    plannerLatencyMs?: number;
-    /** True when the LLM planner was enabled but fell back to the heuristic. */
-    plannerFallbackUsed?: boolean;
-    /** Model that served the LLM classification, when one was used. */
-    plannerModelUsed?: string;
-    /**
-     * The regex-heuristic baseline mode, captured whenever the LLM planner ran
-     * (any source). Lets operators compare planned-vs-heuristic during rollout —
-     * distinct from `plannedMode`, which on the LLM path is the LLM's choice.
-     */
-    plannerHeuristicMode?: RecallPlanMode;
-    /**
-     * In shadow mode, the mode the LLM *would* have chosen (recorded for
-     * comparison) while `effectiveMode` stays on the heuristic decision.
-     */
-    shadowLlmMode?: RecallPlanMode;
-}
-/**
- * Map the orchestrator's internal `recallSource` strings to the
- * X-ray `servedBy` vocabulary (issue #570 PR 1).  The X-ray tier
- * ladder intentionally flattens QMD / embedding / cold-fallback to
- * the `hybrid` tier because they all materialize through the same
- * hybrid BM25+vector pipeline from the caller's perspective.  The
- * `recent_scan` path gets its own dedicated tier because it bypasses
- * the hybrid pipeline entirely.  `none` is treated as `hybrid` on the
- * theory that a query that returned nothing still routed through the
- * hybrid pipeline — but callers should normally gate capture on
- * `recalledMemoryIds.length > 0`.
- */
-declare function mapRecallSourceToXrayServedBy(source: "none" | "hot_qmd" | "hot_embedding" | "cold_fallback" | "recent_scan"): RecallXrayServedBy;
-interface RecallInvocationOptions {
-    namespace?: string;
-    topK?: number;
-    mode?: RecallPlanMode;
-    abortSignal?: AbortSignal;
-    /** Server-resolved identity of the connector performing this recall. */
-    sourceConnector?: string;
-    /**
-     * Capture a `RecallXraySnapshot` for this recall (issue #570).  When
-     * `true`, the orchestrator builds a snapshot from the data it has
-     * already gathered and stashes it in memory, accessible via
-     * `getLastXraySnapshot()`.  When `false` or absent, nothing is
-     * captured and recall behavior is unchanged (schema-only slice).
-     */
-    xrayCapture?: boolean;
-    /**
-     * Per-invocation override for `recallBudgetChars` (issue #570 PR 3/4).
-     * Flows through `getRecallBudgetChars()` for this recall only — no
-     * shared config mutation, so concurrent recalls on the same
-     * orchestrator are not affected (CLAUDE.md rule 47: no shared
-     * mutable state across async boundaries).  Must be a non-negative
-     * finite integer; non-conforming values are ignored and the
-     * configured budget is used.
-     */
-    budgetCharsOverride?: number;
-    /**
-     * Per-invocation principal override (issue #570 PR 4).  When set,
-     * the orchestrator uses this principal for ACL / namespace checks
-     * instead of `resolvePrincipal(sessionKey, config)`.  This is the
-     * escape hatch for access surfaces (HTTP / MCP) that have already
-     * authenticated the caller upstream — threading an unmapped
-     * principal through the session-key-based resolver would otherwise
-     * collapse it to `"default"` and produce false denials in
-     * namespace-enabled deployments (CLAUDE.md rule 42).
-     */
-    principalOverride?: string;
-    /**
-     * Historical recall point (issue #680).  When set, the orchestrator
-     * filters out memories whose `valid_at` is after this timestamp OR
-     * whose `invalid_at` is at-or-before this timestamp, so callers see
-     * the corpus as it existed at `asOf`.  ISO 8601 string; comparisons
-     * use `Date.parse()` so timezone-aware values round-trip correctly
-     * (CLAUDE.md gotcha — never compare ISO strings lexicographically).
-     * Invalid values must be rejected at input boundaries (CLAUDE.md
-     * rule 51); the orchestrator does NOT silently fall back here.
-     */
-    asOf?: string;
-    /**
-     * Issue #681 — when `true`, bypasses `graphTraversalConfidenceFloor`
-     * and includes edges below the floor in graph traversal.  Useful for
-     * diagnostic recall queries that need to surface results that would
-     * normally be pruned by confidence decay.  Default `false`.
-     */
-    includeLowConfidence?: boolean;
-    /**
-     * #1952 — per-call override enabling state-aware recall views for this
-     * recall only (MCP `stateView` boolean). ORs with the `recallStateViews`
-     * config flag; a change-intent query is still required for any effect.
-     */
-    stateView?: boolean;
-    /**
-     * User-aware context scopes active for this recall. Used by X-ray
-     * provenance safety checks so boundary-scoped memories are evaluated
-     * against the caller's real context.
-     */
-    currentContextScopes?: readonly unknown[];
-    /**
-     * Wall-clock ms the caller waited to begin execution — per-principal
-     * semaphore queue + single-flight wait (issue #1906). Folded into
-     * recall-timings additively as `queueWaitMs`; omitted phases are simply
-     * absent, so existing timing consumers are unaffected.
-     */
-    queueWaitMs?: number;
-    onContextComposition?: (composition: RecallContextComposition) => void | PromiseLike<void>;
-}
-type QueryAwarePrefilter = {
-    candidatePaths: Set<string> | null;
-    temporalFromDate: string | null;
-    matchedTags: string[];
-    expandedTags: string[];
-    combination: "none" | "temporal" | "tag" | "intersection" | "union";
-    filteredToFullSearch: boolean;
-};
-declare function throwIfRecallAborted(signal?: AbortSignal, message?: string): void;
-declare function raceRecallAbort<T>(promise: Promise<T>, signal?: AbortSignal, message?: string): Promise<T>;
-/** Maximum age (ms) before a compaction-reset signal file is considered stale and removed. */
-declare const COMPACTION_SIGNAL_MAX_AGE_MS: number;
-type DaySummaryGatherOptions = {
-    timeZone?: string;
-    now?: Date;
-    /** Opt-in location context (issue #2925); false/absent keeps output byte-identical. */
-    includeLocation?: boolean;
-};
-declare function normalizeIanaTimeZone(value: unknown): string | undefined;
-declare function formatDateInTimeZone(date: Date, timeZone: string): string;
-declare function utcDateKeysForLocalDay(date: Date, timeZone: string): string[];
-declare function parseFiniteDate(value: unknown): Date | null;
-declare function filterHourlySummaryMarkdownForLocalDay(raw: string, utcDate: string, timeZone: string, targetLocalDate: string): string | null;
-type SearchCollectionState = "present" | "missing" | "unknown" | "skipped";
-declare function qmdStartupCollectionCheckWithTimeout(promise: Promise<SearchCollectionState>, controller: AbortController, label: string): Promise<SearchCollectionState>;
-/** 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 targetSourceValidAtSortMs(turns: readonly BufferTurn[]): number;
-declare function splitTurnsBySourceValidAt(turns: readonly BufferTurn[], options?: {
-    includeContext?: boolean;
-}): BufferTurn[][];
-declare function isArtifactMemoryPath(filePath: string): boolean;
-declare function buildCompressionGuidelinesMarkdown(events: MemoryActionEvent[], generatedAtIso?: string): string;
-declare function applyQueryAwareCandidateFilter(candidates: QmdSearchResult[], candidatePaths: Set<string> | null): QmdSearchResult[];
-declare function tokenizeRecallQuery(prompt: string): string[];
-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;
-interface RecallModeGraphOptions {
-    plannerEnabled: boolean;
-    graphRecallEnabled: boolean;
-    multiGraphMemoryEnabled: boolean;
-    graphExpandedIntentEnabled?: boolean;
-    prompt: string;
-}
-declare function resolveRecallModeDecision(options: RecallModeGraphOptions): RecallModeDecision;
-/**
- * Async recall-mode decision with optional LLM-based planning (issue #1367 /
- * Option C). Falls back to the heuristic decision when the LLM planner is
- * disabled, in shadow mode, or unavailable/failed — so this is always safe to
- * await on the recall hot path. Provider-agnostic: the LLM call routes through
- * the gateway/fallback chain.
- *
- * `recallPlannerEnabled === false` keeps the legacy "always full" behavior and
- * skips the LLM entirely (the planner as a whole is off).
- */
-declare function resolveRecallModeDecisionAsync(options: RecallModeGraphOptions & {
-    config: PluginConfig;
-    /**
-     * Recall-operation capability gates (issue #1523). REQUIRED: the recall
-     * orchestrator always passes a resolved set — the LLM planner gate reads
-     * `caps.recallPlannerLlm`, never re-derives from config.
-     */
-    caps: CapabilitySet;
-    hints?: string[];
-    llm?: FallbackLlmClient;
-    signal?: AbortSignal;
-}): Promise<RecallModeDecision>;
-declare function computeArtifactCandidateFetchLimit(targetCount: number): number;
-declare function computeQmdHybridFetchLimit(recallFetchLimit: number, artifactsEnabled: boolean, maxArtifactRecall: number): number;
-declare function summarizeGraphShadowComparison(baseline: QmdSearchResult[], merged: QmdSearchResult[], topN: number): {
-    baselineCount: number;
-    graphCount: number;
-    overlapCount: number;
-    overlapRatio: number;
-    averageOverlapDelta: number;
-};
-declare function parseGraphRecallRankedResults(value: unknown): GraphRecallRankedResult[];
-declare function parseMemoryIntentSnapshot(value: unknown): MemoryIntent;
-declare function parseQmdRecallResults(value: unknown): QmdSearchResult[];
-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;
-
-interface QmdStartupCollectionCheckResult {
-    namespace: string;
-    state: SearchCollectionState;
-}
-/**
- * Bound the complete startup collection-check batch, not just each individual
- * check. This preserves service availability when a backend ignores an abort
- * signal or a check promise never settles: startup continues with fail-open
- * `unknown` states and the normal background retry path can repair search.
- */
-declare function qmdStartupCollectionChecksWithTimeout(checks: readonly Promise<QmdStartupCollectionCheckResult>[], namespaces: readonly string[], timeoutMs?: number): Promise<QmdStartupCollectionCheckResult[]>;
-
-type NamespaceMaintenanceJobName = string;
-type NamespaceMaintenanceSkipReason = "fanout_disabled" | "empty_root" | "branch_disabled" | "project_disabled" | "team_project_disabled" | "catalog_read_failed" | "unsafe_or_stale_root" | "budget_exhausted" | "lock_held" | "batch_lock_incomplete" | "throttled" | "job_failed";
-interface NamespaceMaintenanceCandidate {
-    namespace: string;
-    kind: NamespaceKind;
-    storageDir?: string;
-    source: "configured" | "catalog";
-    lastWriteAt?: string;
-    lastMaintenanceAt?: string;
-}
-interface NamespaceMaintenanceRunStatus {
-    namespace: string;
-    jobName: NamespaceMaintenanceJobName;
-    state: "ran" | "skipped" | "failed";
-    reason?: NamespaceMaintenanceSkipReason;
-    startedAt: string;
-    completedAt: string;
-    itemCount?: number;
-    error?: string;
-}
-interface NamespaceMaintenanceSummary {
-    jobName: NamespaceMaintenanceJobName;
-    generatedAt: string;
-    ran: number;
-    skipped: number;
-    failed: number;
-    statuses: NamespaceMaintenanceRunStatus[];
-}
-
-/**
- * Namespace maintenance fanout coordinator (issue #1500).
- *
- * Builds on the namespace-aware maintenance planner (#1499 / #1517) to fan out
- * the REMAINING background maintenance jobs — dreams, pattern reinforcement,
- * governance/lifecycle, contradiction scans, semantic/causal consolidation,
- * graph decay, fact archival, tier migration — across all maintained
- * namespaces.
- *
- * The planner (`namespace-planner.ts`) already handles namespace discovery
- * (configured + catalog), per-kind gating, cycle budgeting, per-job+namespace
- * locking, status recording, and catalog maintenance timestamps. QMD
- * maintenance was wired through it in #1517. This module standardizes the
- * per-job adapter pattern so every other maintenance job can be fanned out
- * with one call, and aggregates per-namespace health for doctor/dashboard.
- *
- * Design contract (issue #1500 compatibility requirements):
- * - Existing direct `runJob({ namespace })` calls continue to work unchanged.
- * - Namespaces disabled: fanout is a no-op (the planner returns only the
- *   default namespace; jobs run exactly as before).
- * - `maintenanceNamespaceFanoutEnabled: false`: fanout is a no-op.
- * - A failure in one namespace must not abort other namespaces (the planner
- *   already isolates per-namespace failures).
- * - Per-namespace locks prevent duplicate concurrent runs (planner-provided).
- */
-
-/**
- * Context passed to a fanout job runner. The runner receives the per-namespace
- * candidate (namespace name, kind, storage dir) and a storage resolver that
- * the orchestrator wires to `storageRouter.storageFor(namespace)`.
- *
- * The storage resolver is intentionally typed as `unknown` here so this module
- * does not depend on the `StorageManager` class — the orchestrator provides the
- * typed resolver. This keeps the fanout module free of orchestrator/storage
- * imports and unit-testable with a stub.
- */
-interface NamespaceMaintenanceFanoutRunnerContext {
-    config: PluginConfig;
-    candidate: NamespaceMaintenanceCandidate;
-    resolveStorage: (namespace: string) => Promise<unknown>;
-}
-interface NamespaceMaintenanceJobHealth {
-    jobName: string;
-    ran: number;
-    skipped: number;
-    failed: number;
-    lastRunAt: string | null;
-    namespaces: NamespaceMaintenanceRunStatus[];
-}
-interface NamespaceMaintenanceHealthSummary {
-    generatedAt: string;
-    fanoutEnabled: boolean;
-    namespacesEnabled: boolean;
-    maxNamespacesPerCycle: number;
-    jobs: NamespaceMaintenanceJobHealth[];
-    totalRan: number;
-    totalSkipped: number;
-    totalFailed: number;
-}
-
-declare class Orchestrator {
-    readonly storage: StorageManager;
-    private readonly storageRouter;
-    /** Rebuildable namespace catalog (issue #1499). Inert unless namespaces enabled. */
-    readonly namespaceCatalog: NamespaceCatalog;
-    private readonly namespaceStorageDirHints;
-    private namespaceStorageDirHintsLoaded;
-    private readonly namespaceSearchRouter;
-    qmd: SearchBackend;
-    /**
-     * Maintenance scheduler (issue #1526 PR1). Owns cron auto-registration,
-     * debounced QMD index maintenance, and consolidation scheduling. Job
-     * runners (consolidation/pattern-reinforcement/governance) stay here.
-     */
-    readonly maintenanceScheduler: MaintenanceScheduler;
-    private prioritizedEmbedding?;
-    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 judgeVerdictCache;
-    /**
-     * Per-orchestrator defer-counter map (issue #562, PR 2). Tracks how many
-     * times the judge has returned `"defer"` for a given candidate content
-     * hash so the defer cap can be enforced.
-     */
-    private readonly judgeDeferCounts;
-    /**
-     * Faithfulness gate distribution counters (issue #1576). Per-orchestrator
-     * running tally surfaced via console_state telemetry. No module-level state
-     * (rule 11) — these hang off the orchestrator instance.
-     */
-    private faithfulnessCounters;
-    /**
-     * Side-channel: number of facts deferred in the most recent
-     * `persistExtraction` call (issue #562, PR 2). The caller reads this after
-     * `persistExtraction` returns to decide whether to retain buffer turns for
-     * the next extraction pass. Not part of the return signature because many
-     * callers already destructure `persistedIds` by position.
-     */
-    private lastPersistExtractionDeferredCount;
-    /**
-     * Side-channel (#1635): pending_review persisted ids from the last
-     * persistExtraction; runExtraction excludes them from the thread episode set.
-     */
-    private lastPersistExtractionPendingReviewIds;
-    private readonly _fastGatewayLlm;
-    get fastGatewayLlm(): FallbackLlmClient | null;
-    getConsoleFaithfulnessDistribution(): FaithfulnessGateCounters | undefined;
-    readonly modelRegistry: ModelRegistry;
-    readonly relevance: RelevanceStore;
-    readonly negatives: NegativeExampleStore;
-    readonly lastRecall: LastRecallStore;
-    readonly handleHistory: RecallHandleHistoryStore;
-    readonly tierMigrationStatus: TierMigrationStatusStore;
-    readonly tierMigrationCoordinator: TierMigrationCoordinator;
-    readonly compressionGuidelineCoordinator: CompressionGuidelineCoordinator;
-    readonly semanticConsolidationCoordinator: SemanticConsolidationCoordinator;
-    readonly lifecyclePolicyCoordinator: LifecyclePolicyCoordinator;
-    readonly entitySynthesisCoordinator: EntitySynthesisCoordinator;
-    /**
-     * In-memory X-ray snapshot from the most recent `recall()` call that
-     * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
-     * per-process; later slices add CLI/HTTP/MCP surfaces that consume
-     * this via the shared renderer.  `null` until the first capture, and
-     * NEVER overwritten by a recall that did not request capture —
-     * requests without the flag leave prior captures intact so the
-     * capturing caller can still read their snapshot back.
-     */
-    private lastXraySnapshot;
-    /** Per-instance ordering domain for every writer of `lastXraySnapshot`. */
-    private readonly xrayCaptureQueue;
-    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 selections keyed by sessionKey.
-     * Set by the before_prompt_build 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;
-    /**
-     * Per-session coding-agent context (issue #569). Populated by connectors at
-     * session-start (PRs 5/6/7) via `setCodingContextForSession`. Used by both
-     * the recall path and the write path so that memory routing respects the
-     * project/branch scope a session is operating in (rule 42 — read + write
-     * through the same namespace layer).
-     */
-    private _codingContextBySession;
-    /**
-     * Per-session peer ID registry (issue #679 PR 3/5).
-     * Set by connectors / hooks via `setPeerIdForSession` so `recallInternal`
-     * can inject the peer's profile into recall context when
-     * `peerProfileRecallEnabled` is true. Cleared when the session ends.
-     * Keyed by sessionKey so concurrent sessions don't clobber each other
-     * (rule 11 — scope globals per plugin ID / session).
-     */
-    private _peerIdBySession;
-    /**
-     * Defensive init for the session-binding maps (issue #1526 seam 28
-     * review). `Object.create(Orchestrator.prototype)` stubs in legacy
-     * tests skip class-field initializers, so the maps may be undefined on
-     * fakes; SessionContextCoordinator calls this before writing so the
-     * maps are created ON THE ORCHESTRATOR (or fake), never on the
-     * coordinator.
-     */
-    ensureSessionBindingMaps(): void;
-    private routingRulesStore;
-    private contentHashIndex;
-    private readonly contentHashIndexesByStorageDir;
-    private readonly artifactSourceStatusCache;
-    private accessTrackingBuffer;
-    private passiveCorrectionDedup;
-    private _passiveCorrectionService;
-    private passiveCorrectionTelemetry;
-    private _dependencyPropagationDelivery;
-    private _dependencyPropagationRecovery;
-    private destroyed;
-    private get dependencyPropagationDelivery();
-    readonly extractionQueueCoordinator: ExtractionQueueCoordinator;
-    private _extractionRunCoordinator;
-    private get extractionRunCoordinator();
-    private _consolidationRunCoordinator;
-    private get consolidationRunCoordinator();
-    private _extractionPersistCoordinator;
-    private get extractionPersistCoordinator();
-    /**
-     * Issue #1526: recall result formatting + identity continuity section moved
-     * to RecallResultFormatter.
-     */
-    readonly recallResultFormatter: RecallResultFormatter;
-    /**
-     * Issue #1526: conversation-index subsystem moved to
-     * ConversationIndexCoordinator.
-     */
-    readonly conversationIndexCoordinator: ConversationIndexCoordinator;
-    readonly recallRerankCoordinator: RecallRerankCoordinator;
-    readonly recallSectionCoordinator: RecallSectionCoordinator;
-    readonly qmdResultResolver: QmdResultResolver;
-    readonly contradictionLinkingCoordinator: ContradictionLinkingCoordinator;
-    readonly graphRecallCoordinator: GraphRecallCoordinator;
-    private heartbeatObserverChains;
-    private recentExtractionFingerprints;
-    private readonly consolidationObservers;
-    private readonly wearablesServiceByNamespace;
-    private readonly meetingsServiceByNamespace;
-    private wearablesAutoSyncHandle;
-    private lastQmdReprobeAtMs;
-    private lastFileHygieneRunAtMs;
-    private lastPatternReinforcementAtByNs;
-    private lastRecallFailureLogAtMs;
-    private lastRecallFailureAtMs;
-    private suppressedRecallFailures;
-    private readonly policyRuntime;
-    private runtimePolicyValues;
-    private utilityRuntimeValues;
-    private evalShadowWriteChain;
-    private directAnswerObservationChain;
-    private initPromise;
-    private resolveInit;
-    /**
-     * Resolves when deferred initialization (QMD probe, warmup, caches, cron)
-     * completes. CLI and http-serve callers that need `qmd.isAvailable()` to
-     * reflect reality should `await orchestrator.deferredReady` after
-     * `initialize()`. Gateway callers can ignore it — recall() degrades
-     * gracefully when QMD isn't ready yet.
-     *
-     * Also resolves (without error) when `initialize()` throws before reaching
-     * the deferred-init phase, so callers never hang on a permanently-pending
-     * promise.
-     *
-     * Host adapters that need to tie deferred init to their stop() lifecycle
-     * should `await orchestrator.deferredReady` before proceeding with teardown
-     * to prevent background QMD/warmup/cron tasks from racing with shutdown.
-     */
-    deferredReady: Promise<void>;
-    private resolveDeferredReady;
-    private deferredInitAbort;
-    /**
-     * Whether the deferred init's QMD startup sync completed successfully.
-     * When false after deferredReady resolves, the server retry loop should
-     * attempt startupSearchSync() even if `qmd.isAvailable()` is true —
-     * availability only means probe succeeded, not that the index is current.
-     */
-    deferredSyncSucceeded: boolean;
-    /**
-     * Abort deferred initialization so background QMD sync/warmup stops
-     * promptly on shutdown. Safe to call multiple times or before init.
-     */
-    abortDeferredInit(): void;
-    disposeSearchBackendIfNeeded(): Promise<void>;
-    /** Track a recall-side write so destroy() can wait for it before teardown. @internal */
-    trackRecallBackgroundWrite(promise: Promise<void>, label: string): void;
-    /**
-     * Stop background initialization and release runtime-owned handles.
-     * Long-lived hosts should call this from their shutdown path; one-shot
-     * commands should call it before returning to let Node exit naturally.
-     */
-    destroy(): Promise<void>;
-    /** Set per-session workspace for the next recall() call (compaction reset). @internal */
-    setRecallWorkspaceOverride(sessionKey: string, dir: string): void;
-    /** Remove a per-session workspace selection (cleanup on error or early return). @internal */
-    clearRecallWorkspaceOverride(sessionKey: string): void;
-    resolvePrincipal(sessionKey?: string): string | undefined;
-    resolveSelfNamespace(sessionKey?: string): string;
-    private lcmReadNamespaceForSession;
-    setCodingContextForSession(sessionKey: string, codingContext: CodingContext | null): void;
-    getCodingContextForSession(sessionKey: string | undefined): CodingContext | null;
-    applyCodingNamespaceOverlay(sessionKey: string | undefined, baseNamespace: string): string;
-    setPeerIdForSession(sessionKey: string, peerId: string | null): void;
-    getPeerIdForSession(sessionKey: string | undefined): string | null;
-    /**
-     * Read-side overlay: returns the list of namespaces a session should read
-     * from, including any read fallbacks (branch → project, global root).
-     *
-     * Returns `null` when:
-     *   - `namespacesEnabled` is false (overlay would create false isolation)
-     *   - no context attached to the session
-     *   - `codingMode.projectScope` is false (CLAUDE.md #30 escape hatch)
-     *
-     * The returned `namespace` / `readFallbacks` are RAW overlay fragments
-     * (e.g. `project-origin-ab12`). Callers MUST combine them with the
-     * principal-derived base through `combineNamespaces()` before passing to
-     * storage, so principal isolation is preserved (rule 42).
-     *
-     * @internal
-     */
-    applyCodingRecallOverlay(sessionKey: string | undefined): {
-        namespace: string;
-        readFallbacks: string[];
-    } | null;
-    getStorageForNamespace(namespace?: string): Promise<StorageManager>;
-    filterPrivateSearchResults: (results: QmdSearchResult[], namespaces?: readonly string[], preserveUnresolved?: boolean, visibilityCache?: Map<string, boolean>) => Promise<QmdSearchResult[]>;
-    private configuredNamespaceList;
-    private rememberNamespaceStorageDirHint;
-    private storageDirMatchesNamespaceHint;
-    private namespaceStorageDirHintOwnershipRank;
-    private preferNamespaceStorageDirHintOwner;
-    private loadNamespaceStorageDirHintsFromCatalog;
-    private maintenanceNamespaces;
-    /**
-     * Fan out a maintenance job across all maintained namespaces (issue #1500).
-     *
-     * Delegates to the namespace-maintenance-fanout coordinator, which plans
-     * namespace discovery (configured + catalog), applies the cycle budget,
-     * acquires per-job+namespace locks, records status files, and touches the
-     * catalog's `lastMaintenanceAt`. The runner receives a per-namespace
-     * candidate and a storage resolver wired to `this.getStorage(namespace)`.
-     *
-     * When namespaces are disabled the planner returns only the default
-     * namespace, so the job runs exactly once — preserving single-user behavior.
-     */
-    runNamespaceMaintenanceFanoutForJob(jobName: string, runner: (ctx: NamespaceMaintenanceFanoutRunnerContext) => Promise<{
-        itemCount?: number;
-    } | undefined>, options?: {
-        enabled?: boolean;
-    }): Promise<NamespaceMaintenanceSummary>;
-    /**
-     * Read-only namespace maintenance health summary for doctor / dashboard /
-     * CLI (issue #1500). Aggregates all per-namespace maintenance status files
-     * into one report without running any maintenance.
-     */
-    readNamespaceMaintenanceHealth(): Promise<NamespaceMaintenanceHealthSummary>;
-    private buildConfiguredQmdSearchOptions;
-    searchAcrossNamespaces(options: {
-        query: string;
-        namespaces?: string[];
-        maxResults?: number;
-        mode?: "search" | "hybrid" | "bm25" | "vector";
-        searchOptions?: SearchQueryOptions;
-        execution?: SearchExecutionOptions;
-    }): Promise<QmdSearchResult[]>;
-    searchHealthForNamespace(namespace: string, execution?: SearchExecutionOptions): Promise<NamespaceSearchHealth>;
-    refreshNamespacesAfterConvergence(namespaces: readonly string[]): Promise<void>;
-    invalidateLiveContentHashIndex(): void;
-    private contentHashIndexForStorage;
-    private hasContentHashDedup;
-    private addContentHashDedup;
-    private removeContentHashForMemory;
-    private backfillTemporalBoundsOnDedupHit;
-    private saveContentHashIndexes;
-    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 completion through the gateway when configured, otherwise 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>;
-    };
-    /**
-     * Build a briefing follow-up generator backed by the configured LLM chain
-     * (gateway model source or local LLM). Returns `undefined` when no chain
-     * is available so `buildBriefing` can surface a clear unavailable reason
-     * instead of failing at call time. Used by the access service and CLI as
-     * the fallback when no direct `openaiApiKey` is configured, so briefing
-     * follow-ups ride the same routing as every other fast-tier LLM feature.
-     */
-    get briefingChainFollowupGenerator(): BriefingFollowupGenerator | undefined;
-    initialize(): Promise<void>;
-    private deferredInitialize;
-    startupSearchSync(signal?: AbortSignal): Promise<boolean>;
-    runPatternReinforcement(options?: {
-        force?: boolean;
-        namespace?: string;
-    }): Promise<{
-        ran: boolean;
-        skippedReason?: "disabled" | "cadence";
-        namespace: string;
-        result?: PatternReinforcementResult;
-    }>;
-    runPatternReinforcementFanout(options?: {
-        force?: boolean;
-    }): Promise<NamespaceMaintenanceSummary>;
-    /**
-     * Fan out lifecycle/governance policy across all maintained namespaces
-     * (issue #1500). Each namespace gets its own lifecycle pass against its
-     * namespace-scoped storage. When namespaces are disabled, runs once against
-     * default storage.
-     */
-    runLifecyclePolicyFanout(): Promise<NamespaceMaintenanceSummary>;
-    /**
-     * Fan out semantic consolidation across all maintained namespaces (issue #1500).
-     * Each namespace gets its own consolidation pass against its namespace-scoped
-     * storage. When namespaces are disabled, runs once against default storage.
-     */
-    runSemanticConsolidationFanout(options?: {
-        dryRun?: boolean;
-    }): Promise<NamespaceMaintenanceSummary>;
-    /**
-     * Fan out deep-sleep governance across all maintained namespaces (issue #1500).
-     * Each namespace gets its own governance scan against its namespace-scoped
-     * storage. When namespaces are disabled, runs once against default storage.
-     */
-    runDeepSleepGovernanceFanout(options?: {
-        dryRun?: boolean;
-    }): Promise<NamespaceMaintenanceSummary>;
-    runLiveConnectors(options?: {
-        force?: boolean;
-        abortSignal?: AbortSignal;
-    }): Promise<LiveConnectorsRunSummary>;
-    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;
-    }>;
-    reindexMemoryById(id: string, options?: {
-        storage?: StorageManager;
-    }): Promise<void>;
-    registerConsolidationObserver(observer: (observation: ConsolidationObservation) => Promise<void> | void): () => void;
-    runSemanticConsolidationNow(options?: {
-        dryRun?: boolean;
-        thresholdOverride?: number;
-        storage?: StorageManager;
-    }): Promise<SemanticConsolidationResult>;
-    runDeepSleepGovernanceNow(options?: {
-        dryRun?: boolean;
-        storage?: StorageManager;
-    }): Promise<{
-        scannedMemories: number;
-        appliedActionCount: number;
-        notes?: string;
-    }>;
-    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, options?: DaySummaryGatherOptions): Promise<DaySummaryResult | null>;
-    gatherTodayFacts(namespace?: string, options?: DaySummaryGatherOptions): Promise<string>;
-    previewMemoryActionEvent(event: Omit<MemoryActionEvent, "timestamp"> & {
-        timestamp?: string;
-    }): MemoryActionEvent;
-    appendMemoryActionEvent(event: Omit<MemoryActionEvent, "timestamp"> & {
-        timestamp?: string;
-    }): Promise<boolean>;
-    private searchConversationRecallResults;
-    private formatConversationRecallSection;
-    getRecoverySummary(sessionKey?: string): Promise<{
-        generatedAt: string;
-        sessionKey?: string;
-        healthy: boolean;
-        issueCount: number;
-        incompleteTurns: number;
-        brokenChains: number;
-        checkpointHealthy: boolean;
-    }>;
-    private validateLocalLlmModel;
-    private invokeRecall;
-    recall(prompt: string, sessionKey?: string, options?: RecallInvocationOptions): Promise<string>;
-    /**
-     * Return the most recent X-ray snapshot captured during a recall.
-     * Returns `null` when no such capture has occurred on this
-     * orchestrator instance.  Returned snapshot is a deep copy so
-     * caller mutation cannot tear the stored value.
-     *
-     * @deprecated Reading this after a separate `recall()` is not atomic. Use
-     * `recallWithXrayCapture()` when the snapshot must belong to that call.
-     */
-    getLastXraySnapshot(): RecallXraySnapshot | null;
-    /**
-     * Clear the captured X-ray snapshot. Exposed for tests / explicit reset.
-     *
-     * @deprecated A separate clear → recall → get sequence is not atomic. Use
-     * `recallWithXrayCapture()` for capture operations.
-     */
-    clearLastXraySnapshot(): void;
-    /** Atomically run recall and return the cloned X-ray snapshot it published. */
-    recallWithXrayCapture(prompt: string, sessionKey?: string, options?: Omit<RecallInvocationOptions, "xrayCapture">): Promise<{
-        result: string;
-        snapshot: RecallXraySnapshot | null;
-        recallStartedAt: number;
-    }>;
-    private runRecallWithXrayCapture;
-    waitForDirectAnswerObservationIdle(timeoutMs?: number): Promise<boolean>;
-    private enqueueDirectAnswerObservation;
-    private annotateDirectAnswerTier;
-    private logRecallFailure;
-    private artifactTypeForCategory;
-    private truncateArtifactForRecall;
-    private fetchActiveArtifactsForNamespace;
-    private recallArtifactsAcrossNamespaces;
-    private scopeQueryAwarePaths;
-    private buildQueryAwarePrefilter;
-    private searchScopedMemoryCandidates;
-    private fetchQmdMemoryResultsWithArtifactTopUp;
-    expandResultsViaGraph(options: GraphRecallExpansionOptions): Promise<GraphRecallExpansionResult>;
-    private recordLastGraphRecallSnapshot;
-    private recordLastIntentSnapshot;
-    private recordLastQmdRecallSnapshot;
-    private recordLastIntentSnapshotForNamespace;
-    private resolveStateDirForNamespace;
-    private buildGraphRecallRankedResults;
-    private getRecallSectionEntry;
-    private isRecallSectionEnabled;
-    private isSpecializedRecallSectionEnabled;
-    private getRecallSectionMaxChars;
-    private getRecallSectionNumber;
-    private appendRecallSection;
-    private truncateRecallSectionToBudget;
-    private getRecallBudgetChars;
-    private assembleRecallSections;
-    /**
-     * Clock source for the shared post-retrieval assembly/enrichment budget. The
-     * deadline is set from this value and every expiry check reads it back, so a
-     * test can drive the budget deterministically instead of racing the few-ms
-     * wall-clock window that made the "skips … after budget expires" tests flaky.
-     * Production behavior is unchanged — it returns the wall clock.
-     */
-    protected recallAssemblyClockMs(): number;
-    /**
-     * Recall-internal coordinator (issue #1526 seam 18). Owns the full
-     * `recallInternal` assembly pipeline. Lazy: created on first access so
-     * Object.create(prototype) tests that set fields post-construction work,
-     * and so subclass/test overrides of orchestrator members (e.g. the
-     * `recallAssemblyClockMs` clock seam) are observed live via accessors.
-     */
-    private _recallInternalCoordinator;
-    private get recallInternalCoordinator();
-    /**
-     * Recall search-pipeline coordinator (issue #1526 seam 19). Owns QMD
-     * search post-processing (prefilter, fallbacks, safety filter, boost).
-     * Lazy + accessor-wired for the same reasons as seam 18: instance-level
-     * test overrides of orchestrator members must stay live.
-     */
-    private _recallSearchPipelineCoordinator;
-    private get recallSearchPipelineCoordinator();
-    /**
-     * Turn-ingestion coordinator (issue #1526 seam 20). Owns the buffer-side
-     * extraction entry points. Lazy + accessor-wired so prototype-call tests
-     * and instance-level stubs stay live (same rule as seams 18/19).
-     */
-    private _turnIngestionCoordinator;
-    private get turnIngestionCoordinator();
-    /**
-     * Recall-introspection coordinator (issue #1526 seam 21). Owns the
-     * last-recall snapshot/explain surfaces and direct-answer annotation.
-     * Lazy + accessor-wired (late-binding rule, seams 18–20).
-     */
-    private _recallIntrospectionCoordinator;
-    get recallIntrospection(): RecallIntrospectionCoordinator;
-    /**
-     * Orchestrator-init coordinator (issue #1526 seam 22). Owns
-     * initialize/deferredInitialize/startupSearchSync. Lazy + accessor-wired
-     * (late-binding rule, seams 18–21); the init gate fields stay on the
-     * orchestrator and are mutated through set accessors.
-     */
-    private _orchestratorInitCoordinator;
-    private get orchestratorInitCoordinator();
-    /**
-     * Persistence-index coordinator (issue #1526 seam 23). Owns post-persist
-     * bookkeeping (content-hash dedup, temporal indexes, graph edges,
-     * semantic dedup lookup). Lazy + accessor-wired (late-binding rule).
-     */
-    private _persistenceIndexCoordinator;
-    private get persistenceIndexCoordinator();
-    /**
-     * Workspace-ops coordinator (issue #1526 seam 24). Owns periodic
-     * workspace/operations surfaces. Lazy + accessor-wired (late-binding
-     * rule, seams 18–23).
-     */
-    private _workspaceOpsCoordinator;
-    private get workspaceOpsCoordinator();
-    /**
-     * Namespace read-fanout coordinator (issue #1526 seam 26). Owns
-     * namespace-scoped read fanout (hints, cross-namespace search/reads,
-     * artifact statuses). Lazy + accessor-wired (late-binding rule).
-     */
-    private _namespaceReadFanoutCoordinator;
-    private get namespaceReadFanoutCoordinator();
-    /** RecallEntryCoordinator (issue #1526 seam 28). Lazy; selfDeps live wiring. */
-    private _recallEntryCoordinator;
-    private get recallEntryCoordinator();
-    /** SessionContextCoordinator (issue #1526 seam 28). Lazy; selfDeps live wiring. */
-    private _sessionContextCoordinator;
-    /**
-     * Self-handle read through the selfDeps proxy (seam 28): coordinators
-     * that construct services against the orchestrator instance (e.g. the
-     * passive-correction CorrectionService) receive it via deps instead of
-     * capturing the coordinator's own `this`.
-     */
-    get orchestratorSelf(): Orchestrator;
-    private get sessionContextCoordinator();
-    private recallInternal;
-    processTurn(role: "user" | "assistant", content: string, sessionKey?: string, options?: TurnIngestionOptions & {
-        persistProcessedFingerprint?: boolean;
-    }): Promise<void>;
-    flushSession(sessionKey: string, options: SessionFlushOptions): Promise<void>;
-    ingestReplayBatch(turns: ReplayTurn[], options?: {
-        deadlineMs?: number;
-        archiveLcm?: boolean;
-        abortSignal?: AbortSignal;
-        /**
-         * Pin extraction writes to this namespace instead of deriving one from
-         * `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))` + the
-         * coding overlay (#1495). The access `observe` surface resolves a single
-         * effective scope plan and passes its `writeNamespace` here so the
-         * extracted memories land in the SAME namespace as LCM archival,
-         * objective-state snapshots, and project-scoped recall — without relying
-         * on re-deriving the namespace from a namespace-prefixed session key.
-         * Same hook bulk-import uses (#460).
-         */
-        writeNamespaceOverride?: string;
-        /**
-         * Pin the provenance PRINCIPAL instead of deriving it from
-         * `resolvePrincipal(turn.sessionKey)` (#1495 thread 1). The access
-         * `observe` surface authenticates the caller at the transport layer and
-         * passes its resolved principal here so extracted-memory provenance uses
-         * the SAME identity the surface authorized — independent of storage
-         * routing (`writeNamespaceOverride`) and of whatever `resolvePrincipal`
-         * would parse from the raw session key. Mirrors the recall path's
-         * `principalOverride` (issue #570 PR 4).
-         */
-        principalOverride?: string;
-        /** Persist the authenticated session owner on buffered turns. */
-        sessionOwnerPrincipal?: string;
-    }): Promise<void>;
-    /**
-     * Return the namespace that `ingestBulkImportBatch` writes into (#460).
-     *
-     * Exposed so host CLIs can snapshot the same storage root that extraction
-     * actually writes to, avoiding the "CLI counts files at namespace A while
-     * writes land in namespace B" footgun that a naïve
-     * `config.defaultNamespace` snapshot could hit when a namespace policy
-     * named `"default"` also exists.
-     *
-     * Today bulk-import is pinned to `config.defaultNamespace`; future
-     * per-invocation namespace routing would thread an explicit target here
-     * and through `ingestBulkImportBatch`.
-     */
-    bulkImportWriteNamespace(): string;
-    getWearablesService(namespace?: string): WearablesService;
-    getMeetingsService(namespace?: string): Promise<MeetingsService>;
-    ingestBulkImportBatch(turns: ImportTurn[], options?: {
-        deadlineMs?: number;
-        failOnExtractionFailure?: boolean;
-        includeSourceValidAtContext?: boolean;
-    }): Promise<BulkImportBatchIngestResult>;
-    observeSessionHeartbeat(sessionKey: string, options?: {
-        bufferKey?: string;
-    }): Promise<void>;
-    private queueBufferedExtraction;
-    private normalizeExtractionFingerprintTurns;
-    private buildExtractionFingerprint;
-    private shouldQueueExtraction;
-    private maybeCapturePassiveCorrections;
-    private passiveCorrectionService;
-    runExtraction(...args: Parameters<ExtractionRunCoordinator["runExtraction"]>): Promise<ExtractionRunResult>;
-    /** Live extraction resilience snapshot (provider circuit breaker + per-
-     *  fingerprint backoff population) for status/doctor surfaces. */
-    getExtractionResilienceStatus(): ExtractionResilienceStatus;
-    private recordProcessedExtractionFingerprint;
-    private runTierMigrationCycle;
-    private maybeScheduleConsolidation;
-    requestQmdMaintenance(): void;
-    /**
-     * Public entrypoint for tool-driven QMD maintenance requests.
-     * Delegates to the maintenance scheduler (issue #1526 PR1).
-     */
-    requestQmdMaintenanceForTool(reason: string): void;
-    persistExtraction(result: ExtractionResult, storage: StorageManager, threadIdForExtraction?: string | null, sourceContext?: ExtractionSourceContext, baseNamespace?: string, scopeProfileWritePlan?: ResolvedScopeProfilePlan | null, 
-    /** Verbatim source turn text the facts were extracted from (faithfulness gate #1576). */
-    sourceText?: string, graphCaps?: GraphConstructionCapabilitySet, lifecycleCaps?: MemoryLifecycleCapabilitySet): Promise<{
-        persistedIds: string[];
-        memoryPathById: Map<string, string>;
-    }>;
-    /**
-     * Append persisted ids to the thread episode set, excluding pending_review
-     * fact ids (#1635) so they don't re-seed predecessor edges. Fail-open like
-     * the raw appendEpisodeIds call it replaces.
-     */
-    private appendPersistedThreadEpisodes;
-    private indexPersistedMemory;
-    /** Delegation wrapper so the persist wiring and root-test stubs route through `this` (#2813 CI-0). */
-    private buildGraphEdge;
-    private graphIndexFor;
-    private updateTemporalTagIndexes;
-    /** IDs of facts persisted in the last extraction */
-    private lastPersistedIds;
-    private runConsolidation;
-    private buildCompressionGuidelineRecallSection;
-    runLifecyclePolicyNow(storage?: StorageManager): Promise<{
-        memoriesAssessed: number;
-    }>;
-    private runLifecyclePolicyPass;
-    /**
-     * Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated.
-     * Read by WorkspaceOpsCoordinator (seam 24) via `Orchestrator.…`, hence
-     * not `private`.
-     */
-    static readonly IDENTITY_CONSOLIDATE_THRESHOLD = 8000;
-    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 readQmdResultMemory;
-    private resolveColdQmdResultForRecall;
-    private storageForAbsoluteQmdResultPath;
-    private applyMemoryWorthRerank;
-    private applyTrustScoreRerank;
-    private applyTrustScoreToBranch;
-    private diversifyAndLimitRecallResults;
-    private applyMmrToQmdResults;
-    private buildLastRecallBudgetSummary;
-    private collectLastRecallSources;
-    semanticDedupLookup(content: string, limit: number, targetStorage: StorageManager): Promise<SemanticDedupHit[]>;
-    /**
-     * Resolve the namespace-scoped filter to pass into
-     * `EmbeddingFallback.search()` for semantic dedup. Returns an empty
-     * object (no filter) when namespaces are disabled, preserving the
-     * pre-PR #399 behavior for single-tenant installs.
-     *
-     * Index entries are stored as paths relative to `config.memoryDir`, so:
-     *   - A non-default namespace `ns` lives under `namespaces/<ns>/…` and
-     *     we include exactly that prefix.
-     *   - The default namespace may live at `memoryDir` root (legacy) or at
-     *     `memoryDir/namespaces/<default>/…` (migrated). When it lives at
-     *     root we include everything but EXCLUDE all `namespaces/…` entries
-     *     so facts from non-default namespaces can't cross-match.
-     */
-    private semanticDedupScopeFor;
-    private searchEmbeddingFallback;
-    private searchQueryAwareFallback;
-    private applyColdFallbackPipeline;
-    /**
-     * Record that memories were accessed (retrieved).
-     * Updates are batched in memory and flushed during consolidation.
-     */
-    trackMemoryAccess(memoryIds: string[], memoryPaths?: string[], memoryNamespaces?: Array<string | undefined>): void;
-    flushAccessTracking(): Promise<void>;
-    private loadSearchResultMemoryMap;
-    private filterSearchResultsByRecallSafety;
-    private filterSearchResultsForRecall;
-    private boostSearchResults;
-    private extractMemoryIdsFromResults;
-    recordMemoryFeedback(memoryId: string, vote: "up" | "down", note?: string): Promise<void>;
-    recordNotUsefulMemories(memoryIds: string[], note?: string): Promise<void>;
-    getLastRecall(sessionKey: string): LastRecallSnapshot | null;
-    drainPendingRecallImpressions(): Promise<DrainPendingImpressionsResult>;
-    /**
-     * Issue #1582 — resolve a memory handle (`[m:4f2a]` / bare hex) to its memory
-     * id against THIS session's recent recall history. Returns the id on a unique
-     * hit, `null` on a miss, and throws on ambiguity (callers must disambiguate —
-     * rule 34/51). Resolution is per-session and snapshot-scoped; there is no
-     * global handle→id map (rule 42).
-     */
-    resolveMemoryHandle(handle: string, sessionKey: string): string | null;
-    /**
-     * Issue #1582 — resolve a caller reference that may be EITHER a memory id or
-     * a handle to a concrete memory id. Handles resolve against the session's
-     * recall history; raw ids pass through unchanged. The single shared helper
-     * every surface (memory_get / feedback / outcome / correction targetIds)
-     * calls so handle resolution has one path (rule 22).
-     */
-    resolveMemoryIdOrHandle(ref: string, sessionKey?: string): string;
-    /**
-     * Check if a new memory contradicts an existing one.
-     * Uses QMD to find similar memories, then LLM to verify contradiction.
-     */
-    private checkForContradiction;
-    /**
-     * #1645: Complete the deferred contradiction auto-resolve after writeMemory
-     * returns and the new write's tombstone status is known. Retires the old
-     * memory + deindexes it ONLY when the new write is genuinely active (not
-     * tombstone-blocked / pending_review). A blocked write must not retire the
-     * only active copy — deferring here closes the "contradictionAutoResolve
-     * supersedes before tombstone status is known" defect class.
-     */
-    private applyDeferredContradictionResolve;
-    /**
-     * Suggest links for a new memory based on similar existing memories.
-     */
-    private suggestLinksForMemory;
-    private namespaceFromPath;
-    private storageDirNamespace;
-    /**
-     * Public best-effort catalog write touch (issue #1499). User-facing explicit
-     * captures (`memory_store`) and review-queue approvals persist via
-     * `persistExplicitCapture()` → `storage.writeMemory()`, which bypasses the
-     * extraction write path that owns the catalog touch. Without this their
-     * namespaces never record `lastWriteAt`, so the catalog under-reports write
-     * recency (round 5, codex P2). Fire-and-forget and failure-tolerant — a
-     * catalog error must never affect the explicit write (gotcha #13, rule #40).
-     *
-     * An undefined/empty `namespace` means the write targeted the DEFAULT namespace
-     * (`getStorage(undefined)` routes there), so we record it under the configured
-     * default rather than skipping it (round 6, codex P2 — default `memory_store`
-     * and inline-note writes were missing from `writtenSince`/maintenance).
-     */
-    private readAllMemoriesForNamespaces;
-}
-
-export { summarizeGraphShadowComparison as $, normalizeIanaTimeZone as A, type BulkImportBatchIngestResult as B, ConversationIndexCoordinator as C, type DaySummaryGatherOptions as D, type ExtractionRunResult as E, parseFiniteDate as F, type GraphRecallSnapshot as G, parseGraphRecallRankedResults as H, type IntentDebugSnapshot as I, parseMemoryIntentSnapshot as J, parseQmdRecallResults as K, qmdStartupCollectionCheckWithTimeout as L, qmdStartupCollectionChecksWithTimeout as M, raceRecallAbort as N, Orchestrator as O, type PatternReinforcementResult as P, type QmdRecallSnapshot as Q, type RecallInvocationOptions as R, resolveEffectiveIdentityInjectionMode as S, TierMigrationCoordinator as T, resolveEffectiveRecallMode as U, resolvePersistedMemoryRelativePath as V, resolveRecallModeDecision as W, resolveRecallModeDecisionAsync as X, resolveRecentThreadMemoryPaths as Y, shouldFilterLifecycleRecallCandidate as Z, splitTurnsBySourceValidAt as _, BulkImportBatchPartialFailureError as a, targetSourceValidAtSortMs as a0, throwIfRecallAborted as a1, tokenizeRecallQuery as a2, utcDateKeysForLocalDay as a3, COMPACTION_SIGNAL_MAX_AGE_MS as b, type GraphRecallRankedResult as c, defaultWorkspaceDir as d, type GraphRecallShadowComparison as e, type QueryAwarePrefilter as f, type RecallModeDecision as g, appendMemoryToGraphContext as h, applyQueryAwareCandidateFilter as i, blendGraphExpandedRecallScore as j, buildCompressionGuidelinesMarkdown as k, buildMemoryPathById as l, computeArtifactCandidateFetchLimit as m, computeArtifactRecallLimit as n, computeQmdHybridFetchLimit as o, deriveTopicsFromExtraction as p, filterHourlySummaryMarkdownForLocalDay as q, formatDateInTimeZone as r, sanitizeSessionKeyForFilename as s, graphPathRelativeToStorage as t, hasIdentityRecoveryIntent as u, isArtifactMemoryPath as v, lifecycleRecallScoreAdjustment as w, mapRecallSourceToXrayServedBy as x, mergeArtifactRecallCandidates as y, mergeGraphExpandedResults as z };