@remnic/core 9.22.0 → 9.22.2

package/dist/{orchestrator-DB93S48I.d.ts → orchestrator-C9ZVppNh.d.ts}

@@ -3,17 +3,17 @@ 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, S as StorageManager } from './storage-BKhHHnRo.js';
+import { S as StorageManager } from './storage-XGawwqXE.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 { n as BufferTurn, J as ExtractionResult, ah as ImportanceScore, x as MemoryStatus, aI as WearableConversation, aJ as WearableSourceSettings, aK as WearableNativeMemory, aL as WearableMemoryMode, aM as WearableSourceConnector, aN as WearablesConfig, aO as WearableSyncSummary, aP as WearableSourceStatus, aQ as WearableDayTranscript, au as FusedWearableConversation, aR as WearableCorrectionRule, P as PluginConfig, M as MemoryFile, ab as MemoryActionEvent, Q as QmdSearchResult, R as RecallPlanMode, I as IdentityInjectionMode, aS as RecallSectionConfig, ay as MemoryLink, aG as CodingContext, r as SourceConnectorProvenance, ai as MemoryIntent, o as MemoryFrontmatter, v as BehaviorLoopPolicyState, aT as BootstrapOptions, aU as BootstrapResult, aV as ConsolidationObservation, N as DaySummaryResult, a1 as ImportTurn } from './types-GBQZuT7l.js';
+import { M as MaintenanceScheduler } from './maintenance-C98njYb8.js';
+import { P as PluginConfig, M as MemoryFile, ab as MemoryActionEvent, Q as QmdSearchResult, R as RecallPlanMode, I as IdentityInjectionMode, b3 as RecallSectionConfig, aF as MemoryLink, J as ExtractionResult, n as BufferTurn, b1 as CodingContext, r as SourceConnectorProvenance, ai as MemoryIntent, o as MemoryFrontmatter, v as BehaviorLoopPolicyState, b4 as BootstrapOptions, b5 as BootstrapResult, b6 as ConsolidationObservation, N as DaySummaryResult, a1 as ImportTurn } from './types-Bbs0qz6b.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-BaZlg0D8.js';
+import { S as SemanticConsolidationResult } from './semantic-consolidation-B2xo26UQ.js';
 import { EmbeddingFallback } from './embedding-fallback.js';
 import { ExtractionEngine } from './extraction.js';
 import { ObjectiveStateSearchResult } from './objective-state.js';
@@ -32,7 +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-KG2nODX7.js';
+import { R as ResolvedScopeProfilePlan } from './scope-profiles-EhyuAKkd.js';
 import { GraphIndex } from './graph.js';
 import { RecallXrayServedBy, RecallXraySnapshot } from './recall-xray.js';
 import { LiveConnectorsRunSummary } from './live-connectors-runner.js';
@@ -42,71 +42,14 @@ 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 { W as WearablesService, M as MeetingsService } from './service-DgFWlZ-r.js';
 import { LcmEngine } from './lcm/engine.js';
-import { b as NamespaceKind, N as NamespaceCatalog } from './catalog-iWvWz61I.js';
+import { b as NamespaceKind, N as NamespaceCatalog } from './catalog-BFTVo2Ez.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';
 
