@remnic/core 9.3.743 → 9.3.745

package/dist/{orchestrator-CupigmWu.d.ts → orchestrator-BBGXLd20.d.ts}

@@ -8,12 +8,12 @@ import { HourlySummarizer } from './summarizer.js';
 import { LocalLlmClient } from './local-llm.js';
 import { FallbackLlmClient } from './fallback-llm.js';
 import { MaintenanceScheduler } from './orchestration/maintenance.js';
-import { u as BufferTurn, y as ExtractionResult, M as MemoryCategory, ab as ImportanceScore, f as MemoryStatus, aE as WearableConversation, aF as WearableSourceSettings, aG as WearableNativeMemory, aH as WearableMemoryMode, aI as WearableSourceConnector, aJ as WearablesConfig, aK as WearableSyncSummary, aL as WearableSourceStatus, aM as WearableDayTranscript, aN as WearableCorrectionRule, P as PluginConfig, g as MemoryFile, $ as MemoryActionEvent, Q as QmdSearchResult, a5 as ContinuityIncidentRecord, h as RecallPlanMode, I as IdentityInjectionMode, aO as RecallSectionConfig, ap as MemoryLink, aA as CodingContext, e as BehaviorLoopPolicyState, aP as BootstrapOptions, aQ as BootstrapResult, aR as ConsolidationObservation, D as DaySummaryResult, ac as MemoryIntent, k as MemoryFrontmatter } from './types-5Jik3r4G.js';
-import { TierMigrationStatusStore, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallBudgetSummary, LastRecallStore, RecallHandleHistoryStore, GraphRecallExpandedEntry, LastRecallSnapshot } from './recall-state.js';
+import { aB as ScopeProfileConfig, aC as ScopeProfileLayerId, aD as ScopeProfilePromotionTarget, u as BufferTurn, y as ExtractionResult, M as MemoryCategory, ac as ImportanceScore, f as MemoryStatus, aE as WearableConversation, aF as WearableSourceSettings, aG as WearableNativeMemory, aH as WearableMemoryMode, aI as WearableSourceConnector, aJ as WearablesConfig, aK as WearableSyncSummary, aL as WearableSourceStatus, aM as WearableDayTranscript, aN as WearableCorrectionRule, P as PluginConfig, g as MemoryFile, a0 as MemoryActionEvent, Q as QmdSearchResult, a6 as ContinuityIncidentRecord, h as RecallPlanMode, I as IdentityInjectionMode, aO as RecallSectionConfig, ap as MemoryLink, ax as CodingContext, ad as MemoryIntent, e as BehaviorLoopPolicyState, aP as BootstrapOptions, aQ as BootstrapResult, aR as ConsolidationObservation, D as DaySummaryResult, k as MemoryFrontmatter } from './types-CZm6rx9-.js';
+import { TierMigrationStatusStore, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallBudgetSummary, GraphRecallExpandedEntry, LastRecallStore, RecallHandleHistoryStore, LastRecallSnapshot } from './recall-state.js';
 import { CompoundingEngine } from './compounding/engine.js';
 import { UtilityRuntimeValues } from './utility-runtime.js';
 import { CompressionGuidelineCoordinator } from './orchestration/compression-guideline-coordinator.js';
-import { S as SemanticConsolidationResult } from './semantic-consolidation-ByzGwC9c.js';
+import { S as SemanticConsolidationResult } from './semantic-consolidation-D3aSiu9t.js';
 import { EmbeddingFallback } from './embedding-fallback.js';
 import { ExtractionEngine } from './extraction.js';
 import { ObjectiveStateSearchResult } from './objective-state.js';
@@ -27,7 +27,11 @@ import { TrustStageResultItem } from './trust-score-stage.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 } from './capabilities.js';
+import { CapabilitySet, GraphConstructionCapabilitySet, MemoryLifecycleCapabilitySet } from './capabilities.js';
+import { BoxBuilder } from './boxes.js';
+import { NamespaceStorageRouter } from './namespaces/storage.js';
+import { ThreadingManager } from './threading.js';
+import { GraphIndex } from './graph.js';
 import { LiveConnectorsRunSummary } from './live-connectors-runner.js';
 import { ModelRegistry } from './model-registry.js';
 import { RelevanceStore } from './relevance.js';
