@remnic/core 9.69.55 → 9.69.57

package/dist/wearables/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Wearable transcript subsystem — public surface.
+ *
+ * Connector packages import the registry + types; hosts construct a
+ * `WearablesService` (usually via the orchestrator accessor).
+ */
+export * from "./types.js";
+export { describeErrorForOperator, WearablesInputError } from "./errors.js";
+export { defaultWearableCleanupSettings, defaultWearableFusionConfig, defaultWearableSourceSettings, defaultWearablesConfig, KNOWN_WEARABLE_SOURCE_IDS, parseWearablesConfig, } from "./config.js";
+export { builtInConnectorPackageSpecifier, registerWearableConnector, selfRegisterWearableConnector, getWearableConnector, listWearableConnectors, clearWearableConnectors, ensureBuiltInWearableConnectors, type WearableConnectorFactory, type WearableConnectorFactoryOptions, type WearableConnectorRegistration, } from "./registry.js";
+export { cleanConversation, collapseImmediateRepeats, isLowQualitySegment, stripFillerTokens, type CleanupResult, } from "./cleanup.js";
+export { applyOffTheRecord, BUILT_IN_OFF_THE_RECORD_END, BUILT_IN_OFF_THE_RECORD_START, compileOffTheRecordMarkers, compileRedactionPatterns, redactText, REDACTION_PLACEHOLDER, type CompiledOffTheRecordMarkers, type OffTheRecordMarkerInput, } from "./redaction.js";
+export { buildPhraseMatcher, detectScriptHints, type ScriptHint, } from "./text-language.js";
+export { applyCorrections, compileCorrectionRule, compileCorrectionRules, correctionsFilePath, loadCorrectionsFile, saveCorrectionsFile, type CompiledCorrectionRule, } from "./corrections.js";
+export { DEFAULT_SELF_NAME, distinctSpeakerLabels, emptySpeakerRegistry, loadSpeakerRegistry, resolveSpeaker, saveSpeakerRegistry, speakerRegistryKey, speakersFilePath, type ResolvedSpeaker, type SpeakerOverride, type SpeakerRegistry, } from "./speakers.js";
+export { bodyIsEscaped, composeDayTranscriptBody, composeDayTranscriptMeta, decodeTranscriptBody, escapeSegmentText, hashTranscriptBody, isValidTranscriptDate, parseDayTranscript, parseTranscriptSegmentLine, serializeDayTranscript, TRANSCRIPT_FORMAT_VERSION, unescapeSegmentText, unescapeSpeakerLabel, WEARABLES_DIR_NAME, type TranscriptSegmentMatch, } from "./day-store.js";
+export { emptySyncState, loadSyncState, saveSyncState, syncStateFilePath, updateSourceSyncState, type WearableSourceSyncState, type WearableSyncStateFile, } from "./sync-state.js";
+export { buildExtractionTurns, generateWearableMemories, importNativeMemories, memoryStatusForMode, WEARABLE_SOURCE_PREFIX, wearableDayTag, wearableSourceLabel, writeDailyDigestMemory, type WearableMemoryGenDeps, type WearableMemoryGenResult, type WearableMemoryWriter, } from "./memory-gen.js";
+export { dateInTimezone, defaultTimezone, resolveSyncDates, syncWearableSource, type WearableSyncDeps, type WearableSyncOptions, } from "./pipeline.js";
+export { runWearablesCliCommand, type WearablesCliIo, } from "./cli.js";
+export { locateTranscriptPath, WearablesService, type WearableDayTranscriptView, type WearableMemorySearchResult, type WearableSearchBackend, type WearableStorageIo, type WearableTranscriptSearchResult, type WearablesServiceDeps, } from "./service.js";
+export { clusterConversations, composeFusionDayMeta, DEFAULT_PROXIMITY_GAP_MS, DEFAULT_SOURCE_TRUST, DEFAULT_WINDOW_TOLERANCE_MS, FUSION_KIND, fuseCluster, fuseDay, fusionInputsFromConversations, hashFusionBody, parseFusionDay, reconstructFusionInputs, serializeFusionDay, type FuseClusterResult, type DisagreementKind, type FusionConversationInput, type FusionDayResult, type FusionOptions, type FusionSegmentInput, type FusedConversationProvenance, type FusedContribution, type FusedDayFile, type FusedDayMeta, type FusedDisagreement, type FusedSegment, type FusedSegmentProvenance, type FusedSpeaker, type FusedWearableConversation, type SegmentPickReason, } from "./fusion/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/wearables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wearables/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,6BAA6B,EAC7B,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,gCAAgC,EAChC,yBAAyB,EACzB,6BAA6B,EAC7B,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,6BAA6B,GACnC,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,6BAA6B,EAC7B,0BAA0B,EAC1B,wBAAwB,EACxB,UAAU,EACV,qBAAqB,EACrB,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,GAC7B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,KAAK,UAAU,GAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,sBAAsB,GAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,wBAAwB,EACxB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,EAC1B,sBAAsB,EACtB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,sBAAsB,GAC5B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,cAAc,EACd,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,sBAAsB,EACtB,KAAK,cAAc,GACpB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,8BAA8B,EACnC,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,2BAA2B,EAC3B,WAAW,EACX,WAAW,EACX,OAAO,EACP,6BAA6B,EAC7B,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC"}

