@remnic/core 9.69.56 → 9.69.57

package/dist/wearables/fusion/cluster.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Wearable cross-source fusion — deterministic conversation clustering.
+ *
+ * Conversations from multiple sources recording the same real-world event
+ * overlap or sit within a proximity gap. This module groups them into
+ * clusters that are fully deterministic: the only inputs are start/end
+ * times, source ids, and conversation ids (no randomness, no LLM).
+ *
+ * Cross-source time proximity BRIDGES the same real-world conversation
+ * recorded by DIFFERENT sources. A single source's own distinct
+ * conversations are never merged by time proximity alone — that would
+ * collapse the source's conversation boundaries. Two same-source
+ * conversations may end up in one cluster only when a different-source
+ * conversation within the gap corroborates that they are part of the same
+ * real-world event (a cross-source chain/bridge).
+ */
+import type { FusionConversationInput } from "./types.js";
+/** Default max gap (ms) between two conversations to merge into one cluster. */
+export declare const DEFAULT_PROXIMITY_GAP_MS: number;
+/** The latest extent of a set of segments as an epoch-ms value + its ISO.
+ * Each segment contributes its OWN extent — its `endIso` when known,
+ * otherwise its `startIso` — and the result is the maximum. Reconstructed
+ * `--:--` transcripts rebuild segments with only a start, so this reaches
+ * the last segment start; segment ISOs are already cross-midnight-rolled by
+ * the reconstruct layer, so the derived end is consistent with the segment
+ * timeline. Returns undefined when no segment carries a parseable extent.
+ *
+ * This is the SINGLE shared primitive behind every end/interval derivation
+ * in the fusion pipeline (cluster interval, fused conversation end): when a
+ * conversation-level end is missing, the window falls back to the latest
+ * segment extent instead of collapsing to a zero-length point at the start.
+ */
+export interface SegmentExtent {
+    /** Epoch ms of the latest extent. */
+    ms: number;
+    /** ISO string that produced `ms` (a segment endIso, else its startIso). */
+    iso: string;
+}
+export declare function maxSegmentExtent(segments: readonly {
+    endIso?: string;
+    startIso?: string;
+}[]): SegmentExtent | undefined;
+/**
+ * Cluster conversations across sources for one day. Returns clusters in
+ * chronological order; each cluster is sorted by (start, source, id).
+ * Conversations whose start time is unparseable are emitted as
+ * single-element clusters at the tail (sorted by source then id) so no
+ * data is lost.
+ *
+ * ## Cross-source bridging rule (issue #1849)
+ *
+ * Time proximity is meant to bridge the SAME real-world conversation
+ * recorded by DIFFERENT sources — not to merge one source's own distinct
+ * conversations. Two conversations from the SAME source are therefore
+ * never directly joined by time proximity alone; they may end up in the
+ * same cluster only through a cross-source chain where a different-source
+ * conversation within the gap corroborates the bridge. This preserves the
+ * source's own conversation boundaries when no other source corroborates
+ * a merge.
+ *
+ * Concretely, a union-find pass links every pair of conversations that
+ * (a) come from DIFFERENT sources and (b) sit within the proximity gap
+ * (the later start ≤ the earlier end + gap). The transitive closure then
+ * groups same-source conversations that are bridged by at least one
+ * intervening different-source conversation. A single source with two
+ * near-back-to-back conversations and no other source recording the same
+ * window stays in two separate clusters.
+ */
+export declare function clusterConversations(inputs: readonly FusionConversationInput[], proximityGapMs?: number): FusionConversationInput[][];
+//# sourceMappingURL=cluster.d.ts.map

package/dist/wearables/fusion/cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../../../src/wearables/fusion/cluster.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE1D,gFAAgF;AAChF,eAAO,MAAM,wBAAwB,QAAa,CAAC;AAOnD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;CACb;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,GAC1D,aAAa,GAAG,SAAS,CAY3B;AAqDD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,uBAAuB,EAAE,EAC1C,cAAc,GAAE,MAAiC,GAChD,uBAAuB,EAAE,EAAE,CAsF7B"}

