gentle-pi 4.0.0 → 4.2.0

package/tests/runtime-metrics-extension.test.ts

@@ -13,7 +13,7 @@ function harness(env: NodeJS.ProcessEnv = {}, mode: "tui" | "print" = "tui", shu
 	let session = "first";
 	let finish!: () => void;
 	let signal!: AbortSignal;
-	const sent: RuntimeMetricBucket[][] = [];
+	const sent: (readonly RuntimeMetricBucket[])[] = [];
 	const launches: unknown[] = [];
 	const ctx: any = { cwd: "/fixture", mode, model,
 		sessionManager: { getSessionId: () => session, getEntries: () => assert.fail("no reconstruction") } };

package/tests/runtime-metrics-native.test.ts

@@ -2,8 +2,11 @@ import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
 import { PassThrough } from "node:stream";
 import { test } from "node:test";
-import { readFileSync, realpathSync } from "node:fs";
+import { mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { setGentleAiDevBinaryEnvironmentForTesting } from "../lib/gentle-ai-binary.ts";
+import { setBundledInstallForTesting } from "../lib/gentle-shell-bundled.ts";
 import * as native from "../lib/runtime-metrics-native.ts";
 import { parseAgentClass, type RuntimeMetricBucket } from "../lib/runtime-metrics.ts";
 import { createHash } from "node:crypto";
@@ -273,3 +276,30 @@ test("spawn failure silently discards", async () => {
 		spawn: () => { calls++; throw new Error("private error"); } }), "discarded");
 	assert.equal(calls, 1);
 });
+
+// S9: this package running from a bundled install (the testing overlay stands
+// in for its location; the detection itself is tested with real installs in
+// gentle-ai-binary-isolation.test.ts) and the launcher's GENTLE_SHELL_PREFIX.
+function bundledIsolation(t: { after: (fn: () => void) => void }): { prefix: string; env: NodeJS.ProcessEnv } {
+	const prefix = realpathSync(mkdtempSync(join(tmpdir(), "gentle-ai-isolation-site-")));
+	setBundledInstallForTesting({ root: prefix });
+	t.after(() => {
+		setBundledInstallForTesting(undefined);
+		rmSync(prefix, { recursive: true, force: true });
+	});
+	return { prefix, env: { PATH: "/usr/bin", GENTLE_SHELL_PREFIX: prefix } };
+}
+
+test("the one-shot send runs gentle-ai with Gentle AI's isolation variables only in a bundled install", async (t) => {
+	const { prefix, env } = bundledIsolation(t);
+	for (const [given, home] of [[env, join(prefix, "gentle-ai")], [{ PATH: "/usr/bin" }, undefined]] as const) {
+		const f = fixture();
+		const pending = native.sendNativeRuntimeEvent([], "/fixture", { ...f.deps, env: given });
+		const options = f.calls[0][2] as { env: NodeJS.ProcessEnv };
+		assert.equal(options.env.GENTLE_AI_HOME, home);
+		if (home === undefined) assert.equal(options.env, given, "the environment is passed unchanged");
+		else assert.equal(options.env.GENTLE_AI_NO_SELF_UPDATE, "1");
+		f.close();
+		assert.equal(await pending, "stored");
+	}
+});

package/tests/selection-engine.test.ts

@@ -2,11 +2,16 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { GentlePromptEditor } from "../extensions/gentle-shell.ts";
-import { SelectionEngine } from "../lib/selection-engine.ts";
+import { SelectionEngine, withReverseSpan } from "../lib/selection-engine.ts";
 import { decodePrintableKey } from "../lib/pi-tui-keys.ts";
