@remnic/core 9.69.33 → 9.69.34

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, []);
   }

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

@@ -1,11 +1,17 @@
 /**
  * Read-only vault daily-note journal section (issue #1987 first slice).
  *
- * Pure: file text in, journal body out. Never writes. Strips Remnic-owned
- * marker regions and publisher-owned headings so published timeline text
- * cannot re-enter the journal. Path templates stay in vault-publish.
+ * Pure: caller supplies the file text (one read; the filesystem wrapper
+ * lives in journal-read.ts). Extracts the unique journal section via
+ * the shared ATX heading matcher, then strips every Remnic-owned region
+ * (journal-strip.ts) so published output can never re-enter the journal.
+ * Missing note and missing section are distinct, labeled no-journal
+ * outcomes (§22); duplicate headings refuse with line numbers.
  */
 
+import { parseAtxHeading } from "./journal-section.js";
+import { stripRemnicOwnedRegions } from "./journal-strip.js";
+
 export interface ReadVaultJournalInput {
   fileText: string | null | undefined;
   journalSection: string;
@@ -17,8 +23,6 @@ export type ReadVaultJournalResult =
   | { ok: true; exists: true; text: string; heading: string; warnings: readonly string[] }
   | { ok: false; reason: "duplicate_heading"; lines: readonly number[] };
 
-const REMNIC_OPEN = "<!-- remnic:";
-
 export function readVaultJournal(input: ReadVaultJournalInput): ReadVaultJournalResult {
   if (input.fileText === null || input.fileText === undefined) {
     return { ok: true, exists: false, reason: "missing_file" };
@@ -62,18 +66,6 @@ export function readVaultJournal(input: ReadVaultJournalInput): ReadVaultJournal
   };
 }
 
-/** Remove Remnic marker pairs and publisher-owned heading sections. */
-export function stripRemnicOwnedRegions(
-  text: string,
-  publishSectionNames: readonly string[] = [],
-): { text: string; warnings: readonly string[] } {
-  const marked = cutIntervals(text, remnicIntervals(text));
-  return {
-    text: stripPublishHeadings(marked.text, publishSectionNames),
-    warnings: marked.warnings,
-  };
-}
-
 function splitFileLines(fileText: string): string[] {
   const lines = fileText.split("\n");
   for (let i = 0; i < lines.length; i++) {
@@ -83,128 +75,6 @@ function splitFileLines(fileText: string): string[] {
   return lines;
 }
 
-function parseAtxHeading(line: string): { level: number; text: string } | null {
-  let level = 0;
-  while (level < line.length && level < 6 && line[level] === "#") level++;
-  if (level === 0) return null;
-  const after = line[level];
-  if (after !== " " && after !== "\t") return null;
-
-  let start = level + 1;
-  let end = line.length;
-  while (start < end && (line[start] === " " || line[start] === "\t")) start++;
-  while (end > start && (line[end - 1] === " " || line[end - 1] === "\t")) end--;
-
-  let hashEnd = end;
-  while (hashEnd > start && line[hashEnd - 1] === "#") hashEnd--;
-  if (hashEnd < end && hashEnd > start && (line[hashEnd - 1] === " " || line[hashEnd - 1] === "\t")) {
-    end = hashEnd;
-    while (end > start && (line[end - 1] === " " || line[end - 1] === "\t")) end--;
-  }
-  return { level, text: line.slice(start, end) };
-}
-
-function remnicIntervals(text: string): {
-  intervals: Array<{ start: number; end: number }>;
-  warnings: string[];
-} {
-  const starts: Array<{ name: string; start: number; after: number }> = [];
-  const ends: Array<{ name: string; start: number; end: number }> = [];
-
-  let from = 0;
-  while (from < text.length) {
-    const open = text.indexOf(REMNIC_OPEN, from);
-    if (open === -1) break;
-    const afterOpen = open + REMNIC_OPEN.length;
-    const commentEnd = text.indexOf("-->", afterOpen);
-    if (commentEnd === -1) break;
-    const inner = text.slice(afterOpen, commentEnd).trim();
-    if (inner.endsWith(":start")) {
-      const name = inner.slice(0, -":start".length);
-      if (name.length > 0) starts.push({ name, start: open, after: commentEnd + 3 });
-    } else if (inner.endsWith(":end")) {
-      const name = inner.slice(0, -":end".length);
-      if (name.length > 0) ends.push({ name, start: open, end: commentEnd + 3 });
-    }
-    from = commentEnd + 3;
-  }
-
-  const usedEnds = new Set<number>();
-  const intervals: Array<{ start: number; end: number }> = [];
-  const warnings: string[] = [];
-
-  for (const start of starts) {
-    const match = ends.find((end) => end.name === start.name && end.start >= start.after && !usedEnds.has(end.start));
-    if (match) {
-      usedEnds.add(match.start);
-      intervals.push({ start: start.start, end: eatTrailingNewline(text, match.end) });
-    } else {
-      intervals.push({ start: start.start, end: text.length });
-      warnings.push(`unclosed remnic region "${start.name}"`);
-    }
-  }
-
-  for (const end of ends) {
-    if (usedEnds.has(end.start)) continue;
-    const startBefore = starts.some((start) => start.start < end.start);
-    if (!startBefore) intervals.push({ start: 0, end: eatTrailingNewline(text, end.end) });
-  }
-
-  return { intervals: mergeIntervals(intervals), warnings };
-}
-
-function eatTrailingNewline(text: string, index: number): number {
-  if (text[index] === "\n") return index + 1;
-  if (text[index] === "\r" && text[index + 1] === "\n") return index + 2;
-  if (text[index] === "\r") return index + 1;
-  return index;
-}
-
-function mergeIntervals(items: Array<{ start: number; end: number }>): Array<{ start: number; end: number }> {
-  if (items.length === 0) return [];
-  const sorted = items.slice().sort((a, b) => a.start - b.start || a.end - b.end);
-  const out = [{ start: sorted[0]!.start, end: sorted[0]!.end }];
-  for (let i = 1; i < sorted.length; i++) {
-    const cur = sorted[i]!;
-    const last = out[out.length - 1]!;
-    if (cur.start <= last.end) last.end = Math.max(last.end, cur.end);
-    else out.push({ start: cur.start, end: cur.end });
-  }
-  return out;
-}
-
-function cutIntervals(
-  text: string,
-  found: { intervals: Array<{ start: number; end: number }>; warnings: string[] },
-): { text: string; warnings: string[] } {
-  let out = "";
-  let pos = 0;
-  for (const interval of found.intervals) {
-    if (interval.start > pos) out += text.slice(pos, interval.start);
-    pos = Math.max(pos, interval.end);
-  }
-  if (pos < text.length) out += text.slice(pos);
-  return { text: out, warnings: found.warnings };
-}
-
-function stripPublishHeadings(text: string, names: readonly string[]): string {
-  if (names.length === 0 || text.length === 0) return text;
-  const lines = text.split("\n");
-  const keep = lines.map(() => true);
-  for (let i = 0; i < lines.length; i++) {
-    if (!keep[i]) continue;
-    const heading = parseAtxHeading(lines[i]!);
-    if (!heading || !names.includes(heading.text)) continue;
-    keep[i] = false;
-    for (let j = i + 1; j < lines.length; j++) {
-      const next = parseAtxHeading(lines[j]!);
-      if (next && next.level <= heading.level) break;
-      keep[j] = false;
-    }
-  }
-  return lines.filter((_, i) => keep[i]).join("\n");
-}
-
 function trimNewlines(text: string): string {
   let start = 0;
   let end = text.length;

package/src/activity/journal.test.ts

@@ -32,44 +32,95 @@ test("activity.timeline.journal.enabled defaults off", () => {
   );
 });
 
-test("activity.timeline.journal source defaults to file with no heading", () => {
+test("activity.timeline.journal source defaults to memoryDir with extraction off", () => {
   const journal = parseActivityConfig(undefined).timeline.journal;
-  assert.equal(journal.source, "file");
-  assert.equal(journal.heading, undefined);
+  assert.deepEqual(journal, { enabled: false, source: "memoryDir", extractionMode: "off" });
 });
 
-test("activity.timeline.journal vault mode trims and stores the heading", () => {
-  const journal = parseActivityConfig({ timeline: { journal: { enabled: true, source: "vault", heading: " Journal " } } }).timeline.journal;
-  assert.deepEqual(journal, { enabled: true, source: "vault", heading: "Journal" });
+const VAULT_OK = {
+  enabled: true,
+  vaultPath: "/vault",
+  readback: { journalSection: "Journal" },
+};
+
+test("activity.timeline.journal vault mode parses with prerequisites satisfied", () => {
+  const journal = parseActivityConfig({
+    timeline: { journal: { enabled: true, source: "vault" }, vault: VAULT_OK },
+  }).timeline.journal;
+  assert.deepEqual(journal, { enabled: true, source: "vault", extractionMode: "off" });
 });
 
-test("activity.timeline.journal vault mode requires a non-empty heading", () => {
-  for (const heading of [undefined, "", "   "]) {
-    assert.throws(
-      () => parseActivityConfig({ timeline: { journal: { source: "vault", heading } } }),
-      RangeError,
-    );
+function captureError(fn: () => unknown): Error {
+  try {
+    fn();
+  } catch (err) {
+    return err as Error;
   }
+  throw new Error("expected parseActivityConfig to throw");
+}
+
+test("activity.timeline.journal vault mode names every missing prerequisite", () => {
+  const err = captureError(() => parseActivityConfig({ timeline: { journal: { source: "vault" } } }));
+  assert.ok(err instanceof RangeError);
+  assert.match(err.message, /vault\.readback\.journalSection/);
 });
 
-test("activity.timeline.journal rejects an unknown source", () => {
-  assert.throws(
-    () => parseActivityConfig({ timeline: { journal: { source: "memoryDir" } } }),
-    /activity\.timeline\.journal\.source must be one of "file", "vault"/,
+test("activity.timeline.journal vault mode with only the section set still names vault.enabled and dailyNotePath", () => {
+  const err = captureError(() =>
+    parseActivityConfig({
+      timeline: { journal: { source: "vault" }, vault: { readback: { journalSection: "Diary" } } },
+    }),
   );
+  assert.ok(err instanceof RangeError);
+  assert.doesNotMatch(err.message, /journalSection/);
+  assert.match(err.message, /vault\.enabled/);
+});
+
+test("activity.timeline.journal aliases source file to memoryDir", () => {
+  const journal = parseActivityConfig({ timeline: { journal: { source: "file" } } }).timeline.journal;
+  assert.equal(journal.source, "memoryDir");
 });
 
-test("activity.timeline.journal rejects a non-string heading", () => {
+test("activity.timeline.journal rejects an unknown source", () => {
   assert.throws(
-    () => parseActivityConfig({ timeline: { journal: { heading: 5 } } }),
-    /activity\.timeline\.journal\.heading must be a string/,
+    () => parseActivityConfig({ timeline: { journal: { source: "disk" } } }),
+    /activity\.timeline\.journal\.source must be one of "memoryDir", "vault"/,
   );
 });
 
-test("activity.timeline.journal file mode ignores a provided heading", () => {
-  const journal = parseActivityConfig({ timeline: { journal: { source: "file", heading: "Ignored" } } }).timeline.journal;
-  assert.deepEqual(journal, { enabled: false, source: "file" });
-  assert.equal("heading" in journal, false);
+test("activity.timeline.journal.heading fills vault.readback.journalSection when the new key is absent", () => {
+  const vault = parseActivityConfig({
+    timeline: { journal: { heading: "  Diary  " }, vault: { readback: { journalSection: "" } } },
+  }).timeline.vault;
+  assert.equal(vault.readback.journalSection, "Diary");
+});
+
+test("activity.timeline.vault.readback.journalSection wins over journal.heading", () => {
+  const vault = parseActivityConfig({
+    timeline: {
+      journal: { heading: "Diary" },
+      vault: { readback: { journalSection: "Journal" } },
+    },
+  }).timeline.vault;
+  assert.equal(vault.readback.journalSection, "Journal");
+});
+
+
+test("activity.timeline.journal extractionMode allows off and review only", () => {
+  for (const extractionMode of ["off", "review"]) {
+    const journal = parseActivityConfig({
+      timeline: { journal: { extractionMode } },
+    }).timeline.journal;
+    assert.equal(journal.extractionMode, extractionMode);
+  }
+  assert.throws(
+    () => parseActivityConfig({ timeline: { journal: { extractionMode: "auto" } } }),
+    /activity\.timeline\.journal\.extractionMode must be one of "off", "review"/,
+  );
+  assert.throws(
+    () => parseActivityConfig({ timeline: { journal: { extractionMode: "smart" } } }),
+    /activity\.timeline\.journal\.extractionMode must be one of "off", "review"/,
+  );
 });
 
 test("seed is a hard no-op without force", () => {