@remnic/core 9.69.33 → 9.69.35

package/src/activity/journal-strip.test.ts

@@ -3,61 +3,68 @@ import test from "node:test";
 
 import { stripRemnicOwnedRegions } from "./journal-strip.js";
 
-test("stripRemnicOwnedRegions removes a marker pair and keeps user text", () => {
-  const text = [
-    "Morning standup.",
-    "<!-- remnic:timeline:start -->",
-    "9:00 deep work",
-    "<!-- remnic:timeline:end -->",
-    "Wrote the parser.",
-  ].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, []), "Morning standup.\nWrote the parser.");
+const START = (name = "timeline") => `<!-- remnic:${name}:start -->`;
+const END = (name = "timeline") => `<!-- remnic:${name}:end -->`;
+
+test("removes a marker pair and keeps user text", () => {
+  const text = ["Morning standup.", START(), "9:00 deep work", END(), "Wrote the parser."].join("\n");
+  const result = stripRemnicOwnedRegions(text, []);
+  assert.equal(result.text, "Morning standup.\nWrote the parser.");
+  assert.deepEqual(result.warnings, []);
 });
 
-test("stripRemnicOwnedRegions keeps one blank line where a removal doubled it", () => {
-  const text = [
-    "Before.",
-    "",
-    "<!-- remnic:timeline:start -->",
-    "generated",
-    "<!-- remnic:timeline:end -->",
-    "",
-    "After.",
-  ].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, []), "Before.\n\nAfter.");
+test("keeps one blank line where a removal doubled it", () => {
+  const text = ["Before.", "", START(), "generated", END(), "", "After."].join("\n");
+  assert.equal(stripRemnicOwnedRegions(text, []).text, "Before.\n\nAfter.");
 });
 
-test("stripRemnicOwnedRegions removes two distinct marker pairs", () => {
+test("removes two distinct marker pairs", () => {
   const text = [
     "head",
-    "<!-- remnic:timeline:start -->",
+    START("timeline"),
     "timeline body",
-    "<!-- remnic:timeline:end -->",
+    END("timeline"),
     "middle",
-    "<!-- remnic:digest:start -->",
+    START("digest"),
     "digest body",
-    "<!-- remnic:digest:end -->",
+    END("digest"),
     "tail",
   ].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, []), "head\nmiddle\ntail");
+  const result = stripRemnicOwnedRegions(text, []);
+  assert.equal(result.text, "head\nmiddle\ntail");
+  assert.deepEqual(result.warnings, []);
+});
+
+test("strips an unterminated start marker to the end and warns", () => {
+  const text = ["kept", START(), "generated", "later user text"].join("\n");
+  const result = stripRemnicOwnedRegions(text, []);
+  assert.equal(result.text, "kept");
+  assert.equal(result.warnings.length, 1);
+  assert.match(result.warnings[0]!, /unclosed remnic region "timeline"/);
 });
 
-test("stripRemnicOwnedRegions strips an unterminated start marker to the end of input", () => {
-  const text = ["kept", "<!-- remnic:timeline:start -->", "generated", "later user text"].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, []), "kept");
+test("an unmatched end marker fails closed: everything before it is stripped, with a warning", () => {
+  // A pair split across the section boundary leaves a bare END inside the
+  // journal section; text before it is presumed published output.
+  const text = ["Before.", END(), "After."].join("\n");
+  const result = stripRemnicOwnedRegions(text, []);
+  assert.equal(result.text, "After.");
+  assert.equal(result.warnings.length, 1);
+  assert.match(result.warnings[0]!, /unmatched remnic region end "timeline"/);
 });
 
-test("stripRemnicOwnedRegions removes an orphan end marker and keeps surrounding text", () => {
-  const text = ["Before.", "<!-- remnic:timeline:end -->", "After."].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, []), "Before.\nAfter.");
+test("matched pairs after an unmatched end are still removed", () => {
+  const text = ["leaked", END(), "kept", START(), "owned", END(), "also kept"].join("\n");
+  const result = stripRemnicOwnedRegions(text, []);
+  assert.equal(result.text, "kept\nalso kept");
 });
 
-test("stripRemnicOwnedRegions removes an owned heading section up to the next same-level heading", () => {
+test("removes an owned heading section up to the next same-level heading", () => {
   const text = ["## Journal", "intro", "## Timeline", "card one", "## Notes", "kept"].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]), "## Journal\nintro\n## Notes\nkept");
+  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]).text, "## Journal\nintro\n## Notes\nkept");
 });
 