package/dist/wearables/fusion/fuse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Wearable cross-source fusion — day-level orchestrator.
+ *
+ * Takes every enabled source's normalized conversations for one day,
+ * clusters them across sources, reconciles each cluster, and attaches a
+ * stable content-hash id so re-running over unchanged inputs produces a
+ * byte-identical artifact (idempotent — no duplicate files).
+ *
+ * Deterministic end to end: no timestamps from "now", no LLM, no
+ * randomness. The only time-derived value is the `fusedAt` frontmatter
+ * field added at storage time (excluded from the content hash).
+ */
+import type { FusionConversationInput, FusionDayResult, FusionOptions } from "./types.js";
+/**
+ * Fusion algorithm/schema version. Folded into the day content hash (the
+ * idempotency key) so a change to the clustering, reconciliation, or
+ * reconstruction algorithm invalidates cached artifacts even when the raw
+ * inputs and fusion config are byte-identical — pre-existing `_fusion/`
+ * files are regenerated rather than served stale. Bump this whenever the
+ * fusion algorithm meaningfully changes (this PR changed it repeatedly).
+ * The per-conversation id (`canonicalInputsKey`) is intentionally NOT
+ * folded with the version, so a conversation keeps a stable identity.
+ */
+export declare const FUSION_ALGO_VERSION = "2026-07-12-1";
+/**
+ * Day idempotency key: the input-only hash combined with the effective
+ * fusion-config fingerprint AND the fusion algorithm version. Same inputs +
+ * same config + same version => same hash (no duplicate rewrite); a config
+ * change OR an algorithm-version bump => new hash => rebuild. The version
+ * is what forces regeneration when the ALGORITHM itself changes but the
+ * inputs and config are byte-identical (issue #1849).
+ */
+export declare function canonicalDayKey(date: string, inputs: readonly FusionConversationInput[], options: FusionOptions, algoVersion?: string): string;
+/**
+ * Fuse every source's conversations for one day into a stable result.
+ * Empty input yields an empty (but well-formed) result so callers can
+ * treat "nothing to fuse" uniformly.
+ */
+export declare function fuseDay(date: string, inputs: readonly FusionConversationInput[], options?: FusionOptions): FusionDayResult;
+//# sourceMappingURL=fuse.d.ts.map

package/dist/wearables/fusion/fuse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuse.d.ts","sourceRoot":"","sources":["../../../src/wearables/fusion/fuse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH,OAAO,KAAK,EACV,uBAAuB,EACvB,eAAe,EACf,aAAa,EAGd,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AA2ElD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,uBAAuB,EAAE,EAC1C,OAAO,EAAE,aAAa,EACtB,WAAW,GAAE,MAA4B,GACxC,MAAM,CAaR;AAqBD;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,uBAAuB,EAAE,EAC1C,OAAO,GAAE,aAAkB,GAC1B,eAAe,CA6CjB"}

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

