@remnic/core 9.3.623 → 9.3.625

package/dist/{orchestrator-CqWOjfgl.d.ts → orchestrator-CEycaY3M.d.ts}

@@ -13,12 +13,12 @@ import { LastRecallStore, TierMigrationStatusStore, GraphRecallExpandedEntry, Ti
 import { RecallXraySnapshot } from './recall-xray.js';
 import { SessionObserverState } from './session-observer-state.js';
 import { EmbeddingFallback } from './embedding-fallback.js';
-import { S as SemanticDedupHit } from './semantic-SLAa_prH.js';
+import { a as SemanticDedupHit } from './semantic-DJR8_DMQ.js';
 import { ReplayTurn } from './replay/types.js';
 import { I as ImportTurn } from './types-BliCnURB.js';
-import { PluginConfig, CodingContext, QmdSearchResult, BehaviorLoopPolicyState, BootstrapOptions, BootstrapResult, ConsolidationObservation, MemoryFile, DaySummaryResult, MemoryActionEvent, RecallPlanMode, MemoryIntent, EntityTimelineEntry, ExtractionResult, MemoryFrontmatter, IdentityInjectionMode } from './types.js';
+import { N as BufferTurn, af as ExtractionResult, M as MemoryCategory, I as ImportanceScore, j as MemoryStatus, aw as WearableConversation, ax as WearableSourceSettings, ay as WearableNativeMemory, az as WearableMemoryMode, aA as WearableSourceConnector, aB as WearablesConfig, aC as WearableSyncSummary, aD as WearableSourceStatus, aE as WearableDayTranscript, aF as WearableCorrectionRule, P as PluginConfig, aG as CodingContext, Q as QmdSearchResult, e as BehaviorLoopPolicyState, aH as BootstrapOptions, aI as BootstrapResult, aJ as ConsolidationObservation, g as MemoryFile, ah as DaySummaryResult, m as MemoryActionEvent, H as RecallPlanMode, ai as MemoryIntent, aK as EntityTimelineEntry, i as MemoryFrontmatter, J as IdentityInjectionMode } from './types-D5VRAI04.js';
 import { LcmEngine } from './lcm/engine.js';
-import { S as SemanticConsolidationResult } from './semantic-consolidation-4HkHWgeI.js';
+import { S as SemanticConsolidationResult } from './semantic-consolidation-FbhPeJjB.js';
 import { ConversationIndexBackendInspection } from './conversation-index/backend.js';
 import { SharedContextManager } from './shared-context/manager.js';
 import { CompoundingEngine } from './compounding/engine.js';
@@ -86,6 +86,354 @@ interface PatternReinforcementResult {
     clusters: PatternReinforcementClusterResult[];
 }
 
+/**
+ * Wearable speaker registry — maps provider diarization labels to
+ * human names, persistently, per source.
+ *
+ * Providers expose speakers differently (Limitless: names + a "user"
+ * marker; Bee: opaque labels like "0"/"1"; Omi: "SPEAKER_00" + is_user
+ * + optional person ids). The registry stores operator-confirmed
+ * mappings keyed `<sourceId>:<speakerKey>` in
+ * `state/wearables/speakers.json`, plus the wearer's display name.
+ *
+ * Resolution precedence (most-authoritative first):
+ *   1. registry override for `<sourceId>:<speakerKey>`
+ *   2. provider-identified wearer  -> selfName
+ *   3. provider-supplied speaker name
+ *   4. the raw speaker key, prefixed "Speaker" when it is bare digits
+ */
+interface SpeakerOverride {
+    name: string;
+    /** Mark this speaker as the wearer (their words become "you"). */
+    isSelf?: boolean;
+    updatedAt: string;
+}
+interface SpeakerRegistry {
+    version: 1;
+    /** Display name used for the wearer across all sources. */
+    selfName: string;
+    /** Overrides keyed `<sourceId>:<speakerKey>`. */
+    speakers: Record<string, SpeakerOverride>;
+}
+declare const DEFAULT_SELF_NAME = "Me";
+declare function emptySpeakerRegistry(): SpeakerRegistry;
+declare function speakersFilePath(memoryDir: string): string;
+declare function loadSpeakerRegistry(memoryDir: string): Promise<SpeakerRegistry>;
+declare function saveSpeakerRegistry(memoryDir: string, registry: SpeakerRegistry): Promise<void>;
+declare function speakerRegistryKey(sourceId: string, speakerKey: string): string;
+interface ResolvedSpeaker {
+    /** Display label used in transcripts, e.g. "Jane" or "Me (you)". */
+    label: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+}
+declare function resolveSpeaker(sourceId: string, segment: {
+    speakerKey: string;
+    speakerName?: string;
+    isWearer?: boolean;
+}, registry: SpeakerRegistry): ResolvedSpeaker;
+/**
+ * Distinct speaker labels for a set of segments, in first-appearance
+ * order — used for day-transcript frontmatter.
+ */
+declare function distinctSpeakerLabels(sourceId: string, segments: Array<{
+    speakerKey: string;
+    speakerName?: string;
+    isWearer?: boolean;
+}>, registry: SpeakerRegistry): string[];
+
+/**
+ * Wearable memory generation — trust-gated extraction from cleaned day
+ * transcripts.
+ *
+ * Wearable ASR quality varies wildly between providers and rooms, so
+ * unlike live-session extraction this path is gated per source:
+ *
+ *  - memoryMode "off"     -> never runs
+ *  - memoryMode "review"  -> candidates land with status
+ *                            "pending_review" (operator approves via
+ *                            the existing review-queue surfaces)
+ *  - memoryMode "auto"    -> candidates that pass every gate land
+ *                            active
+ *
+ * Deterministic gates (applied in order, all modes except "off"):
+ *  1. category gate     — procedure / reasoning_trace candidates are
+ *                         skipped (they need richer persistence than
+ *                         this path provides)
+ *  2. confidence floor  — `minConfidence`
+ *  3. importance floor  — local `scoreImportance` >= `minImportance`
+ *  4. dedup             — storage content-hash index + intra-run set
+ *  5. day cap           — top `maxMemoriesPerDay` by importance score
+ *                         (0 disables the cap)
+ *
+ * The extraction engine itself is injected so this module stays free of
+ * LLM-client construction; callers hand in `orchestrator`-owned or
+ * 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;
+        importance?: ImportanceScore;
+        validAt?: string;
+        structuredAttributes?: Record<string, string>;
+        contentHashSource?: string;
+        status?: MemoryStatus;
+        memoryKind?: "episode" | "note" | "box" | "dream" | "procedural";
+    }): Promise<string>;
+    hasFactContentHash(content: string): Promise<boolean>;
+}
+interface WearableMemoryGenDeps {
+    extract(turns: BufferTurn[]): Promise<ExtractionResult>;
+    writer: WearableMemoryWriter;
+}
+interface WearableMemoryGenResult {
+    created: number;
+    skipped: number;
+    skippedByReason: Record<string, number>;
+    /** Non-fatal problems (e.g. the extraction engine erroring). */
+    warnings: string[];
+}
+declare const WEARABLE_SOURCE_PREFIX = "wearable";
+declare function wearableSourceLabel(sourceId: string): string;
+declare function wearableDayTag(date: string): string;
+/**
+ * Render a cleaned conversation into extraction-ready turns. Each turn
+ * carries a labeled multi-speaker transcript block; the wearer is
+ * marked "(you)" so first-person facts attribute correctly.
+ */
+declare function buildExtractionTurns(sourceId: string, date: string, conversation: WearableConversation, registry: SpeakerRegistry): BufferTurn[];
+/**
+ * Run extraction + gates over a day's conversations and persist the
+ * survivors. Returns counts for the sync summary.
+ */
+declare function generateWearableMemories(sourceId: string, date: string, conversations: WearableConversation[], settings: WearableSourceSettings, registry: SpeakerRegistry, deps: WearableMemoryGenDeps): Promise<WearableMemoryGenResult>;
+/**
+ * Write one compact daily-digest memory summarizing the day's recorded
+ * conversations. Deterministic (no LLM): titles, time ranges, speaker
+ * counts. Gated by `wearables.digestEnabled`.
+ */
+declare function writeDailyDigestMemory(sourceId: string, date: string, conversations: WearableConversation[], settings: WearableSourceSettings, registry: SpeakerRegistry, writer: WearableMemoryWriter): Promise<boolean>;
+/**
+ * Import provider-extracted memories (Bee facts, Omi memories) into the
+ * review queue. Always `pending_review` regardless of memoryMode — the
+ * provider's extraction quality is outside Remnic's control.
+ */
+declare function importNativeMemories(sourceId: string, memories: WearableNativeMemory[], alreadyImportedIds: ReadonlySet<string>, writer: WearableMemoryWriter): Promise<{
+    imported: number;
+    importedIds: string[];
+}>;
+
+/**
+ * Wearable sync pipeline — pull → clean → label → correct → store →
+ * (optionally) remember, for one source.
+ *
+ * Stage order per conversation is deliberate:
+ *  1. off-the-record elision  (before anything can persist the span)
+ *  2. cleanup                 (merging first lets redaction see numbers
+ *                              that ASR split across segments)
+ *  3. redaction               (built-in + user patterns)
+ *  4. corrections             (user-specific word fixes)
+ *
+ * Day files are rebuilt idempotently; the per-day body hash recorded in
+ * sync state lets unchanged days skip both the rewrite and the
+ * (expensive) memory extraction. Sync state advances only after every
+ * write for the run has succeeded.
+ */
+
+interface WearableSyncOptions {
+    /** Sync exactly this day (YYYY-MM-DD). Overrides `days`. */
+    date?: string;
+    /** Lookback window in days ending today (default 2, max 90). */
+    days?: number;
+    /** Re-run memory extraction even for unchanged days. */
+    forceMemories?: boolean;
+    signal?: AbortSignal;
+}
+interface WearableSyncDeps {
+    /** Memory dir for state files (speakers, corrections, sync ledger). */
+    memoryDir: string;
+    /** Read the stored content hash for a day file, if present. */
+    readDayContentHash(sourceId: string, date: string): Promise<string | null>;
+    /** Persist a serialized day-transcript file (atomic). */
+    writeDayTranscript(sourceId: string, date: string, serialized: string): Promise<void>;
+    /** Optional hook fired once after any day files changed (reindex). */
+    afterTranscriptsWritten?(): Promise<void>;
+    /**
+     * Memory-generation dependencies, or null when no extraction engine
+     * is available in this context (transcripts still sync; memory
+     * creation is skipped with a warning when the mode wanted it).
+     */
+    memoryGen: WearableMemoryGenDeps | null;
+    /** Clock injection for tests. */
+    now?: () => Date;
+}
+/** Format a Date as YYYY-MM-DD in the given IANA timezone. */
+declare function dateInTimezone(date: Date, timezone: string): string;
+/** Resolve the list of days to sync, oldest first. */
+declare function resolveSyncDates(options: WearableSyncOptions, timezone: string, now: Date): string[];
+/** Sync one source. */
+declare function syncWearableSource(connector: WearableSourceConnector, settings: WearableSourceSettings, config: WearablesConfig, options: WearableSyncOptions, deps: WearableSyncDeps): Promise<WearableSyncSummary>;
+declare function defaultTimezone(): string;
+
+/**
+ * WearablesService — the single implementation behind every wearables
+ * access surface (CLI, MCP tools, HTTP routes). Surfaces stay thin and
+ * delegate here; formatting differences live with the surface, behavior
+ * lives here (same renderer-sharing rule as recall explain/xray).
+ */
+
+/** Storage capabilities the service needs (satisfied by StorageManager). */
+interface WearableStorageIo {
+    readonly dir: string;
+    writeWearableDayTranscript(sourceId: string, date: string, serialized: string): Promise<void>;
+    readWearableDayTranscript(sourceId: string, date: string): Promise<string | null>;
+    listWearableTranscriptDays(sourceId?: string): Promise<Array<{
+        source: string;
+        date: string;
+    }>>;
+    readAllMemories(): Promise<Array<{
+        path: string;
+        frontmatter: {
+            id: string;
+            source: string;
+            created: string;
+            tags: string[];
+            status?: string;
+            structuredAttributes?: Record<string, string>;
+        };
+        content: string;
+    }>>;
+    writeMemory: WearableMemoryGenDeps["writer"]["writeMemory"];
+    hasFactContentHash(content: string): Promise<boolean>;
+}
+interface WearableSearchBackend {
+    /** Full-text search over the memory dir; null when unavailable. */
+    search(query: string, maxResults: number): Promise<Array<{
+        path: string;
+        score: number;
+        preview: string;
+    }> | null>;
+}
+interface WearablesServiceDeps {
+    config: WearablesConfig;
+    getStorage(): Promise<WearableStorageIo>;
+    /** Extraction hook; null when no engine is available. */
+    extract: WearableMemoryGenDeps["extract"] | null;
+    /** Search backend (QMD); null disables indexed search. */
+    searchBackend: WearableSearchBackend | null;
+    /** Fired after transcript writes so the search index refreshes. */
+    reindexSearch?: () => Promise<void>;
+}
+interface WearableTranscriptSearchResult {
+    source: string;
+    date: string;
+    score: number;
+    snippet: string;
+    /** "indexed" (QMD) or "scan" (substring fallback). */
+    backend: "indexed" | "scan";
+}
+interface WearableMemorySearchResult {
+    id: string;
+    source: string;
+    date?: string;
+    conversationId?: string;
+    status?: string;
+    content: string;
+    created: string;
+}
+interface WearableDayTranscriptView {
+    source: string;
+    date: string;
+    meta: WearableDayTranscript["meta"] | null;
+    body: string;
+    /** Other sources that also recorded during this day (overlap hint). */
+    overlapsWith: string[];
+}
+declare class WearablesService {
+    private readonly deps;
+    constructor(deps: WearablesServiceDeps);
+    get enabled(): boolean;
+    private assertEnabled;
+    private timezone;
+    private enabledSources;
+    /** Status for every configured source (and connector availability). */
+    status(): Promise<{
+        enabled: boolean;
+        timezone: string;
+        sources: WearableSourceStatus[];
+        connectorsInstalled: string[];
+    }>;
+    /** Run a sync for one source or all enabled sources. */
+    sync(options: WearableSyncOptions & {
+        source?: string;
+    }): Promise<WearableSyncSummary[]>;
+    /** Verify connectivity/credentials for one source. */
+    checkAuth(sourceId: string): Promise<{
+        ok: boolean;
+        detail?: string;
+    }>;
+    /**
+     * Full transcript(s) for a day. Without `source`, returns every
+     * source that recorded that day, annotated with overlap hints.
+     */
+    dayTranscript(date: string, sourceId?: string): Promise<WearableDayTranscriptView[]>;
+    /** List days that have stored transcripts. */
+    listDays(sourceId?: string): Promise<Array<{
+        source: string;
+        date: string;
+    }>>;
+    /**
+     * Search stored transcripts. Uses the indexed backend when available
+     * and falls back to a bounded substring scan otherwise — the two
+     * paths are distinguishable in the result (`backend`) so callers can
+     * tell "no hits" from "weaker search ran".
+     */
+    searchTranscripts(query: string, options?: {
+        source?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<WearableTranscriptSearchResult[]>;
+    /**
+     * Memories created from wearable transcripts, filterable by source
+     * and/or day. Includes pending_review candidates — the whole point of
+     * review mode is seeing what's queued.
+     */
+    transcriptMemories(options?: {
+        source?: string;
+        date?: string;
+        limit?: number;
+    }): Promise<WearableMemorySearchResult[]>;
+    listSpeakers(): Promise<SpeakerRegistry>;
+    setSpeaker(sourceId: string, speakerKey: string, name: string, opts?: {
+        isSelf?: boolean;
+    }): Promise<SpeakerRegistry>;
+    setSelfName(name: string): Promise<SpeakerRegistry>;
+    removeSpeaker(sourceId: string, speakerKey: string): Promise<SpeakerRegistry>;
+    listCorrections(): Promise<{
+        fromConfig: WearableCorrectionRule[];
+        fromState: WearableCorrectionRule[];
+        stateFilePath: string;
+    }>;
+    addCorrection(rule: WearableCorrectionRule): Promise<void>;
+    removeCorrection(index: number): Promise<WearableCorrectionRule>;
+}
+/** Map an indexed-search hit path back to (source, date), or null. */
+declare function locateTranscriptPath(hitPath: string): {
+    source: string;
+    date: string;
+} | null;
+
 declare function dedupeEntitySynthesisEvidenceEntries(entries: EntityTimelineEntry[]): EntityTimelineEntry[];
 interface GraphRecallSnapshot {
     recordedAt: string;
@@ -473,6 +821,7 @@ declare class Orchestrator {
     private consolidationInFlight;
     private readonly consolidationObservers;
     private qmdMaintenanceTimer;
+    private wearablesServiceInstance;
     private qmdMaintenancePending;
     private qmdMaintenanceInFlight;
     private lastQmdEmbedAtMs;
@@ -943,6 +1292,14 @@ declare class Orchestrator {
      * and through `ingestBulkImportBatch`.
      */
     bulkImportWriteNamespace(): string;
+    /**
+     * Lazily-constructed wearables service (Limitless / Bee / Omi
+     * transcript ingestion). All wearables surfaces — CLI, MCP tools,
+     * HTTP routes — share this one instance so sync state, search, and
+     * memory writes stay consistent. Writes are pinned to the same
+     * deterministic namespace bulk-import uses.
+     */
+    getWearablesService(): WearablesService;
     /**
      * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
      * normalizes user/assistant turns into the extraction buffer and awaits
@@ -1214,4 +1571,4 @@ declare class Orchestrator {
     private readArchivedMemoriesForNamespaces;
 }
 
-export { resolveRecallModeDecisionAsync as A, resolveRecentThreadMemoryPaths as B, shouldFilterLifecycleRecallCandidate as C, summarizeGraphShadowComparison as D, type GraphRecallSnapshot as G, type IntentDebugSnapshot as I, Orchestrator as O, type PatternReinforcementResult as P, type QmdRecallSnapshot as Q, type RecallInvocationOptions as R, type GraphRecallRankedResult as a, type GraphRecallShadowComparison as b, type RecallModeDecision as c, defaultWorkspaceDir as d, appendMemoryToGraphContext as e, blendGraphExpandedRecallScore as f, buildCompressionGuidelinesMarkdown as g, buildMemoryPathById as h, computeArtifactCandidateFetchLimit as i, computeArtifactRecallLimit as j, computeQmdHybridFetchLimit as k, dedupeEntitySynthesisEvidenceEntries as l, deriveTopicsFromExtraction as m, filterRecallCandidates as n, formatCompressionGuidelinesForRecall as o, graphPathRelativeToStorage as p, hasIdentityRecoveryIntent as q, isArtifactMemoryPath as r, sanitizeSessionKeyForFilename as s, lifecycleRecallScoreAdjustment as t, mergeArtifactRecallCandidates as u, mergeGraphExpandedResults as v, resolveEffectiveIdentityInjectionMode as w, resolveEffectiveRecallMode as x, resolvePersistedMemoryRelativePath as y, resolveRecallModeDecision as z };
+export { computeQmdHybridFetchLimit 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 GraphRecallRankedResult as L, type GraphRecallShadowComparison as M, type RecallInvocationOptions as N, Orchestrator as O, type PatternReinforcementResult as P, type QmdRecallSnapshot as Q, type ResolvedSpeaker as R, type SpeakerRegistry as S, type RecallModeDecision as T, appendMemoryToGraphContext as U, blendGraphExpandedRecallScore as V, WearablesService as W, buildCompressionGuidelinesMarkdown as X, buildMemoryPathById as Y, computeArtifactCandidateFetchLimit as Z, computeArtifactRecallLimit as _, type SpeakerOverride as a, dedupeEntitySynthesisEvidenceEntries as a0, deriveTopicsFromExtraction as a1, filterRecallCandidates as a2, formatCompressionGuidelinesForRecall 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 };

package/dist/orchestrator.d.ts

@@ -6,7 +6,7 @@ import './summarizer.js';
 import './local-llm.js';
 import './fallback-llm.js';
 import './live-connectors-runner.js';
-export { a as GraphRecallRankedResult, b as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, R as RecallInvocationOptions, c as RecallModeDecision, e as appendMemoryToGraphContext, f as blendGraphExpandedRecallScore, g as buildCompressionGuidelinesMarkdown, h as buildMemoryPathById, i as computeArtifactCandidateFetchLimit, j as computeArtifactRecallLimit, k as computeQmdHybridFetchLimit, l as dedupeEntitySynthesisEvidenceEntries, d as defaultWorkspaceDir, m as deriveTopicsFromExtraction, n as filterRecallCandidates, o as formatCompressionGuidelinesForRecall, p as graphPathRelativeToStorage, q as hasIdentityRecoveryIntent, r as isArtifactMemoryPath, t as lifecycleRecallScoreAdjustment, u as mergeArtifactRecallCandidates, v as mergeGraphExpandedResults, w as resolveEffectiveIdentityInjectionMode, x as resolveEffectiveRecallMode, y as resolvePersistedMemoryRelativePath, z as resolveRecallModeDecision, A as resolveRecallModeDecisionAsync, B as resolveRecentThreadMemoryPaths, s as sanitizeSessionKeyForFilename, C as shouldFilterLifecycleRecallCandidate, D as summarizeGraphShadowComparison } from './orchestrator-CqWOjfgl.js';
+export { L as GraphRecallRankedResult, M as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, N as RecallInvocationOptions, T as RecallModeDecision, U as appendMemoryToGraphContext, V as blendGraphExpandedRecallScore, X as buildCompressionGuidelinesMarkdown, Y as buildMemoryPathById, Z as computeArtifactCandidateFetchLimit, _ as computeArtifactRecallLimit, $ as computeQmdHybridFetchLimit, a0 as dedupeEntitySynthesisEvidenceEntries, q as defaultWorkspaceDir, a1 as deriveTopicsFromExtraction, a2 as filterRecallCandidates, a3 as formatCompressionGuidelinesForRecall, 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-CEycaY3M.js';
 import './model-registry.js';
 import './relevance.js';
 import './negative.js';
@@ -14,12 +14,12 @@ import './recall-state.js';
 import './recall-xray.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
-import './semantic-SLAa_prH.js';
+import './semantic-DJR8_DMQ.js';
 import './replay/types.js';
 import './types-BliCnURB.js';
-import './types.js';
+import './types-D5VRAI04.js';
 import './lcm/engine.js';
-import './semantic-consolidation-4HkHWgeI.js';
+import './semantic-consolidation-FbhPeJjB.js';
 import './conversation-index/backend.js';
 import './shared-context/manager.js';
 import './compounding/engine.js';

package/dist/orchestrator.js

@@ -27,7 +27,7 @@ import {
   sanitizeSessionKeyForFilename,
   shouldFilterLifecycleRecallCandidate,
   summarizeGraphShadowComparison
-} from "./chunk-RKW6QR7W.js";
+} from "./chunk-AZ4RI3QD.js";
 import "./chunk-5RIRL3XL.js";
 import "./chunk-4HFJQCJZ.js";
 import "./chunk-6BDVBBBY.js";
@@ -42,7 +42,7 @@ import "./chunk-UWK5OXUJ.js";
 import "./chunk-TECVW3JP.js";
 import "./chunk-T2PO5MUF.js";
 import "./chunk-HP5FMB6L.js";
-import "./chunk-2L54V4ZO.js";
+import "./chunk-UELS6WWF.js";
 import "./chunk-DRD2Q7HQ.js";
 import "./chunk-LXOM6IQU.js";
 import "./chunk-S75M5ZRK.js";
@@ -83,7 +83,7 @@ import "./chunk-54V4BZWP.js";
 import "./chunk-XZ4WBBB5.js";
 import "./chunk-77NAFXUD.js";
 import "./chunk-DB5A3NHS.js";
-import "./chunk-BNW5NJJH.js";
+import "./chunk-LQYTQCXM.js";
 import "./chunk-6NKAQ74D.js";
 import "./chunk-OAZ5MFUB.js";
 import "./chunk-PYPOFEMK.js";
@@ -94,17 +94,17 @@ import "./chunk-6HEM6HTQ.js";
 import "./chunk-XCAZF7KQ.js";
 import "./chunk-3PG3H5TD.js";
 import "./chunk-OD4FM2U7.js";
-import "./chunk-QFQQFX2H.js";
-import "./chunk-UGEBPVNI.js";
+import "./chunk-3R2UZV3U.js";
+import "./chunk-GE7Q7KXP.js";
 import "./chunk-LN4YGHTM.js";
 import "./chunk-JLNBQWZ2.js";
 import "./chunk-2PRQG7PV.js";
 import "./chunk-X6IRLNOO.js";
 import "./chunk-2F6NP3NT.js";
 import "./chunk-TERNBNJB.js";
-import "./chunk-R3OQGYOU.js";
+import "./chunk-P2D2MM47.js";
 import "./chunk-W4RVMTHR.js";
-import "./chunk-2UFQYU5F.js";
+import "./chunk-57QXN2CS.js";
 import "./chunk-ZRWB5D4H.js";
 import "./chunk-A6D7A2FW.js";
 import "./chunk-FF4KLI5W.js";
@@ -119,7 +119,7 @@ import "./chunk-CYEPCZN5.js";
 import "./chunk-DCGT4FPP.js";
 import "./chunk-Q4CAQGKQ.js";
 import "./chunk-CINZGPSJ.js";
-import "./chunk-W3BKVM64.js";
+import "./chunk-QDV6VAD4.js";
 import "./chunk-ZFXCQPNO.js";
 import "./chunk-Q6YIJGXJ.js";
 import "./chunk-ORFGK3XI.js";
@@ -150,6 +150,7 @@ import "./chunk-7SI52C65.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-RK6F44Y6.js";
+import "./chunk-NDAH7BJ5.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-LBJBNWS2.js";
 import "./chunk-KD3QD3A5.js";
@@ -158,9 +159,10 @@ import "./chunk-H3FZVNRN.js";
 import "./chunk-HQ6NIBL6.js";
 import "./chunk-PVGDJXVK.js";
 import "./chunk-OADWQ5CR.js";
+import "./chunk-7WV3F5DQ.js";
 import "./chunk-EDQVAMQI.js";
 import "./chunk-JGSKJHF7.js";
-import "./chunk-BPSGLMQ4.js";
+import "./chunk-YQNADJCT.js";
 import "./chunk-CI7RKSRE.js";
 import "./chunk-6HMYUWXR.js";
 import "./chunk-EI6V5UXY.js";
@@ -171,10 +173,10 @@ import "./chunk-H3PHZLMF.js";
 import "./chunk-XL7FK7PJ.js";
 import "./chunk-2LSZVONP.js";
 import "./chunk-DEUNUKTD.js";
-import "./chunk-PJGB7XRR.js";
+import "./chunk-UGHUNQ74.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-4R4KTDIE.js";
+import "./chunk-FPNQF475.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-MB5RSUW6.js";

package/dist/patterns-cli.d.ts

@@ -1,4 +1,4 @@
-import { MemoryCategory, MemoryFile } from './types.js';
+import { M as MemoryCategory, g as MemoryFile } from './types-D5VRAI04.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 

package/dist/policy-runtime.d.ts

@@ -1,4 +1,4 @@
-import { PluginConfig, BehaviorLoopPolicyState } from './types.js';
+import { P as PluginConfig, e as BehaviorLoopPolicyState } from './types-D5VRAI04.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 

package/dist/qmd-recall-cache.d.ts

@@ -1,4 +1,4 @@
-import { RecallPlanMode } from './types.js';
+import { H as RecallPlanMode } from './types-D5VRAI04.js';
 import { SearchQueryOptions } from './search/port.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';

package/dist/qmd.d.ts

@@ -1,4 +1,4 @@
-import { QmdSearchResult, QmdSearchExplain } from './types.js';
+import { Q as QmdSearchResult, aj as QmdSearchExplain } from './types-D5VRAI04.js';
 import { SearchBackend, SearchQueryOptions, SearchExecutionOptions } from './search/port.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';

package/dist/recall-disclosure-escalation.d.ts

@@ -1,4 +1,4 @@
-import { RecallDisclosure } from './types.js';
+import { K as RecallDisclosure } from './types-D5VRAI04.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 

package/dist/recall-explain-renderer.d.ts

@@ -1,5 +1,5 @@
 import { LastRecallSnapshot } from './recall-state.js';
-import { RecallTierExplain } from './types.js';
+import { R as RecallTierExplain } from './types-D5VRAI04.js';
 import { RecallXraySnapshot } from './recall-xray.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';

package/dist/recall-explain-renderer.js

@@ -5,10 +5,10 @@ import {
   toRecallExplainJson,
   toRecallExplainText,
   toRecallXraySnapshotFromLegacy
-} from "./chunk-PSUB67YB.js";
+} from "./chunk-PW6GURU3.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-BPSGLMQ4.js";
-import "./chunk-4R4KTDIE.js";
+import "./chunk-YQNADJCT.js";
+import "./chunk-FPNQF475.js";
 import "./chunk-AC5LO7IU.js";
 import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";

package/dist/recall-planner-llm.d.ts

@@ -1,4 +1,4 @@
-import { RecallPlanMode, PluginConfig } from './types.js';
+import { H as RecallPlanMode, P as PluginConfig } from './types-D5VRAI04.js';
 import { FallbackLlmClient, FallbackLlmOptions } from './fallback-llm.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';

package/dist/recall-state.d.ts

@@ -1,4 +1,4 @@
-import { RecallPlanMode, IdentityInjectionMode, RecallTierExplain } from './types.js';
+import { H as RecallPlanMode, J as IdentityInjectionMode, R as RecallTierExplain } from './types-D5VRAI04.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 

package/dist/recall-tag-filter.d.ts

@@ -1,6 +1,6 @@
 import { RecallFilterTrace } from './recall-xray.js';
 import './memory-provenance.js';
-import './types.js';
+import './types-D5VRAI04.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 import './user-model.js';

package/dist/recall-xray-cli.d.ts

@@ -1,5 +1,5 @@
 import { RecallXrayFormat } from './recall-xray-renderer.js';
-import { RecallDisclosure } from './types.js';
+import { K as RecallDisclosure } from './types-D5VRAI04.js';
 import './recall-xray.js';
 import './memory-provenance.js';
 import './user-model.js';

package/dist/recall-xray-cli.js

@@ -2,11 +2,11 @@ import {
   parseXrayBudgetFlag,
   parseXrayCliOptions,
   parseXrayDisclosureFlag
-} from "./chunk-3QSU4NFF.js";
-import "./chunk-PSUB67YB.js";
+} from "./chunk-QHXW3LZV.js";
+import "./chunk-PW6GURU3.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-BPSGLMQ4.js";
-import "./chunk-4R4KTDIE.js";
+import "./chunk-YQNADJCT.js";
+import "./chunk-FPNQF475.js";
 import "./chunk-AC5LO7IU.js";
 import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";

package/dist/recall-xray-renderer.d.ts

@@ -1,6 +1,6 @@
 import { RecallXraySnapshot } from './recall-xray.js';
 import './memory-provenance.js';
-import './types.js';
+import './types-D5VRAI04.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 import './user-model.js';

package/dist/recall-xray-renderer.js

@@ -5,10 +5,10 @@ import {
   renderXrayJson,
   renderXrayMarkdown,
   renderXrayText
-} from "./chunk-PSUB67YB.js";
+} from "./chunk-PW6GURU3.js";
 import "./chunk-SOBJ6NEY.js";
-import "./chunk-BPSGLMQ4.js";
-import "./chunk-4R4KTDIE.js";
+import "./chunk-YQNADJCT.js";
+import "./chunk-FPNQF475.js";
 import "./chunk-AC5LO7IU.js";
 import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";