-test("stripRemnicOwnedRegions does not end an owned section at a deeper heading", () => {
+test("does not end an owned section at a deeper heading", () => {
   const text = [
     "## Journal",
     "## Timeline",
@@ -67,31 +74,35 @@ test("stripRemnicOwnedRegions does not end an owned section at a deeper heading"
     "## Notes",
     "kept",
   ].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]), "## Journal\n## Notes\nkept");
+  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]).text, "## Journal\n## Notes\nkept");
 });
 
-test("stripRemnicOwnedRegions preserves a non-owned heading section", () => {
+test("preserves a non-owned heading section", () => {
   const text = ["## Journal", "## Timeline", "card one", "## Notes", "kept"].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["Digest"]), text);
+  assert.equal(stripRemnicOwnedRegions(text, ["Digest"]).text, text);
 });
 
-test("stripRemnicOwnedRegions ignores blank and whitespace owned heading entries", () => {
+test("ignores blank and whitespace owned heading entries", () => {
   const text = ["## Timeline", "card one", ""].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["", "   ", "\t"]), text);
+  assert.equal(stripRemnicOwnedRegions(text, ["", "   ", "\t"]).text, text);
 });
 
-test("stripRemnicOwnedRegions trims configured owned heading entries", () => {
+test("trims configured owned heading entries", () => {
   const text = ["## Timeline", "card", "## Notes", "kept"].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["  Timeline  "]), "## Notes\nkept");
+  assert.equal(stripRemnicOwnedRegions(text, ["  Timeline  "]).text, "## Notes\nkept");
 });
 
-test("stripRemnicOwnedRegions returns empty string for empty input", () => {
-  assert.equal(stripRemnicOwnedRegions("", ["Timeline"]), "");
+test("returns empty string for empty input", () => {
+  const result = stripRemnicOwnedRegions("", ["Timeline"]);
+  assert.equal(result.text, "");
+  assert.deepEqual(result.warnings, []);
 });
 
-test("stripRemnicOwnedRegions returns unchanged text when nothing is owned", () => {
+test("returns unchanged text when nothing is owned", () => {
   const text = ["first", "", "second", "", "third"].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]), text);
+  const result = stripRemnicOwnedRegions(text, ["Timeline"]);
+  assert.equal(result.text, text);
+  assert.deepEqual(result.warnings, []);
 });
 
 // Regression: the journal-section reader normalizes tab separators, extra
@@ -108,12 +119,9 @@ test("owned heading matching accepts every ATX form the section reader accepts",
     "## Timeline ##",
     "## Timeline ### ",
   ]) {
-    const stripped = stripRemnicOwnedRegions(
-      [headingLine, body].join("\n"),
-      ["Timeline"],
-    );
+    const result = stripRemnicOwnedRegions([headingLine, body].join("\n"), ["Timeline"]);
     assert.equal(
-      stripped,
+      result.text,
       ["## User Notes", "kept"].join("\n"),
       `heading line ${JSON.stringify(headingLine)} must strip as owned`,
     );
@@ -122,5 +130,51 @@ test("owned heading matching accepts every ATX form the section reader accepts",
 
 test("an indented heading is not owned, matching the section reader", () => {
   const text = ["  ## Timeline", "not owned body"].join("\n");
-  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]), text);
+  assert.equal(stripRemnicOwnedRegions(text, ["Timeline"]).text, text);
+});
+
+// Generative property test (issue #1987): for random user text with random
+// Remnic regions injected at random positions, strip returns EXACTLY the
+// user text — no user line lost, no owned line kept. Seeded PRNG for
+// deterministic CI.
+test("property: injected regions vanish and user text survives byte-for-byte", () => {
+  let seed = 0x2a1987;
+  const rand = (max: number): number => {
+    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+    return seed % max;
+  };
+  const USER_LINES = [
+    "Walked the dog.",
+    "Tagebuch 📝 Eintrag.",
+    "  indented thought",
+    "I decided to ship the parser.",
+    "We committed to the review pass.",
+  ];
+  const REGION_NAMES = ["timeline", "weekly", "digest", "standup"];
+
+  for (let iteration = 0; iteration < 200; iteration += 1) {
+    const userLineCount = 1 + rand(USER_LINES.length);
+    const userLines: string[] = [];
+    for (let i = 0; i < userLineCount; i += 1) userLines.push(USER_LINES[rand(USER_LINES.length)]!);
+    const regionCount = rand(4);
+    const injections: Array<{ at: number; lines: string[] }> = [];
+    for (let i = 0; i < regionCount; i += 1) {
+      const name = REGION_NAMES[rand(REGION_NAMES.length)]!;
+      injections.push({
+        at: rand(userLines.length + 1),
+        lines: [START(name), `OWNED ${name} ${i}`, END(name)],
+      });
+    }
+    let mixed: string[] = [];
+    let userCursor = 0;
+    for (const injection of injections.sort((a, b) => a.at - b.at)) {
+      mixed = mixed.concat(userLines.slice(userCursor, injection.at), injection.lines);
+      userCursor = injection.at;
+    }
+    mixed = mixed.concat(userLines.slice(userCursor));
+
+    const result = stripRemnicOwnedRegions(mixed.join("\n"), ["Timeline"]);
+    assert.equal(result.text, userLines.join("\n"), `iteration ${iteration}: ${JSON.stringify(mixed)}`);
+    assert.deepEqual(result.warnings, [], `iteration ${iteration} must be warning-free`);
+  }
 });

