@remnic/core 9.21.0 → 9.22.1

package/dist/service-DgFWlZ-r.d.ts

@@ -0,0 +1,835 @@
+import { n as BufferTurn, J as ExtractionResult, ah as ImportanceScore, x as MemoryStatus, aN as WearableConversation, aO as WearableSourceSettings, aP as WearableNativeMemory, aQ as WearableMemoryMode, aR as WearableSourceConnector, aS as WearablesConfig, aT as WearableSyncSummary, aU as WearableSourceStatus, aV as WearableDayTranscript, ay as FusedWearableConversation, aW as WearableCorrectionRule, aX as MeetingBuildInput, aY as MeetingsConfig, aD as FusedMeeting, aB as MeetingRecord, aZ as MeetingsDetectionInput, a_ as FusionConversationInput, a$ as MeetingActivitySnapshot, b0 as DetectedMeeting } from './types-Bbs0qz6b.js';
+import { M as MemoryWriteResult, F as FusionArtifactStore, a as MeetingRecordStore, b as MeetingRecordSummary } from './storage-XGawwqXE.js';
+import { SealedMemoryEnvelope } from './write-envelope.js';
+import { JudgeCandidate, JudgeBatchResult } from './extraction-judge.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[];
+
+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>;
+    /**
+     * Meeting tail-step (issue #1900): fired once after a sync with the union of
+     * days it touched, so a dependent subsystem (meeting building) can rebuild the
+     * affected day(s). Wired for EVERY sync path — auto-sync AND manual
+     * HTTP/MCP/CLI backfill — because they all share this one service. Optional;
+     * omitted by hosts that do not build meetings. The hook self-gates and never
+     * fails the sync.
+     */
+    onDaysSynced?: (days: readonly string[]) => void | 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;
+
+/**
+ * Meeting fusion (issue #1900, Phase 4 slice 2).
+ *
+ * For a detected meeting window `[startUtc, endUtc)` (half-open, AGENTS.md §23),
+ * fuse the concurrent signals into a screen-aware `FusedMeeting`:
+ *
+ *   1. Transcript — clip every wearable source's segments to the window and run
+ *      them through the SHARED wearables reconciliation (`fuseCluster`). Higher-
+ *      `sourceTrust` text wins overlapping regions and the out-voted sources are
+ *      recorded per segment; this module never re-implements alignment/dedup —
+ *      the repo rule is "extend the shared fusion module, never fork it".
+ *   2. Screen context — other-app foreground dwell within the window, kept only
+ *      when it lasts `contextDwellSeconds`, plus deduped on-screen text excerpts
+ *      capped at `maxContextChars`.
+ *   3. Attendees — distinct non-wearer speaker labels from the fused transcript
+ *      (already resolved through the wearables speaker registry upstream).
+ *
+ * Pure and deterministic: same inputs ⇒ same `FusedMeeting`.
+ */
+
+/** Per-run tuning that mirrors the wearables fusion knobs. */
+interface MeetingFusionOptions {
+    /** Per-source trust priors handed to reconciliation. */
+    sourceTrust?: Record<string, number>;
+    /** Max drift (ms) for two segments to align across sources. */
+    windowToleranceMs?: number;
+}
+/** Fuse one detected meeting's transcript + screen context into a FusedMeeting. */
+declare function fuseMeeting(input: MeetingBuildInput, config: MeetingsConfig, options?: MeetingFusionOptions): FusedMeeting;
+
+/**
+ * Meeting memory-generation SEAM (issue #1900 — engine/memory decouple).
+ *
+ * Engine-layer boundary between the deterministic meeting builder and the
+ * memory-generation layer. `MeetingsBuilder` (detect/fuse/store/build) depends
+ * ONLY on `MeetingMemoryGenerator` declared here — never on `memory-gen.ts` — so
+ * the deterministic engine carries zero dependency on episode/fact generation
+ * and ships in its own scope-budgeted PR. The concrete generator lives in
+ * `memory-gen.ts` behind `createMeetingMemoryGenerator`, which implements this
+ * interface by driving the existing episode/fact/retract logic.
+ */
+
+/**
+ * Narrow writer interface satisfied by `StorageManager` — the same sealed
+ * write entry point the wearables generator uses, so meeting memories inherit
+ * encrypted-at-rest + atomic write + dedup without this module knowing the key.
+ */
+interface MeetingMemoryWriter {
+    writeSealedMemory(envelope: SealedMemoryEnvelope, extras: {
+        importance?: ImportanceScore;
+        contentHashSource?: string;
+        status?: MemoryStatus;
+        memoryKind?: "episode" | "note" | "box" | "dream" | "procedural";
+    }): Promise<MemoryWriteResult>;
+    /**
+     * True when an active/pending memory whose frontmatter `source` equals
+     * `source` already carries this exact content. Meeting memories are episodes
+     * (`moment`) and decisions/commitments (`decision`/`commitment`) — categories
+     * the storage fact-hash index does NOT cover — so idempotency is a
+     * source-scoped content scan, mirroring the wearables writer, NOT
+     * `hasFactContentHash` (fact-only; always false here → duplicates on rebuild).
+     */
+    hasMemoryFromSource(source: string, content: string): Promise<boolean>;
+    /**
+     * Retire (invalidate) every memory whose frontmatter `source` equals `source`.
+     * Returns the count retired. Used to reconcile away a removed meeting's
+     * episode/summary memories so recall never surfaces a meeting `show` can't load.
+     */
+    retireMemoriesFromSource(source: string): Promise<number>;
+}
+/** Result of generating episode memories for a day's meetings. */
+interface MeetingEpisodeGenResult {
+    /** Episodes newly written. */
+    written: number;
+    /** Episodes skipped because an identical one already existed. */
+    skipped: number;
+}
+/** Day-level aggregate of the trust-gated summary/fact layer across records. */
+interface MeetingsDayFactGenResult {
+    /** True when the LLM extractor ran for at least one record. */
+    llmInvoked: boolean;
+    /** Facts written active. */
+    active: number;
+    /** Facts queued for review (pending_review). */
+    review: number;
+    /** Candidates/summaries dropped below the trust bar or judge-rejected. */
+    dropped: number;
+    /** Candidates/summaries skipped because an identical memory already existed. */
+    skipped: number;
+    /** Count of records whose summary memory was written. */
+    summariesWritten: number;
+    /** Facts the #1579 tombstone chokepoint downgraded to pending_review (no
+     *  active copy). Surfaced distinctly from `active`/`review` so callers never
+     *  count a blocked write as a successfully written active/review fact (#1645).
+     *  Optional so the seam's canned outcomes stay valid when unset. */
+    tombstoneBlocked?: number;
+}
+/**
+ * Outcome the memory generator returns to the builder after a day's records are
+ * built and persisted. Counts feed the day-build summary; `reindexNeeded` folds
+ * the "reindex when new episodes/facts were written even if no record changed"
+ * rule so the builder never reaches into the memory layer to decide it.
+ */
+interface MeetingMemoryOutcome {
+    /** Episode-memory counts, present only when records were built. */
+    episodes?: MeetingEpisodeGenResult;
+    /** Trust-gated summary/fact counts, present only when summary deps ran. */
+    facts?: MeetingsDayFactGenResult;
+    /** True when newly written memories require an isolated reindex. */
+    reindexNeeded: boolean;
+    /** Non-fatal warnings raised while generating memories. */
+    warnings: readonly string[];
+}
+/**
+ * Seam the deterministic builder depends on. Invoked once per day build after
+ * the record-store writes with, for the day:
+ *   - `built`       — every record composed this build (new, updated, unchanged).
+ *   - `removedIds`  — stale ids the rebuild reconciled away (retract memories).
+ *   - `unchangedIds`— built ids whose stored `contentHash` was IDENTICAL this
+ *                     build (nothing rewritten). The generator SKIPS all
+ *                     episode/summary/fact work for these: an idempotent rebuild
+ *                     must not re-invoke the LLM or duplicate memories.
+ *   - `updatedIds`  — built ids that existed before AND were rewritten this build
+ *                     (same id, changed `contentHash`). The generator REFRESHES
+ *                     them: retract the stale episode/summary memories for that
+ *                     source, then regenerate from the new record.
+ * Ids not in `unchangedIds` or `updatedIds` are newly built — generated fresh
+ * with no retract. The three id sets are disjoint subsets of `built`. The
+ * implementation reports the counts + reindex signal the builder folds into its
+ * day summary.
+ */
+interface MeetingMemoryGenerator {
+    onRecordsBuilt(input: {
+        built: readonly MeetingRecord[];
+        removedIds: readonly string[];
+        unchangedIds: readonly string[];
+        updatedIds: readonly string[];
+    }): Promise<MeetingMemoryOutcome>;
+}
+
+/**
+ * Meeting building orchestration (issue #1900, Phase 4 slice 2).
+ *
+ * Ties the pure pieces together: detect the day's meetings, fuse each window's
+ * transcript + screen context, and compose idempotent records. Day data is
+ * supplied through an injected source so fixtures (and the later activity/
+ * wearables wiring) share one code path — no hidden IO here.
+ *
+ * Gated on `meetings.enabled`: a disabled subsystem builds nothing on every
+ * surface (degradation-matrix row). Degrades within an enabled build too — a
+ * window with no audio yields an empty transcript, and no activity yields a
+ * record with no screen-context section — because `fuseMeeting` handles both.
+ */
+
+/** All of a day's already-loaded signals a build needs. */
+interface MeetingDayData {
+    /** App spans + audio windows for the day (fed to the detector). */
+    detection: MeetingsDetectionInput;
+    /** Fusion conversation inputs across all wearable sources for the day. */
+    conversations: FusionConversationInput[];
+    /** Screen-activity snapshots for the day. */
+    activity?: MeetingActivitySnapshot[];
+}
+/** Supplies a day's signals. Backed by fixtures in tests; by the activity +
+ *  wearables stores in the wiring slice. */
+interface MeetingsDaySource {
+    loadDayData(date: string): Promise<MeetingDayData> | MeetingDayData;
+}
+declare function buildMeetingRecordsForDay(data: MeetingDayData, config: MeetingsConfig, options?: MeetingFusionOptions, 
+/** Map a detected meeting to the id its record should carry. Defaults to the
+ *  detector's start-anchored id; the builder overrides this to preserve an
+ *  existing overlapping record's id across shifted-start resyncs. */
+resolveMeetingId?: (meeting: DetectedMeeting) => string): MeetingRecord[];
+/** Per-meeting outcome of a day build. */
+interface MeetingBuildOutcome {
+    id: string;
+    startUtc: string;
+    endUtc: string;
+    detectionSource: string;
+    sources: string[];
+    attendees: string[];
+    snapshotCount: number;
+    /** False when the record's contentHash was unchanged (nothing rewritten). */
+    written: boolean;
+}
+/** Result of building one day's meetings. */
+interface MeetingsDayBuildSummary {
+    date: string;
+    /** False when `meetings.enabled` is off (zero behavior). */
+    enabled: boolean;
+    meetings: MeetingBuildOutcome[];
+    /** Records written (new or changed). */
+    built: number;
+    /** Records skipped (unchanged contentHash). */
+    skipped: number;
+    /** Ids of stale same-day records deleted because they no longer detect. */
+    removed: string[];
+    /**
+     * Set when the optional reindex hook rejected AFTER records were already
+     * persisted. The store mutation still succeeded — the build is reported as
+     * successful with this generic warning, and the next scheduled index catches
+     * up. Deliberately does NOT embed the raw error text: this string is printed
+     * to the CLI's stdout, and internal error detail is logged separately.
+     */
+    reindexWarning?: string;
+    /**
+     * Set when the injected `memoryGenerator` rejected AFTER records were already
+     * persisted, OR when a successful generation returned non-fatal warnings. Like
+     * `reindexWarning`, the record writes still succeeded, so the build is reported
+     * successful with this warning; on rejection the next build (or scheduled
+     * maintenance) regenerates the missing memories. Carries no raw exception text —
+     * only the generic rejection message or the generator's own warning strings.
+     */
+    memoryWarning?: string;
+    /**
+     * Deterministic episode-memory counts, present only when a `memoryGenerator`
+     * was injected. One recall-anchor episode is written per built record (idempotent).
+     */
+    episodes?: MeetingEpisodeGenResult;
+    /**
+     * Trust-gated summary/fact counts (decisions, commitments, questions, and the
+     * synthesized summary), present only when a `memoryGenerator` with summary deps
+     * ran and `summaryMode !== "off"`. Aggregated across the day's records.
+     */
+    facts?: MeetingsDayFactGenResult;
+}
+/** Optional side effects the builder fires after a day build. */
+interface MeetingsBuilderHooks {
+    /**
+     * Invoked once per build when records changed (`built > 0 || removed > 0`).
+     * Meeting records live inside the QMD collection root for full-text search,
+     * so a host that wants them discoverable immediately (rather than at the next
+     * scheduled reindex) supplies a reindex here. No-op when omitted — records are
+     * still picked up by the next index update.
+     */
+    reindex?(summary: MeetingsDayBuildSummary): void | Promise<void>;
+}
+/** Orchestrates a store-backed build of a day's meetings. */
+declare class MeetingsBuilder {
+    private readonly opts;
+    constructor(opts: {
+        source: MeetingsDaySource;
+        store: MeetingRecordStore;
+        config: MeetingsConfig;
+        fusionOptions?: MeetingFusionOptions;
+        hooks?: MeetingsBuilderHooks;
+        /**
+         * When present, the memory-generation layer runs after the record-store
+         * writes: deterministic recall-anchor episodes per built record, the
+         * trust-gated summary/facts layer, and retract-on-removal — all behind the
+         * `MeetingMemoryGenerator` seam (issue #1900). Omitted → pure
+         * detect+fuse+store with no memory writes. The engine depends only on this
+         * interface, never on the memory-gen module.
+         */
+        memoryGenerator?: MeetingMemoryGenerator;
+    });
+    buildDay(date: string): Promise<MeetingsDayBuildSummary>;
+    /**
+     * Pick the existing same-day record whose window best overlaps `meeting` and
+     * reuse its id — but ONLY when adoption is safe: the windows substantially
+     * coincide (overlap covers a majority of the shorter window), OR a corroborating
+     * identity signal (same app, same title, or a shared transcript source) is
+     * BACKED by a non-marginal overlap (>= a quarter of the shorter window). Coarse
+     * identity signals alone never license adoption across a thin sliver of overlap,
+     * or two genuinely different back-to-back same-app meetings would overwrite each
+     * other's record and `show <old-id>` would point at the wrong meeting. Candidate
+     * selection is deterministic (max overlap, then earliest start, then id).
+     * Returns the detector's fresh id when nothing qualifies.
+     */
+    private adoptExistingId;
+}
+
+/**
+ * Meetings service (issue #1900) — the orchestrator-owned facade every meeting
+ * surface (CLI, MCP tools, HTTP routes) shares, so behavior + validation never
+ * fork across hosts (the same rule the wearables service follows). It owns the
+ * record store, the store-backed builder, and the debounced post-sync build
+ * scheduler.
+ *
+ * `meetings.enabled` is honored at every entrypoint: `meetingsList`/`meetingsGet`
+ * short-circuit to an empty/absent result when disabled, `meetingsBuild`
+ * delegates to the builder (which already reports `enabled: false` and writes
+ * nothing), and the tail-step `requestBuild` is a no-op. Caller-correctable
+ * faults (bad dates/ids) throw `MeetingsInputError`, which the transports map to
+ * 400-class responses; the CLI reuses the store + builder directly through the
+ * shared `runMeetingsCliCommand` runner.
+ */
+
+/** One day's stored meeting summaries in a list result. */
+interface MeetingsListDay {
+    date: string;
+    meetings: MeetingRecordSummary[];
+}
+/** Structured result of a meetings list query (all days, or one day). */
+interface MeetingsListResult {
+    /** False when `meetings.enabled` is off (zero behavior). */
+    enabled: boolean;
+    days: MeetingsListDay[];
+}
+/** Structured result of fetching one stored meeting record. */
+interface MeetingsGetResult {
+    /** False when `meetings.enabled` is off (zero behavior). */
+    enabled: boolean;
+    found: boolean;
+    id: string;
+    /** Raw persisted markdown, or null when disabled/absent. */
+    record: string | null;
+}
+interface MeetingsServiceDeps {
+    config: MeetingsConfig;
+    store: MeetingRecordStore;
+    builder: MeetingsBuilder;
+    /** Trailing-edge coalescing window for post-sync rebuilds (ms). */
+    buildDebounceMs: number;
+    /** Observe a tail-step build failure (logging); never called on success. */
+    onBuildError?(date: string, err: unknown): void;
+}
+declare class MeetingsService {
+    readonly store: MeetingRecordStore;
+    readonly builder: MeetingsBuilder;
+    readonly config: MeetingsConfig;
+    private readonly scheduler;
+    constructor(deps: MeetingsServiceDeps);
+    /** List stored meetings for one day, or across all days when no date given. */
+    meetingsList(date?: string): Promise<MeetingsListResult>;
+    /** Fetch one stored meeting record's raw markdown by id. */
+    meetingsGet(id: string): Promise<MeetingsGetResult>;
+    /** Detect + fuse + store the day's meetings. Gated inside the builder. */
+    meetingsBuild(date: string): Promise<MeetingsDayBuildSummary>;
+    /**
+     * Tail-step after a sync touched a day: schedule a debounced (re)build. A
+     * no-op when the subsystem is disabled, so a sync of other signals never
+     * spins up meeting building behind the master gate.
+     */
+    requestBuild(date: string): void;
+    /**
+     * Activity tail-step (issue #1900): schedule a debounced (re)build for every
+     * local day the sync touched. The tick's own local day (from `ranAtIso`, in
+     * the activity timezone) is always eligible; `touchedDates` adds any OTHER
+     * days a rolling/backfill sync changed, so a change to yesterday's activity
+     * rebuilds yesterday's meetings rather than only today's. No-op when disabled,
+     * so a sync of other signals never spins up meeting building behind the gate.
+     */
+    requestBuildForActivitySync(ranAtIso: string, timezone: string, touchedDates?: readonly string[]): void;
+    /** Force any pending debounced builds to run now (teardown/tests). */
+    flushBuilds(): Promise<void>;
+    /** Cancel armed build timers (orchestrator teardown). */
+    dispose(): void;
+}
+
+export { wearableSourceLabel as $, type WearableSyncOptions as A, type WearableTranscriptSearchResult as B, type WearablesServiceDeps as C, DEFAULT_SELF_NAME as D, buildExtractionTurns as E, buildMeetingRecordsForDay as F, dateInTimezone as G, defaultTimezone as H, distinctSpeakerLabels as I, emptySpeakerRegistry as J, fuseMeeting as K, generateWearableMemories as L, MeetingsService as M, importNativeMemories as N, loadSpeakerRegistry as O, locateTranscriptPath as P, memoryStatusForMode as Q, type ResolvedSpeaker as R, type SpeakerRegistry as S, resolveSpeaker as T, resolveSyncDates as U, saveSpeakerRegistry as V, WearablesService as W, speakerRegistryKey as X, speakersFilePath as Y, syncWearableSource as Z, wearableDayTag as _, type MeetingsDayBuildSummary as a, writeDailyDigestMemory as a0, type MeetingsGetResult as b, type MeetingsListResult as c, type MeetingMemoryWriter as d, type MeetingMemoryGenerator as e, type MeetingEpisodeGenResult as f, MeetingsBuilder as g, type MeetingsDaySource as h, type MeetingDayData as i, type MeetingBuildOutcome as j, type MeetingFusionOptions as k, type MeetingMemoryOutcome as l, type MeetingsBuilderHooks as m, type MeetingsDayFactGenResult as n, type MeetingsListDay as o, type MeetingsServiceDeps as p, type SpeakerOverride as q, WEARABLE_SOURCE_PREFIX as r, type WearableDayTranscriptView as s, type WearableMemoryGenDeps as t, type WearableMemoryGenResult as u, type WearableMemorySearchResult as v, type WearableMemoryWriter as w, type WearableSearchBackend as x, type WearableStorageIo as y, type WearableSyncDeps as z };