gentle-pi 3.7.0 → 4.0.0

package/tests/history-session-writer.test.ts

@@ -0,0 +1,351 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  appendSessionCapture,
+  openSessionWriter,
+  projectHash,
+  seedFilePath,
+  sessionFilePath,
+} from "../extensions/history/store.ts";
+import promptHistoryExtension, { captureEnabled } from "../extensions/history/index.ts";
+import { writeHistoryCapturePolicy } from "../lib/history-capture-policy.ts";
+
+function makeRoot(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-writer-"));
+}
+
+const CWD = "/pi-history-test/project-a";
+
+/** An empty Gentle config home: the Customize preference is unset. */
+function makeConfigHome(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-config-"));
+}
+
+function fileTexts(file: string): string[] {
+  return fs
+    .readFileSync(file, "utf8")
+    .split("\n")
+    .filter((l) => l.trim().length > 0)
+    .map((l) => (JSON.parse(l) as { text: string }).text);
+}
+
+function openWriterForTest(root: string, instanceId: string) {
+  return openSessionWriter(root, CWD, instanceId);
+}
+
+/** Load the extension against a temp root and return its event handlers. */
+function handlersWith(
+  env: NodeJS.ProcessEnv,
+  root: string,
+  configHome: string = makeConfigHome(),
+): Map<string, (event: unknown) => void> {
+  const registered: Array<[string, unknown]> = [];
+  const pi = {
+    on: (event: string, handler: unknown) => {
+      registered.push([event, handler]);
+    },
+    // Slice-3+ wiring surface: the factory also registers the shortcut,
+    // command, and tool_call dismissal; the capture handler stays the
+    // first registration, so these no-ops only absorb the extra wiring.
+    registerShortcut: () => {},
+    registerCommand: () => {},
+  };
+  promptHistoryExtension(pi as never, {
+    env,
+    root,
+    cwd: CWD,
+    instanceId: "inst-entry",
+    now: () => 1700000000000,
+    agentDir: path.join(root, "agent"),
+    sessionsRoot: path.join(root, "sessions"),
+    // Never read a developer's real Customize preference.
+    gentlePiConfigHome: configHome,
+  });
+  return new Map(
+    registered.map(([event, handler]) => [
+      event,
+      handler as (event: unknown) => void,
+    ]),
+  );
+}
+
+/** Load the extension against a temp root and return the capture handler. */
+function captureHandlerWith(
+  env: NodeJS.ProcessEnv,
+  root: string,
+  configHome?: string,
+) {
+  const handler = handlersWith(env, root, configHome).get("before_agent_start");
+  assert.ok(handler, "the capture handler is registered");
+  return handler;
+}
+
+/** Fill the project dir past the default GC file threshold (50 files). */
+function fillProjectDir(root: string, files: number): string {
+  const dir = path.join(root, "projects", projectHash(CWD));
+  fs.mkdirSync(dir, { recursive: true });
+  for (let i = 1; i <= files; i++) {
+    const file = path.join(dir, `peer-${String(i).padStart(3, "0")}.jsonl`);
+    fs.writeFileSync(file, `${JSON.stringify({ v: 1, text: `peer ${i}` })}\n`);
+    fs.utimesSync(file, new Date(i * 1000), new Date(i * 1000));
+  }
+  return dir;
+}
+
+test("no file is created until the first capture", () => {
+  const root = makeRoot();
+  const state = openWriterForTest(root, "sess-1");
+  const file = sessionFilePath(root, CWD, "sess-1");
+  assert.equal(fs.existsSync(file), false);
+  assert.equal(state.lineCount, 0);
+});
+
+test("first capture lazily creates the file and appends one line", () => {
+  const root = makeRoot();
+  const state = openWriterForTest(root, "sess-1");
+  appendSessionCapture(state, "hello world", 1234);
+  const file = sessionFilePath(root, CWD, "sess-1");
+  assert.equal(fs.existsSync(file), true);
+  const lines = fs.readFileSync(file, "utf8").trim().split("\n");
+  assert.equal(lines.length, 1);
+  const parsed = JSON.parse(lines[0]);
+  assert.equal(parsed.text, "hello world");
+  assert.equal(parsed.ts, 1234);
+  assert.equal(parsed.v, 1);
+  assert.equal(state.lineCount, 1);
+});
+
+test("captures append in order; count tracks", () => {
+  const root = makeRoot();
+  const state = openWriterForTest(root, "sess-2");
+  appendSessionCapture(state, "one");
+  appendSessionCapture(state, "two");
+  appendSessionCapture(state, "three");
+  assert.deepEqual(fileTexts(sessionFilePath(root, CWD, "sess-2")), [
+    "one",
+    "two",
+    "three",
+  ]);
+  assert.equal(state.lineCount, 3);
+});
+
+test("command-like and empty captures are skipped", () => {
+  const root = makeRoot();
+  const state = openWriterForTest(root, "sess-3");
+  appendSessionCapture(state, "/compact");
+  appendSessionCapture(state, "   ");
+  appendSessionCapture(state, "");
+  appendSessionCapture(state, "kept");
+  assert.deepEqual(fileTexts(sessionFilePath(root, CWD, "sess-3")), ["kept"]);
+  assert.equal(state.lineCount, 1);
+});
+
+test("two writers own separate files in the same project dir", () => {
+  const root = makeRoot();
+  const a = openWriterForTest(root, "inst-a");
+  const b = openWriterForTest(root, "inst-b");
+  appendSessionCapture(a, "from-a");
+  appendSessionCapture(b, "from-b");
+  const dir = path.join(root, "projects", projectHash(CWD));
+  const files = fs.readdirSync(dir).sort();
+  assert.deepEqual(files, ["inst-a.jsonl", "inst-b.jsonl"]);
+});
+
+test("the extension entry registers exactly the slice-6 wiring surface", () => {
+  // Module load must stay side-effect free (importing index.ts parses the
+  // whole graph without touching the real ~/.pi store root). Wiring as of
+  // slice 6: before_agent_start capture, session_shutdown GC, tool_call
+  // overlay dismiss, the ctrl+shift+r shortcut, and the history command.
+  const registered: Array<[string, unknown]> = [];
+  const shortcuts: Array<[string, unknown]> = [];
+  const commands: Array<[string, unknown]> = [];
+  const pi = {
+    on: (event: string, handler: unknown) => {
+      registered.push([event, handler]);
+    },
+    registerShortcut: (key: string, def: unknown) => {
+      shortcuts.push([key, def]);
+    },
+    registerCommand: (name: string, def: unknown) => {
+      commands.push([name, def]);
+    },
+  };
+  // Capture off (explicit env, empty config home) keeps the warm-up from
+  // touching the real store root while the defaults are exercised.
+  promptHistoryExtension(pi as never, {
+    env: { GENTLE_PI_HISTORY_CAPTURE: "off" },
+    gentlePiConfigHome: makeConfigHome(),
+  });
+  assert.deepEqual(
+    registered.map(([event]) => event),
+    ["before_agent_start", "session_shutdown", "tool_call"],
+  );
+  assert.deepEqual(shortcuts.map(([key]) => key), ["ctrl+shift+r"]);
+  assert.deepEqual(commands.map(([name]) => name), ["history"]);
+  // Handlers are callable but are NEVER invoked here: a real invocation
+  // would run getWriter() against the user's real ~/.pi/agent/history.
+  for (const [, handler] of registered) {
+    assert.equal(typeof handler, "function");
+  }
+});
+
+test("captureEnabled is a strict opt-in", () => {
+  // Every call gets an empty config home: an env value that defers to the
+  // preference must never read the developer's real Customize setting.
+  const configHome = makeConfigHome();
+  const enabled = (env: NodeJS.ProcessEnv) => captureEnabled(env, configHome);
+  assert.equal(enabled({}), false);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: "0" }), false);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: "false" }), false);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: "off" }), false);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: "yes" }), false);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: " 1 " }), true);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: "TRUE" }), true);
+  assert.equal(enabled({ GENTLE_PI_HISTORY_CAPTURE: "On" }), true);
+  // The unshipped rename from the contributor branch is not a switch.
+  assert.equal(enabled({ [`GENTLE_PI_HISTORY_${"ENABLE"}`]: "1" }), false);
+});
+
+test("the capture handler is a no-op unless the user opts in", () => {
+  const root = makeRoot();
+  const handler = captureHandlerWith({}, root);
+  handler({ prompt: "sensitive prompt" });
+  handler({ prompt: "another one" });
+  // Nothing at all: no capture file, no project dir, no registry entry.
+  assert.deepEqual(fs.readdirSync(root), []);
+});
+
+test("an opted-in session captures delivered prompts", () => {
+  const root = makeRoot();
+  const handler = captureHandlerWith({ GENTLE_PI_HISTORY_CAPTURE: "1" }, root);
+  handler({ prompt: "hello store" });
+  assert.deepEqual(fileTexts(sessionFilePath(root, CWD, "inst-entry")), [
+    "hello store",
+  ]);
+});
+
+test("opted-in capture imports into its own root and defers seed on untrusted tombstones", () => {
+  const root = makeRoot();
+  const sessions = path.join(root, "sessions", "--pi-history-test-project-a--");
+  fs.mkdirSync(sessions, { recursive: true });
+  fs.writeFileSync(path.join(sessions, "s.jsonl"), [
+    JSON.stringify({ type: "session", version: 3 }),
+    JSON.stringify({ type: "message", message: { role: "user", content: "transcript prompt" } }),
+  ].join("\n") + "\n");
+  const agentDir = path.join(root, "agent");
+  fs.mkdirSync(agentDir);
+  fs.writeFileSync(path.join(agentDir, "editor-history.jsonl"),
+    JSON.stringify({ v: 1, text: "legacy prompt" }) + "\n");
+  fs.writeFileSync(path.join(root, "hidden.json"), "{invalid");
+  const handler = captureHandlerWith({ GENTLE_PI_HISTORY_CAPTURE: "1" }, root);
+  handler({ prompt: "current prompt" });
+  assert.deepEqual(fileTexts(path.join(root, "history-global.jsonl")), ["legacy prompt"]);
+  assert.equal(fs.existsSync(seedFilePath(root, CWD)), false);
+  assert.deepEqual(fileTexts(sessionFilePath(root, CWD, "inst-entry")), ["current prompt"]);
+  fs.writeFileSync(path.join(root, "hidden.json"), JSON.stringify(["transcript prompt"]));
+  // A new instance retries bootstrap after tombstones become trusted.
+  captureHandlerWith({ GENTLE_PI_HISTORY_CAPTURE: "1" }, root)({ prompt: "next prompt" });
+  assert.equal(fs.existsSync(seedFilePath(root, CWD)), false);
+});
+
+test("disabling capture stops new lines and leaves existing files alone", () => {
+  const root = makeRoot();
+  const env: NodeJS.ProcessEnv = { GENTLE_PI_HISTORY_CAPTURE: "true" };
+  const handler = captureHandlerWith(env, root);
+  handler({ prompt: "kept" });
+  const file = sessionFilePath(root, CWD, "inst-entry");
+  assert.equal(fs.existsSync(file), true);
+  delete env.GENTLE_PI_HISTORY_CAPTURE;
+  handler({ prompt: "never written" });
+  assert.deepEqual(fileTexts(file), ["kept"]);
+});
+
+test("the Customize preference enables capture without the env switch and toggles live", () => {
+  const root = makeRoot();
+  const configHome = makeConfigHome();
+  const handler = captureHandlerWith({}, root, configHome);
+  handler({ prompt: "before opt-in" });
+  assert.deepEqual(fs.readdirSync(root), []);
+  writeHistoryCapturePolicy("on", { gentlePiConfigHome: configHome });
+  handler({ prompt: "captured" });
+  const file = sessionFilePath(root, CWD, "inst-entry");
+  assert.deepEqual(fileTexts(file), ["captured"]);
+  // Turning the preference off stops new lines and keeps stored history.
+  writeHistoryCapturePolicy("off", { gentlePiConfigHome: configHome });
+  handler({ prompt: "never written" });
+  assert.deepEqual(fileTexts(file), ["captured"]);
+});
+
+test("an explicit env value overrides the Customize preference", () => {
+  const root = makeRoot();
+  const configHome = makeConfigHome();
+  writeHistoryCapturePolicy("on", { gentlePiConfigHome: configHome });
+  captureHandlerWith({ GENTLE_PI_HISTORY_CAPTURE: "0" }, root, configHome)({ prompt: "forced off" });
+  assert.deepEqual(fs.readdirSync(root), []);
+  writeHistoryCapturePolicy("off", { gentlePiConfigHome: configHome });
+  captureHandlerWith({ GENTLE_PI_HISTORY_CAPTURE: "On" }, root, configHome)({ prompt: "forced on" });
+  assert.deepEqual(fileTexts(sessionFilePath(root, CWD, "inst-entry")), ["forced on"]);
+});
+
+test("a malformed Customize preference fails closed", () => {
+  const root = makeRoot();
+  const configHome = makeConfigHome();
+  fs.writeFileSync(path.join(configHome, "history-capture.json"), '{"policy":"on"}');
+  captureHandlerWith({}, root, configHome)({ prompt: "not captured" });
+  assert.deepEqual(fs.readdirSync(root), []);
+  assert.equal(captureEnabled({}, configHome), false);
+});
+
+test("the extension resolves the preference under GENTLE_PI_CONFIG_HOME by default", () => {
+  const root = makeRoot();
+  const configHome = makeConfigHome();
+  writeHistoryCapturePolicy("on", { gentlePiConfigHome: configHome });
+  const registered: Array<[string, unknown]> = [];
+  promptHistoryExtension({ on: (event: string, handler: unknown) => registered.push([event, handler]), registerShortcut: () => {}, registerCommand: () => {} } as never, {
+    env: { GENTLE_PI_CONFIG_HOME: configHome },
+    root,
+    cwd: CWD,
+    instanceId: "inst-entry",
+    now: () => 1700000000000,
+    agentDir: path.join(root, "agent"),
+    sessionsRoot: path.join(root, "sessions"),
+  });
+  const capture = registered.find(([event]) => event === "before_agent_start")![1] as (event: unknown) => void;
+  capture({ prompt: "from config home" });
+  assert.deepEqual(fileTexts(sessionFilePath(root, CWD, "inst-entry")), ["from config home"]);
+});
+
+test("session_shutdown GC is a no-op while capture is off", () => {
+  const root = makeRoot();
+  const dir = fillProjectDir(root, 60);
+  const before = fs.readdirSync(dir).sort();
+  const shutdown = handlersWith({}, root).get("session_shutdown");
+  assert.ok(shutdown, "the shutdown handler is registered");
+  shutdown({});
+  assert.deepEqual(fs.readdirSync(dir).sort(), before);
+  assert.deepEqual(fs.readdirSync(root).sort(), ["projects"]);
+});
+
+test("session_shutdown GC compacts the injected root and keeps its own file", () => {
+  const root = makeRoot();
+  const dir = fillProjectDir(root, 60);
+  // This instance's own capture file is the oldest one in the dir.
+  const own = sessionFilePath(root, CWD, "inst-entry");
+  fs.writeFileSync(own, `${JSON.stringify({ v: 1, text: "own" })}\n`);
+  fs.utimesSync(own, new Date(1), new Date(1));
+  const shutdown = handlersWith({ GENTLE_PI_HISTORY_CAPTURE: "1" }, root).get(
+    "session_shutdown",
+  );
+  assert.ok(shutdown, "the shutdown handler is registered");
+  shutdown({});
+  const names = fs.readdirSync(dir);
+  // Default policy: the newest 10 peers stay, the other 50 merge into one
+  // compact file, and the own file is never a merge candidate.
+  assert.equal(names.filter((n) => n.startsWith("compact-")).length, 1);
+  assert.equal(names.filter((n) => n.startsWith("peer-")).length, 10);
+  assert.equal(fs.existsSync(own), true);
+  assert.deepEqual(fileTexts(own), ["own"]);
+});