package/src/activity/journal-strip.ts

@@ -4,13 +4,19 @@
  * Loop prevention for vault journals: before daily-note text is treated
  * as journal text, every managed marker region and every configured
  * owned heading section is removed, so published output can never
- * re-enter the journal. An unterminated start marker fails closed and
- * strips to the end of the section. Pure string-in/string-out. No
- * filesystem. Heading lines parse through the SAME exported ATX
- * parser the journal-section reader uses, so a heading the reader
- * recognizes is always a heading this stripper strips.
+ * re-enter the journal. Pure string-in/string-out. No filesystem.
+ *
+ * Fail-closed marker semantics — a partial Remnic region is NEVER kept:
+ *  - an unterminated start marker strips to the end of the section and
+ *    records a warning;
+ *  - an end marker with no matching start (a pair split across the
+ *    journal-section boundary) strips everything before it in the
+ *    section, so pre-section published output cannot leak in, and
+ *    records a warning.
+ * Heading lines parse through the SAME exported ATX parser the
+ * journal-section reader uses, so a heading the reader recognizes is
+ * always a heading this stripper strips.
  */
-
 import { parseAtxHeading } from "./journal-section.js";
 
 const MARKER_OPEN = "<!-- remnic:";
@@ -18,16 +24,23 @@ const MARKER_CLOSE = "-->";
 const START_SUFFIX = ":start";
 const END_SUFFIX = ":end";
 
+export interface StripResult {
+  text: string;
+  warnings: readonly string[];
+}
+
 type RegionMarker = { kind: "start" | "end"; name: string };
 
 export function stripRemnicOwnedRegions(
   sectionText: string,
   ownedHeadings: readonly string[],
-): string {
-  return stripOwnedHeadings(stripMarkerRegions(sectionText), ownedHeadings);
+): StripResult {
+  const warnings: string[] = [];
+  const marked = stripMarkerRegions(sectionText, warnings);
+  return { text: stripOwnedHeadings(marked, ownedHeadings), warnings };
 }
 
-function stripMarkerRegions(text: string): string {
+function stripMarkerRegions(text: string, warnings: string[]): string {
   const lines = text.split("\n");
   const keep = lines.map(() => true);
   let openName: string | null = null;
@@ -40,9 +53,21 @@ function stripMarkerRegions(text: string): string {
     }
     if (marker) {
       keep[i] = false;
-      if (marker.kind === "start") openName = marker.name;
+      if (marker.kind === "start") {
+        openName = marker.name;
+      } else {
+        for (let j = 0; j < i; j++) keep[j] = false;
+        // Stray end marker: the matching start lives outside this section
+        // (a pair split across the section boundary). Everything before it
+        // in the section is presumed published output — fail closed.
+        warnings.push(`unmatched remnic region end "${marker.name}"`);
+
+      }
     }
   }
+  if (openName !== null) {
+    warnings.push(`unclosed remnic region "${openName}"`);
+  }
   return emitKeptLines(lines, keep);
 }
 

