@remnic/core 9.69.56 → 9.69.58

package/dist/orchestrator.d.ts

@@ -1,109 +1,867 @@
-import './recall-state.js';
-import './briefing.js';
-import './buffer.js';
-import './extraction-faithfulness.js';
-import './search/port.js';
-import './storage-CMm-3aD3.js';
-import './transcript.js';
-import './summarizer.js';
-import './local-llm-BkkEK9rn.js';
-import './fallback-llm.js';
-import './maintenance-CLBIvVxg.js';
-export { B as BulkImportBatchIngestResult, a as BulkImportBatchPartialFailureError, b as COMPACTION_SIGNAL_MAX_AGE_MS, D as DaySummaryGatherOptions, E as ExtractionRunResult, c as GraphRecallRankedResult, e as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, f as QueryAwarePrefilter, R as RecallInvocationOptions, g as RecallModeDecision, h as appendMemoryToGraphContext, i as applyQueryAwareCandidateFilter, j as blendGraphExpandedRecallScore, k as buildCompressionGuidelinesMarkdown, l as buildMemoryPathById, m as computeArtifactCandidateFetchLimit, n as computeArtifactRecallLimit, o as computeQmdHybridFetchLimit, d as defaultWorkspaceDir, p as deriveTopicsFromExtraction, q as filterHourlySummaryMarkdownForLocalDay, r as formatDateInTimeZone, t as graphPathRelativeToStorage, u as hasIdentityRecoveryIntent, v as isArtifactMemoryPath, w as lifecycleRecallScoreAdjustment, x as mapRecallSourceToXrayServedBy, y as mergeArtifactRecallCandidates, z as mergeGraphExpandedResults, A as normalizeIanaTimeZone, F as parseFiniteDate, H as parseGraphRecallRankedResults, J as parseMemoryIntentSnapshot, K as parseQmdRecallResults, L as qmdStartupCollectionCheckWithTimeout, M as qmdStartupCollectionChecksWithTimeout, N as raceRecallAbort, S as resolveEffectiveIdentityInjectionMode, U as resolveEffectiveRecallMode, V as resolvePersistedMemoryRelativePath, W as resolveRecallModeDecision, X as resolveRecallModeDecisionAsync, Y as resolveRecentThreadMemoryPaths, s as sanitizeSessionKeyForFilename, Z as shouldFilterLifecycleRecallCandidate, _ as splitTurnsBySourceValidAt, $ as summarizeGraphShadowComparison, a0 as targetSourceValidAtSortMs, a1 as throwIfRecallAborted, a2 as tokenizeRecallQuery, a3 as utcDateKeysForLocalDay } from './orchestrator-iexgVLow.js';
-export { formatCompressionGuidelinesForRecall } from './orchestration/compression-guideline-coordinator.js';
-export { f as filterRecallCandidates } from './generic-recall-paths-C0J1Oxb7.js';
-import './live-connectors-runner.js';
-import './model-registry.js';
-import './relevance.js';
-import './negative.js';
-import './recall-xray.js';
-import './session-observer-state.js';
-import './embedding-fallback.js';
-import './semantic-BalR6EXU.js';
-import './capabilities.js';
-import './replay/types.js';
-import './types-Du6VdoAg.js';
-import './service-VealHeqO.js';
-import './lcm/engine.js';
-import './semantic-consolidation-D--qe0eE.js';
-import './catalog-BuMyYPUn.js';
-import './scope-profiles-BN1Dgfha.js';
-import './namespaces/search.js';
-import './shared-context/manager.js';
-import './compounding/engine.js';
-import './policy-runtime.js';
-import './profiling.js';
-import './utils/serialize-mutations.js';
-import './included-memories.js';
-import './message-parts/index.js';
-import './bounded-jsonl-state.js';
-import './operator-doctor-types.js';
-import './external-wiki-config.js';
-import './recall-state-view.js';
-import './contradiction-config.js';
-import './graph-path-scoring-config.js';
-import './background-generation-config.js';
-import './deep-recall-config.js';
-import './recall-navigation-config.js';
-import './recall-recognition-tier.js';
-import './causal-trajectory.js';
-import './objective-state.js';
-import './active-context-config.js';
-import './local-llm-config.js';
-import './semantic-merge-config.js';
-import './types-continuity.js';
-import './corpus-read-cancellation.js';
-import './artifact-search.js';
-import './active-context-transform.js';
-import './context-summary.js';
-import './entity-id-normalization.js';
-import './page-versioning.js';
-import './consolidation-operator.js';
-import './memory-projection-store.js';
-import './maintenance/memory-governance.js';
-import './runtime/better-sqlite.js';
-import 'better-sqlite3';
-import './write-envelope.js';
-import './structured-attributes.js';
-import './fallback-llm-codex-subscription.js';
-import './cli-fallback.js';
-import './resolve-provider-secret.js';
-import './session-integrity.js';
-import './utility-runtime.js';
-import './tier-routing.js';
-import './lifecycle.js';
-import './extraction.js';
-import './schemas.js';
-import 'zod';
-import './extraction-error-classification.js';
-import './trust-zones.js';
-import './harmonic-retrieval.js';
-import './abstraction-nodes.js';
-import './cue-anchors.js';
-import './verified-recall.js';
-import './boxes.js';
-import './semantic-rule-verifier.js';
-import './work-product-ledger.js';
-import './trust-score-stage.js';
-import './trust-score.js';
-import './conversation-index/chunker.js';
-import './conversation-index/backend.js';
-import './faiss-adapter-BHecI1fF.js';
-import './runtime/child-process.js';
-import './dependency-propagation-delivery-BrhPjAHQ.js';
-import './namespaces/storage.js';
-import './threading.js';
-import './graph-DRkl22KE.js';
-import './graph-write-lock.js';
-import './recall-context-composition.js';
-import './framework-CNDn2164.js';
-import './memory-provenance.js';
-import './user-model.js';
-import './extraction-judge.js';
-import './lcm/archive.js';
-import './token-estimate.js';
-import './lcm/recall.js';
-import './lcm/dag.js';
-import './lcm/queue.js';
-import './connectors/codex-materialize.js';
-import './logger.js';
+import { type BriefingFollowupGenerator } from "./briefing.js";
+import { SmartBuffer } from "./buffer.js";
+import type { FaithfulnessGateCounters } from "./extraction-faithfulness.js";
+import type { SearchBackend, SearchExecutionOptions, SearchQueryOptions } from "./search/port.js";
+import { StorageManager } from "./storage.js";
+import { TranscriptManager } from "./transcript.js";
+import { HourlySummarizer } from "./summarizer.js";
+import { LocalLlmClient } from "./local-llm.js";
+import { FallbackLlmClient } from "./fallback-llm.js";
+import { MaintenanceScheduler } from "./orchestration/maintenance.js";
+import { TierMigrationCoordinator } from "./orchestration/tier-migration-coordinator.js";
+import { ExtractionQueueCoordinator } from "./orchestration/extraction-queue-coordinator.js";
+import { CompressionGuidelineCoordinator } from "./orchestration/compression-guideline-coordinator.js";
+import { SemanticConsolidationCoordinator } from "./orchestration/semantic-consolidation-coordinator.js";
+import { LifecyclePolicyCoordinator } from "./orchestration/lifecycle-policy-coordinator.js";
+import { EntitySynthesisCoordinator } from "./orchestration/entity-synthesis-coordinator.js";
+import { RecallResultFormatter } from "./orchestration/recall-result-formatter.js";
+import { ConversationIndexCoordinator } from "./orchestration/conversation-index-coordinator.js";
+import { RecallRerankCoordinator } from "./orchestration/recall-rerank-coordinator.js";
+import { RecallSectionCoordinator } from "./orchestration/recall-section-coordinator.js";
+import { QmdResultResolver } from "./orchestration/qmd-result-resolver.js";
+import { ContradictionLinkingCoordinator } from "./orchestration/contradiction-linking-coordinator.js";
+import { ExtractionRunCoordinator, type ExtractionRunResult, type ExtractionResilienceStatus } from "./orchestration/extraction-run.js";
+import type { ExtractionSourceContext } from "./orchestration/extraction-origin-context.js";
+import type { GraphRecallExpansionOptions, GraphRecallExpansionResult } from "./orchestration/graph-recall-coordinator.js";
+import { type TurnIngestionOptions } from "./orchestration/turn-ingestion.js";
+import { RecallIntrospectionCoordinator } from "./orchestration/recall-introspection.js";
+import { type SessionFlushOptions } from "./orchestration/session-context.js";
+import { type BulkImportBatchIngestResult, type DaySummaryGatherOptions, type RecallInvocationOptions } from "./orchestration/orchestrator-helpers.js";
+export { BulkImportBatchPartialFailureError, COMPACTION_SIGNAL_MAX_AGE_MS, appendMemoryToGraphContext, applyQueryAwareCandidateFilter, buildCompressionGuidelinesMarkdown, buildMemoryPathById, computeArtifactCandidateFetchLimit, computeArtifactRecallLimit, computeQmdHybridFetchLimit, defaultWorkspaceDir, filterHourlySummaryMarkdownForLocalDay, formatDateInTimeZone, isArtifactMemoryPath, lifecycleRecallScoreAdjustment, mapRecallSourceToXrayServedBy, mergeArtifactRecallCandidates, normalizeIanaTimeZone, parseFiniteDate, parseGraphRecallRankedResults, parseMemoryIntentSnapshot, parseQmdRecallResults, qmdStartupCollectionCheckWithTimeout, raceRecallAbort, resolveEffectiveRecallMode, resolvePersistedMemoryRelativePath, resolveRecallModeDecision, resolveRecallModeDecisionAsync, resolveRecentThreadMemoryPaths, sanitizeSessionKeyForFilename, shouldFilterLifecycleRecallCandidate, splitTurnsBySourceValidAt, summarizeGraphShadowComparison, targetSourceValidAtSortMs, throwIfRecallAborted, tokenizeRecallQuery, utcDateKeysForLocalDay, type BulkImportBatchIngestResult, type DaySummaryGatherOptions, type GraphRecallSnapshot, type IntentDebugSnapshot, type QmdRecallSnapshot, type QueryAwarePrefilter, type RecallInvocationOptions, type RecallModeDecision, } from "./orchestration/orchestrator-helpers.js";
+export { qmdStartupCollectionChecksWithTimeout } from "./orchestration/startup-collection-checks.js";
+export { filterRecallCandidates } from "./orchestration/generic-recall-paths.js";
+export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
+import { GraphRecallCoordinator } from "./orchestration/graph-recall-coordinator.js";
+export { mergeGraphExpandedResults, graphPathRelativeToStorage, blendGraphExpandedRecallScore } from "./orchestration/graph-recall-coordinator.js";
+export type { GraphRecallRankedResult, GraphRecallShadowComparison } from "./orchestration/graph-recall-coordinator.js";
+import { type LiveConnectorsRunSummary } from "./live-connectors-runner.js";
+import { type PatternReinforcementResult } from "./maintenance/pattern-reinforcement.js";
+import { ModelRegistry } from "./model-registry.js";
+import { RelevanceStore } from "./relevance.js";
+import { NegativeExampleStore } from "./negative.js";
+import { LastRecallStore, RecallHandleHistoryStore, TierMigrationStatusStore, type LastRecallSnapshot } from "./recall-state.js";
+import { type RecallXraySnapshot } from "./recall-xray.js";
+import { SessionObserverState } from "./session-observer-state.js";
+import { EmbeddingFallback } from "./embedding-fallback.js";
+import { type SemanticDedupHit } from "./dedup/semantic.js";
+export { formatCompressionGuidelinesForRecall } from "./orchestration/compression-guideline-coordinator.js";
+import { type GraphConstructionCapabilitySet, type MemoryLifecycleCapabilitySet } from "./capabilities.js";
+import { type ReplayTurn } from "./replay/types.js";
+import type { ImportTurn } from "./bulk-import/types.js";
+import { WearablesService } from "./wearables/service.js";
+import { MeetingsService } from "./meetings/service.js";
+import { LcmEngine } from "./lcm/index.js";
+import { type SemanticConsolidationResult } from "./semantic-consolidation.js";
+import { NamespaceCatalog } from "./namespaces/catalog.js";
+import { type NamespaceMaintenanceSummary } from "./maintenance/namespace-planner.js";
+import { type NamespaceMaintenanceFanoutRunnerContext, type NamespaceMaintenanceHealthSummary } from "./maintenance/namespace-maintenance-fanout.js";
+import { type ResolvedScopeProfilePlan } from "./namespaces/scope-profiles.js";
+import type { CodingContext } from "./types.js";
+import { type NamespaceSearchHealth } from "./namespaces/search.js";
+import { SharedContextManager } from "./shared-context/manager.js";
+import { CompoundingEngine } from "./compounding/engine.js";
+import { type RuntimePolicyValues } from "./policy-runtime.js";
+import { ProfilingCollector } from "./profiling.js";
+import type { BehaviorLoopPolicyState, BootstrapOptions, BootstrapResult, ConsolidationObservation, ExtractionResult, MemoryActionEvent, MemoryFile, DaySummaryResult, PluginConfig, QmdSearchResult } from "./types.js";
+export type { ExtractionRunResult } from "./orchestration/extraction-run.js";
+export { deriveTopicsFromExtraction } from "./orchestration/extraction-run.js";
+export 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<import("./recall-state.js").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;
+}
+//# sourceMappingURL=orchestrator.d.ts.map