gentle-pi 4.2.0 → 4.4.0

package/tests/review-session-standing-permission-controller.test.ts

@@ -4,7 +4,8 @@ import { mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { PassThrough } from "node:stream";
-import test from "node:test";
+import test, { after, before } from "node:test";
+import { setWindowsAclAuthorityForTesting } from "../lib/review-candidate-view-owner.ts";
 import { Text, visibleWidth } from "@earendil-works/pi-tui";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
@@ -19,6 +20,16 @@ import {
 	presentReviewConsentUi,
 } from "../lib/review-consent-ui.ts";
 
+// Coordination tests use fixture authority; real Windows ACL coverage lives
+// in review-candidate-view.test.ts, in a separate test process.
+let fixtureAclChecks = 0;
+before(() => {
+	if (process.platform === "win32") {
+		setWindowsAclAuthorityForTesting(() => { fixtureAclChecks++; });
+	}
+});
+after(() => setWindowsAclAuthorityForTesting());
+
 function consentFixture(): Record<string, unknown> {
 	const path = join(process.cwd(), "tests", "fixtures", "devbinary", "consent-v3.captured.json");
 	return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
@@ -173,10 +184,12 @@ function siblingWorktree(t: test.TestContext, parentRoot: string): string {
 
 function startStatus(cwd: string, intendedUntracked: readonly string[] = []): ReviewStatusV3 {
 	const views = new CandidateViewRegistry();
+	const checksBefore = fixtureAclChecks;
 	const candidate = views.create({
 		contributorRoot: cwd,
 		...(intendedUntracked.length === 0 ? {} : { intendedUntracked }),
 	});
+	if (process.platform === "win32") assert.ok(fixtureAclChecks > checksBefore, "coordination candidates must use the fixture ACL authority");
 	try {
 		return {
 			contract: "gentle-ai.review-integration/v2",

package/tests/review-session-standing-permission.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -100,6 +100,32 @@ test("review session Git identity lookups hide every Windows child process", asy
 	}
 });
 
+test("synchronous repository discovery stays silent outside Git", (t) => {
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-non-git-identity-")));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	const moduleUrl = new URL("../lib/review-session-standing-permission.ts", import.meta.url).href;
+	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.toUpperCase().startsWith("GIT_")));
+	const child = spawnSync(process.execPath, ["--experimental-strip-types", "--input-type=module", "-e", `
+		import { resolveCanonicalGitRepositoryIdentitySync } from ${JSON.stringify(moduleUrl)};
+		const identity = resolveCanonicalGitRepositoryIdentitySync(process.cwd());
+		console.log(JSON.stringify({ identity: identity ?? null }));
+	`], { cwd, env, encoding: "utf8", timeout: 10_000 });
+	assert.equal(child.error, undefined);
+	assert.equal(child.status, 0, child.stderr);
+	assert.deepEqual(JSON.parse(child.stdout), { identity: null });
+	assert.equal(child.stderr, "", "a caught Git failure must not write over the TUI editor");
+});
+
+test("synchronous repository discovery preserves clone identity across worktrees", (t) => {
+	const root = repository(t);
+	const sibling = siblingWorktree(t, root);
+	const unrelated = repository(t);
+	const identity = resolveCanonicalGitRepositoryIdentitySync(root);
+	assert.match(identity ?? "", /^sha256:/);
+	assert.equal(resolveCanonicalGitRepositoryIdentitySync(sibling), identity);
+	assert.notEqual(resolveCanonicalGitRepositoryIdentitySync(unrelated), identity);
+});
+
 test("headless, child, empty-session, and non-Git contexts cannot offer or consume standing permission", async (t) => {
 	const root = repository(t);
 	const manager = {};

package/tests/run-test-suite.test.ts

@@ -123,6 +123,8 @@ console.log("ENV_PROBE=" + JSON.stringify({
   home,
   files: home && existsSync(home) ? readdirSync(home) : null,
   sentinel: process.env.TEST_ENV_SENTINEL,
+  tmp: process.env.TMPDIR ?? null,
+  tmpExists: process.env.TMPDIR ? existsSync(process.env.TMPDIR) : null,
 }));
 `);
 	writeFileSync(stagesPath, JSON.stringify([
@@ -200,3 +202,16 @@ test("direct invocation rejects a malformed stages file with a non-zero exit", (
 	assert.equal(result.status, 1);
 	assert.match(result.stderr ?? "", /stages file must be an array/);
 });
+
+// Harness roadmap T3: each subagent gets its own TMPDIR, and unit fixtures that
+// leave a fake child unfinished would leave it behind; the stage owns them all.
+test("unit stage gets a private TMPDIR removed after the stage; later stages keep the inherited one", (t) => {
+	const inherited = mkdtempSync(join(tmpdir(), "gentle-pi-caller-tmp-"));
+	t.after(() => rmSync(inherited, { recursive: true, force: true }));
+	const [unit, provider] = probeStageEnvironment(t, { TMPDIR: inherited });
+	assert.notEqual(unit.tmp, inherited);
+	assert.match(unit.tmp, /gentle-pi-unit-tmp-/);
+	assert.equal(unit.tmpExists, true, "the private TMPDIR exists while the stage runs");
+	assert.equal(existsSync(unit.tmp), false, "the private TMPDIR is removed after the stage");
+	assert.equal(provider.tmp, inherited);
+});

package/tests/runtime-harness.mjs

@@ -604,9 +604,19 @@ async function run() {
 			assert.equal(writerDispatch.task, task, "writer guard must not mutate child input");
 		}
 
+		// S16: generic writers are admitted only for a task of an existing feature document (or at the measured
+		// context backstop); the accepted cases below name one, and an undocumented launch is told to work inline.
+		await mkdir(join(toolCwd, "odd", "tasks"), { recursive: true });
+		await writeFile(join(toolCwd, "odd", "tasks", "harness.md"), "# Harness\n");
+		const undocumentedWriter = await toolHook(
+			{ toolName: "subagent_run", input: { agent: "gentle-ai-worker", task: "Implement the requested change.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts", mode: "task" } },
+			createCtx(toolCwd),
+		);
+		assert.equal(undocumentedWriter?.block, true, "an undocumented writer must be blocked before dispatch");
+		assert.match(undocumentedWriter?.reason ?? "", /write this unit inline yourself/);
 		const scopedWriterDispatch = {
 			agent: "gentle-ai-worker",
-			task: "Implement the requested change.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts\ntests/runtime-harness.mjs",
+			task: "Spec: odd/tasks/harness.md, T1. Implement the requested change.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts\ntests/runtime-harness.mjs",
 			mode: "task",
 		};
 		assert.equal(
@@ -620,7 +630,7 @@ async function run() {
 					toolName: "subagent_run",
 					input: {
 						agent: "worker",
-						task: "Implement the requested change.",
+						task: "Spec: odd/tasks/harness.md, T2. Implement the requested change.",
 						context: "## Allowed edit surfaces\n- assets/orchestrator.md",
 						mode: "task",
 					},
@@ -717,7 +727,7 @@ async function run() {
 				"valid scope followed by a repository-root scope",
 				{
 					agent: "gentle-ai-worker",
-					task: "## Allowed edit surfaces\nextensions/gentle-ai.ts\n\n## Allowed edit surfaces\n.",
+					task: "Spec: odd/tasks/harness.md, T4.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts\n\n## Allowed edit surfaces\n.",
 					mode: "task",
 				},
 			],
@@ -725,7 +735,7 @@ async function run() {
 				"valid task scope plus invalid context scope",
 				{
 					agent: "gentle-ai-worker",
-					task: "## Allowed edit surfaces\nextensions/gentle-ai.ts",
+					task: "Spec: odd/tasks/harness.md, T5.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts",
 					context: "## Allowed edit surfaces\n.",
 					mode: "task",
 				},
@@ -734,7 +744,7 @@ async function run() {
 				"conflicting valid task and context scopes",
 				{
 					agent: "gentle-ai-worker",
-					task: "## Allowed edit surfaces\nextensions/gentle-ai.ts",
+					task: "Spec: odd/tasks/harness.md, T6.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts",
 					context: "## Allowed edit surfaces\ntests/runtime-harness.mjs",
 					mode: "task",
 				},
@@ -749,7 +759,7 @@ async function run() {
 					toolName: "subagent_run",
 					input: {
 						agent: "gentle-ai-worker",
-						task: "## Allowed edit surfaces\nextensions/gentle-ai.ts\ntests/runtime-harness.mjs\n\n## Allowed edit surfaces\n- `tests/runtime-harness.mjs`\n- `extensions/gentle-ai.ts`",
+						task: "Spec: odd/tasks/harness.md, T3.\n\n## Allowed edit surfaces\nextensions/gentle-ai.ts\ntests/runtime-harness.mjs\n\n## Allowed edit surfaces\n- `tests/runtime-harness.mjs`\n- `extensions/gentle-ai.ts`",
 						mode: "task",
 					},
 				},

package/tests/session-changes-shell.test.ts

@@ -39,7 +39,7 @@ function fixture(entries: any[] = [], options: { root?: string; sessionId?: stri
 		for(let i=0;i<200&&!overlay.view;i++){ if(await Promise.race([opened.then(()=>true),new Promise(r=>setTimeout(()=>r(false),5))])) break; }
 		if(!overlay.view) return undefined;
 		const text=overlay.view.render(200).join("\n");
-		const trees=(overlay.view.trees as any[]).map(tree=>({root:tree.root as string,branch:tree.branch as string|undefined,files:tree.model.files.map((file:any)=>file.path) as string[],added:tree.model.added as number,deleted:tree.model.deleted as number}));
+		const trees=(overlay.view.children[0].trees as any[]).map(tree=>({root:tree.root as string,branch:tree.branch as string|undefined,files:tree.model.files.map((file:any)=>file.path) as string[],added:tree.model.added as number,deleted:tree.model.deleted as number}));
 		overlay.close!(); await opened;
 		return {text,trees,files:trees.flatMap(tree=>tree.files)};
 	};

package/tests/session-changes.test.ts

@@ -4,6 +4,7 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { SessionChanges, readChangeSnapshot, sessionChangeRoots, SESSION_CHANGE_ENTRY, MAX_CHANGE_BYTES } from "../lib/session-changes.ts";
+import { emptyChanges } from "../lib/shell-changes.ts";
 import { SESSION_WORKTREE_ENTRY } from "../lib/session-worktree-registry.ts";
 
 const text = (text: string) => ({ kind: "text" as const, text });
@@ -12,7 +13,7 @@ const evidence = (id = "a", root = "/repo", path = "file.ts", before = text("old
 
 test("session changes starts empty without reading the worktree or its untracked contents", () => {
 	const changes = new SessionChanges("session");
-	assert.deepEqual(changes.model, { files: [], added: 0, deleted: 0 });
+	assert.deepEqual(changes.model, { ...emptyChanges(), digest: emptyChanges().digest });
 	assert.deepEqual(changes.worktrees, []);
 });
 

package/tests/session-profile-append-controller-fork.test.ts

@@ -0,0 +1,458 @@
+// Fork lifecycle seams against public Pi SessionManager fixtures in temp dirs.
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import {
+ createSessionProfileAppendController,
+ type SessionProfileAppendOptions,
+ type SessionProfileAppendOutcome,
+ type SessionProfileForkTarget,
+} from "../lib/session-profile-append-controller.ts";
+
+type Controller = ReturnType<typeof createSessionProfileAppendController>;
+
+function fixture(memory = false) {
+ const root = mkdtempSync(join(tmpdir(), "profile-fork-"));
+ const manager = memory
+  ? SessionManager.inMemory(root)
+  : SessionManager.create(root, join(root, "sessions"));
+ let fail = false,
+  calls = 0;
+ const controller = createSessionProfileAppendController(
+  manager,
+  (type, data) => {
+   calls++;
+   manager.appendCustomEntry(type, data);
+   if (fail) throw new Error("injected callback failure after public append");
+  },
+ );
+ return {
+  manager,
+  controller,
+  failing(value: boolean) {
+   fail = value;
+  },
+  calls: () => calls,
+ };
+}
+function flush(manager: SessionManager) {
+ manager.appendMessage({
+  role: "user",
+  content: "isolated fork fixture",
+  timestamp: 1,
+ });
+}
+function name(outcome: SessionProfileAppendOutcome, expected: string) {
+ const state = outcome.state as { status: string; binding?: { name: string } };
+ assert.equal(state.status, "bound");
+ assert.equal(state.binding?.name, expected);
+}
+function persistedCopy(manager: SessionManager, leaf: string) {
+ const sourceFile = manager.getSessionFile();
+ assert.ok(sourceFile);
+ const copy = SessionManager.open(sourceFile, manager.getSessionDir());
+ copy.createBranchedSession(leaf);
+ return copy;
+}
+// Mirrors the host order: capture, copy, detach with the preparation, then
+// attach the destination with the handoff and its own public view. An
+// in-memory fork rewrites the same manager, so it copies after detach.
+function fork(
+ parent: Controller,
+ manager: SessionManager,
+ target: SessionProfileForkTarget,
+ copy: (prepared: boolean) => SessionManager,
+ options: SessionProfileAppendOptions = {},
+) {
+ const captured = parent.captureForkEvidence(target, manager);
+ const previousSessionFile = manager.getSessionFile();
+ const inPlace = manager.getSessionFile() === undefined;
+ let child = inPlace ? manager : copy(captured.status === "captured");
+ const handoff = parent.detach({
+  reason: "fork",
+  targetSessionFile: inPlace ? undefined : child.getSessionFile(),
+  preparation:
+   captured.status === "captured" ? captured.evidence : undefined,
+ });
+ if (inPlace) child = copy(captured.status === "captured");
+ let appends = 0;
+ const append = (type: string, data: unknown) => {
+  appends++;
+  child.appendCustomEntry(type, data);
+ };
+ // The host keeps one controller per manager; an in-memory fork reuses it.
+ const controller =
+  child === manager
+   ? parent
+   : createSessionProfileAppendController(child, append);
+ const attachment = controller.attach(
+  child,
+  append,
+  {
+   reason: "fork",
+   previousSessionFile,
+   ...(handoff ? { fork: { handoff, publicView: child } } : {}),
+  },
+  options,
+ );
+ return {
+  captured,
+  handoff,
+  child,
+  controller,
+  attachment,
+  outcome: attachment.refresh(),
+  appends: () => appends,
+  reattach: () =>
+   createSessionProfileAppendController(child, append).attach(child, append, {
+    reason: "fork",
+    previousSessionFile,
+    ...(handoff ? { fork: { handoff, publicView: child } } : {}),
+   }),
+ };
+}
+
+test("disk-first fork retains copied failure quarantine but does not inherit binding", () => {
+ const f = fixture();
+ f.failing(true);
+ assert.equal(f.controller.bind("failed", {}).status, "indeterminate");
+ f.failing(false);
+ const failed = f.manager.getLeafId();
+ assert.ok(failed);
+ assert.equal(existsSync(f.manager.getSessionFile()!), false);
+ // Genuine public first flush now writes the known-failed record as well.
+ flush(f.manager);
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: failed, position: "at" },
+  () => persistedCopy(f.manager, failed),
+ );
+ assert.equal(forked.captured.status, "captured");
+ assert.ok(forked.handoff);
+ // No conversation on the copied path: the child file need not exist yet.
+ assert.equal(forked.outcome.status, "indeterminate");
+ assert.equal(existsSync(forked.child.getSessionFile()!), false);
+ flush(forked.child);
+ assert.equal(forked.attachment.refresh().state.status, "absent");
+ assert.equal(forked.attachment.clear().status, "persisted");
+ // A consumed handoff cannot be replayed into a second attachment.
+ assert.equal(forked.reattach().refresh().status, "indeterminate");
+});
+
+test("actual copied cut beyond the prepared ancestor fails closed", () => {
+ const f = fixture();
+ flush(f.manager);
+ assert.equal(f.controller.bind("trusted", {}).status, "persisted");
+ const preparedCut = f.manager.getLeafId();
+ assert.ok(preparedCut);
+ f.failing(true);
+ const failed = f.controller.bind("known-failed", {});
+ f.failing(false);
+ assert.equal(failed.status, "append-failed-preserved");
+ name(failed, "trusted");
+ const actualCut = f.manager.getLeafId();
+ assert.ok(actualCut);
+ assert.notEqual(actualCut, preparedCut);
+ const sourceFile = f.manager.getSessionFile()!;
+ const sourceEntries = JSON.stringify(f.manager.getEntries());
+ const sourceDisk = readFileSync(sourceFile, "utf8");
+ let childEntries = "",
+  childDisk = "";
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: preparedCut, position: "at" },
+  () => {
+   const child = persistedCopy(f.manager, actualCut);
+   assert.ok(child.getBranch().some((entry) => entry.id === preparedCut));
+   childEntries = JSON.stringify(child.getEntries());
+   childDisk = readFileSync(child.getSessionFile()!, "utf8");
+   assert.ok(childDisk.includes(actualCut), "public copy stores the failure");
+   return child;
+  },
+ );
+ assert.deepEqual(forked.outcome, {
+  status: "indeterminate",
+  state: { status: "indeterminate", reason: "ambiguous-append" },
+ });
+ assert.deepEqual(forked.attachment.refresh(), forked.outcome);
+ assert.equal(forked.appends(), 0);
+ assert.equal(f.calls(), 2);
+ assert.equal(JSON.stringify(forked.child.getEntries()), childEntries);
+ assert.equal(readFileSync(forked.child.getSessionFile()!, "utf8"), childDisk);
+ assert.equal(JSON.stringify(f.manager.getEntries()), sourceEntries);
+ assert.equal(readFileSync(sourceFile, "utf8"), sourceDisk);
+});
+
+for (const position of ["before", "at"] as const) {
+ test(`cancelled ${position} capture leaves entries, activation and callbacks unchanged`, () => {
+  const f = fixture();
+  assert.equal(f.controller.bind("pending", {}).status, "not-persisted");
+  const leaf = f.manager.getLeafId();
+  assert.ok(leaf);
+  const before = JSON.stringify(f.manager.getEntries());
+  const captured = f.controller.captureForkEvidence(
+   { entryId: position === "at" ? leaf : "missing", position },
+   f.manager,
+  );
+  assert.equal(
+   captured.status,
+   position === "at" ? "captured" : "indeterminate",
+  );
+  assert.equal(JSON.stringify(f.manager.getEntries()), before);
+  assert.equal(f.controller.refresh().status, "not-persisted");
+  assert.equal(f.controller.bind("next", {}).status, "not-persisted");
+  assert.equal(f.calls(), 2);
+ });
+}
+
+test("valid cancelled before-user capture leaves disk and explicit binding unchanged", () => {
+ const f = fixture();
+ flush(f.manager);
+ const user = f.manager.getLeafId();
+ assert.ok(user);
+ f.controller.bind("current", {});
+ const entries = JSON.stringify(f.manager.getEntries());
+ const disk = readFileSync(f.manager.getSessionFile()!, "utf8");
+ assert.equal(
+  f.controller.captureForkEvidence(
+   { entryId: user, position: "before" },
+   f.manager,
+  ).status,
+  "captured",
+ );
+ assert.equal(JSON.stringify(f.manager.getEntries()), entries);
+ assert.equal(readFileSync(f.manager.getSessionFile()!, "utf8"), disk);
+ name(f.controller.refresh(), "current");
+ assert.equal(f.calls(), 1);
+});
+
+test("capture rejects a public view other than the attached source", () => {
+ const f = fixture();
+ flush(f.manager);
+ const other = fixture();
+ assert.deepEqual(
+  f.controller.captureForkEvidence(
+   { entryId: f.manager.getLeafId()!, position: "at" },
+   other.manager,
+  ),
+  { status: "indeterminate", reason: "unobservable-fork" },
+ );
+});
+
+test("label removal permits only the expected copied parentId rechain", () => {
+ const f = fixture();
+ f.controller.bind("base", {});
+ flush(f.manager);
+ const base = f.manager.getLeafId();
+ assert.ok(base);
+ f.manager.appendLabelChange(base, "fixture-label");
+ f.controller.bind("selected", {});
+ const leaf = f.manager.getLeafId();
+ assert.ok(leaf);
+ const original = f.manager.getEntry(leaf)!;
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: leaf, position: "at" },
+  () => persistedCopy(f.manager, leaf),
+ );
+ assert.notEqual(forked.child.getEntry(leaf)?.parentId, original.parentId);
+ name(forked.outcome, "selected");
+});
+
+for (const position of ["before", "at"] as const) {
+ test(`fork boundary label supports ${position} without requiring its removed ID`, () => {
+  const f = fixture();
+  flush(f.manager);
+  f.controller.bind("retained", {});
+  const retained = f.manager.getLeafId();
+  assert.ok(retained);
+  f.manager.appendLabelChange(retained, "boundary");
+  const label = f.manager.getLeafId();
+  assert.ok(label);
+  let entryId = label;
+  if (position === "before") {
+   flush(f.manager);
+   entryId = f.manager.getLeafId()!;
+  }
+  const forked = fork(f.controller, f.manager, { entryId, position }, () => {
+   const copy = persistedCopy(f.manager, label);
+   assert.equal(copy.getEntry(label), undefined);
+   return copy;
+  });
+  assert.equal(forked.captured.status, "captured");
+  name(forked.outcome, "retained");
+ });
+}
+
+test("actual fork path excludes failed sibling and never imports its quarantine", () => {
+ const f = fixture();
+ f.controller.bind("base", {});
+ flush(f.manager);
+ const base = f.manager.getLeafId();
+ assert.ok(base);
+ f.failing(true);
+ f.controller.bind("failed-left", {});
+ f.failing(false);
+ const failed = f.manager.getLeafId();
+ f.manager.branch(base);
+ f.controller.bind("right", {});
+ const right = f.manager.getLeafId();
+ assert.ok(right);
+ assert.notEqual(right, failed);
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: right, position: "at" },
+  () => persistedCopy(f.manager, right),
+ );
+ assert.equal(
+  forked.child.getBranch().some((entry) => entry.id === failed),
+  false,
+ );
+ name(forked.outcome, "right");
+});
+
+for (const changed of ["data", "timestamp", "parentId", "extra"] as const) {
+ test(`copied same-ID ${changed} mutation fails closed without blessing destination disk`, () => {
+  const f = fixture();
+  flush(f.manager);
+  f.controller.bind("trusted", {});
+  const leaf = f.manager.getLeafId();
+  assert.ok(leaf);
+  let copy: SessionManager | undefined;
+  const forked = fork(
+   f.controller,
+   f.manager,
+   { entryId: leaf, position: "at" },
+   () => {
+    copy = persistedCopy(f.manager, leaf);
+    const row = copy.getEntry(leaf)! as unknown as Record<string, any>;
+    if (changed === "data") row.data.name = "FAILED";
+    if (changed === "timestamp") row.timestamp = "changed";
+    if (changed === "parentId") row.parentId = "unexpected-parent";
+    if (changed === "extra") row.extra = { changed: true };
+    return copy;
+   },
+   {
+    // Inject matching disk content, not ordinary Pi ID reuse.
+    readFile: (path) =>
+     copy && path === copy.getSessionFile()
+      ? [copy.getHeader(), ...copy.getEntries()]
+         .map((entry) => JSON.stringify(entry))
+         .join("\n")
+      : readFileSync(path, "utf8"),
+   },
+  );
+  assert.equal(forked.outcome.status, "indeterminate");
+  assert.equal(forked.attachment.clear().status, "persisted");
+  forked.child.branch(leaf);
+  assert.equal(forked.attachment.refresh().status, "indeterminate");
+ });
+}
+
+test("in-memory fork keeps same-manager evidence but never restores pending state", () => {
+ const f = fixture(true);
+ assert.equal(f.controller.bind("pending", {}).status, "not-persisted");
+ const leaf = f.manager.getLeafId();
+ assert.ok(leaf);
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: leaf, position: "at" },
+  () => {
+   f.manager.createBranchedSession(leaf);
+   return f.manager;
+  },
+ );
+ assert.equal(forked.captured.status, "captured");
+ assert.equal(forked.outcome.status, "indeterminate");
+ assert.equal(
+  forked.attachment.bind("new-explicit", {}).status,
+  "not-persisted",
+ );
+ // The parent attachment was revoked by detach and cannot append.
+ assert.equal(f.controller.clear().status, "indeterminate");
+});
+
+test("fork before root creates empty child without parent binding", () => {
+ const f = fixture();
+ flush(f.manager);
+ const firstUser = f.manager.getLeafId();
+ assert.ok(firstUser);
+ f.controller.bind("parent", {});
+ const previousSessionFile = f.manager.getSessionFile();
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: firstUser, position: "before" },
+  () => {
+   const child = SessionManager.create(
+    f.manager.getCwd(),
+    f.manager.getSessionDir(),
+   );
+   child.newSession({ parentSession: previousSessionFile });
+   return child;
+  },
+ );
+ assert.equal(forked.captured.status, "captured");
+ assert.equal(forked.outcome.status, "indeterminate");
+ assert.equal(forked.attachment.bind("child", {}).status, "not-persisted");
+});
+
+test("detach rejects a preparation captured by another controller", () => {
+ const f = fixture();
+ flush(f.manager);
+ const leaf = f.manager.getLeafId();
+ assert.ok(leaf);
+ const other = createSessionProfileAppendController(f.manager, () => {});
+ const captured = other.captureForkEvidence(
+  { entryId: leaf, position: "at" },
+  f.manager,
+ );
+ assert.equal(captured.status, "captured");
+ assert.equal(
+  f.controller.detach({
+   reason: "fork",
+   targetSessionFile: join(f.manager.getSessionDir(), "child.jsonl"),
+   preparation: captured.status === "captured" ? captured.evidence : undefined,
+  }),
+  undefined,
+ );
+ // Even a rejected proof still revokes the old capability.
+ assert.equal(f.controller.refresh().status, "indeterminate");
+});
+
+test("empty destination cannot claim a prepared non-empty copied path", () => {
+ const f = fixture();
+ flush(f.manager);
+ f.controller.bind("parent", {});
+ const leaf = f.manager.getLeafId();
+ assert.ok(leaf);
+ const previousSessionFile = f.manager.getSessionFile();
+ const forked = fork(
+  f.controller,
+  f.manager,
+  { entryId: leaf, position: "at" },
+  () => {
+   const child = SessionManager.create(
+    f.manager.getCwd(),
+    f.manager.getSessionDir(),
+   );
+   child.newSession({ parentSession: previousSessionFile });
+   return child;
+  },
+ );
+ assert.equal(forked.captured.status, "captured");
+ assert.equal(forked.outcome.status, "indeterminate");
+ // A rejected destination cut cannot activate even a fresh explicit setup.
+ assert.deepEqual(forked.attachment.bind("child", {}), {
+  status: "indeterminate",
+  state: { status: "indeterminate", reason: "append-not-corroborated" },
+ });
+});