package/dist/wearables/mcp-tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wearables MCP tool definitions (issue #1900 / #2123) — the five
+ * `engram.wearables_*` / `engram.transcript_*` tool-def objects, extracted from
+ * access-mcp.ts so the surface file stays under its structural ceiling. Spread
+ * back into `this.tools` (`...WEARABLES_MCP_TOOLS`); tools/list is verified at
+ * runtime. MCP_MIGRATED_OPERATIONS + callTool dispatch stay inline in
+ * access-mcp.ts. Each schema carries `namespace` + `sessionKey` so the MCP
+ * scope-override injects the caller namespace (caller-derived symmetry, #2123).
+ */
+import type { McpTool } from "../access-mcp.js";
+export declare const WEARABLES_MCP_TOOLS: McpTool[];
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/wearables/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/wearables/mcp-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,eAAO,MAAM,mBAAmB,EAAE,OAAO,EAkIxC,CAAC"}

package/dist/wearables/memory-gen.d.ts

@@ -0,0 +1,139 @@
+/**
+ * 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.
+ */
+import type { MemoryWriteResult } from "../storage.js";
+import { type SealedMemoryEnvelope } from "../write-envelope.js";
+import type { JudgeBatchResult, JudgeCandidate } from "../extraction-judge.js";
+import { type CorroborationContext } from "./trust.js";
+import type { BufferTurn, ExtractionResult, ImportanceScore, MemoryStatus } from "../types.js";
+import { type SpeakerRegistry } from "./speakers.js";
+import type { WearableConversation, WearableMemoryMode, WearableNativeMemory, WearableSourceSettings } from "./types.js";
+export declare function memoryStatusForMode(mode: WearableMemoryMode): Extract<MemoryStatus, "active" | "pending_review">;
+/** Narrow writer interface satisfied by `StorageManager`. */
+export 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>;
+}
+export 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;
+}
+export 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;
+}
+export declare const WEARABLE_SOURCE_PREFIX = "wearable";
+export declare function wearableSourceLabel(sourceId: string): string;
+export 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.
+ */
+export 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.
+ */
+export 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`.
+ */
+export declare function writeDailyDigestMemory(sourceId: string, date: string, conversations: WearableConversation[], settings: WearableSourceSettings, registry: SpeakerRegistry, writer: WearableMemoryWriter): Promise<boolean>;
+export declare function importNativeMemories(sourceId: string, memories: WearableNativeMemory[], alreadyImportedIds: ReadonlySet<string>, settings: WearableSourceSettings, deps: WearableMemoryGenDeps): Promise<{
+    imported: number;
+    tombstoneBlocked: number;
+    importedIds: string[];
+    warnings: string[];
+}>;
+//# sourceMappingURL=memory-gen.d.ts.map

package/dist/wearables/memory-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-gen.d.ts","sourceRoot":"","sources":["../../src/wearables/memory-gen.ts"],"names":[],"mappings":"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"}

package/dist/wearables/pipeline.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+import { type WearableMemoryGenDeps } from "./memory-gen.js";
+import type { LocationConfig } from "../location/types.js";
+import type { WearableSourceConnector, WearableSourceSettings, WearableSyncSummary, WearablesConfig } from "./types.js";
+export 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;
+}
+export 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;
+    /**
+     * Location config for the missing-only conversation location fill
+     * (issue #2925). Absent, or location tagging disabled, changes nothing.
+     */
+    locationConfig?: LocationConfig;
+}
+/** Format a Date as YYYY-MM-DD in the given IANA timezone. */
+export declare function dateInTimezone(date: Date, timezone: string): string;
+/** Resolve the list of days to sync, oldest first. */
+export declare function resolveSyncDates(options: WearableSyncOptions, timezone: string, now: Date): string[];
+/** Sync one source. */
+export declare function syncWearableSource(connector: WearableSourceConnector, settings: WearableSourceSettings, config: WearablesConfig, options: WearableSyncOptions, deps: WearableSyncDeps): Promise<WearableSyncSummary>;
+export declare function defaultTimezone(): string;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/wearables/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/wearables/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAkBH,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AAezB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAEV,uBAAuB,EACvB,sBAAsB,EACtB,mBAAmB,EACnB,eAAe,EAChB,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC3E,yDAAyD;IACzD,kBAAkB,CAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B;;;;OAIG;IACH,SAAS,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACxC;;;OAGG;IACH,wBAAwB,CAAC,CACvB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChC;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IACxE,iCAAiC;IACjC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB;;;OAGG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAcnE;AAED,sDAAsD;AACtD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,mBAAmB,EAC5B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,IAAI,GACR,MAAM,EAAE,CAiCV;AAoID,uBAAuB;AACvB,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,uBAAuB,EAClC,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,mBAAmB,CAAC,CA4V9B;AA6BD,wBAAgB,eAAe,IAAI,MAAM,CAMxC"}

package/dist/wearables/redaction.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Wearable transcript redaction — privacy guard applied before any
+ * transcript text is persisted or fed to extraction.
+ *
+ * Always-on recorders capture things nobody intended to store: card
+ * numbers read aloud, SSNs dictated to a pharmacy line. Built-in
+ * patterns cover the unambiguous, high-sensitivity cases; users can add
+ * their own regexes via `wearables.redactionPatterns` (validated at
+ * config parse — invalid patterns are rejected loudly, never ignored).
+ *
+ * All built-in patterns are simple linear scans (no nested quantifiers)
+ * to stay safely outside polynomial-ReDoS territory.
+ */
+import type { OffTheRecordMarkerSettings, WearableConversation } from "./types.js";
+export declare const REDACTION_PLACEHOLDER = "[redacted]";
+export interface RedactionResult {
+    text: string;
+    redactions: number;
+}
+export declare function redactText(text: string, userPatterns: RegExp[]): RedactionResult;
+/**
+ * Compile user-supplied redaction patterns. Throws with a descriptive
+ * message on the first invalid pattern — config parsing surfaces this
+ * to the operator instead of silently skipping the rule.
+ */
+export declare function compileRedactionPatterns(patterns: string[]): RegExp[];
+/**
+ * Built-in phrases that BEGIN an off-the-record span.
+ *
+ * Conservative by design: a false positive elides real transcript
+ * content. Every phrase is a fixed multi-word expression, or a loanword
+ * that only means "off the record" (issue #2196). Operators extend this
+ * list through `wearables.offTheRecordMarkers.start`.
+ */
+export declare const BUILT_IN_OFF_THE_RECORD_START: readonly string[];
+/**
+ * Built-in phrases that END an off-the-record span.
+ *
+ * Shorter than the start list on purpose. A start phrase with no
+ * matching end phrase elides through the end of the conversation, which
+ * is the fail-closed direction; an over-eager end phrase would leak. So
+ * a language only appears here when the phrase is unambiguous.
+ */
+export declare const BUILT_IN_OFF_THE_RECORD_END: readonly string[];
+/**
+ * Loose form of the parsed `OffTheRecordMarkerSettings`: callers that
+ * only override one field pass a partial, so every property is
+ * optional and read-only here.
+ */
+export type OffTheRecordMarkerInput = {
+    readonly [K in keyof OffTheRecordMarkerSettings]?: K extends "useBuiltIns" ? boolean : readonly string[];
+};
+export interface CompiledOffTheRecordMarkers {
+    start: RegExp | null;
+    end: RegExp | null;
+}
+/**
+ * Compile marker settings into matchers. Omitting `settings` yields the
+ * built-in lists, so callers that never configured markers keep the
+ * previous behavior plus the new languages.
+ */
+export declare function compileOffTheRecordMarkers(settings?: OffTheRecordMarkerInput): CompiledOffTheRecordMarkers;
+export interface OffTheRecordResult {
+    conversation: WearableConversation;
+    droppedSegments: number;
+}
+/**
+ * Drop segments between a spoken off-the-record marker and the next
+ * back-on-the-record marker (or conversation end). The marker segments
+ * themselves are kept, with the off-record span replaced by a visible
+ * placeholder so the transcript shows that content was elided by
+ * request rather than lost.
+ */
+export declare function applyOffTheRecord(conversation: WearableConversation, markers?: CompiledOffTheRecordMarkers): OffTheRecordResult;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/wearables/redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../../src/wearables/redaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EACV,0BAA0B,EAC1B,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAqBlD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EAAE,GACrB,eAAe,CA6BjB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAwBrE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAe1D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EASxD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,CAAC,IAAI,MAAM,0BAA0B,CAAC,CAAC,EAAE,CAAC,SAAS,aAAa,GACtE,OAAO,GACP,SAAS,MAAM,EAAE;CACtB,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,CAAC,EAAE,uBAAuB,GACjC,2BAA2B,CAc7B;AAED,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,oBAAoB,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,oBAAoB,EAClC,OAAO,GAAE,2BAA0D,GAClE,kBAAkB,CAsCpB"}

package/dist/wearables/registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Wearable connector registry.
+ *
+ * Concrete connectors live in optional à-la-carte packages and register
+ * a factory here (directly, or via the built-in loader below which
+ * dynamic-imports the known packages with computed specifiers so
+ * bundlers and the dts resolver never require them at build time).
+ */
+import type { WearableSourceConnector, WearableSourceSettings } from "./types.js";
+export interface WearableConnectorFactoryOptions {
+    settings: WearableSourceSettings;
+    /** IANA timezone transcripts are bucketed in. */
+    timezone: string;
+}
+export type WearableConnectorFactory = (options: WearableConnectorFactoryOptions) => WearableSourceConnector;
+export interface WearableConnectorRegistration {
+    id: string;
+    displayName: string;
+    factory: WearableConnectorFactory;
+}
+export declare function registerWearableConnector(registration: WearableConnectorRegistration): void;
+export declare function getWearableConnector(id: string): WearableConnectorRegistration | undefined;
+/**
+ * Register a connector package with this registry immediately (idempotent)
+ * and return its `ensure*Registered()` companion.
+ *
+ * Connector packages call this once at module scope with their registration
+ * record, so importing the module registers the connector as a side effect.
+ * The returned companion re-checks the live registry on every call — so it
+ * also re-registers after a test-only registry reset — and returns false
+ * while the connector stays registered. `registerWearableConnector` throws
+ * on duplicate ids, which is why the registry is checked before each call.
+ */
+export declare function selfRegisterWearableConnector(registration: WearableConnectorRegistration): () => boolean;
+export declare function listWearableConnectors(): string[];
+/** Test-only: reset the registry between cases. */
+export declare function clearWearableConnectors(): void;
+/**
+ * npm specifier of the optional package that provides a source's connector.
+ * Built-in sources map to their real package (e.g. `desktop` ->
+ * `@remnic/capture-audio`, not the nonexistent `@remnic/connector-desktop`);
+ * unknown ids fall back to the `connector-<id>` convention. Used by
+ * missing-connector install hints so they name the exact install command.
+ */
+export declare function builtInConnectorPackageSpecifier(id: string): string;
+export declare function ensureBuiltInWearableConnectors(): Promise<void>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/wearables/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/wearables/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,EAAE,sBAAsB,CAAC;IACjC,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,OAAO,EAAE,+BAA+B,KACrC,uBAAuB,CAAC;AAE7B,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,wBAAwB,CAAC;CACnC;AAID,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,6BAA6B,GAC1C,IAAI,CAoBN;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,MAAM,GACT,6BAA6B,GAAG,SAAS,CAK3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,YAAY,EAAE,6BAA6B,GAC1C,MAAM,OAAO,CAQf;AAED,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAED,mDAAmD;AACnD,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAkBD;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAGnE;AAID,wBAAsB,+BAA+B,IAAI,OAAO,CAAC,IAAI,CAAC,CA6BrE"}

package/dist/wearables/service.d.ts

@@ -0,0 +1,225 @@
+/**
+ * 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).
+ */
+import type { LocationConfig } from "../location/types.js";
+import { type FusionArtifactStore, type FusedWearableConversation } from "./fusion/index.js";
+import type { WearableMemoryGenDeps } from "./memory-gen.js";
+import { type WearableSyncOptions } from "./pipeline.js";
+import { type SpeakerRegistry } from "./speakers.js";
+import type { WearableCorrectionRule, WearableDayTranscript, WearableSourceStatus, WearableSyncSummary, WearablesConfig } from "./types.js";
+/** Storage capabilities the service needs (satisfied by StorageManager). */
+export 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>;
+}
+export 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>;
+}
+export 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>;
+    /**
+     * Location config for the missing-only conversation location fill
+     * (issue #2925). Absent changes nothing; the fill itself stays gated
+     * on the location tagging flags.
+     */
+    locationConfig?: LocationConfig;
+}
+export interface WearableTranscriptSearchResult {
+    source: string;
+    date: string;
+    score: number;
+    snippet: string;
+    /** "indexed" (QMD) or "scan" (substring fallback). */
+    backend: "indexed" | "scan";
+}
+export interface WearableMemorySearchResult {
+    id: string;
+    source: string;
+    date?: string;
+    conversationId?: string;
+    status?: string;
+    content: string;
+    created: string;
+}
+export interface WearableDayTranscriptView {
+    source: string;
+    date: string;
+    meta: WearableDayTranscript["meta"] | null;
+    body: string;
+    /** Other sources that also recorded during this day (overlap hint). */
+    overlapsWith: string[];
+}
+/**
+ * Build the memory writer used by wearable syncs. The storage fact
+ * hash index only covers category "fact", so dedup for the other
+ * categories wearables write (moment digests, decisions, preferences,
+ * commitments) additionally scans existing wearable-tagged memories for
+ * an exact content match — without this, a forced or retried day
+ * re-writes identical digests and candidates (Codex P2 on PR #1458).
+ * The scan is bounded to wearable-sourced memories and sits on the
+ * cached readAllMemories() path.
+ */
+export declare function createWearableMemoryWriter(storage: WearableStorageIo): WearableMemoryGenDeps["writer"];
+export 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. */
+export declare function locateTranscriptPath(hitPath: string): {
+    source: string;
+    date: string;
+} | null;
+//# sourceMappingURL=service.d.ts.map