@remnic/core 9.4.2 → 9.6.0

package/src/wearables/storage-io.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { mkdtempSync, rmSync } from "node:fs";
+import { mkdir, readFile, readdir, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
 import { test } from "node:test";
@@ -184,3 +185,148 @@ test("non-transcript files in the wearables tree are ignored by listing", async
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("fused-day artifacts write/read/list and stay out of transcript listings", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    // Seed a raw transcript so the listing is non-empty.
+    await storage.writeWearableDayTranscript(
+      "limitless",
+      "2026-06-10",
+      "---\nkind: wearable-transcript\n---\n\nbody\n",
+    );
+    // Write a fused-day artifact.
+    assert.equal(await storage.fusionArtifactStore().readFusedDay("2026-06-10"), null);
+    await storage.fusionArtifactStore().writeFusedDay(
+      "2026-06-10",
+      "---\nkind: wearable-fusion\n---\n\n[]\n",
+    );
+    const raw = await storage.fusionArtifactStore().readFusedDay("2026-06-10");
+    assert.ok(raw?.includes("wearable-fusion"));
+    assert.deepEqual(await storage.fusionArtifactStore().listFusedDays(), ["2026-06-10"]);
+
+    // The reserved _fusion dir must NOT show up as a pseudo-source in
+    // the per-source transcript listing.
+    const transcriptDays = await storage.listWearableTranscriptDays();
+    assert.ok(transcriptDays.every((entry) => entry.source !== "_fusion"));
+    assert.equal(transcriptDays.length, 1);
+
+    // Malformed dates are rejected before path math (no traversal).
+    await assert.rejects(
+      storage.fusionArtifactStore().readFusedDay("../../etc/passwd"),
+      /invalid wearable fusion date/,
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("a symlinked _fusion dir that escapes the memory dir is refused, not followed", async () => {
+  const { storage, dir } = makeStorage();
+  // Outside target: a sibling temp dir NOT under the memory dir root.
+  const escapeDir = mkdtempSync(path.join(tmpdir(), "remnic-fusion-escape-"));
+  try {
+    // Ensure the wearables parent exists, then plant a symlinked _fusion
+    // dir that points outside the allowed root (AGENTS.md pattern #3).
+    await mkdir(path.join(dir, "wearables"), { recursive: true });
+    await symlink(escapeDir, path.join(dir, "wearables", "_fusion"), "dir");
+
+    const store = storage.fusionArtifactStore();
+    // Write must be refused — never followed into the escape dir.
+    await assert.rejects(
+      store.writeFusedDay("2026-06-10", "---\nkind: wearable-fusion\n---\n\n[]\n"),
+      /resolves outside the memory dir/,
+    );
+    // Read and list are refused for the same reason.
+    await assert.rejects(
+      store.readFusedDay("2026-06-10"),
+      /resolves outside the memory dir/,
+    );
+    await assert.rejects(
+      store.listFusedDays(),
+      /resolves outside the memory dir/,
+    );
+    // Nothing was written into the escape target.
+    const leaked = await readdir(escapeDir).catch(() => []);
+    assert.equal(leaked.length, 0, "no fused artifact must leak into the symlink target");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    rmSync(escapeDir, { recursive: true, force: true });
+  }
+});
+
+test("a symlinked wearables root that escapes the memory dir is refused, not followed", async () => {
+  const { storage, dir } = makeStorage();
+  // Outside target: a sibling temp dir NOT under the memory dir root.
+  const escapeDir = mkdtempSync(path.join(tmpdir(), "remnic-wearables-escape-"));
+  try {
+    // The memory dir root exists (makeStorage created it); plant a
+    // wearables ROOT that is itself a symlink pointing outside memoryDir.
+    // Containment is anchored to realpath(memoryDir), so this must be
+    // rejected for every fusion IO — never followed (issue #1849).
+    await symlink(escapeDir, path.join(dir, "wearables"), "dir");
+
+    const store = storage.fusionArtifactStore();
+    // Write must be refused even though the leaf artifact does not yet
+    // exist — never followed into the symlinked escape root.
+    await assert.rejects(
+      store.writeFusedDay("2026-06-10", "---\nkind: wearable-fusion\n---\n\n[]\n"),
+      /resolves outside the memory dir/,
+    );
+    // Read, list, and delete are refused for the same reason.
+    await assert.rejects(
+      store.readFusedDay("2026-06-10"),
+      /resolves outside the memory dir/,
+    );
+    await assert.rejects(
+      store.listFusedDays(),
+      /resolves outside the memory dir/,
+    );
+    await assert.rejects(
+      store.deleteFusedDay("2026-06-10"),
+      /resolves outside the memory dir/,
+    );
+    // Nothing was written into the escape target.
+    const leaked = await readdir(escapeDir).catch(() => []);
+    assert.equal(leaked.length, 0, "no fused artifact must leak into the symlinked wearables root");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    rmSync(escapeDir, { recursive: true, force: true });
+  }
+});
+
+test("a symlinked _fusion dir that resolves INSIDE the memory dir is refused, not followed (issue #1849)", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    // A real raw source transcript living under the wearables tree, and
+    // a `_fusion` symlink that aliases the SAME directory (resolves
+    // inside the memory dir, so the escape guard alone would allow it).
+    // Without the explicit symlink rejection, writeFusedDay("2026-06-10")
+    // would follow the link and OVERWRITE the raw source file.
+    const rawDir = path.join(dir, "wearables", "limitless");
+    const rawFile = path.join(rawDir, "2026-06-10.md");
+    await mkdir(rawDir, { recursive: true });
+    await writeFile(rawFile, "RAW SOURCE TRANSCRIPT\n", "utf-8");
+    await mkdir(path.join(dir, "wearables"), { recursive: true });
+    await symlink(rawDir, path.join(dir, "wearables", "_fusion"), "dir");
+
+    const store = storage.fusionArtifactStore();
+    // Write must be refused because `_fusion` is a symlink — even though
+    // its target resolves inside the memory dir.
+    await assert.rejects(
+      store.writeFusedDay("2026-06-10", "---\nkind: wearable-fusion\n---\n\n[]\n"),
+      /is a symbolic link/,
+    );
+    // Read, list, and delete are refused for the same reason.
+    await assert.rejects(store.readFusedDay("2026-06-10"), /is a symbolic link/);
+    await assert.rejects(store.listFusedDays(), /is a symbolic link/);
+    await assert.rejects(store.deleteFusedDay("2026-06-10"), /is a symbolic link/);
+
+    // The raw source file must be untouched — the fused artifact was
+    // never written through the symlink.
+    const after = await readFile(rawFile, "utf-8");
+    assert.equal(after, "RAW SOURCE TRANSCRIPT\n", "raw source file must not be overwritten");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/wearables/types.ts

@@ -285,6 +285,30 @@ export interface WearablesConfig {
   corrections: WearableCorrectionRule[];
   /** Per-source settings, keyed by connector id. */
   sources: Record<string, WearableSourceSettings>;
+  /**
+   * Cross-source fusion settings (issue #1810). Default disabled —
+   * enabling it is the only behavior change fusion introduces.
+   */
+  fusion: WearableFusionConfig;
+}
+
+/**
+ * Cross-source fusion configuration (issue #1810). When disabled (the
+ * default), no fusion artifacts are written and no behavior changes.
+ */
+export interface WearableFusionConfig {
+  /** Master gate for fusion. Default false. */
+  enabled: boolean;
+  /**
+   * Max gap (ms) between two conversations to merge into one fused
+   * cluster. Default 300000 (5 minutes).
+   */
+  proximityGapMs: number;
+  /**
+   * Max drift (ms) for two segments to align across sources. Default
+   * 30000 (30 seconds).
+   */
+  windowToleranceMs: number;
 }
 
 /** Summary returned by a sync run (one source). */
@@ -330,6 +354,13 @@ export interface WearableDayTranscriptMeta {
   /** SHA-256 of the body — used to skip unchanged rewrites. */
   contentHash: string;
   syncedAt: string;
+  /**
+   * Body serialization format version. Present (>= 2) only on bodies written
+   * by the escape-aware serializer; absent on legacy transcripts. Decoders
+   * gate on this so a legacy body's literal two-character `\n`/`\r` is never
+   * altered (issue #1849).
+   */
+  formatVersion?: number;
 }
 
 /** A parsed day-transcript file. */