package/src/activity/journal-vault-integration.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Integration: vault journal → review-only extraction → review queue
+ * (issue #1987 acceptance criteria).
+ *
+ * Full round trip in a temp memoryDir + fixture vault against the REAL
+ * StorageManager: pending_review candidates only, hash-skip on unchanged
+ * days, exactly one re-extraction per edit, publisher coexistence on the
+ * same note, and no journal-derived memory reaching active without
+ * approval.
+ */
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { StorageManager } from "../index.js";
+import { createJournalMemoryWriter, runJournalReviewExtraction } from "../activity/journal-extract.js";
+import { readJournalForDate } from "../activity/journal-read.js";
+import {
+  journalUnchanged,
+  readTimelineState,
+  setJournalHash,
+  hashJournalText,
+  writeTimelineState,
+} from "../activity/journal-state.js";
+import { publishVaultNote } from "../activity/vault-publisher.js";
+import type { ActivityTimelineVaultConfig } from "../activity/types.js";
+
+const START = "<!-- remnic:timeline:start -->";
+const END = "<!-- remnic:timeline:end -->";
+
+function vaultConfig(vaultPath: string): ActivityTimelineVaultConfig {
+  return {
+    enabled: true,
+    vaultPath,
+    dailyNotePath: "{yyyy}-{MM}-{dd}.md",
+    weeklyNotePath: "",
+    createMissingNotes: true,
+    noteTemplate: "",
+    sectionStrategy: "markers",
+    publish: {
+      timeline: { enabled: true, target: "daily", section: "timeline" },
+      standup: { enabled: false, target: "daily", section: "Standup" },
+      weekly: { enabled: false, target: "weekly", section: "Weekly Review" },
+      locations: { enabled: false, target: "daily", section: "Locations" },
+    },
+    insertUnderHeading: "",
+    readback: { journalSection: "Journal" },
+    wikilinks: { places: false, placesFolder: "Places" },
+    properties: { mode: "off", prefix: "remnic_" },
+    autoPublish: true,
+  };
+}
+
+interface Fixture {
+  vault: string;
+  memoryDir: string;
+  storage: StorageManager;
+  config: ActivityTimelineVaultConfig;
+}
+
+async function withFixture(fn: (fx: Fixture) => Promise<void>): Promise<void> {
+  const vault = mkdtempSync(path.join(tmpdir(), "remnic-journal-it-vault-"));
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-journal-it-mem-"));
+  const storage = new StorageManager(memoryDir);
+  await storage.ensureDirectories();
+  try {
+    await fn({ vault, memoryDir, storage, config: vaultConfig(vault) });
+  } finally {
+    rmSync(vault, { recursive: true, force: true });
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+}
+
+function notePath(fx: Fixture, date: string): string {
+  return path.join(fx.vault, `${date}.md`);
+}
+
+function writeNote(fx: Fixture, date: string, lines: string[]): void {
+  writeFileSync(notePath(fx, date), lines.join("\n"));
+}
+
+function mockExtract(facts: string[]) {
+  return async () => ({
+    facts: facts.map((content) => ({
+      content,
+      category: "decision" as const,
+      confidence: 0.9,
+      tags: [],
+      entityRef: undefined,
+    })),
+    profileUpdates: [],
+    entities: [],
+    questions: [],
+  });
+}
+
+test("vault journal round trip: pending_review only, journalSource=vault, hash-skip, re-extract once", async () => {
+  await withFixture(async (fx) => {
+    writeNote(fx, "2026-08-20", [
+      "---",
+      "date: 2026-08-20",
+      "---",
+      "## Journal",
+      "I decided to move the parser to its own module.",
+      START,
+      "- 09:00 published card",
+      END,
+      "## Timeline",
+      START,
+      "sibling published",
+      END,
+      "",
+    ]);
+    const read = readJournalForDate({ vault: fx.config, date: "2026-08-20" });
+    assert.ok(read.ok && read.exists);
+    assert.match(read.text, /I decided to move the parser/);
+    assert.doesNotMatch(read.text, /published card/);
+    assert.doesNotMatch(read.text, /sibling published/);
+
+    // First extraction: exactly one pending_review candidate.
+    const first = await runJournalReviewExtraction({
+      date: "2026-08-20",
+      journalText: read.text,
+      source: "vault",
+      journalConfig: { extractionMode: "review" },
+      deps: {
+        extract: mockExtract(["I decided to move the parser to its own module."]),
+        writer: createJournalMemoryWriter(fx.storage),
+      },
+    });
+    assert.equal(first.pendingReview, 1);
+    assert.equal(first.completed, true);
+
+    const memories = await fx.storage.readAllMemories();
+    assert.equal(memories.length, 1);
+    const memory = memories[0]!;
+    assert.equal(memory.frontmatter.status, "pending_review");
+    assert.deepEqual(memory.frontmatter.tags, ["journal", "journal-day:2026-08-20"]);
+    assert.equal(memory.frontmatter.valid_at, "2026-08-20T00:00:00.000Z");
+    assert.equal(memory.frontmatter.structuredAttributes?.journalSource, "vault");
+
+    // Hash-skip: unchanged note + stored hash → zero new candidates.
+    const state = setJournalHash(readTimelineState(fx.memoryDir), "2026-08-20", hashJournalText(read.text));
+    writeTimelineState(fx.memoryDir, state);
+    assert.equal(journalUnchanged(readTimelineState(fx.memoryDir), "2026-08-20", read.text), true);
+    const second = await runJournalReviewExtraction({
+      date: "2026-08-20",
+      journalText: read.text,
+      source: "vault",
+      journalConfig: { extractionMode: "review" },
+      deps: {
+        extract: mockExtract(["I decided to move the parser to its own module."]),
+        writer: createJournalMemoryWriter(fx.storage),
+      },
+    });
+    assert.equal(second.pendingReview, 0);
+    assert.equal(second.skipped, 1);
+    assert.equal((await fx.storage.readAllMemories()).length, 1);
+
+    // Note edited: the changed hash re-runs the pass; the new fact lands
+    // pending_review, the old one is untouched (not active, not duplicated).
+    writeNote(fx, "2026-08-20", [
+      "## Journal",
+      "I decided to move the parser to its own module.",
+      "I also committed to a weekly review pass.",
+      "",
+    ]);
+    const reread = readJournalForDate({ vault: fx.config, date: "2026-08-20" });
+    assert.ok(reread.ok && reread.exists);
+    const third = await runJournalReviewExtraction({
+      date: "2026-08-20",
+      journalText: reread.text,
+      source: "vault",
+      journalConfig: { extractionMode: "review" },
+      deps: {
+        extract: mockExtract([
+          "I decided to move the parser to its own module.",
+          "I also committed to a weekly review pass.",
+        ]),
+        writer: createJournalMemoryWriter(fx.storage),
+      },
+    });
+    assert.equal(third.pendingReview, 1);
+    assert.equal(third.skipped, 1);
+    const after = await fx.storage.readAllMemories();
+    assert.equal(after.length, 2);
+    for (const m of after) {
+      assert.equal(m.frontmatter.status, "pending_review", "no journal memory reaches active without approval");
+    }
+  });
+});
+
+test("publisher and readback coexist byte-safely on the same note", async () => {
+  await withFixture(async (fx) => {
+    mkdirSync(path.join(fx.vault, "templates"), { recursive: true });
+    writeNote(fx, "2026-08-21", [
+      "---",
+      "date: 2026-08-21",
+      "---",
+      "## Journal",
+      "user line one",
+      "user line two",
+      "## Timeline",
+      "",
+    ]);
+    const before = readFileSync(notePath(fx, "2026-08-21"), "utf8");
+
+    // Publish a timeline region into the note (markers strategy).
+    const status = publishVaultNote({
+      vaultPath: fx.vault,
+      notePathTemplate: "{yyyy}-{MM}-{dd}.md",
+      date: "2026-08-21",
+      sections: [{ name: "timeline", content: "- published card" }],
+      strategy: "markers",
+      insertUnderHeading: "Timeline",
+    });
+    assert.equal(status.results[0]?.outcome, "updated");
+    const afterPublish = readFileSync(notePath(fx, "2026-08-21"), "utf8");
+    assert.notEqual(afterPublish, before);
+    assert.match(afterPublish, /remnic:timeline:start/);
+
+    // Readback returns the user text byte-identically; only Remnic's own
+    // region was added by the publish.
+    const read = readJournalForDate({ vault: fx.config, date: "2026-08-21" });
+    assert.ok(read.ok && read.exists);
+    assert.equal(read.text, "user line one\nuser line two");
+  });
+});

package/src/activity/journal-vault-provenance.test.ts

@@ -14,16 +14,16 @@ test("vault source produces the documented tags, attributes, and validAt", () =>
   );
 });
 