@@ -0,0 +1,16 @@
+/**
+ * Wearable cross-source fusion — public surface (issue #1810).
+ *
+ * Deterministic, config-gated fusion of multi-source wearable
+ * transcripts into `FusedWearableConversation` artifacts. No LLM calls
+ * in this module — see the PR body for the deferred follow-ups
+ * (LLM-assisted reconciliation, memory extraction over fused artifacts,
+ * full segment alignment, search-index integration).
+ */
+export type { DisagreementKind, FusionConversationInput, FusionDayResult, FusionOptions, FusionSegmentInput, FusedConversationProvenance, FusedContribution, FusedDayFile, FusedDayMeta, FusedDisagreement, FusedSegment, FusedSegmentProvenance, FusedSpeaker, FusedWearableConversation, SegmentPickReason, } from "./types.js";
+export { DEFAULT_PROXIMITY_GAP_MS, clusterConversations, } from "./cluster.js";
+export { DEFAULT_SOURCE_TRUST, DEFAULT_WINDOW_TOLERANCE_MS, fuseCluster, fusionInputsFromConversations, type FuseClusterResult, } from "./reconcile.js";
+export { FUSION_ALGO_VERSION, canonicalDayKey, fuseDay } from "./fuse.js";
+export { FUSION_DIR_NAME, FUSION_KIND, FusionArtifactStore, type FusionFileIo, composeFusionDayMeta, hashFusionBody, parseFusionDay, serializeFusionDay, } from "./store.js";
+export { reconstructFusionInputs } from "./reconstruct.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/wearables/fusion/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY,EACV,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,2BAA2B,EAC3B,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,sBAAsB,EACtB,YAAY,EACZ,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,WAAW,EACX,6BAA6B,EAC7B,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EACL,eAAe,EACf,WAAW,EACX,mBAAmB,EACnB,KAAK,YAAY,EACjB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/wearables/fusion/reconcile.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Wearable cross-source fusion — deterministic reconciliation.
+ *
+ * Given one cluster (conversations from N sources that overlapped in
+ * time), produce a single reconciled timeline where each utterance
+ * carries the best source's text plus per-segment provenance, and
+ * conflicts that could not be settled deterministically are recorded as
+ * disagreements.
+ *
+ * Reconciliation rules (all deterministic, no LLM):
+ *  - text: prefer higher source trust, then the more-complete (longer)
+ *    transcript over a truncated one; otherwise a stable tie-break.
+ *  - disagreement: when two sources offer genuinely different text for
+ *    the same window/speaker (neither contains the other), record every
+ *    candidate and keep a provisional winner marked uncertain — we never
+ *    silently pick.
+ *  - speaker: resolved labels unify the wearer across sources; generic
+ *    labels that cannot be cross-matched keep a lowered confidence.
+ *
+ * Full segment-level alignment beyond time windows is a deferred
+ * follow-up (see PR body). This pass aligns by (speaker, time window).
+ */
+import { type SpeakerRegistry } from "../speakers.js";
+import type { WearableConversation } from "../types.js";
+import type { FusionConversationInput, FusionOptions, FusedDisagreement, FusedSegment, FusedSpeaker } from "./types.js";
+/** Default max drift (ms) for two segments to align across sources. */
+export declare const DEFAULT_WINDOW_TOLERANCE_MS = 30000;
+/** Default trust weight for a source with no configured prior. */
+export declare const DEFAULT_SOURCE_TRUST = 0.8;
+export interface FuseClusterResult {
+    sources: string[];
+    speakers: FusedSpeaker[];
+    title?: string;
+    summary?: string;
+    startIso: string;
+    endIso?: string;
+    segments: FusedSegment[];
+    disagreements: FusedDisagreement[];
+}
+/**
+ * Build fusion inputs from raw provider conversations + the shared
+ * speaker registry. This is the precise connector path: full ISO
+ * timestamps and resolved speaker labels. (The on-demand service path
+ * instead reconstructs inputs from stored transcripts — see
+ * `reconstruct.ts`.)
+ */
+export declare function fusionInputsFromConversations(sourceId: string, conversations: readonly WearableConversation[], registry: SpeakerRegistry): FusionConversationInput[];
+/**
+ * Fuse one cluster into a reconciled conversation (without id/date).
+ */
+export declare function fuseCluster(cluster: readonly FusionConversationInput[], options?: FusionOptions): FuseClusterResult;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/wearables/fusion/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../../src/wearables/fusion/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EACV,uBAAuB,EACvB,aAAa,EAEb,iBAAiB,EACjB,YAAY,EACZ,YAAY,EAEb,MAAM,YAAY,CAAC;AAEpB,uEAAuE;AACvE,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAClD,kEAAkE;AAClE,eAAO,MAAM,oBAAoB,MAAM,CAAC;AASxC,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,aAAa,EAAE,iBAAiB,EAAE,CAAC;CACpC;AAqGD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,QAAQ,EAAE,eAAe,GACxB,uBAAuB,EAAE,CAsB3B;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,uBAAuB,EAAE,EAC3C,OAAO,GAAE,aAAkB,GAC1B,iBAAiB,CAsSnB"}