@@ -39,12 +43,39 @@ import { ReplayTurn } from './replay/types.js';
 import { I as ImportTurn } from './types-gb_SNtjR.js';
 import { JudgeCandidate, JudgeBatchResult } from './extraction-judge.js';
 import { LcmEngine } from './lcm/engine.js';
-import { b as NamespaceKind, N as NamespaceCatalog } from './catalog-CX0CjOaf.js';
+import { b as NamespaceKind, N as NamespaceCatalog } from './catalog-D_ZDxu8Y.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';
 
+interface ScopeProfileLayerResolution {
+    id: ScopeProfileLayerId;
+    kind: "user-project" | "team-project" | "user-global" | "server-shared";
+    namespace?: string;
+    readable: boolean;
+    writable: boolean;
+    promotable: boolean;
+    reason: string;
+}
+interface ScopeProfilePromotionResolution {
+    target: ScopeProfilePromotionTarget;
+    namespace?: string;
+    authorized: boolean;
+    reason: string;
+}
+interface ResolvedScopeProfilePlan {
+    profileId: string;
+    profile: ScopeProfileConfig;
+    baseNamespace: string;
+    writeLayer: ScopeProfileLayerId;
+    writeNamespace: string;
+    readNamespaces: string[];
+    layers: ScopeProfileLayerResolution[];
+    promotionTargets: ScopeProfilePromotionResolution[];
+    warnings: string[];
+}
+
 /**
  * Wearable speaker registry — maps provider diarization labels to
  * human names, persistently, per source.
@@ -1294,6 +1325,216 @@ declare class ContradictionLinkingCoordinator {
     suggestLinksForMemory(content: string, category: string, namespaceScope: string): Promise<MemoryLink[]>;
 }
 
+/**
+ * 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: () => ExtractionEngine;
+    getStorageRouter: () => NamespaceStorageRouter;
+    getThreading: () => ThreadingManager;
+    persistExtraction: (result: ExtractionResult, storage: StorageManager, threadIdForExtraction?: string | null, sourceContext?: {
+        sessionKey?: string;
+        principal?: string;
+        validAt?: string;
+    }, baseNamespace?: string, scopeProfileWritePlan?: ResolvedScopeProfilePlan | null, sourceText?: string, graphCaps?: GraphConstructionCapabilitySet, lifecycleCaps?: MemoryLifecycleCapabilitySet) => Promise<string[]>;
+    maybeCapturePassiveCorrections: (turns: readonly BufferTurn[], opts: {
+        sessionKey: string;
+        principal?: string;
+        namespace: string;
+        bufferKey: string;
+        isLiveSession: boolean;
+    }) => Promise<void>;
+    resolveSelfNamespace: (sessionKey?: string) => string;
+    getCodingContextForSession: (sessionKey: string) => CodingContext | null;
+    applyCodingNamespaceOverlay: (sessionKey: string, namespace: string) => string;
+    boxBuilderFor: (storage: StorageManager) => BoxBuilder;
+    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>;
+}
+declare function deriveTopicsFromExtraction(result: ExtractionResult): string[];
+/**
+ * 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;
+    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>;
+    runExtraction(turns: BufferTurn[], options?: {
+        clearBufferAfterExtraction?: boolean;
+        skipCharThreshold?: boolean;
+        skipUserTurnThreshold?: boolean;
+        deadlineMs?: number;
+        bufferKey?: string;
+        abortSignal?: AbortSignal;
+        failOnExtractionFailure?: boolean;
+        /**
+         * Explicit namespace override for the write path (#460).  When set,
+         * extraction writes go to this namespace 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)` (#1495 thread 1). 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
+         * (un-prefixed) key and storage is pinned via `writeNamespaceOverride`.
+         */
+        principalOverride?: string;
+    }): 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 — no logic changes; 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;
+}
+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;
+    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[]) => Promise<MemoryFile | null>;
+    });
+    expandResultsViaGraph(options: {
+        memoryResults: QmdSearchResult[];
+        recallNamespaces: string[];
+        recallResultLimit: number;
+        deadlineAtMs?: number | null;
+        /** Issue #681 — when true, bypass graphTraversalConfidenceFloor. */
+        includeLowConfidence?: boolean;
+    }): Promise<{
+        merged: QmdSearchResult[];
+        seedPaths: string[];
+        expandedPaths: GraphRecallExpandedEntry[];
+        seedResults: QmdSearchResult[];
+    }>;
+    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;
+}
+
 /**
  * Pattern-reinforcement maintenance job (issue #687 PR 2/4).
  *
@@ -1459,6 +1700,7 @@ declare class BulkImportBatchPartialFailureError extends Error {
     readonly originalError: unknown;
     constructor(message: string, partialResult: BulkImportBatchIngestResult, originalError: unknown);
 }
+
 interface GraphRecallSnapshot {
     recordedAt: string;
     mode: RecallPlanMode | string;
@@ -1477,19 +1719,6 @@ interface GraphRecallSnapshot {
     finalResults?: GraphRecallRankedResult[];
     shadowComparison?: GraphRecallShadowComparison;
 }
-interface GraphRecallRankedResult {
-    path: string;
-    score: number;
-    docid?: string;
-    sourceLabels: string[];
-}
-interface GraphRecallShadowComparison {
-    baselineCount: number;
-    graphCount: number;
-    overlapCount: number;
-    overlapRatio: number;
-    averageOverlapDelta: number;
-}
 interface IntentDebugSnapshot {
     recordedAt: string;
     promptHash: string;
@@ -1639,7 +1868,7 @@ declare function defaultWorkspaceDir(): string;
  */
 declare function sanitizeSessionKeyForFilename(sessionKey: string): string;
 declare function isArtifactMemoryPath(filePath: string): boolean;
