@remnic/core 9.7.14 → 9.8.0

package/dist/{orchestrator-BbZ_dQSU.d.ts → orchestrator-CQJ8U7En.d.ts}

@@ -1,19 +1,19 @@
+import { TierMigrationStatusStore, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallBudgetSummary, GraphRecallExpandedEntry, LastRecallStore, RecallHandleHistoryStore, 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 { M as MemoryWriteResult, F as FusionArtifactStore, a as FusedWearableConversation, S as StorageManager } from './storage-CrvzaM9C.js';
+import { M as MemoryWriteResult, F as FusionArtifactStore, a as FusedWearableConversation, S as StorageManager } from './storage-NIyKYD8g.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 { aI as ScopeProfileConfig, aJ as ScopeProfileLayerId, aK as ScopeProfilePromotionTarget, o as BufferTurn, y as ExtractionResult, u as MemoryCategory, ak as ImportanceScore, v as MemoryStatus, aL as WearableConversation, aM as WearableSourceSettings, aN as WearableNativeMemory, aO as WearableMemoryMode, aP as WearableSourceConnector, aQ as WearablesConfig, aR as WearableSyncSummary, aS as WearableSourceStatus, aT as WearableDayTranscript, aU as WearableCorrectionRule, P as PluginConfig, M as MemoryFile, a8 as MemoryActionEvent, Q as QmdSearchResult, ae as ContinuityIncidentRecord, b as RecallPlanMode, I as IdentityInjectionMode, aV as RecallSectionConfig, ax as MemoryLink, aG as CodingContext, t as SourceConnectorProvenance, al as MemoryIntent, p as MemoryFrontmatter, g as BehaviorLoopPolicyState, aW as BootstrapOptions, aX as BootstrapResult, aY as ConsolidationObservation, J as DaySummaryResult, _ as ImportTurn } from './types-Bl4BWDM8.js';
-import { TierMigrationStatusStore, TierMigrationStatusSnapshot, TierMigrationCycleSummary, LastRecallBudgetSummary, GraphRecallExpandedEntry, LastRecallStore, RecallHandleHistoryStore, LastRecallSnapshot } from './recall-state.js';
+import { n as BufferTurn, J as ExtractionResult, ah as ImportanceScore, x as MemoryStatus, aF as WearableConversation, aG as WearableSourceSettings, aH as WearableNativeMemory, aI as WearableMemoryMode, aJ as WearableSourceConnector, aK as WearablesConfig, aL as WearableSyncSummary, aM as WearableSourceStatus, aN as WearableDayTranscript, aO as WearableCorrectionRule, P as PluginConfig, M as MemoryFile, ab as MemoryActionEvent, Q as QmdSearchResult, R as RecallPlanMode, I as IdentityInjectionMode, aP as RecallSectionConfig, av as MemoryLink, aD as CodingContext, r as SourceConnectorProvenance, ai as MemoryIntent, o as MemoryFrontmatter, v as BehaviorLoopPolicyState, aQ as BootstrapOptions, aR as BootstrapResult, aS as ConsolidationObservation, N as DaySummaryResult, a1 as ImportTurn } from './types-D_fG2ix8.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-fvdZRa5Z.js';
+import { S as SemanticConsolidationResult } from './semantic-consolidation-DILZEQq3.js';
 import { EmbeddingFallback } from './embedding-fallback.js';
 import { ExtractionEngine } from './extraction.js';
 import { ObjectiveStateSearchResult } from './objective-state.js';
@@ -24,6 +24,7 @@ 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';
@@ -31,6 +32,7 @@ import { CapabilitySet, GraphConstructionCapabilitySet, MemoryLifecycleCapabilit
 import { BoxBuilder } from './boxes.js';
 import { NamespaceStorageRouter } from './namespaces/storage.js';
 import { ThreadingManager } from './threading.js';
+import { R as ResolvedScopeProfilePlan } from './scope-profiles-EpJG7yKP.js';
 import { GraphIndex } from './graph.js';
 import { RecallXrayServedBy, RecallXraySnapshot } from './recall-xray.js';
 import { LiveConnectorsRunSummary } from './live-connectors-runner.js';
@@ -40,41 +42,15 @@ import { NegativeExampleStore } from './negative.js';
 import { SessionObserverState } from './session-observer-state.js';
 import { a as SemanticDedupHit } from './semantic-TddhF0y7.js';
 import { ReplayTurn } from './replay/types.js';
+import { SealedMemoryEnvelope } from './write-envelope.js';
 import { JudgeCandidate, JudgeBatchResult } from './extraction-judge.js';
 import { LcmEngine } from './lcm/engine.js';
-import { b as NamespaceKind, N as NamespaceCatalog } from './catalog-uX9sT9ws.js';
+import { b as NamespaceKind, N as NamespaceCatalog } from './catalog-BWqHb5HT.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.
@@ -234,21 +210,15 @@ interface CorroborationContext {
  * standalone engines alike.
  */
 
-/**
- * Memory status used for a given memory mode. Least-privilege default:
- * anything that is not explicitly "auto" lands in the review queue
- * rather than active recall.
- */
 declare function memoryStatusForMode(mode: WearableMemoryMode): Extract<MemoryStatus, "active" | "pending_review">;
 /** Narrow writer interface satisfied by `StorageManager`. */
 interface WearableMemoryWriter {
-    writeMemory(category: MemoryCategory, content: string, options: {
-        confidence?: number;
-        tags?: string[];
-        source?: string;
+    /**
+     * Sealed-envelope write entry point (issue #1989 PR4): cross-cutting
+     * fields ride the composed envelope; per-write extras stay explicit.
+     */
+    writeSealedMemory(envelope: SealedMemoryEnvelope, extras: {
         importance?: ImportanceScore;
-        validAt?: string;
-        structuredAttributes?: Record<string, string>;
         contentHashSource?: string;
         status?: MemoryStatus;
         memoryKind?: "episode" | "note" | "box" | "dream" | "procedural";
@@ -449,7 +419,7 @@ interface WearableStorageIo {
         };
         content: string;
     }>>;
-    writeMemory: WearableMemoryGenDeps["writer"]["writeMemory"];
+    writeSealedMemory: WearableMemoryGenDeps["writer"]["writeSealedMemory"];
     hasFactContentHash(content: string): Promise<boolean>;
     findWearableMemoryByContent(content: string): Promise<{
         id: string;
@@ -1091,6 +1061,10 @@ declare function resolveEffectiveIdentityInjectionMode(options: {
 declare class RecallResultFormatter {
     private readonly config;
     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;
@@ -1146,15 +1120,22 @@ declare class RecallRerankCoordinator {
     private readonly getStorage;
     private readonly readQmdResultMemory;
     private readonly memoryWorthCounterCache;
-    private static readonly MEMORY_WORTH_CACHE_TTL_MS;
     private readonly trustSignalCache;
-    private static readonly TRUST_SIGNAL_CACHE_TTL_MS;
+    /**
+     * 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[]) => Promise<MemoryFile | null>;
+        readQmdResultMemory: (resultPath: string, fallbackStorage: StorageManager, recallNamespaces: readonly string[], preferredNamespace?: string) => Promise<MemoryFile | null>;
     });
-    applyMemoryWorthRerank(results: QmdSearchResult[], namespaces: string[]): Promise<QmdSearchResult[]>;
+    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}
@@ -1169,7 +1150,7 @@ declare class RecallRerankCoordinator {
      * per-recall local — never instance state — so concurrent recalls cannot
      * race on it (review: shared-trust-map concurrency).
      */
-    applyTrustScoreRerank(results: QmdSearchResult[], namespaces: string[]): Promise<{
+    applyTrustScoreRerank(results: QmdSearchResult[], namespaces: string[], preloadedFrontmatter?: ReadonlyMap<string, MemoryFile>, abortSignal?: AbortSignal): Promise<{
         results: QmdSearchResult[];
         trustByPath: Map<string, TrustStageResultItem> | null;
     }>;
@@ -1183,7 +1164,7 @@ declare class RecallRerankCoordinator {
      * 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): Promise<{
+    applyTrustScoreToBranch(results: QmdSearchResult[], namespaces: string[], caps: CapabilitySet, label: string, preloadedFrontmatter?: ReadonlyMap<string, MemoryFile>, abortSignal?: AbortSignal): Promise<{
         results: QmdSearchResult[];
         trustByPath: Map<string, TrustStageResultItem> | null;
     }>;
@@ -1218,6 +1199,20 @@ declare class RecallRerankCoordinator {
  * TierMigrationCoordinator accessor pattern.
  */
 
+interface RecallSectionAppendOptions {
+    atomic?: boolean;
+    memoryId?: string;
+    memoryPath?: string;
+    memoryNamespace?: string;
+}
+interface RecallSectionChunk {
+    content: string;
+    atomic?: boolean;
+    memoryId?: string;
+    memoryPath?: string;
+    memoryNamespace?: string;
+}
+type RecallSectionBuckets = Map<string, Array<string | RecallSectionChunk>>;
 /**
  * Coordinator for the recall section budgeting + assembly subsystem.
  *
@@ -1238,21 +1233,20 @@ declare class RecallSectionCoordinator {
     isSpecializedRecallSectionEnabled(sectionId: string, topLevelEnabled: boolean): boolean;
     getRecallSectionMaxChars(sectionId: string): number | null | undefined;
     getRecallSectionNumber(sectionId: string, key: keyof RecallSectionConfig): number | undefined;
-    appendRecallSection(sectionBuckets: Map<string, string[]>, sectionId: string, content: string): boolean;
+    appendRecallSection(sectionBuckets: RecallSectionBuckets, sectionId: string, content: string, options?: RecallSectionAppendOptions): boolean;
+    truncateProfileToBoundary(content: string, maxChars: number): string;
     truncateRecallSectionToBudget(content: string, maxChars: number): string;
-    protectedRecallSectionIds(sectionBuckets: Map<string, string[]>): Set<string>;
-    protectedRecallReservationChars(content: string): number;
-    estimateReservedRecallBudget(entries: Array<{
-        id: string;
-        content: string;
-    }>, startIndex: number, protectedIds: Set<string>, alreadyIncludedCount: number): number;
     getRecallBudgetChars(override?: number): number;
-    assembleRecallSections(sectionBuckets: Map<string, string[]>, budgetOverride?: number): {
+    assembleRecallSections(sectionBuckets: RecallSectionBuckets, budgetOverride?: number): {
         sections: string[];
         includedIds: string[];
         omittedIds: string[];
         truncated: boolean;
         finalChars: number;
+        includedMemoryIds: string[];
+        includedMemoryPaths: string[];
+        includedMemoryNamespaces: Array<string | undefined>;
+        omittedMemoryIds: string[];
     };
     buildLastRecallBudgetSummary(options: {
         requestedTopK?: number;
@@ -1262,9 +1256,13 @@ declare class RecallSectionCoordinator {
         finalContextChars?: number;
         truncated?: boolean;
         includedSections?: string[];
+        includedMemoryIds?: string[];
+        includedMemoryPaths?: string[];
+        includedMemoryNamespaces?: Array<string | undefined>;
+        omittedMemoryIds?: string[];
         omittedSections?: string[];
     }): LastRecallBudgetSummary;
-    collectLastRecallSources(sectionBuckets: Map<string, string[]>, recallSource: "none" | "hot_qmd" | "hot_embedding" | "cold_fallback" | "recent_scan"): string[];
+    collectLastRecallSources(sectionBuckets: RecallSectionBuckets, recallSource: "none" | "hot_qmd" | "hot_embedding" | "cold_fallback" | "recent_scan"): string[];
 }
 
 /**
@@ -1312,7 +1310,7 @@ declare class QmdResultResolver {
         qmdCollectionNamespaceFromPrefix: (collectionPrefix: string) => string | null;
         namespaceFromPath: (p: string) => string;
     });
-    readQmdResultMemory(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<MemoryFile | null>;
+    readQmdResultMemory(resultPath: string, fallbackStorage: StorageManager, recallNamespaces?: readonly string[], preferredNamespace?: string): Promise<MemoryFile | null>;
     resolveColdQmdResultForRecall(result: QmdSearchResult, fallbackStorage: StorageManager, recallNamespaces?: readonly string[]): Promise<{
         namespace: string;
         result: QmdSearchResult;
@@ -1457,7 +1455,10 @@ interface ExtractionRunCoordinatorDeps {
         principal?: string;
         validAt?: string;
         sourceConnector?: string;
-    }, baseNamespace?: string, scopeProfileWritePlan?: ResolvedScopeProfilePlan | null, sourceText?: string, graphCaps?: GraphConstructionCapabilitySet, lifecycleCaps?: MemoryLifecycleCapabilitySet) => Promise<string[]>;
+    }, 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;
@@ -1663,7 +1664,7 @@ declare class GraphRecallCoordinator {
             dir: string;
             namespace: string;
         } | null>;
-        readQmdResultMemory: (resultPath: string, fallbackStorage: StorageManager, recallNamespaces: readonly string[]) => Promise<MemoryFile | null>;
+        readQmdResultMemory: (resultPath: string, fallbackStorage: StorageManager, recallNamespaces: readonly string[], preferredNamespace?: string) => Promise<MemoryFile | null>;
     });
     expandResultsViaGraph(options: {
         memoryResults: QmdSearchResult[];
@@ -1987,6 +1988,13 @@ interface RecallInvocationOptions {
      * 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;
 }
 type QueryAwarePrefilter = {
     candidatePaths: Set<string> | null;
@@ -2226,6 +2234,7 @@ declare class Orchestrator {
      * runners (consolidation/pattern-reinforcement/governance) stay here.
      */
     readonly maintenanceScheduler: MaintenanceScheduler;
+    private prioritizedEmbedding?;
     private readonly conversationQmd?;
     private readonly conversationFaiss?;
     private readonly conversationIndexBackend?;
@@ -2897,7 +2906,17 @@ declare class Orchestrator {
      * Delegates to the maintenance scheduler (issue #1526 PR1).
      */
     requestQmdMaintenanceForTool(reason: string): void;
-    private persistExtraction;
+    persistExtraction(result: ExtractionResult, storage: StorageManager, threadIdForExtraction?: string | null, sourceContext?: {
+        sessionKey?: string;
+        principal?: string;
+        validAt?: string;
+        sourceConnector?: string;
+    }, 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
@@ -2938,17 +2957,6 @@ declare class Orchestrator {
     private emitTrace;
     private queueEvalShadowRecall;
     private publishRecallResults;
-    /**
-     * Apply MMR over the pre-truncation recall candidate pool and then slice
-     * the result to `limit`. This is the single place in the pipeline where
-     * MMR runs, and it must be called *before* callers throw away candidates
-     * that would otherwise sit below the final cutoff. Running MMR post-slice
-     * is a no-op in the cases we care about — diverse candidates just below
-     * the cutoff are already gone and can never be promoted.
-     *
-     * Callers must pass the full candidate pool (post-rerank, pre-slice).
-     */
-    private qmdCollectionNamespaceFromPrefix;
     private readQmdResultMemory;
     private resolveColdQmdResultForRecall;
     private storageForAbsoluteQmdResultPath;
@@ -2982,19 +2990,17 @@ declare class Orchestrator {
      * Record that memories were accessed (retrieved).
      * Updates are batched in memory and flushed during consolidation.
      */
-    trackMemoryAccess(memoryIds: string[]): void;
+    trackMemoryAccess(memoryIds: string[], memoryPaths?: string[], memoryNamespaces?: Array<string | undefined>): void;
     flushAccessTracking(): Promise<void>;
     private loadSearchResultMemoryMap;
     private filterSearchResultsByRecallSafety;
     private filterSearchResultsForRecall;
     private boostSearchResults;
-    /**
-     * Extract memory IDs from QMD search results for access tracking.
-     */
     private extractMemoryIdsFromResults;
     recordMemoryFeedback(memoryId: string, vote: "up" | "down", note?: string): Promise<void>;
     recordNotUsefulMemories(memoryIds: string[], note?: string): Promise<void>;
     getLastRecall(sessionKey: string): LastRecallSnapshot | null;
+    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
@@ -3049,4 +3055,4 @@ declare class Orchestrator {
     private readArchivedMemoriesForNamespaces;
 }
 
-export { type GraphRecallShadowComparison as $, memoryStatusForMode as A, resolveSpeaker as B, ConversationIndexCoordinator as C, DEFAULT_SELF_NAME as D, resolveSyncDates as E, sanitizeSessionKeyForFilename as F, type GraphRecallSnapshot as G, saveSpeakerRegistry as H, type IntentDebugSnapshot as I, speakerRegistryKey as J, speakersFilePath as K, syncWearableSource as L, wearableDayTag as M, wearableSourceLabel as N, Orchestrator as O, type PatternReinforcementResult as P, writeDailyDigestMemory as Q, type ResolvedScopeProfilePlan as R, type ScopeProfileLayerResolution as S, TierMigrationCoordinator as T, type BulkImportBatchIngestResult as U, BulkImportBatchPartialFailureError as V, WearablesService as W, COMPACTION_SIGNAL_MAX_AGE_MS as X, type DaySummaryGatherOptions as Y, type ExtractionRunResult as Z, type GraphRecallRankedResult as _, type ScopeProfilePromotionResolution as a, type QmdRecallSnapshot as a0, type QueryAwarePrefilter as a1, type RecallInvocationOptions as a2, type RecallModeDecision as a3, appendMemoryToGraphContext as a4, applyQueryAwareCandidateFilter as a5, blendGraphExpandedRecallScore as a6, buildCompressionGuidelinesMarkdown as a7, buildMemoryPathById as a8, computeArtifactCandidateFetchLimit as a9, shouldFilterLifecycleRecallCandidate as aA, splitTurnsBySourceValidAt as aB, summarizeGraphShadowComparison as aC, targetSourceValidAtSortMs as aD, throwIfRecallAborted as aE, tokenizeRecallQuery as aF, utcDateKeysForLocalDay as aG, computeArtifactRecallLimit as aa, computeQmdHybridFetchLimit as ab, deriveTopicsFromExtraction as ac, filterHourlySummaryMarkdownForLocalDay as ad, filterRecallCandidates as ae, formatDateInTimeZone as af, graphPathRelativeToStorage as ag, hasIdentityRecoveryIntent as ah, isArtifactMemoryPath as ai, lifecycleRecallScoreAdjustment as aj, mapRecallSourceToXrayServedBy as ak, mergeArtifactRecallCandidates as al, mergeGraphExpandedResults as am, normalizeIanaTimeZone as an, parseFiniteDate as ao, parseGraphRecallRankedResults as ap, parseMemoryIntentSnapshot as aq, parseQmdRecallResults as ar, qmdStartupCollectionCheckWithTimeout as as, raceRecallAbort as at, resolveEffectiveIdentityInjectionMode as au, resolveEffectiveRecallMode as av, resolvePersistedMemoryRelativePath as aw, resolveRecallModeDecision as ax, resolveRecallModeDecisionAsync as ay, resolveRecentThreadMemoryPaths as az, 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 };
+export { type RecallInvocationOptions as $, sanitizeSessionKeyForFilename as A, saveSpeakerRegistry as B, ConversationIndexCoordinator as C, DEFAULT_SELF_NAME as D, speakerRegistryKey as E, speakersFilePath as F, type GraphRecallSnapshot as G, syncWearableSource as H, type IntentDebugSnapshot as I, wearableDayTag as J, wearableSourceLabel as K, writeDailyDigestMemory as L, type BulkImportBatchIngestResult as M, BulkImportBatchPartialFailureError as N, Orchestrator as O, type PatternReinforcementResult as P, COMPACTION_SIGNAL_MAX_AGE_MS as Q, type ResolvedSpeaker as R, type SpeakerRegistry as S, TierMigrationCoordinator as T, type DaySummaryGatherOptions as U, type ExtractionRunResult as V, WearablesService as W, type GraphRecallRankedResult as X, type GraphRecallShadowComparison as Y, type QmdRecallSnapshot as Z, type QueryAwarePrefilter as _, type SpeakerOverride as a, type RecallModeDecision as a0, appendMemoryToGraphContext as a1, applyQueryAwareCandidateFilter as a2, blendGraphExpandedRecallScore as a3, buildCompressionGuidelinesMarkdown as a4, buildMemoryPathById as a5, computeArtifactCandidateFetchLimit as a6, computeArtifactRecallLimit as a7, computeQmdHybridFetchLimit as a8, deriveTopicsFromExtraction as a9, targetSourceValidAtSortMs as aA, throwIfRecallAborted as aB, tokenizeRecallQuery as aC, utcDateKeysForLocalDay as aD, filterHourlySummaryMarkdownForLocalDay as aa, filterRecallCandidates as ab, formatDateInTimeZone as ac, graphPathRelativeToStorage as ad, hasIdentityRecoveryIntent as ae, isArtifactMemoryPath as af, lifecycleRecallScoreAdjustment as ag, mapRecallSourceToXrayServedBy as ah, mergeArtifactRecallCandidates as ai, mergeGraphExpandedResults as aj, normalizeIanaTimeZone as ak, parseFiniteDate as al, parseGraphRecallRankedResults as am, parseMemoryIntentSnapshot as an, parseQmdRecallResults as ao, qmdStartupCollectionCheckWithTimeout as ap, raceRecallAbort as aq, resolveEffectiveIdentityInjectionMode as ar, resolveEffectiveRecallMode as as, resolvePersistedMemoryRelativePath as at, resolveRecallModeDecision as au, resolveRecallModeDecisionAsync as av, resolveRecentThreadMemoryPaths as aw, shouldFilterLifecycleRecallCandidate as ax, splitTurnsBySourceValidAt as ay, summarizeGraphShadowComparison as az, 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 };

package/dist/orchestrator.d.ts

@@ -1,41 +1,47 @@
+import './recall-state.js';
 import './briefing.js';
 import './buffer.js';
 import './extraction-faithfulness.js';
 import './search/port.js';
-import './storage-CrvzaM9C.js';
+import './storage-NIyKYD8g.js';
 import './transcript.js';
 import './summarizer.js';
 import './local-llm.js';
 import './fallback-llm.js';
 import './orchestration/maintenance.js';
-export { U as BulkImportBatchIngestResult, V as BulkImportBatchPartialFailureError, X as COMPACTION_SIGNAL_MAX_AGE_MS, Y as DaySummaryGatherOptions, Z as ExtractionRunResult, _ as GraphRecallRankedResult, $ as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, a0 as QmdRecallSnapshot, a1 as QueryAwarePrefilter, a2 as RecallInvocationOptions, a3 as RecallModeDecision, a4 as appendMemoryToGraphContext, a5 as applyQueryAwareCandidateFilter, a6 as blendGraphExpandedRecallScore, a7 as buildCompressionGuidelinesMarkdown, a8 as buildMemoryPathById, a9 as computeArtifactCandidateFetchLimit, aa as computeArtifactRecallLimit, ab as computeQmdHybridFetchLimit, t as defaultWorkspaceDir, ac as deriveTopicsFromExtraction, ad as filterHourlySummaryMarkdownForLocalDay, ae as filterRecallCandidates, af as formatDateInTimeZone, ag as graphPathRelativeToStorage, ah as hasIdentityRecoveryIntent, ai as isArtifactMemoryPath, aj as lifecycleRecallScoreAdjustment, ak as mapRecallSourceToXrayServedBy, al as mergeArtifactRecallCandidates, am as mergeGraphExpandedResults, an as normalizeIanaTimeZone, ao as parseFiniteDate, ap as parseGraphRecallRankedResults, aq as parseMemoryIntentSnapshot, ar as parseQmdRecallResults, as as qmdStartupCollectionCheckWithTimeout, at as raceRecallAbort, au as resolveEffectiveIdentityInjectionMode, av as resolveEffectiveRecallMode, aw as resolvePersistedMemoryRelativePath, ax as resolveRecallModeDecision, ay as resolveRecallModeDecisionAsync, az as resolveRecentThreadMemoryPaths, F as sanitizeSessionKeyForFilename, aA as shouldFilterLifecycleRecallCandidate, aB as splitTurnsBySourceValidAt, aC as summarizeGraphShadowComparison, aD as targetSourceValidAtSortMs, aE as throwIfRecallAborted, aF as tokenizeRecallQuery, aG as utcDateKeysForLocalDay } from './orchestrator-BbZ_dQSU.js';
+export { M as BulkImportBatchIngestResult, N as BulkImportBatchPartialFailureError, Q as COMPACTION_SIGNAL_MAX_AGE_MS, U as DaySummaryGatherOptions, V as ExtractionRunResult, X as GraphRecallRankedResult, Y as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Z as QmdRecallSnapshot, _ as QueryAwarePrefilter, $ as RecallInvocationOptions, a0 as RecallModeDecision, a1 as appendMemoryToGraphContext, a2 as applyQueryAwareCandidateFilter, a3 as blendGraphExpandedRecallScore, a4 as buildCompressionGuidelinesMarkdown, a5 as buildMemoryPathById, a6 as computeArtifactCandidateFetchLimit, a7 as computeArtifactRecallLimit, a8 as computeQmdHybridFetchLimit, q as defaultWorkspaceDir, a9 as deriveTopicsFromExtraction, aa as filterHourlySummaryMarkdownForLocalDay, ab as filterRecallCandidates, ac as formatDateInTimeZone, ad as graphPathRelativeToStorage, ae as hasIdentityRecoveryIntent, af as isArtifactMemoryPath, ag as lifecycleRecallScoreAdjustment, ah as mapRecallSourceToXrayServedBy, ai as mergeArtifactRecallCandidates, aj as mergeGraphExpandedResults, ak as normalizeIanaTimeZone, al as parseFiniteDate, am as parseGraphRecallRankedResults, an as parseMemoryIntentSnapshot, ao as parseQmdRecallResults, ap as qmdStartupCollectionCheckWithTimeout, aq as raceRecallAbort, ar as resolveEffectiveIdentityInjectionMode, as as resolveEffectiveRecallMode, at as resolvePersistedMemoryRelativePath, au as resolveRecallModeDecision, av as resolveRecallModeDecisionAsync, aw as resolveRecentThreadMemoryPaths, A as sanitizeSessionKeyForFilename, ax as shouldFilterLifecycleRecallCandidate, ay as splitTurnsBySourceValidAt, az as summarizeGraphShadowComparison, aA as targetSourceValidAtSortMs, aB as throwIfRecallAborted, aC as tokenizeRecallQuery, aD as utcDateKeysForLocalDay } from './orchestrator-CQJ8U7En.js';
 export { formatCompressionGuidelinesForRecall } from './orchestration/compression-guideline-coordinator.js';
 import './live-connectors-runner.js';
 import './model-registry.js';
 import './relevance.js';
 import './negative.js';
-import './recall-state.js';
 import './recall-xray.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
 import './semantic-TddhF0y7.js';
+import './capabilities.js';
 import './replay/types.js';
-import './types-Bl4BWDM8.js';
+import './types-D_fG2ix8.js';
 import './lcm/engine.js';
-import './semantic-consolidation-fvdZRa5Z.js';
-import './catalog-uX9sT9ws.js';
+import './semantic-consolidation-DILZEQq3.js';
+import './catalog-BWqHb5HT.js';
+import './scope-profiles-EpJG7yKP.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 './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './types-continuity.js';
 import './page-versioning.js';
 import './consolidation-operator.js';
 import './memory-projection-store.js';
 import './maintenance/memory-governance.js';
-import './message-parts/index.js';
 import './runtime/better-sqlite.js';
 import 'better-sqlite3';
+import './write-envelope.js';
 import './structured-attributes.js';
 import './resolve-provider-secret.js';
 import './session-integrity.js';
@@ -61,7 +67,6 @@ import './conversation-index/chunker.js';
 import './conversation-index/backend.js';
 import './faiss-adapter-BHecI1fF.js';
 import './runtime/child-process.js';
-import './capabilities.js';
 import './namespaces/storage.js';
 import './threading.js';
 import './graph.js';