-import { CURSOR_MARKER, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, stripTerminalSequences as stripAnsi, TuiMainScreen, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
-import { stripAnsi } from "../lib/terminal-theme.ts";
+import { withPromptHint } from "../lib/shell-prompt.ts";
+
+function resolveFakeCursors(rows: string[], hardware = false): string[] {
+	const host = TuiMainScreen.prototype as unknown as { resolveFakeCursors(rows: string[]): string[] };
+	return host.resolveFakeCursors.call({ showHardwareCursor: hardware }, rows);
+}
 
 // Native selection engine tests: drive a real CustomEditor through the
 // SelectionEngine the same way GentlePromptEditor wires it — engine.handleInput
@@ -45,6 +50,30 @@ const click = (x: number, y: number, width: number): TuiMouseEvent => ({
 	type: "click", button: "left", x, y, width, height: 30, screenX: x, screenY: y, shift: false, alt: false, ctrl: false,
 });
 
+test("legacy and APC cursors preserve native selection and empty hints", () => {
+	const legacy = `${CURSOR_MARKER}\x1b[7ma\x1b[0mbc`;
+	assert.equal(withReverseSpan(legacy, 0, 3), `\x1b[7m${CURSOR_MARKER}\x1b[7ma\x1b[0m\x1b[7mbc\x1b[27m`);
+	const apc = `${CURSOR_MARKER}\x1b_pi:fc\x07a\x1b_pi:/fc\x07bc`;
+	const selected = withReverseSpan(apc, 0, 3);
+	assert.ok(selected.includes(`${CURSOR_MARKER}\x1b_pi:fc\x07`));
+	for (const hardware of [false, true]) {
+		const resolved = resolveFakeCursors([selected], hardware)[0];
+		assert.ok(resolved.includes("\x1b[7mbc\x1b[27m"));
+		assert.equal(stripAnsi(resolved), "abc");
+	}
+	// Outside selection the host still suppresses only the focused fake cursor.
+	assert.equal(resolveFakeCursors([apc], true)[0], `${CURSOR_MARKER}abc`);
+	assert.ok(resolveFakeCursors([apc.replace(CURSOR_MARKER, "")], true)[0].includes("\x1b[7ma\x1b[27m"));
+	for (const cursor of ["\x1b[7m \x1b[0m", "\x1b_pi:fc\x07 \x1b_pi:/fc\x07"]) {
+		const row = `${CURSOR_MARKER}${cursor}${" ".repeat(30)}`;
+		const hinted = withPromptHint(row, "type here", (_role, text) => text);
+		assert.ok(hinted.startsWith(`${CURSOR_MARKER}${cursor}`));
+		assert.ok(hinted.includes("type here"));
+		assert.equal(visibleWidth(hinted), visibleWidth(row));
+		assert.equal(withPromptHint(row + "draft", "type here", (_role, text) => text), row + "draft");
+	}
+});
+
 test("T2 float prompt native cursor, selection, replacement and mouse share geometry", () => {
 	const previous = cardStyle();
 	setCardStyle(CARD_STYLE.FLOAT);
@@ -56,11 +85,12 @@ test("T2 float prompt native cursor, selection, replacement and mouse share geom
 		let rows = editor.render(80);
 		assert.match(rows[0], /\x1b\[35m▎\x1b\[39m/);
 		assert.equal(visibleWidth(rows[1].split(CURSOR_MARKER)[0]), 6);
-		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b[7md\x1b[0m\x1b[44m`));
+		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b_pi:fc\x07d\x1b_pi:/fc\x07`));
+		assert.ok(resolveFakeCursors(rows)[1].includes(`${CURSOR_MARKER}\x1b[7md\x1b[27m`));
 		editor.handleInput("\x1b[1;2H");
 		rows = editor.render(80);
 		assert.equal(stripAnsi(rows[1].replaceAll(CURSOR_MARKER, "")).trim(), "▎ abcd");
-		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b[7ma\x1b[0m\x1b[44m\x1b[7mbc\x1b[27md`), "native selection inversion survives the software cursor reset");
+		assert.ok(rows[1].includes(`${CURSOR_MARKER}\x1b_pi:fc\x07a\x1b_pi:/fc\x07\x1b[7mbc\x1b[27md`), "native selection inversion survives the deferred software cursor reset");
 		assert.match(rows[2], /3 chars selected/);
 		assert.doesNotMatch(rows[2], /╯/);
 		assert.ok(rows[2].includes("\x1b[44m"));
@@ -168,6 +198,36 @@ test("alt+a selects all; backspace replaces the whole text", () => {
 	assert.equal(cursorOf(editor).line, 0);
 });
 
+test("alt+e selects all; backspace replaces the whole text", () => {
+	const editor = makeEditor();
+	const engine = new SelectionEngine(editor);
+	const native = (d: string) => editor.handleInput(d);
+	editor.setText("abc\ndef");
+	engine.handleInput("\x1be", native);
+	engine.handleInput(BACKSPACE, native);
+	assert.equal(editor.getText(), "");
+});
+
+// gentle-shell#1565: a registered extension shortcut owns its chord before
+// any selection key, matching CustomEditor's own precedence.
+test("selection chords yield to a claiming shortcut and keep selecting otherwise", () => {
+	const editor = makeEditor();
+	const engine = new SelectionEngine(editor);
+	const forwarded: string[] = [];
+	const native = (d: string) => { forwarded.push(d); editor.handleInput(d); };
+	const probed: string[] = [];
+	const shortcut = (d: string) => { probed.push(d); return d === ALT_A; };
+	editor.setText("abc");
+	engine.handleInput(ALT_A, native, shortcut);
+	assert.deepEqual(probed, [ALT_A]);
+	assert.deepEqual(forwarded, []);
+	engine.handleInput(BACKSPACE, native, shortcut);
+	assert.equal(editor.getText(), "ab", "a claimed chord must not select");
+	engine.handleInput("\x1be", native, shortcut);
+	engine.handleInput(BACKSPACE, native, shortcut);
+	assert.equal(editor.getText(), "", "an unclaimed chord still selects");
+});
+
 test("movement collapses the selection; later delete behaves natively", () => {
 	const editor = makeEditor();
 	const engine = new SelectionEngine(editor);

package/tests/session-change-capture.test.ts

@@ -4,7 +4,7 @@ import { mkdtemp, writeFile, rm, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { installSessionChangeCapture, publishForeignSessionChange } from "../lib/session-change-capture.ts";
-import { SessionChanges, SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+import { SessionChanges, SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
 
 async function fixture(run: (f: any) => Promise<void>, child = false) {
 	const root = await realpath(await mkdtemp(join(tmpdir(), "change-capture-")));
@@ -50,8 +50,9 @@ test("successful writes capture only the exact tool target and persist for reloa
 	assert.equal(entries[0].customType,SESSION_CHANGE_ENTRY);
 	await writeFile(join(root,"file"),"later human output\n");
 	const changes = new SessionChanges("session",entries);
-	assert.match(changes.loadDiff(root,changes.model.files[0]),/\+agent output/);
-	assert.doesNotMatch(changes.loadDiff(root,changes.model.files[0]),/later human/);
+	assert.match(entries[0].data.evidence.after.text,/agent output/);
+	assert.doesNotMatch(entries[0].data.evidence.after.text,/later human/);
+	assert.equal(changes.model.files.length,1);
 }));
 
 test("failed and stale-session tool outcomes never add session changes", async () => fixture(async ({root,fire,entries,switchSession}) => {
@@ -78,9 +79,9 @@ test("child carries bounded evidence in the existing tool-result details transpo
 	assert.deepEqual(entries,[]);
 },true));
 
-test("the capture-limit warning is emitted once, not on every later write", async () => fixture(async ({root,fire,pi}) => {
-	const events: Array<{notice?: string}> = [];
-	pi.events.on(SESSION_CHANGE_EVENT, (data: {notice?: string}) => events.push(data));
+test("capture caps bound session entries without a Changes notice", async () => fixture(async ({root,entries,fire,pi}) => {
+	const events: unknown[] = [];
+	pi.events.on("gentle-pi:session-change", (data: unknown) => events.push(data));
 	for (let i = 0; i < 80; i++) {
 		const path = `f${i}`;
 		const content = "x".repeat(60 * 1024) + "\n";
@@ -90,8 +91,7 @@ test("the capture-limit warning is emitted once, not on every later write", asyn
 		await fire("tool_result",{...event,isError:false});
 		await fire("tool_execution_end",{toolCallId:`w${i}`,toolName:"write",isError:false});
 	}
-	const withNotice = events.filter(event => event.notice !== undefined);
-	assert.equal(withNotice.length,1);
-	assert.match(withNotice[0].notice!,/limit reached/);
-	assert.equal(events.length,80);
+	const persisted = entries.filter(entry => entry.customType === SESSION_CHANGE_ENTRY).length;
+	assert.ok(persisted > 0 && persisted < 80, `the session byte cap stops persisting evidence (${persisted})`);
+	assert.deepEqual(events, [], "Changes reads Git; capture emits no refresh or limit notice");
 }));

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

@@ -1,9 +1,19 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import shell from "../extensions/gentle-shell.ts";
-import { SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import shell, { shellGitRunner } from "../extensions/gentle-shell.ts";
+import { SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
+import { SESSION_WORKTREE_ENTRY } from "../lib/session-worktree-registry.ts";
 
-function fixture(entries: any[] = []) {
+// /gentle:changes shows the current Git state (working tree vs HEAD, untracked
+// included) of the session's repository and of every worktree its subagents
+// used. Captured write/edit evidence only names roots; Git names the files.
+
+type Runner = (root: string) => (args: string[]) => Promise<{ stdout: string; code: number }>;
+function fixture(entries: any[] = [], options: { root?: string; sessionId?: string; gitRunner?: Runner; pollMs?: number } = {}) {
 	const handlers = new Map<string, Function[]>(), listeners = new Map<string, Function[]>();
 	const commands = new Map<string, any>(), widgets = new Map<string, any>();
 	let gitCalls = 0;
@@ -11,55 +21,239 @@ function fixture(entries: any[] = []) {
 		events: { on: (key, fn) => { listeners.set(key,[...(listeners.get(key) ?? []), fn]); return () => {}; }, emit: (key,data) => listeners.get(key)?.forEach(fn=>fn(data)) },
 		appendEntry: (customType,data) => entries.push({type:"custom",customType,data}), registerTool() {}, registerShortcut() {}, registerMessageRenderer() {},
 		registerCommand: (key, registration) => commands.set(key,registration) };
-	const notices: string[] = [];
-	const ctx: any = { hasUI:true, cwd:"/repo", sessionManager:{getSessionId:()=>"session",getEntries:()=>entries},
-		ui: { setFooter() {}, getEditorComponent:()=>({}), setWorkingVisible() {}, setWidget:(key,value)=>widgets.set(key,value), notify:(text)=>notices.push(text) } };
-	shell(pi,{}, {resolveWorktree:()=>({root:"/repo",commonDir:"/git"}),devBinary:()=>undefined,
-		gitRunner:()=>async()=>{gitCalls++; return await new Promise<any>(()=>{});} });
+	const notices: string[] = [], levels: string[] = [];
+	const root = options.root ?? "/repo";
+	const sessionId = options.sessionId ?? "session";
+	const overlay: { view?: any; close?: () => void } = {};
+	const ctx: any = { hasUI:true, cwd:root, sessionManager:{getSessionId:()=>sessionId,getEntries:()=>entries},
+		ui: { setFooter() {}, getEditorComponent:()=>({}), setWorkingVisible() {}, setWidget:(key,value)=>value===undefined?widgets.delete(key):widgets.set(key,value), notify:(text,level)=>{ notices.push(text); levels.push(level); },
+			custom:(factory:any)=>new Promise(resolve=>{ overlay.close=()=>resolve(null); overlay.view=factory({terminal:{rows:40,columns:200},requestRender(){}},{fg:(_c:string,t:string)=>t,bold:(t:string)=>t},{},resolve); }) } };
+	shell(pi,{GENTLE_PI_SHELL_CHANGES_POLL_MS:String(options.pollMs ?? 60_000)}, {resolveWorktree:()=>({root,commonDir:root+"/.git"}),devBinary:()=>undefined,
+		gitRunner:(cwd)=>async(args)=>{gitCalls++; return options.gitRunner ? options.gitRunner(cwd)(args) : await new Promise<any>(()=>{});} });
 	const fire=async(key,event={})=>{for(const fn of handlers.get(key)??[]) await fn(event,ctx);};
-	return {pi,ctx,entries,notices,commands,widgets,fire,gitCalls:()=>gitCalls};
+	// Opens the panel and closes it again: its groups (root, branch, files)
+	// and the rendered group rows.
+	const panel=async()=>{
+		overlay.view=undefined;
+		const opened=commands.get("gentle:changes").handler("",ctx);
+		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}));
+		overlay.close!(); await opened;
+		return {text,trees,files:trees.flatMap(tree=>tree.files)};
+	};
+	return {pi,ctx,entries,notices,levels,commands,widgets,fire,panel,overlay,gitCalls:()=>gitCalls};
+}
+
+function tempRepo(t: { after(fn: () => void): void }, name = "gentle-changes-") {
+	const root = realpathSync(mkdtempSync(join(tmpdir(), name)));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const git = (...args: string[]) => execFileSync("git", ["-C", root, "-c", "user.name=test", "-c", "user.email=test@example.com", "-c", "commit.gpgsign=false", ...args], { encoding: "utf8" });
+	git("init", "-q", "--initial-branch=main");
+	writeFileSync(join(root, "file.ts"), "base\n");
+	git("add", "file.ts"); git("commit", "-q", "-m", "base");
+	return { root, git };
 }
-test("Gentle Shell startup never waits for a repository scan",async()=>{
-	const f=fixture();
-	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked by Git inventory")),100))]);
-	assert.equal(f.gitCalls(),0);
-	await f.commands.get("gentle:changes").handler("",f.ctx);
-	assert.match(f.notices.join("\n"),/captured.*agent|agent.*changes/i);
+const sessionRoot = (root: string, evidence = "session:cwd", sessionId = "session") => ({ type: "custom", customType: SESSION_WORKTREE_ENTRY, data: { sessionId, root, evidence } });
+const captured = (root: string, id: string, path = "file.ts", sessionId = "session") => ({ type: "custom", customType: SESSION_CHANGE_ENTRY,
+	data: { sessionId, evidence: { id, root, path, before: { kind: "text", text: "base\n" }, after: { kind: "text", text: "agent\n" } } } });
+const settle = async () => { for (let i = 0; i < 40; i++) await new Promise(resolve => setTimeout(resolve, 5)); };
+const real: Runner = (cwd) => shellGitRunner(cwd);
+
+test("Gentle Shell startup never waits for a repository scan", async () => {
+	const f = fixture([sessionRoot("/repo"), captured("/repo", "a")]);
+	await Promise.race([f.fire("session_start"), new Promise((_, reject) => setTimeout(() => reject(new Error("startup blocked by Git inventory")), 100))]);
+	assert.equal(f.gitCalls(), 0, "session_start never runs Git");
+	assert.equal(f.widgets.has("gentle-shell-changes"), false, "the list fills only after a turn end or panel open");
 	await f.fire("session_shutdown");
 });
-test("reload and new evidence refresh Changes without Git or live file reads",async()=>{
-	const f=fixture([{type:"custom",customType:SESSION_CHANGE_ENTRY,data:{sessionId:"session",evidence:{id:"child:1",root:"/repo",path:"own.ts",before:{kind:"absent"},after:{kind:"text",text:"own\n"}}}}]);
-	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked")),100))]);
-	f.pi.events.emit(SESSION_CHANGE_EVENT,{sessionId:"session"});
-	await new Promise(resolve=>setImmediate(resolve));
-	assert.equal(f.gitCalls(),0);
-	assert.equal(typeof f.widgets.get("gentle-shell-changes"),"function");
+
+test("the orchestrator repository's dirty file is listed, and leaves once committed", async (t) => {
+	const repo = tempRepo(t);
+	writeFileSync(join(repo.root, "file.ts"), "human or agent, Git decides\n");
+	writeFileSync(join(repo.root, "new.ts"), "one\ntwo\n");
+	const f = fixture([], { root: repo.root, gitRunner: real });
+	await f.fire("session_start");
+	assert.equal(f.gitCalls(), 0);
+	await f.fire("agent_end"); await settle();
+	assert.equal(f.widgets.has("gentle-shell-changes"), true, "uncaptured working-tree changes are listed");
+	const panel = await f.panel();
+	assert.deepEqual(panel!.trees.map(tree => [tree.root, tree.files, tree.added, tree.deleted]), [[repo.root, ["file.ts", "new.ts"], 3, 1]], "untracked files count their lines");
+	repo.git("add", "-A"); repo.git("commit", "-q", "-m", "work");
+	await f.fire("agent_end"); await settle();
+	assert.equal(f.widgets.has("gentle-shell-changes"), false, "committed work leaves the widget and the counter");
+	assert.equal(await f.panel(), undefined);
+	assert.match(f.notices.join("\n"), /No uncommitted changes/);
 	await f.fire("session_shutdown");
 });
-test("the changes overlay labels each session tree with its root's branch instead of detached",async()=>{
-	const evidence=(root:string,id:string)=>({type:"custom",customType:SESSION_CHANGE_ENTRY,data:{sessionId:"session",evidence:{id,root,path:"own.ts",before:{kind:"absent"},after:{kind:"text",text:"own\n"}}}});
-	const entries=[evidence("/repo","child:1"),evidence("/other","child:2")];
-	const handlers=new Map<string,Function[]>();
-	const commands=new Map<string,any>();
-	const gitRoots:string[]=[];
-	const pi:any={on:(key,fn)=>handlers.set(key,[...(handlers.get(key)??[]),fn]),events:{on:()=>()=>{},emit(){}},appendEntry(){},registerTool(){},registerShortcut(){},registerMessageRenderer(){},registerCommand:(key,registration)=>commands.set(key,registration)};
-	let view:any; let renders=0;
-	const ctx:any={hasUI:true,cwd:"/repo",sessionManager:{getSessionId:()=>"session",getEntries:()=>entries},
-		ui:{setFooter(){},getEditorComponent:()=>({}),setWorkingVisible(){},setWidget(){},notify(){},
-			custom:async(factory:any)=>{view=factory({terminal:{rows:40,columns:120},requestRender:()=>renders++},{fg:(_c:string,t:string)=>t,bold:(t:string)=>t},{},()=>{});return new Promise(()=>{});}}};
-	shell(pi,{},{resolveWorktree:()=>({root:"/repo",commonDir:"/git"}),devBinary:()=>undefined,
-		gitRunner:(root:string)=>async(args:string[])=>{gitRoots.push(root);await new Promise(r=>setImmediate(r));
-			if(args[0]==="symbolic-ref")return root==="/repo"?{stdout:"feature\n",code:0}:{stdout:"",code:1};
-			return {stdout:"deadbeef\n",code:0};}});
-	for(const fn of handlers.get("session_start")??[])await fn({},ctx);
-	void commands.get("gentle:changes").handler("",ctx);
-	await new Promise(r=>setImmediate(r));
-	assert.ok(view,"the overlay opened");
-	for(let i=0;i<6;i++)await new Promise(r=>setImmediate(r));
-	const rendered=view.render(120).join("\n");
-	assert.match(rendered,/feature · repo/,"the repo tree carries its branch");
-	assert.match(rendered,/detached · other/,"a genuinely detached root still reads detached");
-	assert.deepEqual([...new Set(gitRoots)].sort(),["/other","/repo"],"git is asked once per root, only while the overlay is open");
-	assert.ok(renders>0,"a resolved label asks the overlay to repaint");
-	for(const fn of handlers.get("session_shutdown")??[])await fn({},ctx);
+
+test("a subagent worktree is its own group and disappears once the worktree is removed", async (t) => {
+	const repo = tempRepo(t);
+	const linked = join(realpathSync(mkdtempSync(join(tmpdir(), "gentle-changes-wt-"))), "linked");
+	t.after(() => rmSync(join(linked, ".."), { recursive: true, force: true }));
+	repo.git("worktree", "add", "-q", "-b", "agent-branch", linked);
+	writeFileSync(join(repo.root, "file.ts"), "orchestrator\n");
+	writeFileSync(join(linked, "worker.ts"), "worker\n");
+	const f = fixture([sessionRoot(repo.root), sessionRoot(linked, "subagent:spawn")], { root: repo.root, gitRunner: real });
+	await f.fire("session_start");
+	const panel = await f.panel();
+	assert.deepEqual(panel!.trees.map(tree => [tree.root, tree.branch, tree.files]).sort(), [[linked, "agent-branch", ["worker.ts"]], [repo.root, "main", ["file.ts"]]].sort(), "one group per root, each with its own branch");
+	assert.match(panel!.text, /agent-branch · linked/);
+	repo.git("worktree", "remove", "--force", linked);
+	await f.fire("agent_end"); await settle();
+	const after = await f.panel();
+	assert.deepEqual(after!.trees.map(tree => tree.root), [repo.root], "a removed worktree leaves without error");
+	assert.doesNotMatch(f.notices.join("\n"), /Git status failed|Could not read/, "a removed worktree is not a failed scan");
+	await f.fire("session_shutdown");
+});
+
+test("captured evidence only names a subagent's independent repository; Git names its files", async (t) => {
+	const repo = tempRepo(t);
+	const foreign = tempRepo(t, "gentle-changes-foreign-");
+	writeFileSync(join(foreign.root, "real.ts"), "dirty\n");
+	// The captured path is clean in Git, so it is not listed.
+	const f = fixture([sessionRoot(repo.root), captured(foreign.root, "child:1", "file.ts")], { root: repo.root, gitRunner: real });
+	await f.fire("session_start");
+	const panel = await f.panel();
+	assert.deepEqual(panel!.trees.map(tree => [tree.root, tree.files]), [[foreign.root, ["real.ts"]]]);
+	await f.fire("session_shutdown");
+});
+
+test("reload and new sessions read the same state from Git, without stale entries", async (t) => {
+	const repo = tempRepo(t);
+	const linked = join(realpathSync(mkdtempSync(join(tmpdir(), "gentle-changes-wt-"))), "linked");
+	t.after(() => rmSync(join(linked, ".."), { recursive: true, force: true }));
+	repo.git("worktree", "add", "-q", linked);
+	writeFileSync(join(repo.root, "file.ts"), "agent\n");
+	writeFileSync(join(linked, "file.ts"), "worker\n");
+	const entries = [sessionRoot(repo.root), sessionRoot(linked, "subagent:spawn"), captured(repo.root, "a"), captured(repo.root, "b", "gone.ts")];
+	repo.git("commit", "-q", "-am", "orchestrator work");
+	const reloaded = fixture(entries, { root: repo.root, gitRunner: real });
+	await reloaded.fire("session_start");
+	assert.equal(reloaded.gitCalls(), 0);
+	const panel = await reloaded.panel();
+	assert.deepEqual(panel!.trees.map(tree => [tree.root, tree.files]), [[linked, ["file.ts"]]], "committed and captured-only files are not listed after reload");
+	await reloaded.fire("session_shutdown");
+	const next = fixture([...entries], { root: repo.root, sessionId: "new-session", gitRunner: real });
+	await next.fire("session_start");
+	assert.equal(await next.panel(), undefined, "another session's worktrees are not inherited");
+	assert.match(next.notices.join("\n"), /No uncommitted changes/);
+	await next.fire("session_shutdown");
+});
+
+test("a failing Git root is omitted while the other roots stay listed", async (t) => {
+	const repo = tempRepo(t);
+	const broken = tempRepo(t, "gentle-changes-broken-");
+	writeFileSync(join(repo.root, "file.ts"), "agent\n");
+	writeFileSync(join(broken.root, "file.ts"), "agent\n");
+	const failing: Runner = (cwd) => cwd === broken.root ? async () => { throw new Error("git timed out"); } : shellGitRunner(cwd);
+	const f = fixture([sessionRoot(repo.root), sessionRoot(broken.root, "explicit")], { root: repo.root, gitRunner: failing });
+	await f.fire("session_start");
+	await f.fire("agent_end"); await settle();
+	const panel = await f.panel();
+	assert.deepEqual(panel!.trees.map(tree => [tree.root, tree.files]), [[repo.root, ["file.ts"]]]);
+	assert.match(f.notices.join("\n"), /Git status failed for 1 root\b/, "the panel reports the failed root");
+	await f.fire("session_shutdown");
+});
+
+// A root whose `git status` exits nonzero is a failed scan, never a clean
+// root: when it is the only root the panel must not claim a clean tree.
+const statusFailsAt = (broken: string): Runner => (cwd) => cwd === broken ? async (args) => args[0] === "status" ? { stdout: "", code: 128 } : shellGitRunner(cwd)(args) : shellGitRunner(cwd);
+
+test("when every scanned root fails, Changes reports an error instead of a clean tree", async (t) => {
+	const repo = tempRepo(t);
+	writeFileSync(join(repo.root, "file.ts"), "agent\n");
+	const f = fixture([sessionRoot(repo.root)], { root: repo.root, gitRunner: statusFailsAt(repo.root) });
+	await f.fire("session_start");
+	assert.equal(await f.panel(), undefined);
+	assert.doesNotMatch(f.notices.join("\n"), /No uncommitted changes/);
+	assert.match(f.notices.join("\n"), /Could not read Git status for 1 root\b/);
+	assert.equal(f.levels.at(-1), "error");
+	await f.fire("session_shutdown");
+});
+
+test("a clean root next to a failed one reports the failure count, not a plain clean tree", async (t) => {
+	const repo = tempRepo(t);
+	const broken = tempRepo(t, "gentle-changes-broken-");
+	const f = fixture([sessionRoot(repo.root), sessionRoot(broken.root, "explicit")], { root: repo.root, gitRunner: statusFailsAt(broken.root) });
+	await f.fire("session_start");
+	assert.equal(await f.panel(), undefined);
+	assert.match(f.notices.join("\n"), /Git status failed for 1 of 2 roots/);
+	assert.equal(f.levels.at(-1), "warning");
+	await f.fire("session_shutdown");
+});
+
+test("a dirty root next to a failed one opens the panel and reports the failure count", async (t) => {
+	const repo = tempRepo(t);
+	const broken = tempRepo(t, "gentle-changes-broken-");
+	writeFileSync(join(repo.root, "file.ts"), "agent\n");
+	writeFileSync(join(broken.root, "file.ts"), "agent\n");
+	const f = fixture([sessionRoot(repo.root), sessionRoot(broken.root, "explicit")], { root: repo.root, gitRunner: statusFailsAt(broken.root) });
+	await f.fire("session_start");
+	const panel = await f.panel();
+	assert.deepEqual(panel!.trees.map(tree => [tree.root, tree.files]), [[repo.root, ["file.ts"]]]);
+	assert.match(f.notices.join("\n"), /Git status failed for 1 root\b/);
+	await f.fire("session_shutdown");
+});
+
+test("every changed file is listed without a capture limit", async (t) => {
+	const repo = tempRepo(t);
+	mkdirSync(join(repo.root, "many"));
+	for (let i = 0; i < 300; i++) writeFileSync(join(repo.root, "many", `${i}.ts`), "x\n");
+	const f = fixture([], { root: repo.root, gitRunner: real });
+	await f.fire("session_start");
+	const panel = await f.panel();
+	assert.equal(panel!.files.length, 300);
+	assert.equal(panel!.trees[0].added, 300);
+	assert.equal(f.widgets.has("gentle-shell-changes"), true);
+	assert.doesNotMatch(panel!.text, /limit/);
+	assert.doesNotMatch(f.notices.join("\n"), /limit/);
+	await f.fire("session_shutdown");
+});
+
+test("the open panel diffs the selected file against HEAD and reloads a same-count edit", async (t) => {
+	const repo = tempRepo(t);
+	writeFileSync(join(repo.root, "file.ts"), "first\n");
+	writeFileSync(join(repo.root, "new.ts"), "hello\n");
+	const f = fixture([], { root: repo.root, gitRunner: real, pollMs: 20 });
+	await f.fire("session_start");
+	const opened = f.commands.get("gentle:changes").handler("", f.ctx);
+	for (let i = 0; i < 200 && !f.overlay.view; i++) await new Promise(resolve => setTimeout(resolve, 5));
+	const view = f.overlay.view;
+	const shows = async (pattern: RegExp) => {
+		for (let i = 0; i < 100 && !pattern.test(view.render(200).join("\n")); i++) await new Promise(resolve => setTimeout(resolve, 10));
+		return view.render(200).join("\n");
+	};
+	try {
+		view.handleInput("\r");
+		view.handleInput("j");
+		assert.match(await shows(/\+first/), /-base/, "tracked files diff against HEAD");
+		view.handleInput("j");
+		assert.match(await shows(/\+hello/), /\+hello/, "untracked files show their full content");
+		view.handleInput("k");
+		await new Promise(resolve => setTimeout(resolve, 20));
+		writeFileSync(join(repo.root, "file.ts"), "secnd\n");
+		assert.match(await shows(/\+secnd/), /\+secnd/, "the poll reloads a same-count edit");
+	} finally { f.overlay.close!(); await opened; await f.fire("session_shutdown"); }
+});
+
+// A repository rooted at HOME (or a broad user folder) makes `git status` scan
+// the user's whole tree: Changes never scans such a root, at turn end or in
+// the panel, matching the startup warning that tells the user to move.
+test("a repository rooted at HOME is never scanned by Changes", async (t) => {
+	const repo = tempRepo(t, "gentle-changes-home-");
+	writeFileSync(join(repo.root, "file.ts"), "dirty at home\n");
+	const previousHome = process.env.HOME;
+	process.env.HOME = repo.root;
+	t.after(() => { if (previousHome === undefined) delete process.env.HOME; else process.env.HOME = previousHome; });
+	const f = fixture([sessionRoot(repo.root)], { root: repo.root, gitRunner: real });
+	await f.fire("session_start");
+	await f.fire("agent_end"); await settle();
+	assert.equal(f.gitCalls(), 0, "no Git runs against a home-rooted repository");
+	assert.equal(f.widgets.has("gentle-shell-changes"), false);
+	assert.equal(await f.panel(), undefined);
+	assert.equal(f.gitCalls(), 0);
+	assert.doesNotMatch(f.notices.join("\n"), /Git status failed|Could not read/, "a filtered home root is not a failed scan");
+	await f.fire("session_shutdown");
 });

package/tests/session-changes.test.ts

@@ -3,15 +3,16 @@ import test from "node:test";
 import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { SessionChanges, readChangeSnapshot, SESSION_CHANGE_ENTRY, MAX_CHANGE_BYTES } from "../lib/session-changes.ts";
+import { SessionChanges, readChangeSnapshot, sessionChangeRoots, SESSION_CHANGE_ENTRY, MAX_CHANGE_BYTES } from "../lib/session-changes.ts";
+import { SESSION_WORKTREE_ENTRY } from "../lib/session-worktree-registry.ts";
 
 const text = (text: string) => ({ kind: "text" as const, text });
 const absent = { kind: "absent" as const };
 const evidence = (id = "a", root = "/repo", path = "file.ts", before = text("old\n"), after = text("new\n")) => ({ id, root, path, before, after });
 
-test("session changes starts empty without reading the worktree or its untracked contents", async () => {
+test("session changes starts empty without reading the worktree or its untracked contents", () => {
 	const changes = new SessionChanges("session");
-	assert.deepEqual(await changes.refresh(), { files: [], added: 0, deleted: 0 });
+	assert.deepEqual(changes.model, { files: [], added: 0, deleted: 0 });
 	assert.deepEqual(changes.worktrees, []);
 });
 
@@ -20,9 +21,7 @@ test("only attributed changes appear, against the pre-tool content rather than H
 	changes.record(evidence("a", "/repo", "file.ts", text("preexisting human edit\nold\n"), text("preexisting human edit\nnew\n")));
 	assert.equal(changes.model.files.length, 1);
 	assert.equal(changes.model.added, 1);
-	assert.equal(changes.model.deleted, 1);
-	assert.match(changes.loadDiff("/repo", changes.model.files[0]), /\+new/);
-	assert.doesNotMatch(changes.loadDiff("/repo", changes.model.files[0]), /\+preexisting/);
+	assert.equal(changes.model.deleted, 1, "the preexisting line is not counted");
 });
 
 test("diff counts include content lines that resemble patch headers", () => {
@@ -37,7 +36,7 @@ test("contiguous own edits combine and own reverts remove the file and worktree"
 	changes.record(evidence());
 	changes.record(evidence("b", "/repo", "file.ts", text("new\n"), text("final\n")));
 	assert.equal(changes.model.added, 1);
-	assert.match(changes.loadDiff("/repo", changes.model.files[0]), /\+final/);
+	assert.equal(changes.model.deleted, 1);
 	changes.record(evidence("c", "/repo", "file.ts", text("final\n"), text("old\n")));
 	assert.deepEqual(changes.worktrees, []);
 });
@@ -48,7 +47,7 @@ test("external edits between agent operations are not folded into an attributed
 	changes.record(evidence("b", "/repo", "file.ts", text("external\n"), text("agent again\n")));
 	const file = changes.model.files[0];
 	assert.match(file.countsUnavailable!, /external|continuity/i);
-	assert.doesNotMatch(changes.loadDiff("/repo", file), /\+external|\-external/);
+	assert.equal(file.added, 0);
 });
 
 test("new files and child worktrees are admitted only by positive mutation evidence", () => {
@@ -85,30 +84,24 @@ test("bounded captures mark partial counts, including the narrow widget", async
 	assert.match(renderChangesWidget(changes.model,{fg:(_color,text)=>text},75).join("\n"),/partial counts/);
 });
 
-test("same-count edits change preview revisions and malformed evidence is rejected", () => {
+test("malformed evidence is rejected", () => {
 	const changes = new SessionChanges("session");
-	changes.record(evidence());
-	const first = changes.model.files[0].diffRevision;
-	changes.record(evidence("b","/repo","file.ts",text("new\n"),text("other\n")));
-	assert.notEqual(changes.model.files[0].diffRevision,first);
 	assert.equal(changes.record({...evidence("bad"),path:"../escape"}),false);
 	assert.equal(changes.record({...evidence("bad"),path:".git/config"}),false);
 });
 
-test("capture capacity is explicit instead of growing without limit", () => {
+test("capture capacity bounds recorded evidence", () => {
 	const changes = new SessionChanges("session");
 	for(let i=0;i<257;i++) changes.record(evidence(String(i),"/repo",String(i)+".ts"));
 	assert.equal(changes.model.files.length,256);
-	assert.match(changes.notice!,/limit reached/);
+	assert.equal(changes.record(evidence("late","/repo","late.ts")),false);
 });
 
-test("capture-limit notice is delivered once but stays on the model", () => {
-	const changes = new SessionChanges("session");
-	for(let i=0;i<257;i++) changes.record(evidence(String(i),"/repo",String(i)+".ts"));
-	assert.match(changes.takeNotice()!,/limit reached/);
-	assert.equal(changes.takeNotice(),undefined);
-	assert.match(changes.notice!,/limit reached/);
-	assert.match(changes.model.notice!,/limit reached/);
-	assert.equal(new SessionChanges("s").takeNotice(),undefined);
-	assert.equal(new SessionChanges("s").model.notice,undefined);
+test("session roots come from this session's worktree registrations and captured evidence, never files", () => {
+	const registered = (sessionId: string, root: string) => ({ type: "custom", customType: SESSION_WORKTREE_ENTRY, data: { sessionId, root, evidence: "subagent:spawn" } });
+	const captured = (sessionId: string, root: string) => ({ type: "custom", customType: SESSION_CHANGE_ENTRY, data: { sessionId, evidence: evidence(root, root) } });
+	const entries = [registered("session", "/repo"), registered("session", "/linked"), captured("session", "/foreign"), captured("session", "/repo"),
+		registered("other", "/elsewhere"), captured("other", "/theirs"), registered("session", "relative"), { type: "custom", customType: SESSION_CHANGE_ENTRY, data: { sessionId: "session", evidence: { root: "/bad" } } }];
+	assert.deepEqual(sessionChangeRoots("session", entries), ["/repo", "/linked", "/foreign"]);
+	assert.deepEqual(sessionChangeRoots("missing", entries), []);
 });