package/tests/history-store-paths.test.ts

@@ -0,0 +1,79 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  globalSeedPath,
+  projectDir,
+  projectHash,
+  registryPath,
+  seedFilePath,
+  sessionFilePath,
+} from "../extensions/history/store.ts";
+
+const ROOT = path.join(os.tmpdir(), "pi-history-test-root");
+
+test("projectHash returns 16 lowercase hex chars", () => {
+  const hash = projectHash("/pi-history-test/project-a");
+  assert.match(hash, /^[0-9a-f]{16}$/);
+});
+
+test("known vector: stable hash for a fixed path", () => {
+  // The literal exists on no machine, so every platform exercises the
+  // documented raw-string fallback: sha256(literal), first 16 hex chars.
+  assert.equal(
+    projectHash("/pi-history-test/project-a"),
+    "4be15ec687e9df85",
+  );
+});
+
+test("distinct paths produce distinct hashes", () => {
+  assert.notEqual(
+    projectHash("/pi-history-test/project-a"),
+    projectHash("/pi-history-test/project-b"),
+  );
+});
+
+test("symlinked cwd resolves to the same hash as its target", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "paths-sym-"));
+  const target = path.join(dir, "real-project");
+  fs.mkdirSync(target);
+  const link = path.join(dir, "link-project");
+  fs.symlinkSync(target, link);
+  assert.equal(projectHash(link), projectHash(target));
+});
+
+test("trailing slash does not change the identity", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "paths-slash-"));
+  assert.equal(projectHash(dir), projectHash(`${dir}/`));
+});
+
+test("nonexistent path falls back to hashing the raw string (no throw)", () => {
+  const missing = path.join(os.tmpdir(), "paths-missing-does-not-exist");
+  const hash = projectHash(missing);
+  assert.match(hash, /^[0-9a-f]{16}$/);
+});
+
+test("path derivations compose under the root", () => {
+  const cwd = "/pi-history-test/project-a";
+  const hash = projectHash(cwd);
+  assert.equal(projectDir(ROOT, cwd), path.join(ROOT, "projects", hash));
+  assert.equal(
+    sessionFilePath(ROOT, cwd, "abc-123"),
+    path.join(ROOT, "projects", hash, "abc-123.jsonl"),
+  );
+  assert.equal(
+    seedFilePath(ROOT, cwd),
+    path.join(ROOT, "projects", hash, "seed.jsonl"),
+  );
+  assert.equal(globalSeedPath(ROOT), path.join(ROOT, "history-global.jsonl"));
+  assert.equal(registryPath(ROOT), path.join(ROOT, "registry.json"));
+});
+
+test("two cwds map to sibling project dirs", () => {
+  const a = projectDir(ROOT, "/pi-history-test/project-a");
+  const b = projectDir(ROOT, "/pi-history-test/project-b");
+  assert.notEqual(a, b);
+  assert.equal(path.dirname(a), path.dirname(b));
+});