-declare function deriveTopicsFromExtraction(result: ExtractionResult): string[];
+
 declare function buildCompressionGuidelinesMarkdown(events: MemoryActionEvent[], generatedAtIso?: string): string;
 declare function filterRecallCandidates(candidates: QmdSearchResult[], options: {
     namespacesEnabled: boolean;
@@ -1694,15 +1923,6 @@ declare function resolveRecallModeDecisionAsync(options: RecallModeGraphOptions
 }): Promise<RecallModeDecision>;
 declare function computeArtifactCandidateFetchLimit(targetCount: number): number;
 declare function computeQmdHybridFetchLimit(recallFetchLimit: number, artifactsEnabled: boolean, maxArtifactRecall: number): number;
-declare function mergeGraphExpandedResults(primary: QmdSearchResult[], expanded: QmdSearchResult[]): QmdSearchResult[];
-declare function graphPathRelativeToStorage(storageDir: string, candidatePath: string): string | null;
-declare function blendGraphExpandedRecallScore(options: {
-    graphActivationScore: number;
-    seedRecallScore: number;
-    activationWeight: number;
-    blendMin: number;
-    blendMax: number;
-}): number;
 declare function summarizeGraphShadowComparison(baseline: QmdSearchResult[], merged: QmdSearchResult[], topN: number): {
     baselineCount: number;
     graphCount: number;
@@ -1875,6 +2095,25 @@ declare class Orchestrator {
      * hands it to `enqueue`.
      */
     readonly extractionQueueCoordinator: ExtractionQueueCoordinator;
+    /**
+     * Extraction-run pipeline coordinator (issue #1526 seam 15). Owns
+     * `runExtraction` + dedupe fingerprint helpers + processed-fingerprint
+     * recording. The orchestrator delegates and injects its own methods.
+     */
+    private _extractionRunCoordinator;
+    /**
+     * Lazy getter: creates the ExtractionRunCoordinator on first access using
+     * the orchestrator's live field references. Supports Object.create(prototype)
+     * tests that set fields post-construction without invoking the constructor.
+     */
+    private get extractionRunCoordinator();
+    /**
+     * Extraction-persist coordinator (issue #1526 seam 16). Owns the
+     * `persistExtraction` pipeline. Lazy: created on first access so
+     * Object.create(prototype) tests that set fields post-construction work.
+     */
+    private _extractionPersistCoordinator;
+    private get extractionPersistCoordinator();
     /**
      * Issue #1526: recall result formatting + identity continuity section moved
      * to RecallResultFormatter.
@@ -1889,6 +2128,7 @@ declare class Orchestrator {
     readonly recallSectionCoordinator: RecallSectionCoordinator;
     readonly qmdResultResolver: QmdResultResolver;
     readonly contradictionLinkingCoordinator: ContradictionLinkingCoordinator;
+    readonly graphRecallCoordinator: GraphRecallCoordinator;
     private heartbeatObserverChains;
     private recentExtractionFingerprints;
     private readonly consolidationObservers;
@@ -2589,7 +2829,7 @@ declare class Orchestrator {
     /** Lazily construct the CorrectionService for passive capture. Stateless
      *  across requests (per #1580 design); cached for the orchestrator's life. */
     private passiveCorrectionService;
-    private runExtraction;
+    runExtraction(...args: Parameters<ExtractionRunCoordinator["runExtraction"]>): Promise<ExtractionRunResult>;
     private recordProcessedExtractionFingerprint;
     private runTierMigrationCycle;
     getTierMigrationStatus(): Promise<TierMigrationStatusSnapshot>;
@@ -2798,8 +3038,6 @@ declare class Orchestrator {
      * Suggest links for a new memory based on similar existing memories.
      */
     private suggestLinksForMemory;
-    private graphSeedPathRelativeToStorage;
-    private graphSeedPathsWithinDeadline;
     private namespaceFromPath;
     private storageDirNamespace;
     /**
@@ -2820,4 +3058,4 @@ declare class Orchestrator {
     private readArchivedMemoriesForNamespaces;
 }
 
-export { computeArtifactCandidateFetchLimit as $, sanitizeSessionKeyForFilename as A, saveSpeakerRegistry as B, speakerRegistryKey as C, DEFAULT_SELF_NAME as D, speakersFilePath as E, syncWearableSource as F, type GraphRecallSnapshot as G, wearableDayTag as H, type IntentDebugSnapshot as I, wearableSourceLabel as J, writeDailyDigestMemory as K, type BulkImportBatchIngestResult as L, BulkImportBatchPartialFailureError as M, type GraphRecallRankedResult as N, Orchestrator as O, type PatternReinforcementResult as P, type GraphRecallShadowComparison as Q, type ResolvedSpeaker as R, type SpeakerRegistry as S, type QmdRecallSnapshot as T, type RecallInvocationOptions as U, type RecallModeDecision as V, WearablesService as W, appendMemoryToGraphContext as X, blendGraphExpandedRecallScore as Y, buildCompressionGuidelinesMarkdown as Z, buildMemoryPathById as _, type SpeakerOverride as a, computeArtifactRecallLimit as a0, computeQmdHybridFetchLimit as a1, deriveTopicsFromExtraction as a2, filterRecallCandidates as a3, graphPathRelativeToStorage as a4, hasIdentityRecoveryIntent as a5, isArtifactMemoryPath as a6, lifecycleRecallScoreAdjustment as a7, mergeArtifactRecallCandidates as a8, mergeGraphExpandedResults as a9, resolveEffectiveIdentityInjectionMode as aa, resolveEffectiveRecallMode as ab, resolvePersistedMemoryRelativePath as ac, resolveRecallModeDecision as ad, resolveRecallModeDecisionAsync as ae, resolveRecentThreadMemoryPaths as af, shouldFilterLifecycleRecallCandidate as ag, summarizeGraphShadowComparison as ah, WEARABLE_SOURCE_PREFIX as b, type WearableDayTranscriptView as c, type WearableMemoryGenDeps as d, type WearableMemoryGenResult as e, type WearableMemorySearchResult as f, type WearableMemoryWriter as g, type WearableSearchBackend as h, type WearableStorageIo as i, type WearableSyncDeps as j, type WearableSyncOptions as k, type WearableTranscriptSearchResult as l, type WearablesServiceDeps as m, buildExtractionTurns as n, dateInTimezone as o, defaultTimezone as p, defaultWorkspaceDir as q, distinctSpeakerLabels as r, emptySpeakerRegistry as s, generateWearableMemories as t, importNativeMemories as u, loadSpeakerRegistry as v, locateTranscriptPath as w, memoryStatusForMode as x, resolveSpeaker as y, resolveSyncDates as z };
+export { appendMemoryToGraphContext as $, memoryStatusForMode as A, resolveSpeaker as B, resolveSyncDates as C, DEFAULT_SELF_NAME as D, sanitizeSessionKeyForFilename as E, saveSpeakerRegistry as F, type GraphRecallSnapshot as G, speakerRegistryKey as H, type IntentDebugSnapshot as I, speakersFilePath as J, syncWearableSource as K, wearableDayTag as L, wearableSourceLabel as M, writeDailyDigestMemory as N, Orchestrator as O, type PatternReinforcementResult as P, type BulkImportBatchIngestResult as Q, type ResolvedScopeProfilePlan as R, type ScopeProfileLayerResolution as S, BulkImportBatchPartialFailureError as T, type ExtractionRunResult as U, type GraphRecallRankedResult as V, WearablesService as W, type GraphRecallShadowComparison as X, type QmdRecallSnapshot as Y, type RecallInvocationOptions as Z, type RecallModeDecision as _, type ScopeProfilePromotionResolution as a, blendGraphExpandedRecallScore as a0, buildCompressionGuidelinesMarkdown as a1, buildMemoryPathById as a2, computeArtifactCandidateFetchLimit as a3, computeArtifactRecallLimit as a4, computeQmdHybridFetchLimit as a5, deriveTopicsFromExtraction as a6, filterRecallCandidates as a7, graphPathRelativeToStorage as a8, hasIdentityRecoveryIntent as a9, isArtifactMemoryPath as aa, lifecycleRecallScoreAdjustment as ab, mergeArtifactRecallCandidates as ac, mergeGraphExpandedResults as ad, resolveEffectiveIdentityInjectionMode as ae, resolveEffectiveRecallMode as af, resolvePersistedMemoryRelativePath as ag, resolveRecallModeDecision as ah, resolveRecallModeDecisionAsync as ai, resolveRecentThreadMemoryPaths as aj, shouldFilterLifecycleRecallCandidate as ak, summarizeGraphShadowComparison as al, type SpeakerRegistry as b, type ResolvedSpeaker as c, type SpeakerOverride as d, WEARABLE_SOURCE_PREFIX as e, type WearableDayTranscriptView as f, type WearableMemoryGenDeps as g, type WearableMemoryGenResult as h, type WearableMemorySearchResult as i, type WearableMemoryWriter as j, type WearableSearchBackend as k, type WearableStorageIo as l, type WearableSyncDeps as m, type WearableSyncOptions as n, type WearableTranscriptSearchResult as o, type WearablesServiceDeps as p, buildExtractionTurns as q, dateInTimezone as r, defaultTimezone as s, defaultWorkspaceDir as t, distinctSpeakerLabels as u, emptySpeakerRegistry as v, generateWearableMemories as w, importNativeMemories as x, loadSpeakerRegistry as y, locateTranscriptPath as z };

package/dist/orchestrator.d.ts

@@ -8,7 +8,7 @@ import './summarizer.js';
 import './local-llm.js';
 import './fallback-llm.js';
 import './orchestration/maintenance.js';
-export { L as BulkImportBatchIngestResult, M as BulkImportBatchPartialFailureError, N as GraphRecallRankedResult, Q as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, T as QmdRecallSnapshot, U as RecallInvocationOptions, V as RecallModeDecision, X as appendMemoryToGraphContext, Y as blendGraphExpandedRecallScore, Z as buildCompressionGuidelinesMarkdown, _ as buildMemoryPathById, $ as computeArtifactCandidateFetchLimit, a0 as computeArtifactRecallLimit, a1 as computeQmdHybridFetchLimit, q as defaultWorkspaceDir, a2 as deriveTopicsFromExtraction, a3 as filterRecallCandidates, a4 as graphPathRelativeToStorage, a5 as hasIdentityRecoveryIntent, a6 as isArtifactMemoryPath, a7 as lifecycleRecallScoreAdjustment, a8 as mergeArtifactRecallCandidates, a9 as mergeGraphExpandedResults, aa as resolveEffectiveIdentityInjectionMode, ab as resolveEffectiveRecallMode, ac as resolvePersistedMemoryRelativePath, ad as resolveRecallModeDecision, ae as resolveRecallModeDecisionAsync, af as resolveRecentThreadMemoryPaths, A as sanitizeSessionKeyForFilename, ag as shouldFilterLifecycleRecallCandidate, ah as summarizeGraphShadowComparison } from './orchestrator-CupigmWu.js';
+export { Q as BulkImportBatchIngestResult, T as BulkImportBatchPartialFailureError, U as ExtractionRunResult, V as GraphRecallRankedResult, X as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Y as QmdRecallSnapshot, Z as RecallInvocationOptions, _ as RecallModeDecision, $ as appendMemoryToGraphContext, a0 as blendGraphExpandedRecallScore, a1 as buildCompressionGuidelinesMarkdown, a2 as buildMemoryPathById, a3 as computeArtifactCandidateFetchLimit, a4 as computeArtifactRecallLimit, a5 as computeQmdHybridFetchLimit, t as defaultWorkspaceDir, a6 as deriveTopicsFromExtraction, a7 as filterRecallCandidates, a8 as graphPathRelativeToStorage, a9 as hasIdentityRecoveryIntent, aa as isArtifactMemoryPath, ab as lifecycleRecallScoreAdjustment, ac as mergeArtifactRecallCandidates, ad as mergeGraphExpandedResults, ae as resolveEffectiveIdentityInjectionMode, af as resolveEffectiveRecallMode, ag as resolvePersistedMemoryRelativePath, ah as resolveRecallModeDecision, ai as resolveRecallModeDecisionAsync, aj as resolveRecentThreadMemoryPaths, E as sanitizeSessionKeyForFilename, ak as shouldFilterLifecycleRecallCandidate, al as summarizeGraphShadowComparison } from './orchestrator-BBGXLd20.js';
 export { formatCompressionGuidelinesForRecall } from './orchestration/compression-guideline-coordinator.js';
 import './live-connectors-runner.js';
 import './model-registry.js';
@@ -22,11 +22,11 @@ import './semantic-DJR8_DMQ.js';
 import './capabilities.js';
 import './replay/types.js';
 import './types-gb_SNtjR.js';
-import './types-5Jik3r4G.js';
+import './types-CZm6rx9-.js';
 import './lcm/engine.js';
-import './semantic-consolidation-ByzGwC9c.js';
+import './semantic-consolidation-D3aSiu9t.js';
 import './conversation-index/backend.js';
-import './catalog-CX0CjOaf.js';
+import './catalog-D_ZDxu8Y.js';
 import './namespaces/search.js';
 import './shared-context/manager.js';
 import './compounding/engine.js';
@@ -63,6 +63,9 @@ import './trust-score.js';
 import './conversation-index/chunker.js';
 import './faiss-adapter-BHecI1fF.js';
 import './runtime/child-process.js';
+import './namespaces/storage.js';
+import './threading.js';
+import './graph.js';
 import './extraction-judge.js';
 import './framework-CNDn2164.js';
 import './memory-provenance.js';