@remnic/core 9.5.0 → 9.6.1

package/src/wearables/cli.ts

@@ -33,6 +33,8 @@ Commands:
     --source <id>  --from <date>  --to <date>  --limit <n>
   memories [options]             List memories created from transcripts
     --source <id>  --date <date>  --limit <n>
+  fuse <YYYY-MM-DD>              Fuse enabled sources' transcripts for a day
+  fused <YYYY-MM-DD>             List fused conversations for a day
   speakers list                  Show the speaker registry
   speakers self <name>           Set the wearer's display name
   speakers set <source> <key> <name> [--self]
@@ -419,6 +421,69 @@ export async function runWearablesCliCommand(
           `unknown corrections action '${action}' — expected list, add, or remove`,
         );
       }
+      case "fuse": {
+        const parsed = parseFlags(rest);
+        const date = flagString(parsed, "--date") ?? parsed.positional[0];
+        if (!date) {
+          throw new WearablesInputError(
+            "fuse requires a date (e.g. wearables fuse 2026-06-10)",
+          );
+        }
+        const result = await service.fuseDay(date);
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+          return 0;
+        }
+        // `written:false` has two distinct meanings (issue #1849): a genuine
+        // idempotent no-op (inputs unchanged) OR a deliberate SKIP — e.g.
+        // mixed source timezones — where fusion was refused and any
+        // previously-fused artifact for the day was cleared. The JSON path
+        // carries `skipped`, but the text path collapsed both into
+        // "(unchanged)", hiding a skip (and a possible artifact deletion)
+        // behind an idempotent-looking label. Check `skipped` first and emit
+        // a distinct skip line; reserve "(unchanged)" for written:false
+        // WITHOUT a skip reason. Mirrors the `skipped` field the JSON path
+        // serializes.
+        if (result.skipped) {
+          io.stdout.write(
+            `Skipped fusing ${date}: ${result.skipped.reason} — no fused artifact written; any existing fused artifact for the day was cleared.\n`,
+          );
+        } else {
+          io.stdout.write(
+            `Fused ${date}: ${result.conversationCount} conversation${result.conversationCount === 1 ? "" : "s"} from ${result.sources.length} source${result.sources.length === 1 ? "" : "s"}.${result.written ? "" : " (unchanged)"}\n`,
+          );
+        }
+        return 0;
+      }
+      case "fused": {
+        const parsed = parseFlags(rest);
+        const date = flagString(parsed, "--date") ?? parsed.positional[0];
+        if (!date) {
+          throw new WearablesInputError(
+            "fused requires a date (e.g. wearables fused 2026-06-10)",
+          );
+        }
+        const conversations = await service.fusedConversations(date);
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify({ date, conversations }, null, 2)}\n`);
+          return 0;
+        }
+        if (conversations.length === 0) {
+          io.stdout.write(`No fused conversations for ${date}.\n`);
+          return 0;
+        }
+        for (const conv of conversations) {
+          io.stdout.write(
+            `${conv.id} ${conv.startIso}${conv.endIso ? ` \u2013 ${conv.endIso}` : ""} (${conv.sources.join(", ")}, ${conv.segments.length} segment${conv.segments.length === 1 ? "" : "s"})\n`,
+          );
+          for (const disagreement of conv.disagreements) {
+            io.stdout.write(
+              `  disagreement [${disagreement.kind}] @ ${disagreement.subject}: ${disagreement.candidates.length} candidate${disagreement.candidates.length === 1 ? "" : "s"}\n`,
+            );
+          }
+        }
+        return 0;
+      }
       default:
         throw new WearablesInputError(
           `unknown wearables command '${command}'\n\n${USAGE}`,

package/src/wearables/config.test.ts

@@ -245,3 +245,35 @@ test("a deep window narrower than the tick window is rejected, 0 disables", () =
     5,
   );
 });
+
+
+test("fusion defaults to disabled with documented knobs", () => {
+  const parsed = parseWearablesConfig({});
+  assert.equal(parsed.fusion.enabled, false);
+  assert.equal(parsed.fusion.proximityGapMs, 300_000);
+  assert.equal(parsed.fusion.windowToleranceMs, 30_000);
+});
+
+test("fusion enabled flag and knobs parse and validate", () => {
+  const parsed = parseWearablesConfig({
+    fusion: { enabled: true, proximityGapMs: 120_000, windowToleranceMs: 15_000 },
+  });
+  assert.equal(parsed.fusion.enabled, true);
+  assert.equal(parsed.fusion.proximityGapMs, 120_000);
+  assert.equal(parsed.fusion.windowToleranceMs, 15_000);
+});
+
+test("fusion knobs reject non-positive integers", () => {
+  assert.throws(
+    () => parseWearablesConfig({ fusion: { proximityGapMs: 0 } }),
+    /proximityGapMs must be a positive integer/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ fusion: { windowToleranceMs: -5 } }),
+    /windowToleranceMs must be a positive integer/,
+  );
+});
+
+test("fusion block must be an object when present", () => {
+  assert.throws(() => parseWearablesConfig({ fusion: "on" }), /must be an object/);
+});

package/src/wearables/config.ts

@@ -16,6 +16,7 @@ import type {
   WearableCleanupSettings,
   WearableCorrectionRule,
   WearableMemoryMode,
+  WearableFusionConfig,
   WearableSourceSettings,
   WearablesConfig,
 } from "./types.js";
@@ -47,6 +48,11 @@ const MAX_AUTO_SYNC_WINDOW_DAYS = 90;
 const DEFAULT_SOURCE_TRUST = 0.8;
 const DEFAULT_AUTO_APPROVE_TRUST = 0.7;
 const DEFAULT_REVIEW_TRUST = 0.45;
+// Cross-source fusion (#1810) — disabled by default; enabling is the
+// only behavior change fusion introduces.
+const DEFAULT_FUSION_ENABLED = false;
+const DEFAULT_FUSION_PROXIMITY_GAP_MS = 300_000;
+const DEFAULT_FUSION_WINDOW_TOLERANCE_MS = 30_000;
 
 // Sources whose provider emits per-utterance text but unreliable
 // speaker labels (Bee falls back to a generic "unknown" label when
@@ -91,6 +97,14 @@ export function defaultWearableSourceSettings(
   };
 }
 
+export function defaultWearableFusionConfig(): WearableFusionConfig {
+  return {
+    enabled: DEFAULT_FUSION_ENABLED,
+    proximityGapMs: DEFAULT_FUSION_PROXIMITY_GAP_MS,
+    windowToleranceMs: DEFAULT_FUSION_WINDOW_TOLERANCE_MS,
+  };
+}
+
 export function defaultWearablesConfig(): WearablesConfig {
   return {
     enabled: false,
@@ -104,6 +118,7 @@ export function defaultWearablesConfig(): WearablesConfig {
     autoSyncDeepDays: DEFAULT_AUTO_SYNC_DEEP_DAYS,
     corrections: [],
     sources: {},
+    fusion: defaultWearableFusionConfig(),
   };
 }
 
@@ -331,6 +346,42 @@ function parseSourceSettings(
  * Parse the `wearables` config block. `undefined` yields the disabled
  * default config; any present-but-malformed value throws.
  */
+function parseFusionSettings(
+  value: unknown,
+  keyPath: string,
+): WearableFusionConfig {
+  if (value === undefined) return defaultWearableFusionConfig();
+  const raw = requireObject(value, keyPath);
+  const defaults = defaultWearableFusionConfig();
+  const parsePositiveInt = (
+    value: unknown,
+    name: string,
+    fallback: number,
+  ): number => {
+    if (value === undefined) return fallback;
+    const coerced = coerceNumber(value);
+    if (coerced === undefined || !Number.isInteger(coerced) || coerced <= 0) {
+      throw new Error(
+        `${keyPath}.${name} must be a positive integer (got ${JSON.stringify(value)})`,
+      );
+    }
+    return coerced;
+  };
+  return {
+    enabled: parseBool(raw.enabled, `${keyPath}.enabled`, defaults.enabled),
+    proximityGapMs: parsePositiveInt(
+      raw.proximityGapMs,
+      "proximityGapMs",
+      defaults.proximityGapMs,
+    ),
+    windowToleranceMs: parsePositiveInt(
+      raw.windowToleranceMs,
+      "windowToleranceMs",
+      defaults.windowToleranceMs,
+    ),
+  };
+}
+
 export function parseWearablesConfig(value: unknown): WearablesConfig {
   if (value === undefined) return defaultWearablesConfig();
   const raw = requireObject(value, "wearables");
@@ -455,6 +506,7 @@ export function parseWearablesConfig(value: unknown): WearablesConfig {
     autoSyncIntervalMinutes,
     autoSyncDays,
     autoSyncDeepDays,
+    fusion: parseFusionSettings(raw.fusion, "wearables.fusion"),
     corrections: parseCorrectionRules(raw.corrections, "wearables.corrections"),
     sources,
   };

package/src/wearables/day-store.test.ts

@@ -2,12 +2,16 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 
 import {
+  bodyIsEscaped,
   composeDayTranscriptBody,
   composeDayTranscriptMeta,
+  decodeTranscriptBody,
   hashTranscriptBody,
   isValidTranscriptDate,
   parseDayTranscript,
+  parseTranscriptSegmentLine,
   serializeDayTranscript,
+  TRANSCRIPT_FORMAT_VERSION,
 } from "./day-store.js";
 import { emptySpeakerRegistry } from "./speakers.js";
 import type { WearableConversation } from "./types.js";
@@ -141,3 +145,245 @@ test("invalid timezone falls back to UTC clock rendering instead of crashing", (
   );
   assert.match(body, /## \d{2}:\d{2}–\d{2}:\d{2} · Morning coffee/);
 });
+
+
+test("decodeTranscriptBody decodes segment text but leaves headings/locations untouched (#1849)", () => {
+  // Hand-written stored body: segment text carries the escaped forms
+  // (backslash-n for a newline) exactly as composeDayTranscriptBody
+  // serializes them, while the title/location are NOT escaped on write.
+  const body =
+    "# bee transcript — 2026-06-10\n" +
+    "\n" +
+    "## 09:00–09:10 · C:\\roadmap (conversation c1)\n" +
+    "\n" +
+    "*Location: D:\\data*\n" +
+    "\n" +
+    '**Me (you)** [09:00]: Line one.\\nLine two.\n';
+  const decoded = decodeTranscriptBody(body, true);
+  // Segment text IS decoded: backslash-n -> real newline.
+  assert.ok(decoded.includes("Line one.\nLine two."), "segment newline decoded");
+  assert.ok(!decoded.includes("Line one.\\nLine two."), "no escaped-newline leak in segment");
+  // Title and location are NOT escaped on write, so a literal backslash
+  // there must pass through verbatim (only segment text is decoded).
+  assert.ok(decoded.includes("· C:\\roadmap (conversation c1)"), "title backslash untouched");
+  assert.ok(decoded.includes("*Location: D:\\data*"), "location backslash untouched");
+});
+
+test("decodeTranscriptBody recovers original segment text from a composed body (#1849)", () => {
+  const original = "First line.\nSecond line with a backslash \\ here.";
+  const conversations: WearableConversation[] = [
+    {
+      id: "c1",
+      source: "bee",
+      startIso: "2026-06-10T09:00:00Z",
+      segments: [{ speakerKey: "user", isWearer: true, text: original }],
+    },
+  ];
+  const body = composeDayTranscriptBody("bee", "2026-06-10", "UTC", conversations, REGISTRY);
+  // The stored body carries the ESCAPED form, not the original...
+  assert.ok(!body.includes(original), "stored body is escaped, not the raw original");
+  assert.ok(body.includes("First line.\\nSecond line"), "stored body has the escaped newline");
+  // ...and decoding recovers the original utterance verbatim.
+  assert.ok(
+    decodeTranscriptBody(body, true).includes(original),
+    "decoded body recovers the original segment text",
+  );
+});
+
+
+test("speaker label with markdown delimiters round-trips through compose → parse and decodeTranscriptBody (#1849)", () => {
+  // A speaker label containing `**`, `[`, `]` — the exact characters that
+  // delimit a segment line. Without safe serialization the label breaks
+  // parseTranscriptSegmentLine parsing; with escape/unescape it round-trips
+  // losslessly through composition, parsing, and display decoding.
+  const registry = emptySpeakerRegistry();
+  registry.selfName = "Me";
+  registry.speakers["bee:SPEAKER_01"] = {
+    name: "A**B",
+    updatedAt: "2026-06-10T00:00:00Z",
+  };
+  const conversations: WearableConversation[] = [
+    {
+      id: "c1",
+      source: "bee",
+      startIso: "2026-06-10T09:00:00Z",
+      segments: [
+        { speakerKey: "user", isWearer: true, text: "Hi there.", startIso: "2026-06-10T09:00:00Z" },
+        { speakerKey: "SPEAKER_01", text: "Delimited label.", startIso: "2026-06-10T09:01:00Z" },
+      ],
+    },
+  ];
+  const body = composeDayTranscriptBody("bee", "2026-06-10", "UTC", conversations, registry);
+  // The raw stored body escapes the delimiters so the parser never sees
+  // a forged `**` or `[` boundary inside the label.
+  assert.ok(
+    body.includes("**A\\*\\*B**"),
+    "label delimiters are escaped in the stored body: " + body,
+  );
+  // Display decoding recovers the ORIGINAL label for view/search surfaces.
+  const decoded = decodeTranscriptBody(body, true);
+  assert.ok(
+    decoded.includes("**A**B** [09:01]: Delimited label."),
+    "decoded body shows the original unescaped label: " + decoded,
+  );
+  // parseDayTranscript preserves the body bytes verbatim.
+  const serialized = serializeDayTranscript(
+    composeDayTranscriptMeta("bee", "2026-06-10", "UTC", conversations, registry, body, "2026-06-11T01:00:00.000Z"),
+    body,
+  );
+  const parsed = parseDayTranscript(serialized);
+  assert.ok(parsed);
+  assert.equal(parsed!.body, body, "body survives serialization round-trip");
+});
+
+test("legacy raw label without escape sequences parses and decodes verbatim (#1849)", () => {
+  // A hand-written stored body whose label was NEVER escaped (a pre-
+  // escaper transcript). decodeTranscriptBody and the segment-line parser
+  // must treat it as a no-op: no backslash sequences => unchanged label.
+  const body =
+    "# bee transcript — 2026-06-10\n" +
+    "\n" +
+    "## 09:00–09:10 (conversation c1)\n" +
+    "\n" +
+    "**Me (you)** [09:00]: Hello world.\n" +
+    "**Guest** [09:01]: Good morning.\n";
+  const decoded = decodeTranscriptBody(body);
+  assert.equal(decoded, body, "legacy body with no escapes decodes verbatim");
+});
+
+test("legacy body with literal backslash-n/backslash-r is never decoded (#1849)", () => {
+  // A pre-escaper transcript whose segment text contains the LITERAL
+  // two-character sequences \n and \r (not escape sequences). The
+  // format-aware decoder MUST leave them byte-for-byte unchanged so the
+  // original content is never corrupted.
+  const legacyBody =
+    "# bee transcript — 2026-06-10\n" +
+    "\n" +
+    "## 09:00–09:10 (conversation c1)\n" +
+    "\n" +
+    "**Guest** [09:00]: A literal backslash-n \\n and backslash-r \\r here.\n";
+  // Default (escaped=false): legacy body is a no-op.
+  assert.equal(
+    decodeTranscriptBody(legacyBody),
+    legacyBody,
+    "legacy body must not be decoded without an explicit format marker",
+  );
+  // Even when explicitly told the body IS escaped, the literal sequences
+  // \n / \r WOULD be decoded — but only NEW-format bodies (meta carries
+  // formatVersion >= 2) are ever passed escaped=true by the service.
+  // Here we verify the SAFETY of the default: callers that forget the
+  // flag never corrupt legacy content.
+  assert.equal(
+    decodeTranscriptBody(legacyBody, false),
+    legacyBody,
+    "escaped=false leaves legacy literal escapes unchanged",
+  );
+});
+
+test("new-format body with formatVersion marker decodes correctly (#1849)", () => {
+  const conversations: WearableConversation[] = [
+    {
+      id: "c1",
+      source: "bee",
+      startIso: "2026-06-10T09:00:00Z",
+      segments: [{ speakerKey: "user", isWearer: true, text: "Line one.\nLine two." }],
+    },
+  ];
+  const body = composeDayTranscriptBody("bee", "2026-06-10", "UTC", conversations, REGISTRY);
+  const meta = composeDayTranscriptMeta(
+    "bee", "2026-06-10", "UTC", conversations, REGISTRY, body, "2026-06-11T01:00:00.000Z",
+  );
+  // The meta carries the format version marker.
+  assert.equal(meta.formatVersion, TRANSCRIPT_FORMAT_VERSION);
+  assert.ok(bodyIsEscaped(meta), "new-format meta is recognized as escaped");
+  // bodyIsEscaped returns false for legacy (no marker) and null.
+  assert.equal(bodyIsEscaped(null), false);
+  assert.equal(bodyIsEscaped(undefined), false);
+  assert.equal(bodyIsEscaped({}), false);
+  assert.equal(bodyIsEscaped({ formatVersion: 1 }), false);
+  // Decoding with the escaped flag recovers the original newline.
+  const decoded = decodeTranscriptBody(body, bodyIsEscaped(meta));
+  assert.ok(decoded.includes("Line one.\nLine two."), "new-format body decodes the newline");
+});
+
+test("composeDayTranscriptMeta stamps formatVersion and serialize/parse round-trips it (#1849)", () => {
+  const body = composeDayTranscriptBody(
+    "limitless", "2026-06-10", "UTC", CONVERSATIONS, REGISTRY,
+  );
+  const meta = composeDayTranscriptMeta(
+    "limitless", "2026-06-10", "UTC", CONVERSATIONS, REGISTRY, body, "2026-06-11T01:00:00.000Z",
+  );
+  assert.equal(meta.formatVersion, TRANSCRIPT_FORMAT_VERSION);
+  const serialized = serializeDayTranscript(meta, body);
+  assert.ok(serialized.includes("formatVersion: 2"), "serialized file carries the marker");
+  const parsed = parseDayTranscript(serialized);
+  assert.ok(parsed);
+  assert.equal(parsed!.meta.formatVersion, TRANSCRIPT_FORMAT_VERSION);
+  // A legacy file (hand-written, no formatVersion line) parses with
+  // formatVersion undefined so bodyIsEscaped returns false.
+  const legacyFile =
+    "---\nkind: wearable-transcript\nsource: \"bee\"\ndate: \"2026-06-10\"\n" +
+    "timezone: \"UTC\"\nconversationCount: 1\nsegmentCount: 1\n" +
+    "speakers: []\ndurationMinutes: 0\ncontentHash: \"x\"\nsyncedAt: \"y\"\n" +
+    "---\n\n# bee transcript — 2026-06-10\n";
+  const legacyParsed = parseDayTranscript(legacyFile);
+  assert.ok(legacyParsed);
+  assert.equal(legacyParsed!.meta.formatVersion, undefined);
+  assert.equal(bodyIsEscaped(legacyParsed!.meta), false);
+});
+
+test("parseTranscriptSegmentLine extracts label, clock, and text (#1849)", () => {
+  const m = parseTranscriptSegmentLine("**Pat** [09:30]: Hello world.");
+  assert.deepEqual(m, { label: "Pat", clock: "09:30", text: "Hello world." });
+});
+
+test("parseTranscriptSegmentLine handles single-char label and empty text", () => {
+  const m = parseTranscriptSegmentLine("**X** [00:00]: ");
+  assert.deepEqual(m, { label: "X", clock: "00:00", text: "" });
+});
+
+test("parseTranscriptSegmentLine preserves backslash escape sequences in label/text", () => {
+  // Escaped labels/text from the escape-aware serializer carry literal
+  // backslash sequences that must survive the linear parser unchanged.
+  const m = parseTranscriptSegmentLine("**Pat \\*Smith\\*** [09:00]: Hello \\n world.");
+  assert.ok(m);
+  assert.equal(m!.label, "Pat \\*Smith\\*");
+  assert.equal(m!.clock, "09:00");
+  assert.equal(m!.text, "Hello \\n world.");
+});
+
+test("parseTranscriptSegmentLine returns null for non-segment lines", () => {
+  assert.equal(parseTranscriptSegmentLine(""), null);
+  assert.equal(parseTranscriptSegmentLine("not a segment"), null);
+  assert.equal(parseTranscriptSegmentLine("**no close"), null);
+  assert.equal(parseTranscriptSegmentLine("**label** no bracket"), null);
+  assert.equal(parseTranscriptSegmentLine("**label** [clock] no colon-space"), null);
+  assert.equal(parseTranscriptSegmentLine("**label** [clock]:no space"), null);
+  assert.equal(parseTranscriptSegmentLine("**label** []: text"), null);
+});
+
+test("parseTranscriptSegmentLine is linear-safe on adversarial repeated delimiters (#1849)", () => {
+  // A line with many '*' chars must not cause polynomial backtracking.
+  // The linear scan finds the first '**' followed by \s[ — or returns
+  // null — without exploring exponential alternatives.
+  const longLabel = "a".repeat(10_000);
+  const adversarial = `**${longLabel}** [09:00]: text`;
+  const m = parseTranscriptSegmentLine(adversarial);
+  assert.ok(m, "long label with valid delimiters must parse");
+  assert.equal(m!.label, longLabel);
+  assert.equal(m!.clock, "09:00");
+  assert.equal(m!.text, "text");
+
+  // All stars, no closing \s[ — must return null quickly.
+  const noClose = "**" + "*".repeat(10_000);
+  assert.equal(parseTranscriptSegmentLine(noClose), null);
+
+  // All stars followed by valid suffix — the first '**' positions are
+  // all stars (not followed by \s), so the scan walks the entire run
+  // in O(n) and finds the '** ' before '['.
+  const allStars = "**" + "*".repeat(10_000) + "** [09:00]: text";
+  const m2 = parseTranscriptSegmentLine(allStars);
+  assert.ok(m2, "star-prefixed line with valid delimiters must parse");
+  assert.equal(m2!.clock, "09:00");
+  assert.equal(m2!.text, "text");
+});