-/**
- * 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[];
-
 /**
  * Pattern-reinforcement maintenance job (issue #687 PR 2/4).
  *
@@ -168,420 +111,6 @@ interface PatternReinforcementResult {
     clusters: PatternReinforcementClusterResult[];
 }
 
-interface CorroborationContext {
-    /**
-     * Same-day transcript bodies from OTHER sources, keyed by source id.
-     * Pre-tokenized once per sync (day bodies are large).
-     */
-    otherSourceDayTokens: Map<string, Set<string>>;
-    /** Existing active memories: id + content. */
-    existingMemories: Array<{
-        id: string;
-        content: 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.
- */
-
-declare function memoryStatusForMode(mode: WearableMemoryMode): Extract<MemoryStatus, "active" | "pending_review">;
-/** Narrow writer interface satisfied by `StorageManager`. */
-interface WearableMemoryWriter {
-    /**
-     * 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;
-        contentHashSource?: string;
-        status?: MemoryStatus;
-        memoryKind?: "episode" | "note" | "box" | "dream" | "procedural";
-    }): Promise<MemoryWriteResult>;
-    hasFactContentHash(content: string): Promise<boolean>;
-    /**
-     * Locate an earlier wearable write of the same content (any status).
-     * Optional: enables in-place promotion when re-scoring with stronger
-     * evidence.
-     */
-    findWearableMemoryByContent?(content: string): Promise<{
-        id: string;
-        status: MemoryStatus | undefined;
-    } | null>;
-    /**
-     * Promote a pending_review wearable memory to active, merging trust
-     * evidence. Returns false when missing or no longer pending.
-     */
-    promoteWearableMemory?(id: string, attributeUpdates: Record<string, string>, confidence?: number): Promise<boolean>;
-    /**
-     * Demote a pending_review wearable memory to rejected on an explicit
-     * judge-reject re-verdict. Returns false when missing or no longer
-     * pending. Active rows are never auto-demoted.
-     */
-    demoteWearableMemory?(id: string, attributeUpdates: Record<string, string>): Promise<boolean>;
-}
-interface WearableMemoryGenDeps {
-    extract(turns: BufferTurn[]): Promise<ExtractionResult>;
-    writer: WearableMemoryWriter;
-    /**
-     * LLM-as-judge batch evaluation (the existing extraction judge).
-     * Absent when no judge is wired (degraded smart mode: trust scoring
-     * runs on confidence x sourceTrust + corroboration alone).
-     */
-    judgeFacts?(candidates: JudgeCandidate[]): Promise<JudgeBatchResult>;
-    /**
-     * Corroboration evidence for smart mode: other sources' same-day
-     * transcript tokens + existing active memories. Absent disables
-     * corroboration boosts.
-     */
-    corroboration?: CorroborationContext;
-}
-interface WearableMemoryGenResult {
-    created: number;
-    /**
-     * Writes the #1579 tombstone chokepoint downgraded to pending_review (no
-     * active copy). Surfaced distinctly from `created` so sync summaries and
-     * callers don't count blocked content as successfully created (#1645).
-     */
-    tombstoneBlocked: number;
-    /** Earlier borderline writes promoted to active by new evidence. */
-    promoted: number;
-    /** Earlier pending writes retired by a fresh judge-reject verdict. */
-    demoted: number;
-    skipped: number;
-    skippedByReason: Record<string, number>;
-    /** Non-fatal problems (e.g. the extraction engine erroring). */
-    warnings: string[];
-    /**
-     * True when every conversation was extracted (the pass may still
-     * carry degraded-mode warnings, e.g. judge unavailable). False only
-     * when extraction itself aborted mid-day — the signal callers use to
-     * re-run the pass on the next sync. A degraded-but-complete pass
-     * must NOT re-run forever: its facts are already written and dedup
-     * would suppress improvements anyway.
-     */
-    completed: boolean;
-}
-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>;
-declare function importNativeMemories(sourceId: string, memories: WearableNativeMemory[], alreadyImportedIds: ReadonlySet<string>, settings: WearableSourceSettings, deps: WearableMemoryGenDeps): Promise<{
-    imported: number;
-    tombstoneBlocked: number;
-    importedIds: string[];
-    warnings: 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 the sync wrote ANYTHING the search
-     * index should see: day transcripts, created memories, in-place
-     * promotions, or native imports. (A cross-source invalidation can
-     * promote memories on a run with zero transcript writes — the index
-     * must still refresh.)
-     */
-    afterWrites?(): 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;
-    /**
-     * Same-day transcript bodies from OTHER sources, for cross-device
-     * corroboration in smart mode. Absent disables the boost.
-     */
-    readOtherSourceDayBodies?(date: string, excludeSource: string): Promise<Map<string, string>>;
-    /**
-     * Existing memories usable as support evidence: status "active" or
-     * "pending_review" (explicit allow-list — a borderline fact observed
-     * again on a later day is repetition signal, and the +0.10 boost is
-     * how it earns promotion). Rejected/quarantined/superseded/archived/
-     * forgotten rows are never support evidence.
-     */
-    listSupportMemories?(): Promise<Array<{
-        id: string;
-        content: string;
-    }>>;
-    /** 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;
-    }>>;
-    fusionArtifactStore(): FusionArtifactStore;
-    readAllMemories(): Promise<Array<{
-        path: string;
-        frontmatter: {
-            id: string;
-            source: string;
-            created: string;
-            tags: string[];
-            status?: string;
-            /** Archival timestamp — rows with this set are not support. */
-            archivedAt?: string;
-            structuredAttributes?: Record<string, string>;
-        };
-        content: string;
-    }>>;
-    writeSealedMemory: WearableMemoryGenDeps["writer"]["writeSealedMemory"];
-    hasFactContentHash(content: string): Promise<boolean>;
-    findWearableMemoryByContent(content: string): Promise<{
-        id: string;
-        status: string | undefined;
-    } | null>;
-    promoteWearableMemory(id: string, attributeUpdates: Record<string, string>, confidence?: number): Promise<boolean>;
-    demoteWearableMemory(id: string, attributeUpdates: Record<string, 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;
-    /**
-     * LLM-as-judge hook for smart memoryMode (the orchestrator wires the
-     * existing extraction judge here). Absent degrades smart mode to
-     * confidence x sourceTrust + corroboration scoring.
-     */
-    judgeFacts?: WearableMemoryGenDeps["judgeFacts"];
-    /** 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;
-    }>>;
-    /**
-     * Fuse all enabled sources' stored transcripts for one day into a
-     * derived `FusedWearableConversation[]` artifact. Deterministic and
-     * idempotent: unchanged inputs and fusion config produce a stable
-     * content hash and the derived file is left untouched on re-run. Requires
-     * `wearables.fusion.enabled`; otherwise it throws. Raw per-source
-     * transcripts are never modified.
-     */
-    fuseDay(date: string): Promise<{
-        date: string;
-        sources: string[];
-        conversationCount: number;
-        contentHash: string;
-        written: boolean;
-        skipped?: {
-            reason: string;
-        };
-    }>;
-    /**
-     * List fused conversations for a date (the fusion listing surface).
-     * Returns the persisted derived artifact's conversations, or an empty
-     * array when no fused artifact has been written for that day. When a
-     * file EXISTS but its body is corrupt (parseOk:false), throws
-     * WearablesInputError so the caller can distinguish a broken artifact
-     * from a day that was never fused — never silently returns an empty
-     * list that looks identical to "no artifact" (issue #1849).
-     */
-    fusedConversations(date: string): Promise<FusedWearableConversation[]>;
-    /** List dates with stored fused artifacts, newest first. */
-    listFusedDays(): Promise<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;
-
 /**
  * Conversation index coordinator — extracted from the orchestrator (issue #1526).
  *
@@ -2414,7 +1943,8 @@ declare class Orchestrator {
     private heartbeatObserverChains;
     private recentExtractionFingerprints;
     private readonly consolidationObservers;
-    private wearablesServiceInstance;
+    private readonly wearablesServiceByNamespace;
+    private readonly meetingsServiceByNamespace;
     private wearablesAutoSyncHandle;
     private lastQmdReprobeAtMs;
     private lastFileHygieneRunAtMs;
@@ -2880,7 +2410,8 @@ declare class Orchestrator {
      * and through `ingestBulkImportBatch`.
      */
     bulkImportWriteNamespace(): string;
-    getWearablesService(): WearablesService;
+    getWearablesService(namespace?: string): WearablesService;
+    getMeetingsService(namespace?: string): Promise<MeetingsService>;
     ingestBulkImportBatch(turns: ImportTurn[], options?: {
         deadlineMs?: number;
         failOnExtractionFailure?: boolean;
@@ -3057,4 +2588,4 @@ declare class Orchestrator {
     private readArchivedMemoriesForNamespaces;
 }
 
-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 };
+export { summarizeGraphShadowComparison as $, mergeGraphExpandedResults as A, type BulkImportBatchIngestResult as B, ConversationIndexCoordinator as C, type DaySummaryGatherOptions as D, type ExtractionRunResult as E, normalizeIanaTimeZone as F, type GraphRecallSnapshot as G, parseFiniteDate as H, type IntentDebugSnapshot as I, parseGraphRecallRankedResults as J, parseMemoryIntentSnapshot as K, parseQmdRecallResults as L, qmdStartupCollectionCheckWithTimeout as M, raceRecallAbort as N, Orchestrator as O, type PatternReinforcementResult as P, type QmdRecallSnapshot as Q, type RecallInvocationOptions as R, resolveEffectiveIdentityInjectionMode as S, TierMigrationCoordinator as T, resolveEffectiveRecallMode as U, resolvePersistedMemoryRelativePath as V, resolveRecallModeDecision as W, resolveRecallModeDecisionAsync as X, resolveRecentThreadMemoryPaths as Y, shouldFilterLifecycleRecallCandidate as Z, splitTurnsBySourceValidAt as _, BulkImportBatchPartialFailureError as a, targetSourceValidAtSortMs as a0, throwIfRecallAborted as a1, tokenizeRecallQuery as a2, utcDateKeysForLocalDay as a3, COMPACTION_SIGNAL_MAX_AGE_MS as b, type GraphRecallRankedResult as c, defaultWorkspaceDir as d, type GraphRecallShadowComparison as e, type QueryAwarePrefilter as f, type RecallModeDecision as g, appendMemoryToGraphContext as h, applyQueryAwareCandidateFilter as i, blendGraphExpandedRecallScore as j, buildCompressionGuidelinesMarkdown as k, buildMemoryPathById as l, computeArtifactCandidateFetchLimit as m, computeArtifactRecallLimit as n, computeQmdHybridFetchLimit as o, deriveTopicsFromExtraction as p, filterHourlySummaryMarkdownForLocalDay as q, filterRecallCandidates as r, sanitizeSessionKeyForFilename as s, formatDateInTimeZone as t, graphPathRelativeToStorage as u, hasIdentityRecoveryIntent as v, isArtifactMemoryPath as w, lifecycleRecallScoreAdjustment as x, mapRecallSourceToXrayServedBy as y, mergeArtifactRecallCandidates as z };

package/dist/orchestrator.d.ts

@@ -3,13 +3,13 @@ import './briefing.js';
 import './buffer.js';
 import './extraction-faithfulness.js';
 import './search/port.js';
-import './storage-BKhHHnRo.js';
+import './storage-XGawwqXE.js';
 import './transcript.js';
 import './summarizer.js';
 import './local-llm.js';
 import './fallback-llm.js';
-import './orchestration/maintenance.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-DB93S48I.js';
+import './maintenance-C98njYb8.js';
+export { B as BulkImportBatchIngestResult, a as BulkImportBatchPartialFailureError, b as COMPACTION_SIGNAL_MAX_AGE_MS, D as DaySummaryGatherOptions, E as ExtractionRunResult, c as GraphRecallRankedResult, e as GraphRecallShadowComparison, G as GraphRecallSnapshot, I as IntentDebugSnapshot, O as Orchestrator, Q as QmdRecallSnapshot, f as QueryAwarePrefilter, R as RecallInvocationOptions, g as RecallModeDecision, h as appendMemoryToGraphContext, i as applyQueryAwareCandidateFilter, j as blendGraphExpandedRecallScore, k as buildCompressionGuidelinesMarkdown, l as buildMemoryPathById, m as computeArtifactCandidateFetchLimit, n as computeArtifactRecallLimit, o as computeQmdHybridFetchLimit, d as defaultWorkspaceDir, p as deriveTopicsFromExtraction, q as filterHourlySummaryMarkdownForLocalDay, r as filterRecallCandidates, t as formatDateInTimeZone, u as graphPathRelativeToStorage, v as hasIdentityRecoveryIntent, w as isArtifactMemoryPath, x as lifecycleRecallScoreAdjustment, y as mapRecallSourceToXrayServedBy, z as mergeArtifactRecallCandidates, A as mergeGraphExpandedResults, F as normalizeIanaTimeZone, H as parseFiniteDate, J as parseGraphRecallRankedResults, K as parseMemoryIntentSnapshot, L as parseQmdRecallResults, M as qmdStartupCollectionCheckWithTimeout, N as raceRecallAbort, S as resolveEffectiveIdentityInjectionMode, U as resolveEffectiveRecallMode, V as resolvePersistedMemoryRelativePath, W as resolveRecallModeDecision, X as resolveRecallModeDecisionAsync, Y as resolveRecentThreadMemoryPaths, s as sanitizeSessionKeyForFilename, Z as shouldFilterLifecycleRecallCandidate, _ as splitTurnsBySourceValidAt, $ as summarizeGraphShadowComparison, a0 as targetSourceValidAtSortMs, a1 as throwIfRecallAborted, a2 as tokenizeRecallQuery, a3 as utcDateKeysForLocalDay } from './orchestrator-C9ZVppNh.js';
 export { formatCompressionGuidelinesForRecall } from './orchestration/compression-guideline-coordinator.js';
 import './live-connectors-runner.js';
 import './model-registry.js';
@@ -21,11 +21,12 @@ import './embedding-fallback.js';
 import './semantic-TddhF0y7.js';
 import './capabilities.js';
 import './replay/types.js';
-import './types-GBQZuT7l.js';
+import './types-Bbs0qz6b.js';
+import './service-DgFWlZ-r.js';
 import './lcm/engine.js';
-import './semantic-consolidation-BaZlg0D8.js';
-import './catalog-iWvWz61I.js';
-import './scope-profiles-KG2nODX7.js';
+import './semantic-consolidation-B2xo26UQ.js';
+import './catalog-BFTVo2Ez.js';
+import './scope-profiles-EhyuAKkd.js';
 import './namespaces/search.js';
 import './shared-context/manager.js';
 import './compounding/engine.js';
@@ -51,6 +52,7 @@ import './lifecycle.js';
 import './extraction.js';
 import './schemas.js';
 import 'zod';
+import './extraction-error-classification.js';
 import './objective-state.js';
 import './causal-trajectory.js';
 import './trust-zones.js';
@@ -70,10 +72,10 @@ 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';
 import './user-model.js';
+import './extraction-judge.js';
 import './lcm/archive.js';
 import './lcm/summarizer.js';
 import './lcm/dag.js';