package/dist/wearables/fusion/reconstruct.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Wearable cross-source fusion — reconstruct inputs from stored transcripts.
+ *
+ * The on-demand service path fuses from already-synced day transcripts
+ * (offline, no connector calls). Those files store a human-readable
+ * markdown body, so this module parses it back into the normalized
+ * `FusionConversationInput[]` shape the fusion engine consumes.
+ *
+ * Precision caveat (documented, accepted for this foundational PR):
+ * the rendered body carries minute-precision clock times in the
+ * configured timezone. We reconstruct them as `${date}T${HH}:${MM}:00Z`
+ * — every source for a given day is rendered in the SAME timezone, so
+ * relative within-day comparisons and time-window alignment stay
+ * correct even though the absolute ISO is timezone-normalized. Full
+ * segment-level alignment with sub-minute precision is a deferred
+ * follow-up (see PR body).
+ */
+import type { FusionConversationInput } from "./types.js";
+/**
+ * Reconstruct fusion inputs for a day from one or more sources' stored
+ * transcript bodies. Each body is the markdown produced by
+ * `composeDayTranscriptBody` (frontmatter already stripped by the
+ * caller via `parseDayTranscript`).
+ */
+export declare function reconstructFusionInputs(date: string, dayTranscripts: ReadonlyArray<{
+    source: string;
+    body: string;
+    /**
+     * Whether the body was written by the escape-aware serializer
+     * (`bodyIsEscaped(meta)`). When falsy (legacy) the segment text and
+     * speaker label are used verbatim — no escape decoding — so a legacy
+     * transcript's literal two-character `\n`/`\r` is never altered
+     * (issue #1849).
+     */
+    escaped?: boolean;
+}>): FusionConversationInput[];
+//# sourceMappingURL=reconstruct.d.ts.map

package/dist/wearables/fusion/reconstruct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../../../src/wearables/fusion/reconstruct.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,OAAO,KAAK,EACV,uBAAuB,EAExB,MAAM,YAAY,CAAC;AA2DpB;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,aAAa,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC,GACD,uBAAuB,EAAE,CA+I3B"}

