gentle-pi 4.1.0 → 4.3.0

package/tests/session-subject-routing-contract.test.ts

@@ -8,7 +8,8 @@ const source = readFileSync(join(root, "extensions/gentle-agents.ts"), "utf8");
 const match = source.match(/name: "orchestrator_session_id",\s*label: "[^"]+",\s*description: ("(?:[^"\\]|\\.)*")/);
 assert.ok(match, "Registered session tool must expose a public description");
 const description: string = JSON.parse(match[1]);
-const detail = readFileSync(join(root, "assets/orchestrator-delegation.md"), "utf8")
+// S11 T2: the session subject rules moved from the delegation card to its reference.
+const detail = readFileSync(join(root, "assets/orchestrator-delegation-reference.md"), "utf8")
 	.split("## Session subject and display identity\n")[1].split("### Publish and find classified work")[0];
 const docs = readFileSync(join(root, "docs/gentle-agents-activity.md"), "utf8")
 	.split("### Declare a recognizable subject\n")[1].split("### Publish curated state")[0];

package/tests/shell-bar.test.ts

@@ -219,6 +219,13 @@ test("renderShellBar renders one line with the segments in order", () => {
 	);
 });
 
+test("renderShellBar paints the context gauge with the given gauge roles", () => {
+	const [line] = renderShellBar(model(), taggedTheme, 400, undefined, { ok: "gaugeOk", empty: "gaugeEmpty" });
+	assert.match(line, /<gaugeOk>▰▰▰▰<\/gaugeOk><gaugeEmpty>▱▱▱▱<\/gaugeEmpty>/);
+	const [fallback] = renderShellBar(model(), taggedTheme, 400);
+	assert.match(fallback, /<accent>▰▰▰▰<\/accent><border>▱▱▱▱<\/border>/);
+});
+
 test("renderShellBar colors the brand, model, effort, and gauge by role", () => {
 	const [line] = renderShellBar(model(), taggedTheme, 400);
 	assert.match(line, /<accent>✿ gentle shell<\/accent>/);

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

@@ -4,6 +4,7 @@ import { TuiAltScreen, visibleWidth, type Terminal, type TuiMouseEvent } from "@
 import { CHANGE_STATUS, DIFF_TOO_LARGE, changesModel, type ChangedFile } from "../lib/shell-changes.ts";
 import { WorktreeChangesView, ChangesView, colorDiff, type ChangesViewDeps } from "../lib/shell-changes-view.ts";
 import { stripAnsi } from "../lib/terminal-theme.ts";
+import { createNativeFullscreenInteraction } from "../lib/native-fullscreen-interaction.ts";
 
 // The changes overlay: files on the left, the selected file's diff on the
 // right, keys at the bottom. Rendering is pure; git access is injected.
@@ -458,7 +459,7 @@ const statusCases = [
 	[CHANGE_STATUS.ADDED, "A", 3, 0],
 	[CHANGE_STATUS.DELETED, "D", 0, 4],
 	[CHANGE_STATUS.RENAMED, "R", 0, 0],
-	[CHANGE_STATUS.UNTRACKED, "??", 5, 0],
+	[CHANGE_STATUS.UNTRACKED, "U", 5, 0],
 ] as const;
 
 for (const [status, code, added, deleted] of statusCases) {
@@ -757,3 +758,138 @@ test("ChangesView.update keeps the selected file, reloads moved diffs, and survi
 	component.handleInput("j");
 	component.handleInput("o");
 });
+
+// Diff-only mode (F): the file column and its separator leave so the diff
+// spans the whole inner width; j/k still walk files, esc returns first.
+function diffOnlyView(overrides: { rows?: number; loadDiff?: (root: string, target: ChangedFile) => Promise<string> } = {}) {
+	const trees = [
+		{ root: "/main", branch: "main", model: changesModel([file("a.ts", 1, 0), file("b.ts", 1, 0)]) },
+		{ root: "/linked", branch: "agent", model: changesModel([file("c.ts", 1, 0)]) },
+	];
+	const events: string[] = [];
+	const component = new WorktreeChangesView(trees, {
+		theme: plainTheme, rows: overrides.rows ?? 10,
+		loadDiff: overrides.loadDiff ?? (async (root, target) => `+${root}:${target.path} ${"x".repeat(80)}`),
+		onOpen: (root, target) => { events.push(`open:${root}:${target.path}`); },
+		onClose: () => { events.push("close"); },
+		onRefresh: () => { events.push("refresh"); },
+		requestRender() {},
+	});
+	return { component, events };
+}
+
+test("F hides the file list and its separator so the diff spans the full inner width", async () => {
+	const { component } = diffOnlyView();
+	component.handleInput("\r");
+	component.handleInput("j");
+	await settle();
+	const normal = component.render(100);
+	assert.match(normal[1]!, /^│ +▾ main · main +│ M a\.ts +│$/, "the normal view keeps the two-pane layout");
+	assert.match(stripAnsi(normal[2]!), /^│ ▸   M a\.ts .*│ \+\/main:a\.ts x+…│$/, "the narrow diff pane clips a long line");
+	assert.match(normal[8]!, /F diff only/);
+	component.handleInput("F");
+	await settle();
+	const wide = component.render(100);
+	assert.equal(wide.length, 10);
+	for (const line of wide) assert.equal(visibleWidth(line), 100);
+	assert.match(wide[1]!, /^│ M a\.ts +│$/, "the path header starts at the frame edge");
+	assert.equal(wide[2]!, `│ ${`+/main:a.ts ${"x".repeat(80)}`.padEnd(96)} │`, "the diff uses the full inner width");
+	assert.doesNotMatch(wide.slice(1, 8).join("\n"), /main · main|│.*│.*│/, "no list column and no separator remain");
+	assert.match(wide[8]!, /F files/);
+	component.handleInput("F");
+	assert.match(component.render(100)[1]!, /▾ main · main/, "F toggles back to the file list");
+});
+
+test("j/k in diff-only mode walk files across worktrees and the path header follows", async () => {
+	const { component } = diffOnlyView();
+	component.handleInput("F");
+	await settle();
+	assert.match(component.render(100)[1]!, /^│ M a\.ts +│$/, "entering on a group header jumps to its first file");
+	component.handleInput("j");
+	await settle();
+	assert.match(component.render(100)[1]!, /^│ M b\.ts +│$/);
+	component.handleInput("j");
+	await settle();
+	assert.match(component.render(100)[1]!, /^│ M c\.ts +│$/, "j crosses into the next worktree's files");
+	assert.match(component.render(100)[2]!, /\+\/linked:c\.ts/);
+	component.handleInput("j");
+	assert.match(component.render(100)[1]!, /^│ M c\.ts +│$/, "the last file stays selected");
+	component.handleInput("k");
+	await settle();
+	assert.match(component.render(100)[1]!, /^│ M b\.ts +│$/);
+	component.handleInput("j");
+	component.handleInput("\x1b");
+	assert.match(component.render(100).join("\n"), /▸   M c\.ts/, "the files view shows the file chosen in diff-only mode");
+});
+
+test("esc leaves diff-only mode before closing; q, o and r keep working there", async () => {
+	const { component, events } = diffOnlyView();
+	component.handleInput("F");
+	component.handleInput("\x1b");
+	assert.deepEqual(events, [], "the first esc only returns to the file list");
+	assert.match(component.render(100)[1]!, /main · main/);
+	component.handleInput("\x1b");
+	assert.deepEqual(events, ["close"]);
+	component.handleInput("F");
+	component.handleInput("o");
+	component.handleInput("r");
+	component.handleInput("q");
+	assert.deepEqual(events, ["close", "open:/main:a.ts", "refresh", "close"]);
+});
+
+test("diff-only mode has no list mouse zone; the wheel scrolls the widened diff", async () => {
+	const long = Array.from({ length: 30 }, (_, index) => `+line ${index}`).join("\n");
+	const { component } = diffOnlyView({ rows: 8, loadDiff: async () => `@@ -0,0 +1,30 @@\n${long}` });
+	component.handleInput("F");
+	await settle();
+	component.render(80);
+	assert.equal(component.handleMouse(mouseButton("move", "none", 3, 2, 8)), undefined, "no hover target");
+	assert.equal(component.handleMouse(mouseButton("click", "left", 3, 2, 8)), undefined, "no click target");
+	assert.match(component.render(80)[1]!, /^│ M a\.ts +│$/, "a click where the list was does not select");
+	assert.deepEqual(component.handleMouse(mouse("wheel", 3, 2, 3, 8)), { handled: true, render: true });
+	assert.doesNotMatch(component.render(80)[2]!, /@@/, "the left edge now scrolls the diff");
+	component.handleInput("\x1b");
+	component.render(80);
+	assert.deepEqual(component.handleMouse(mouse("click", 3, 3, undefined, 8)), { handled: true, render: true }, "leaving diff-only restores the list zone");
+	assert.match(component.render(80)[3]!, /▸   M b\.ts/);
+});
+
+test("the native fullscreen wrapper keeps keyboard, hover, click and wheel on the changes view", async () => {
+	let onInput: ((data: string) => void) | undefined;
+	const terminal: Terminal = {
+		start(input: Parameters<Terminal["start"]>[0]) { onInput = input; }, stop() {}, async drainInput() {}, write() {}, get columns() { return 80; }, get rows() { return 8; }, get kittyProtocolActive() { return false; }, moveBy() {}, hideCursor() {}, showCursor() {}, clearLine() {}, clearFromCursor() {}, clearScreen() {}, setTitle() {}, setProgress() {}, setProgramStatus() {},
+	};
+	const long = Array.from({ length: 30 }, (_, index) => `+line ${index}`).join("\n");
+	let renders = 0;
+	const trees = [{ root: "/main", branch: "main", model: changesModel([file("a.ts", 1, 0), file("b.ts", 1, 0)]) }];
+	const component = new WorktreeChangesView(trees, {
+		theme: { fg: (color: string, text: string) => color === "warning" ? `\x1b[33m${text}\x1b[39m` : text }, rows: 8, loadDiff: async () => `@@ -0,0 +1,30 @@\n${long}`,
+		onOpen() {}, onClose() {}, onRefresh() {}, requestRender() {},
+	});
+	const interaction = createNativeFullscreenInteraction({ keyboardTarget: component, requestRender: () => { renders++; } });
+	interaction.addChild(component);
+	const tui = new TuiAltScreen(terminal, false, undefined, { mouse: true });
+	tui.setLayoutRoot(interaction);
+	tui.start();
+	interaction.handleInput("\r");
+	assert.ok(renders > 0, "keys reach the view and request a render");
+	tui.renderNow(true);
+	try {
+		onInput?.("\x1b[<35;4;4M");
+		assert.match(interaction.render(80)[3]!, /\x1b\[33mM b\.ts/, "hover paints the row under the pointer");
+		onInput?.("\x1b[<0;4;4M");
+		onInput?.("\x1b[<0;4;4m");
+		assert.match(stripAnsi(interaction.render(80)[3]!), /▸   M b\.ts/, "a click selects the file");
+		await settle();
+		tui.renderNow(true);
+		onInput?.("\x1b[<65;60;3M");
+		assert.doesNotMatch(stripAnsi(interaction.render(80)[2]!), /@@/, "the wheel scrolls the diff");
+		interaction.handleInput("F");
+		tui.renderNow(true);
+		onInput?.("\x1b[<0;4;3M");
+		onInput?.("\x1b[<0;4;3m");
+		assert.match(stripAnsi(interaction.render(80)[1]!), /^│ M b\.ts +│$/, "diff-only mode ignores clicks where the list was");
+	} finally {
+		tui.stop();
+	}
+});

package/tests/shell-changes.test.ts

@@ -159,6 +159,24 @@ test("ChangesTracker reads the working tree on start and again on refresh", asyn
 	assert.deepEqual(calls[1], ["status", "--porcelain=v1", "--untracked-files=all", "-z"]);
 });
 
+test("ChangesTracker skips untracked dependency backups but preserves tracked edits and legitimate new files", async () => {
+	const backup = "node_modules.backup-20261007-192802/pkg/index.js";
+	const nestedBackup = "packages/app/node_modules.backup-local/pkg/index.js";
+	const tracked = "node_modules.backup-local/tracked.ts";
+	const legitimate = ["src/new.ts", "node_modules.backup-notes.md", "node_modules.backup-/new.ts"];
+	const { git } = fakeGit(
+		[`4\t2\t${tracked}\n`],
+		[[`?? ${backup}`, `?? ${nestedBackup}`, ` M ${tracked}`, ...legitimate.map((path) => `?? ${path}`)].join("\0") + "\0"],
+	);
+	const counted: string[] = [];
+	const tracker = new ChangesTracker(git, async (path) => { counted.push(path); return 3; });
+	await tracker.start();
+	assert.deepEqual(counted.sort(), [...legitimate].sort());
+	assert.deepEqual(tracker.model, changesModel([
+		file(tracked, 4, 2), ...legitimate.map((path) => file(path, 3, 0, CHANGE_STATUS.UNTRACKED)),
+	]));
+});
+
 test("ChangesTracker stays quiet outside a git repository", async () => {
 	const { git, calls } = fakeGit([""], [""], 128);
 	const tracker = new ChangesTracker(git);

package/tests/shell-gauge.test.ts

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { paintGauge, renderGauge, type GaugePaint } from "../lib/shell-gauge.ts";
+
+// Issue #2222: gauge-specific theme roles fall back to today's roles when a
+// theme does not define them, so existing themes render byte-identically.
+// (Fixtures here are unit-scoped stubs; Pi's theme schema is validated
+// separately by the loader and was checked directly against ThemeJsonSchema.)
+
+const taggedTheme = {
+	fg(color: string, text: string) {
+		return `<${color}>${text}</${color}>`;
+	},
+};
+
+test("paintGauge falls back to today's roles when no gauge roles are given", () => {
+	assert.equal(paintGauge(45, taggedTheme), `<accent>▰▰▰▰</accent><border>▱▱▱▱</border>`);
+	assert.equal(paintGauge(85, taggedTheme), `<warning>▰▰▰▰▰▰▰</warning><border>▱</border>`);
+	assert.equal(paintGauge(96, taggedTheme), `<error>▰▰▰▰▰▰▰▰</error><border></border>`);
+	assert.equal(paintGauge(null, taggedTheme), `<dim></dim><border>▱▱▱▱▱▱▱▱</border>`);
+});
+
+test("paintGauge uses the gauge-specific roles when the theme defines them", () => {
+	const roles: GaugePaint = { ok: "gaugeOk", warning: "gaugeWarning", error: "gaugeError", empty: "gaugeEmpty" };
+	assert.equal(paintGauge(45, taggedTheme, 8, roles), `<gaugeOk>▰▰▰▰</gaugeOk><gaugeEmpty>▱▱▱▱</gaugeEmpty>`);
+	assert.equal(paintGauge(85, taggedTheme, 8, roles), `<gaugeWarning>▰▰▰▰▰▰▰</gaugeWarning><gaugeEmpty>▱</gaugeEmpty>`);
+	assert.equal(paintGauge(96, taggedTheme, 8, roles), `<gaugeError>▰▰▰▰▰▰▰▰</gaugeError><gaugeEmpty></gaugeEmpty>`);
+	// A null percentage stays dim: there is nothing to gauge yet.
+	assert.equal(paintGauge(null, taggedTheme, 8, roles), `<dim></dim><gaugeEmpty>▱▱▱▱▱▱▱▱</gaugeEmpty>`);
+});
+
+test("paintGauge falls back per role, not per block", () => {
+	// A theme that defines only gaugeWarning keeps accent for the ok range.
+	assert.equal(paintGauge(45, taggedTheme, 8, { warning: "gaugeWarning" }), `<accent>▰▰▰▰</accent><border>▱▱▱▱</border>`);
+	assert.equal(paintGauge(85, taggedTheme, 8, { warning: "gaugeWarning" }), `<gaugeWarning>▰▰▰▰▰▰▰</gaugeWarning><border>▱</border>`);
+});
+
+test("renderGauge uses theme-defined glyphs when given, defaults otherwise", () => {
+	assert.equal(renderGauge(50, 4, { filled: "█", empty: "░" }), "██░░");
+	assert.equal(renderGauge(50, 4), "▰▰▱▱");
+	assert.equal(renderGauge(50, 4, { filled: "█" }), "██▱▱");
+});

package/tests/shell-todo.test.ts

@@ -9,6 +9,7 @@ import {
 	staleTurns,
 	TODO_STATUS,
 	todoPromptBlock,
+	todoStateMessage,
 	todoSummary,
 	type TodoState,
 } from "../lib/shell-todo.ts";
@@ -152,19 +153,21 @@ test("replayTodo rebuilds the latest state from Gentle and rpiv tool results ali
 	assert.deepEqual(replayTodo([]), emptyTodo());
 });
 
-test("todoPromptBlock lists open work with the rules, and stays silent when there is nothing open", () => {
-	const block = todoPromptBlock(seeded(), 0);
-	assert.ok(block);
+test("todoPromptBlock is the byte-stable rules block; todoStateMessage carries the open work (#1662)", () => {
+	const block = todoPromptBlock();
 	assert.match(block, /^## Todo list/m);
 	assert.match(block, /mark a task in_progress before starting/);
-	assert.match(block, /1\. \[done\] Add quiet tool rendering/);
-	assert.match(block, /2\. \[in_progress\] Fix quiet tools conflict — fixing conflict/);
-	assert.match(block, /3\. \[pending\] Show git bash tails/);
 	assert.doesNotMatch(block, /stale/);
-	assert.match(todoPromptBlock(seeded(), 2) ?? "", /stale: 2 turns without an update/);
-	assert.equal(todoPromptBlock(emptyTodo(), 0), undefined);
+	assert.doesNotMatch(block, /Add quiet tool rendering/, "the rules block never contains task content");
+	const message = todoStateMessage(seeded());
+	assert.ok(message);
+	assert.match(message, /1\. \[done\] Add quiet tool rendering/);
+	assert.match(message, /2\. \[in_progress\] Fix quiet tools conflict — fixing conflict/);
+	assert.match(message, /3\. \[pending\] Show git bash tails/);
+	assert.doesNotMatch(message, /stale/);
+	assert.equal(todoStateMessage(emptyTodo()), undefined);
 	const allDone = applyTodo(seeded(), { action: "write", tasks: [{ title: "A", status: "done" }] }, 1).state;
-	assert.equal(todoPromptBlock(allDone, 0), undefined);
+	assert.equal(todoStateMessage(allDone), undefined);
 });
 
 test("collapsed long tasks occupy one body line, including stale state, without losing task data", (t) => {
@@ -446,7 +449,7 @@ test("applyTodo rejects blocked without a note and leaves the list unchanged", (
 test("dropped tasks never count as open: a list of done and dropped is finished, silent, and never stale", () => {
 	const state = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "A", status: "done" }, { title: "B", status: "dropped" }, { title: "C", status: "dropped" }] }, 1).state;
 	assert.deepEqual(todoSummary(state), { done: 1, total: 3, open: 0 });
-	assert.equal(todoPromptBlock(state, 5), undefined);
+	assert.equal(todoStateMessage(state), undefined);
 	assert.equal(staleTurns(state, 9), 0);
 });
 
@@ -454,8 +457,8 @@ test("blocked tasks stay open but alone never make the list stale; an actionable
 	const blockedOnly = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "A", status: "done" }, { title: "Deploy", status: "blocked", note: "waiting for an admin" }] }, 1).state;
 	assert.deepEqual(todoSummary(blockedOnly), { done: 1, total: 2, open: 1 });
 	assert.equal(staleTurns(blockedOnly, 9), 0);
-	const block = todoPromptBlock(blockedOnly, 0) ?? "";
-	assert.match(block, /2\. \[blocked\] Deploy — waiting for an admin/);
+	assert.match(todoStateMessage(blockedOnly) ?? "", /2\. \[blocked\] Deploy — waiting for an admin/);
+	const block = todoPromptBlock();
 	assert.match(block, /A blocked task waits on something outside the list: do not work on it until its condition holds/);
 	assert.match(block, /mark the tasks it made obsolete dropped instead of leaving them pending or marking them done/);
 	const mixed = applyTodo(blockedOnly, { action: "add", title: "Write docs" }, 1).state;

package/tests/small-task-inline-contract.test.ts

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/gentle-ai.ts";
+
+// Pain-point iteration S15. Bench evidence (pps14 x5): one run read "Two unrelated wishes" as separate
+// deliverables, classified a two-feature request as large (branch, feature document, session state), and
+// started two writers for ~100-line units: USD 0.55 against 0.20 for the run that stayed inline. Blind round 4
+// also found delivered tests that pin `git show <baseline commit>`, so the differential check had leaked into
+// committed tests that fail in another clone. These are instruction-delivery contracts, not proof of adherence.
+
+const read = (path: string): string => readFileSync(join(import.meta.dirname, "..", path), "utf8");
+
+test("S15 (a): separate deliverables are ones the user wants apart, not several features asked at once", () => {
+	const core = read("assets/orchestrator.md");
+	assert.ok(
+		core.includes("deliverables the user wants apart (never several features asked at once)"),
+		"Task Size must define separate deliverables",
+	);
+});
+
+test("S15 (b): parallel writers never fire for units of about 100 changed lines or less", () => {
+	const card = read("assets/orchestrator-delegation.md");
+	assert.ok(
+		card.includes("Units of about 100 changed lines or less always run inline: writing them costs less than starting workers."),
+		"the Writer trigger must keep small units inline",
+	);
+});
+
+test("S15 (c): the differential check runs in scratch and is never committed as a test", () => {
+	const clause = "a copy of the base commit in a `mktemp -d` scratch directory, never committed as a test; committed tests never read git history or a fixed commit";
+	const harness = __testing.buildGentlePrompt("neutral");
+	assert.ok(harness.includes(clause), "the always-on test-first policy must keep the differential check in scratch");
+	assert.ok(!harness.includes("(`git stash` or a copy of HEAD)"), "the harness must not suggest git stash or HEAD copies");
+	assert.ok(read("assets/agents/gentle-ai-worker.md").includes(clause), "the worker must keep the differential check in scratch");
+});