package/tests/history-tombstone-exact.test.ts

@@ -0,0 +1,139 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  hidePrompt,
+  readHiddenPrompts,
+  tombstoneKey,
+} from "../extensions/history/hide-prompts.ts";
+import {
+  bootstrapProjectSeed,
+  drainGlobal,
+  drainProject,
+  projectHash,
+  seedFilePath,
+} from "../extensions/history/store.ts";
+
+// Exact tombstones (PR #1393 adaptation): a deletion hides ONLY the exact
+// normalized prompt (whitespace-collapsed, trimmed, case-insensitive) —
+// never every prompt that shares a 120-character prefix. hidden.json keeps
+// its JSON-array-of-strings shape; new entries are hashes, and plaintext
+// entries written by the earlier prefix format stay readable and honored.
+
+const CWD = "/pi-history-test/tombstone-exact";
+
+function makeRoot(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-tomb-"));
+}
+
+function writeLines(file: string, texts: string[]): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    `${texts.map((t) => JSON.stringify({ v: 1, text: t })).join("\n")}\n`,
+    "utf8",
+  );
+}
+
+function drainedProject(root: string): string[] {
+  const drained = drainProject(root, CWD, 1000, root);
+  assert.equal(drained.status, "ok");
+  if (drained.status !== "ok") throw new Error("unreachable");
+  return drained.prompts;
+}
+
+const PREFIX = `${"shared context ".repeat(10)}`; // 150 chars, > 120
+const LONG_A = `${PREFIX}then deploy staging`;
+const LONG_B = `${PREFIX}then deploy production`;
+
+test("tombstoneKey normalizes whitespace and case but never truncates", () => {
+  assert.equal(tombstoneKey("Fix\t the   BUILD "), tombstoneKey("fix the build"));
+  assert.notEqual(tombstoneKey(LONG_A), tombstoneKey(LONG_B));
+  assert.match(tombstoneKey("fix the build"), /^sha256:[0-9a-f]{64}$/);
+});
+
+test("hidden.json stores a hash, never the deleted prompt's text", () => {
+  const root = makeRoot();
+  assert.deepEqual(hidePrompt(root, "my secret token abc123"), {
+    status: "written",
+  });
+  const raw = fs.readFileSync(path.join(root, "hidden.json"), "utf8");
+  assert.equal(raw.includes("secret"), false);
+  assert.deepEqual(JSON.parse(raw), [tombstoneKey("my secret token abc123")]);
+});
+
+test("hiding one long prompt keeps a sibling that shares its 120-char prefix", () => {
+  const root = makeRoot();
+  const dir = path.join(root, "projects", projectHash(CWD));
+  writeLines(path.join(dir, "s.jsonl"), [LONG_A, LONG_B, "short keep"]);
+  assert.deepEqual(hidePrompt(root, LONG_A), { status: "written" });
+
+  const prompts = drainedProject(root);
+  assert.equal(prompts.includes(LONG_A), false, "the deleted prompt stays hidden");
+  assert.ok(prompts.includes(LONG_B), "the prefix sibling must stay visible");
+  assert.ok(prompts.includes("short keep"));
+
+  const global = drainGlobal(root, 1000, root);
+  assert.equal(global.status, "ok");
+  if (global.status !== "ok") throw new Error("unreachable");
+  assert.equal(global.prompts.includes(LONG_A), false);
+  assert.ok(global.prompts.includes(LONG_B));
+});
+
+test("a tombstone hides whitespace and case variants of the exact prompt", () => {
+  const root = makeRoot();
+  const dir = path.join(root, "projects", projectHash(CWD));
+  writeLines(path.join(dir, "s.jsonl"), ["Deploy   THE api", "deploy the api now"]);
+  hidePrompt(root, "deploy the api");
+  assert.deepEqual(drainedProject(root), ["deploy the api now"]);
+});
+
+test("plaintext entries from the earlier prefix format stay readable and honored", () => {
+  const root = makeRoot();
+  const dir = path.join(root, "projects", projectHash(CWD));
+  writeLines(path.join(dir, "s.jsonl"), ["Legacy   Hidden", "visible prompt"]);
+  // The earlier writer stored promptDedupKey output: the whitespace-
+  // collapsed, 120-char, lowercased text.
+  fs.writeFileSync(
+    path.join(root, "hidden.json"),
+    JSON.stringify(["legacy hidden"]),
+    "utf8",
+  );
+  assert.equal(readHiddenPrompts(root).status, "trusted");
+  assert.deepEqual(drainedProject(root), ["visible prompt"]);
+
+  // A new hide appends a hash entry and preserves the legacy entry.
+  hidePrompt(root, "visible prompt");
+  const stored = JSON.parse(
+    fs.readFileSync(path.join(root, "hidden.json"), "utf8"),
+  );
+  assert.deepEqual(stored, ["legacy hidden", tombstoneKey("visible prompt")]);
+  assert.deepEqual(drainedProject(root), []);
+});
+
+test("seed bootstrap skips an exact tombstone but seeds its prefix sibling", () => {
+  const root = makeRoot();
+  const sessionsRoot = path.join(root, "sessions");
+  const sessions = path.join(sessionsRoot, "--pi-history-test-tombstone-exact--");
+  fs.mkdirSync(sessions, { recursive: true });
+  fs.writeFileSync(
+    path.join(sessions, "s.jsonl"),
+    [
+      JSON.stringify({ type: "session", version: 3 }),
+      JSON.stringify({ type: "message", message: { role: "user", content: LONG_A } }),
+      JSON.stringify({ type: "message", message: { role: "user", content: LONG_B } }),
+    ].join("\n") + "\n",
+  );
+  hidePrompt(root, LONG_A);
+
+  const result = bootstrapProjectSeed(root, CWD, sessionsRoot, 500, root);
+  assert.deepEqual(result, { seeded: 1, ran: true });
+  const seeded = fs
+    .readFileSync(seedFilePath(root, CWD), "utf8")
+    .trim()
+    .split("\n")
+    .map((line) => (JSON.parse(line) as { text: string }).text);
+  assert.deepEqual(seeded, [LONG_B]);
+});