package/dist/wearables/fusion/store.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Wearable cross-source fusion — derived-day file serialization.
+ *
+ * One derived file per fused day, stored ALONGSIDE raw source transcripts
+ * (under the wearables tree) but never overwriting them. Format mirrors
+ * the day-transcript convention: YAML frontmatter (`kind:
+ * wearable-fusion`) + a JSON body carrying the structured
+ * `FusedWearableConversation[]`. The frontmatter `contentHash` is the
+ * idempotency key derived from inputs plus the effective fusion config,
+ * so an unchanged re-run (same inputs AND config) produces a
+ * byte-identical file.
+ */
+import type { FusedDayFile, FusedDayMeta, FusedWearableConversation } from "./types.js";
+export declare const FUSION_KIND: "wearable-fusion";
+/** Hash the canonical JSON body for idempotent skip-unchanged checks. */
+export declare function hashFusionBody(conversations: readonly FusedWearableConversation[]): string;
+export declare function composeFusionDayMeta(date: string, conversations: readonly FusedWearableConversation[], sources: readonly string[], contentHash: string, fusedAt: string): FusedDayMeta;
+/** Serialize meta + conversations into the persisted file format. */
+export declare function serializeFusionDay(meta: FusedDayMeta, conversations: readonly FusedWearableConversation[]): string;
+/**
+ * Parse a persisted fused-day file. Returns null when the content does
+ * not look like a fusion artifact (wrong kind / missing frontmatter) so
+ * callers can distinguish "not fused" from a malformed file. A non-null
+ * result carries `parseOk`: false when the JSON body failed to parse, was
+ * not an array, or held a malformed element (conversations is empty in
+ * that case), true for a well-formed (incl. legitimately-empty `[]`)
+ * body — so the skip-unchanged path can force a self-repair rewrite
+ * regardless of the recomputed conversation count or body hash.
+ */
+export declare function parseFusionDay(raw: string): FusedDayFile | null;
+/** Reserved underscore-prefixed subdir for derived fusion artifacts. */
+export declare const FUSION_DIR_NAME = "_fusion";
+/**
+ * Encrypted-at-rest + atomic file IO the fusion artifact store needs.
+ * Satisfied by StorageManager (which owns the secure-store key + atomic
+ * write path) and injected so this module performs NO direct fs — the
+ * derived files inherit the same encrypted-at-rest + atomic-write
+ * semantics as raw day transcripts without this module knowing the key.
+ */
+export interface FusionFileIo {
+    writeFile(filePath: string, content: string): Promise<void>;
+    /** Read a file; rejects with ENOENT when it is absent. */
+    readFile(filePath: string): Promise<string>;
+    /** Directory entries; rejects with ENOENT when the directory is absent. */
+    readDir(dirPath: string): Promise<string[]>;
+    /** Remove a file; rejects with ENOENT when it is absent. */
+    deleteFile(filePath: string): Promise<void>;
+    /**
+     * Resolve a path through symlinks (node:fs/promises realpath); rejects
+     * with ENOENT when the path is absent. Used by the symlink-containment
+     * guard so a symlinked `_fusion` dir (or a symlinked wearables root)
+     * that resolves outside the memory dir is rejected before any
+     * read/write/delete (AGENTS.md #3).
+     */
+    realpath(filePath: string): Promise<string>;
+    /**
+     * Stat a path WITHOUT following a trailing symlink
+     * (node:fs/promises lstat); rejects with ENOENT when the path is
+     * absent. Used to detect a pre-existing symlink at the fusion
+     * artifact directory itself, which is rejected even when its
+     * target resolves inside the memory dir (issue #1849).
+     */
+    lstat(filePath: string): Promise<{
+        isSymbolicLink: boolean;
+    }>;
+}
+/**
+ * Owns the derived fused-day artifact files under
+ * `<wearablesDir>/_fusion/<YYYY-MM-DD>.md`. Path construction, date
+ * validation, and newest-first listing live here (relocated out of the
+ * root storage module — issue #1810 ratchet); the bytes flow through the
+ * injected secure IO.
+ */
+export declare class FusionArtifactStore {
+    private readonly wearablesDir;
+    private readonly memoryDir;
+    private readonly io;
+    constructor(wearablesDir: string, memoryDir: string, io: FusionFileIo);
+    fusedDayPath(date: string): string;
+    writeFusedDay(date: string, serialized: string): Promise<void>;
+    /** Read a stored fused-day artifact; null when absent. */
+    readFusedDay(date: string): Promise<string | null>;
+    /**
+     * Remove a stored fused-day artifact. Idempotent: a no-op when the
+     * artifact is already absent. Used to clear a now-stale derived file
+     * before a fusion run that deliberately refuses to fuse (e.g. a day
+     * whose sources later conflict on timezone) so fusedConversations()
+     * does not keep serving a stale view (issue #1849).
+     */
+    deleteFusedDay(date: string): Promise<void>;
+    /** List dates with stored fused artifacts, newest first. */
+    listFusedDays(): Promise<string[]>;
+    /**
+     * Reject a symlinked/traversing fusion artifact path before any IO. The
+     * fusion dir (`<wearablesDir>/_fusion`) and its parents are followed
+     * directly by the secure IO; a symlink placed there (attacker-writable
+     * or a malformed memory dir) would otherwise be followed and
+     * read/write/delete outside the allowed root (AGENTS.md pattern #3).
+     *
+     * Containment is anchored to the real MEMORY-DIR root, not the
+     * wearables dir, AND the wearables root is checked explicitly: if
+     * `wearablesDir` itself is a symlink that resolves outside memoryDir, a
+     * leaf candidate like `<wearablesDir>/_fusion/<date>.md` may not yet
+     * exist (so its realpath ENOENT-skips) and the write would silently
+     * create the file inside the symlinked escape target. Checking
+     * `wearablesDir` itself — which resolves through the symlink when it
+     * exists — closes that gap, while the per-leaf checks catch a nested
+     * `_fusion` or per-file symlink. Absent paths are allowed (a fresh
+     * write creates them lexically under the root; only a path that
+     * resolves to an existing target can redirect IO). Mirrors
+     * `assertPathInsideRoot` in the storage walkers.
+     */
+    private assertPathContained;
+    /**
+     * Refuse a pre-existing symbolic link at the `<wearablesDir>/_fusion`
+     * directory. Unlike `assertNoEscape` (which follows the link and only
+     * rejects when the target lands outside the memory dir), this catches a
+     * fusion root that aliases an in-bounds path — e.g. a `_fusion` link
+     * pointed at a raw source transcript — so fusion IO never writes
+     * through it and overwrites the aliased file. Absent dirs are allowed
+     * (a fresh write creates a real directory lexically under the root).
+     */
+    private assertFusionDirNotSymlinked;
+    /**
+     * Refuse a candidate whose realpath escapes the memory root. Absent
+     * candidates are allowed: a missing path cannot yet redirect IO, and
+     * the secure write creates it lexically under the root.
+     */
+    private assertNoEscape;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/wearables/fusion/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/wearables/fusion/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,WAAW,EAAG,iBAA0B,CAAC;AAEtD,yEAAyE;AACzE,wBAAgB,cAAc,CAC5B,aAAa,EAAE,SAAS,yBAAyB,EAAE,GAClD,MAAM,CAIR;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,SAAS,yBAAyB,EAAE,EACnD,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,YAAY,CAUd;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,YAAY,EAClB,aAAa,EAAE,SAAS,yBAAyB,EAAE,GAClD,MAAM,CAYR;AAwID;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CA4D/D;AAED,wEAAwE;AACxE,eAAO,MAAM,eAAe,YAAY,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C,2EAA2E;IAC3E,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5C,4DAA4D;IAC5D,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5C;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC/D;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAE5B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAFF,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,YAAY;IAGnC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAS5B,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMpE,0DAA0D;IACpD,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAWxD;;;;;;OAMG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWjD,4DAA4D;IACtD,aAAa,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAqBxC;;;;;;;;;;;;;;;;;;;OAmBG;YACW,mBAAmB;IAuBjC;;;;;;;;OAQG;YACW,2BAA2B;IAgBzC;;;;OAIG;YACW,cAAc;CAa7B"}

package/dist/wearables/fusion/types.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Wearable cross-source fusion — shared types (issue #1810).
+ *
+ * Fusion merges same-day conversations from multiple enabled wearable
+ * sources into `FusedWearableConversation` artifacts: one reconciled
+ * timeline per real-world conversation, with per-segment source
+ * provenance and unresolved conflicts surfaced as `disagreements[]`.
+ *
+ * Everything in this module is DETERMINISTIC — no LLM calls. LLM-assisted
+ * reconciliation, memory-extraction over fused artifacts, and full
+ * segment-level alignment are deferred follow-ups (see PR body).
+ */
+/**
+ * One normalized segment fed into fusion. Speaker labels are already
+ * resolved through the speaker registry (`resolveSpeaker`), and text is
+ * post-cleanup + post-redaction — fusion consumes the same material day
+ * transcripts store, never raw provider output.
+ */
+export interface FusionSegmentInput {
+    /** Resolved speaker label (e.g. "Jane", "Me (you)", "Speaker 0"). */
+    speaker: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+    /** Utterance text. */
+    text: string;
+    /** ISO 8601 start, when known. */
+    startIso?: string;
+    /** ISO 8601 end, when known. */
+    endIso?: string;
+}
+/** One normalized conversation fed into fusion. */
+export interface FusionConversationInput {
+    /** Source id this conversation came from. */
+    source: string;
+    /** Provider-stable conversation id within that source. */
+    conversationId: string;
+    /** Provider title, when available. */
+    title?: string;
+    /** Provider summary, when available. */
+    summary?: string;
+    /** ISO 8601 conversation start. */
+    startIso: string;
+    /** ISO 8601 conversation end, when known. */
+    endIso?: string;
+    /** Ordered normalized segments. */
+    segments: FusionSegmentInput[];
+}
+/** Why a particular source's text was chosen for a fused segment. */
+export type SegmentPickReason = "only-source" | "higher-trust" | "more-complete" | "tie-break";
+/** Kind of unresolved conflict surfaced during reconciliation. */
+export type DisagreementKind = "asr-text" | "speaker" | "timestamp";
+/** Per-segment record of where the chosen text came from and what else was considered. */
+export interface FusedSegmentProvenance {
+    /** Source id the chosen text came from. */
+    source: string;
+    /** Conversation id within that source. */
+    conversationId: string;
+    /** Trust weight of the chosen source at reconciliation time (0..1). */
+    sourceTrust: number;
+    /** Why this source won the pick. */
+    reason: SegmentPickReason;
+    /** Other sources that offered a candidate text for this window/speaker. */
+    alternatives: Array<{
+        source: string;
+        text: string;
+    }>;
+    /** The chosen source's ORIGINAL start time (ISO), when known. The fused
+     * segment is emitted on the group/window ANCHOR timeline position so
+     * pre-sorted chronology stays valid even when the higher-trust source's
+     * clock is later than the anchor; this preserves WHERE the chosen text
+     * was actually recorded for provenance/traceability. */
+    sourceStartIso?: string;
+    /** The chosen source's ORIGINAL end time (ISO), when known (see sourceStartIso). */
+    sourceEndIso?: string;
+}
+/** One reconciled utterance in a fused conversation. */
+export interface FusedSegment {
+    /** Reconciled speaker label. */
+    speaker: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+    /** Reconciled utterance text. */
+    text: string;
+    /** Window start (ISO), when known. */
+    startIso?: string;
+    /** Window end (ISO), when known. */
+    endIso?: string;
+    /** 0..1 confidence in this segment's text + attribution. */
+    confidence: number;
+    provenance: FusedSegmentProvenance;
+}
+/** An unresolved conflict that reconciliation could not settle deterministically. */
+export interface FusedDisagreement {
+    kind: DisagreementKind;
+    /**
+     * What the disagreement concerns — an ISO window anchor, a speaker
+     * label, or "(no timestamp)" for un-timestamped windows.
+     */
+    subject: string;
+    /** The conflicting candidates that could not be auto-resolved. */
+    candidates: Array<{
+        source: string;
+        value: string;
+    }>;
+    /** Best-effort provisional winner; marked uncertain, NOT authoritative. */
+    provisional?: {
+        source: string;
+        value: string;
+    };
+}
+/** A reconciled speaker that appears in the fused conversation. */
+export interface FusedSpeaker {
+    /** Display label. */
+    label: string;
+    /** Whether this speaker is the wearer. */
+    isSelf: boolean;
+    /**
+     * 0..1 — lowered when a speaker could not be confidently matched
+     * across sources (e.g. a generic diarization label seen in one
+     * source only).
+     */
+    confidence: number;
+    /** Source ids that produced this speaker. */
+    sources: string[];
+}
+/** Record of one source conversation that fed a fused conversation. */
+export interface FusedContribution {
+    source: string;
+    conversationId: string;
+    startIso: string;
+    endIso?: string;
+    segmentCount: number;
+}
+/** How a fused conversation was assembled. */
+export interface FusedConversationProvenance {
+    /** Source conversations that fed this cluster. */
+    contributions: FusedContribution[];
+    /** Max gap (ms) two conversations could span and still merge. */
+    proximityGapMs: number;
+    /** Max drift (ms) for two segments to align across sources. */
+    windowToleranceMs: number;
+    /** Clustering method (deterministic, time-proximity based). */
+    method: "time-proximity";
+}
+/**
+ * A real-world conversation reconstructed from one or more wearable
+ * sources recording at the same time. The fused artifact.
+ */
+export interface FusedWearableConversation {
+    /** Stable content-hash id (deterministic from inputs; idempotent). */
+    id: string;
+    /** YYYY-MM-DD the conversation was recorded. */
+    date: string;
+    /** Earliest start across contributing sources. */
+    startIso: string;
+    /** Latest end across contributing sources, when known. */
+    endIso?: string;
+    /** Source ids that contributed at least one conversation. */
+    sources: string[];
+    /** Reconciled speakers (deduped across sources). */
+    speakers: FusedSpeaker[];
+    /** Provider title, when any source supplied one. */
+    title?: string;
+    /** Provider summary, when any source supplied one. */
+    summary?: string;
+    /** Aligned, reconciled segments in chronological order. */
+    segments: FusedSegment[];
+    /** Unresolved conflicts surfaced during reconciliation. */
+    disagreements: FusedDisagreement[];
+    provenance: FusedConversationProvenance;
+}
+/** Options for a fusion pass. */
+export interface FusionOptions {
+    /** Max gap (ms) between conversations to merge into one cluster. */
+    proximityGapMs?: number;
+    /** Max drift (ms) for two segments to align across sources. */
+    windowToleranceMs?: number;
+    /** Per-source trust weights (unknown sources default to 0.8). */
+    sourceTrust?: Record<string, number>;
+}
+/** Result of fusing one day across all sources. */
+export interface FusionDayResult {
+    date: string;
+    conversations: FusedWearableConversation[];
+    /** Distinct source ids that contributed any conversation. */
+    sources: string[];
+    /** SHA-256 over the canonical input serialization + effective fusion config (idempotency key). */
+    contentHash: string;
+}
+/** Frontmatter persisted on a fused-day derived file. */
+export interface FusedDayMeta {
+    kind: "wearable-fusion";
+    date: string;
+    sourceCount: number;
+    conversationCount: number;
+    contentHash: string;
+    /**
+     * SHA-256 over the canonical serialized body (`hashFusionBody`). Stored
+     * so the skip-unchanged path can detect a body whose bytes drifted from
+     * the recomputed artifact even when `contentHash` + conversation count
+     * still match — forcing a self-repair rewrite on body-level corruption.
+     */
+    bodyHash: string;
+    fusedAt: string;
+}
+/** A parsed fused-day derived file. */
+export interface FusedDayFile {
+    meta: FusedDayMeta;
+    conversations: FusedWearableConversation[];
+    /**
+     * False when the JSON body failed to parse (truncated/corrupt). A
+     * legitimately empty (`[]`) body parses fine — parseOk stays true — so
+     * callers can distinguish "nothing to fuse" from a broken file and force
+     * a self-repair rewrite even when the frontmatter hash matches and the
+     * parsed conversation count is also zero.
+     */
+    parseOk: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/wearables/fusion/types.d.ts.map

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

package/dist/wearables/http-glue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wearables HTTP glue (issue #2047) — the wearables-input→400 error mapper
+ * extracted from access-http.ts so that size-grandfathered file keeps only
+ * thin route branches (same pattern as meetings/http-glue.ts). Returns false
+ * for non-wearables faults so backend errors keep flowing to the global 500
+ * handler.
+ */
+import type { ServerResponse } from "node:http";
+type RespondJson = (res: ServerResponse, status: number, payload: unknown) => void;
+export declare function respondWearablesErrorGlue(respondJson: RespondJson, res: ServerResponse, err: unknown): boolean;
+export {};
+//# sourceMappingURL=http-glue.d.ts.map

package/dist/wearables/http-glue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-glue.d.ts","sourceRoot":"","sources":["../../src/wearables/http-glue.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD,KAAK,WAAW,GAAG,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AAEnF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,OAAO,GACX,OAAO,CAUT"}