-test("file source differs only in the attribute value", () => {
+test("memoryDir source differs only in the attribute value", () => {
   const vault = buildJournalMemoryProvenance({ source: "vault", date: "2026-08-01" });
-  const file = buildJournalMemoryProvenance({ source: "file", date: "2026-08-01" });
-  assert.deepEqual(file.structuredAttributes, { journalSource: "file" });
-  assert.deepEqual(file.tags, vault.tags);
-  assert.equal(file.validAt, vault.validAt);
+  const memoryDir = buildJournalMemoryProvenance({ source: "memoryDir", date: "2026-08-01" });
+  assert.deepEqual(memoryDir.structuredAttributes, { journalSource: "memoryDir" });
+  assert.deepEqual(memoryDir.tags, vault.tags);
+  assert.equal(memoryDir.validAt, vault.validAt);
 });
 
 test("every structured attribute value is a string", () => {
-  for (const source of ["file", "vault"] as const) {
+  for (const source of ["memoryDir", "vault"] as const) {
     const { structuredAttributes } = buildJournalMemoryProvenance({
       source,
       date: "2026-08-01",
@@ -35,7 +35,9 @@ test("every structured attribute value is a string", () => {
 });
 
 test("unknown source throws RangeError naming source", () => {
-  for (const source of ["memoryDir", "vault ", "Vault", ""]) {
+  // "file" is a documented legacy alias of "memoryDir" (journal-source.ts),
+  // covered in journal-source.test.ts — it must NOT throw here.
+  for (const source of ["vault ", "Vault", ""]) {
     assert.throws(
       () => buildJournalMemoryProvenance({ source, date: "2026-08-01" }),
       RangeError,

package/src/activity/journal-vault-provenance.ts

@@ -3,9 +3,8 @@
  *
  * Pure: no I/O, no clock — the day comes from the caller. The source is
  * validated through the journal-source parser, so `structuredAttributes.
- * journalSource` is always a canonical journal source value ("file" |
- * "vault"), never a re-declared copy of the allow-list. Exported helper;
- * caller wiring into journal memory generation is a later slice.
+ * journalSource` is always a canonical journal source value ("memoryDir"
+ * | "vault"), never a re-declared copy of the allow-list.
  */
 import { resolveJournalSource } from "./journal-source.js";
 
@@ -26,15 +25,10 @@ export function buildJournalMemoryProvenance(input: {
   if (typeof input.source !== "string") {
     throw new RangeError("journal provenance source must be a string");
   }
-  const resolved = resolveJournalSource({
-    source: input.source,
-    // Provenance never consumes the heading; vault mode just requires a
-    // non-empty one to resolve.
-    heading: "journal",
-  });
+  const resolved = resolveJournalSource({ source: input.source });
   if (!resolved.ok) {
     throw new RangeError(
-      `journal provenance source must be one of "file", "vault": ${JSON.stringify(input.source)}`,
+      `journal provenance source must be one of "memoryDir", "vault": ${JSON.stringify(input.source)}`,
     );
   }
 

package/src/activity/journal-vault-read.test.ts

@@ -1,7 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { readVaultJournal, stripRemnicOwnedRegions } from "./journal-vault-read.js";
+import { readVaultJournal } from "./journal-vault-read.js";
+import { stripRemnicOwnedRegions } from "./journal-strip.js";
 
 const START = "<!-- remnic:timeline:start -->";
 const END = "<!-- remnic:timeline:end -->";
@@ -146,7 +147,7 @@ test("stripRemnicOwnedRegions returns only user text after injected regions", ()
   for (const name of names) {
     const region = `<!-- remnic:${name}:start -->\nOWNED ${name}\n<!-- remnic:${name}:end -->\n`;
     const mixed = `${region}${user}${region}${user}`;
-    const stripped = stripRemnicOwnedRegions(mixed);
+    const stripped = stripRemnicOwnedRegions(mixed, []);
     assert.equal(stripped.text, `${user}${user}`);
     assert.deepEqual(stripped.warnings, []);
   }