gentle-pi 2.5.0 → 2.6.0

package/tests/agents-widget.test.ts

@@ -58,6 +58,12 @@ test("renderAgentsCard draws columns for agent, task, and model · tokens · cos
 	assert.deepEqual(renderAgentsCard([], plainTheme, 60, 0, { collapsed: false }), []);
 });
 
+test("renderAgentsCard renders singleton elapsed time only on its task row", () => {
+	const lines = renderAgentsCard([task({})], plainTheme, 84, 5_000, { collapsed: false }).map(stripAnsi);
+	assert.equal(lines.join("\n").match(/4s/g)?.length, 1);
+	assert.match(lines[1], /4s/);
+});
+
 test("renderAgentsCard keeps every task on one line, clipping long labels, and drops the task column when the card is narrow", () => {
 	const tasks = [task({ id: "a", label: "write the gentle shell footer and all of its tests before lunch" })];
 	const wide = renderAgentsCard(tasks, plainTheme, 84, 5_000, { collapsed: false }).map(stripAnsi);
@@ -65,7 +71,7 @@ test("renderAgentsCard keeps every task on one line, clipping long labels, and d
 	assert.match(wide[1], /^│ ◐  sdd-explore  write the gentle shell foot… +claude-sonnet-5 · 34k · \$0\.27 · 4s │$/);
 	const narrow = renderAgentsCard(tasks, plainTheme, 44, 5_000, { collapsed: false }).map(stripAnsi);
 	assert.equal(narrow.length, 3);
-	assert.match(narrow[1], /^│ ◐  sdd-explore +34k · \$0\.27 · 4s │$/);
+	assert.match(narrow[1], /^│ ◐  sdd-explore +claude-sonnet-5 +│$/);
 });
 
 test("renderAgentsCard shows questions and failures in place of the task, and collapses to the first row", () => {
@@ -85,6 +91,30 @@ test("renderAgentsCard shows questions and failures in place of the task, and co
 	assert.match(collapsed[1], /^│ \?  sdd-explore  asked: Delete\?/);
 });
 
+test("agent model and effort outrank usage at sidebar widths without inventing unknown values", () => {
+	for (const width of [32, 44, 60, 100]) {
+		const lines = renderAgentsCard([task({ agent: "worker", model: "openai/gpt-5", thinking: "high" })], plainTheme, width, 5000, { collapsed: false });
+		assert.equal(lines.length, 3);
+		assert.match(lines[1], /worker/);
+		assert.match(lines[1], /gpt-5 · high/);
+		for (const line of lines) assert.equal(visibleWidth(line), width);
+		if (width <= 44) assert.doesNotMatch(lines[1], /34k|\$0\.27|4s/);
+	}
+	for (const width of [0, 1, 2, 3, 4, 8, 16, 24]) {
+		const lines = renderAgentsCard([task({ agent: "界worker", thinking: "xhigh" })], plainTheme, width, 5000, { collapsed: false });
+		assert.ok(lines.length <= 4, "narrow metadata gets at most one dedicated row");
+		for (const line of lines) assert.equal(visibleWidth(line), width);
+	}
+	const sidebar = renderAgentsCard([task({ agent: "gentle-ai-worker", model: "openai/gpt-5.6", thinking: "high" })], plainTheme, 32, 5000, { collapsed: false });
+	assert.match(sidebar.join("\n"), /gentle-ai-worker/);
+	assert.match(sidebar.join("\n"), /gpt-5\.6 · high/);
+	for (const line of sidebar) assert.equal(visibleWidth(line), 32);
+	const unknown = renderAgentsCard([task({ model: "default", thinking: undefined })], plainTheme, 80, 5000, { collapsed: false }).join("\n");
+	assert.doesNotMatch(unknown, /default|undefined|high|off/);
+	const off = renderAgentsCard([task({ thinking: "off" })], plainTheme, 80, 5000, { collapsed: false }).join("\n");
+	assert.match(off, /claude-sonnet-5 · off/);
+});
+
 test("widgetRows caps the card at a quarter of the terminal, between three and eight rows", () => {
 	assert.equal(widgetRows(40), 8, "tall terminals still stop at eight rows");
 	assert.equal(widgetRows(24), 6);

package/tests/artifact-language.test.ts

@@ -149,6 +149,27 @@ test("SDD proposal questions focus on business and PRD gaps", async () => {
 	);
 });
 
+test("all shipped SDD agents and chains require parent preflight transport", async () => {
+	const agents = [
+		"sdd-init", "sdd-onboard", "sdd-explore", "sdd-research", "sdd-proposal", "sdd-spec", "sdd-design",
+		"sdd-tasks", "sdd-status", "sdd-apply", "sdd-verify", "sdd-sync", "sdd-archive", "sdd-remediate",
+	];
+	const chains = ["sdd-full", "sdd-plan", "sdd-verify"];
+	assert.equal(agents.length, 14);
+	assert.equal(chains.length, 3);
+	for (const agent of agents) {
+		const source = await readFile(join(ROOT, "assets", "agents", `${agent}.md`), "utf8");
+		assert.match(source, /## Parent Preflight Transport/);
+		assert.match(source, /never confirms or persists SDD choices/);
+		assert.doesNotMatch(source, /(?:infer|synthesize) (?:a )?(?:preflight )?(?:confirmation|defaults?) yourself/i);
+	}
+	for (const chain of chains) {
+		const source = await readFile(join(ROOT, "assets", "chains", `${chain}.chain.md`), "utf8");
+		assert.match(source, /## Parent preflight transport guard/);
+		assert.match(source, /Missing or malformed transport blocks the chain before its first phase/);
+	}
+});
+
 test("SDD chain assets distinguish interactive gates from auto execution", async () => {
 	const planChain = await readFile(join(ROOT, "assets/chains/sdd-plan.chain.md"), "utf8");
 	const fullChain = await readFile(join(ROOT, "assets/chains/sdd-full.chain.md"), "utf8");
@@ -212,8 +233,10 @@ test("SDD assets route completed implementation directly through verify, sync, a
 
 	assert.match(tasks, /<!-- sdd-owner: implementation -->/);
 	assert.match(apply, /next_recommended: "sdd-verify"/);
-	assert.match(status, /verify.*ready/i);
-	assert.match(contract, /apply.*verify.*sync.*archive/is);
+	assert.match(status, /gentle-ai\.sdd-status.*v2/i);
+	assert.match(status, /read-only/i);
+	assert.match(contract, /native.*(?:apply|verify).*archive/is);
+	assert.match(contract, /Manual `sdd-sync` remains its intentional local resolver/);
 	assert.match(chain, /apply.*verification/is);
 	assert.doesNotMatch(assets, /<!-- sdd-owner: parent -->/);
 	assert.doesNotMatch(assets, /parent-lifecycle/);

package/tests/ask-user-choice.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { getKeybindings, KeybindingsManager, setKeybindings, stripTerminalSequences, TUI_KEYBINDINGS } from "@earendil-works/pi-tui";
 import askUserChoice from "../extensions/ask-user-choice.ts";
 
 interface ChoiceResult {
@@ -17,6 +17,7 @@ interface ChoiceParameters {
 	additionalProperties?: boolean;
 	properties?: {
 		question?: unknown;
+		allowCustomResponse?: unknown;
 		options?: {
 			minItems?: number;
 			maxItems?: number;
@@ -26,7 +27,10 @@ interface ChoiceParameters {
 }
 
 interface ChoiceTool {
+	renderShell?: string;
 	name: string;
+	description?: string;
+	promptGuidelines?: string[];
 	parameters: ChoiceParameters;
 	execute: (...args: unknown[]) => Promise<ChoiceResult>;
 }
@@ -151,6 +155,10 @@ function tuiContext(inputs: readonly string[], rendered: { value: string }) {
 	};
 }
 
+test("ask_user_choice transcript opts out of Pi's painted tool shell", () => {
+	assert.equal(registerChoiceTool().tool.renderShell, "self");
+});
+
 test("ask_user_choice registers without runtime actions or overriding the open questionnaire", () => {
 	const registration = registerChoiceTool(["read", "ask_user_question"]);
 
@@ -159,14 +167,17 @@ test("ask_user_choice registers without runtime actions or overriding the open q
 	assert.deepEqual(registration.activeTools(), ["read", "ask_user_question"]);
 });
 
-test("ask_user_choice exposes a strict closed single-select schema", () => {
+test("ask_user_choice keeps closed mode by default and makes custom mode opt-in", () => {
 	const { tool } = registerChoiceTool();
 	const optionsSchema = tool.parameters.properties?.options;
 	const optionSchema = optionsSchema?.items;
 
 	assert.equal(tool.name, "ask_user_choice");
 	assert.equal(tool.parameters.additionalProperties, false);
-	assert.deepEqual(Object.keys(tool.parameters.properties ?? {}).sort(), ["options", "question"]);
+	assert.deepEqual(Object.keys(tool.parameters.properties ?? {}).sort(), ["allowCustomResponse", "options", "question"]);
+	assert.equal(tool.parameters.properties?.allowCustomResponse !== undefined, true);
+	assert.match(tool.description ?? "", /allowCustomResponse/);
+	assert.match((tool.promptGuidelines ?? []).join(" "), /Never enable allowCustomResponse.*provider-owned consent prompts.*maintenance authorizations.*exact opaque token/);
 	assert.equal(optionsSchema?.minItems, 2);
 	assert.equal(optionsSchema?.maxItems, 4);
 	assert.equal(optionSchema?.additionalProperties, false);
@@ -295,6 +306,161 @@ test("ask_user_choice retains native rendered hit testing for mouse selection",
 	assert.equal(completionCalls, 1, "late keyboard input cannot complete the choice twice");
 });
 
+test("ask_user_choice supports an opt-in custom response from keyboard navigation", async () => {
+	const { tool } = registerChoiceTool();
+	const rendered: string[] = [];
+	const response = "  exactly as typed  ";
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, {
+		mode: "tui",
+		ui: {
+			custom: async (factory: ChoiceCustomFactory) => {
+				let completed: unknown;
+				const component = factory(
+					{ requestRender() {} },
+					{ fg: (_color, text) => text, bg: (_color, text) => text, bold: (text) => text },
+					{},
+					(value) => { completed = value; },
+				);
+				rendered.push(component.render(80).join("\n"));
+				component.handleInput("\x1b[B");
+				component.handleInput("\x1b[B");
+				component.handleInput("\r");
+				rendered.push(component.render(80).join("\n"));
+				component.handleInput(response);
+				component.handleInput("\r");
+				return completed;
+			},
+		},
+	});
+	assert.match(rendered[0] ?? "", /Other…/);
+	assert.match(rendered[1] ?? "", /Custom response/);
+	assert.deepEqual(result.details, { question: "Explain?", options, customResponse: response });
+	assert.equal(result.content[0]?.text, `User responded: ${response}`);
+});
+
+test("ask_user_choice uses native input decoding and supplied custom editor keybindings", async () => {
+	const { tool } = registerChoiceTool();
+	const configured = new KeybindingsManager(TUI_KEYBINDINGS, {
+		"tui.select.down": "ctrl+n",
+		"tui.select.confirm": "ctrl+o",
+		"tui.select.cancel": "ctrl+x",
+		"tui.input.submit": "ctrl+s",
+		"tui.editor.deleteCharBackward": "ctrl+h",
+	});
+	const previous = getKeybindings();
+	setKeybindings(configured);
+	try {
+		const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, {
+			mode: "tui",
+			ui: { custom: async (factory: ChoiceCustomFactory) => {
+				let completed: unknown;
+				const component = factory(
+					{ requestRender() {} },
+					{ fg: (_color, text) => text, bg: (_color, text) => text, bold: (text) => text },
+					configured, (value) => { completed = value; },
+				);
+				component.handleInput("\x0e");
+				component.handleInput("\x0e");
+				component.handleInput("\x0f");
+				component.handleInput("\x1b[97u");
+				component.handleInput("\x1b[98u");
+				component.handleInput("\x08");
+				component.handleInput("\x18");
+				assert.match(component.render(80).join("\n"), /Other…/);
+				component.handleInput("\x0f");
+				component.handleInput("\x13");
+				return completed;
+			} },
+		});
+		assert.deepEqual(result.details, { question: "Explain?", options, customResponse: "a" });
+	} finally {
+		setKeybindings(previous);
+	}
+});
+
+test("ask_user_choice activates an opt-in custom response from the Other row pointer target", async () => {
+	const { tool } = registerChoiceTool();
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, {
+		mode: "tui",
+		ui: {
+			custom: async (factory: ChoiceCustomFactory) => {
+				let completed: unknown;
+				const component = factory(
+					{ requestRender() {} },
+					{ fg: (_color, text) => text, bg: (_color, text) => text, bold: (text) => text },
+					{},
+					(value) => { completed = value; },
+				);
+				const lines = component.render(80);
+				const otherRow = lines.findIndex((line) => stripTerminalSequences(line).includes("Other…"));
+				assert.ok(otherRow >= 0);
+				const event = (type: string) => ({
+					type, button: "left", x: 0, y: otherRow, screenX: 0, screenY: otherRow,
+					width: 80, height: lines.length, shift: false, alt: false, ctrl: false,
+				});
+				assert.equal(component.handleMouse?.(event("press"))?.focus, true);
+				component.handleMouse?.(event("click"));
+				component.handleInput("pointer response");
+				component.handleInput("\r");
+				return completed;
+			},
+		},
+	});
+	assert.deepEqual(result.details, { question: "Explain?", options, customResponse: "pointer response" });
+});
+
+test("ask_user_choice rejects empty custom responses and escapes back to list cancellation", async () => {
+	const { tool } = registerChoiceTool();
+	const result = await tool.execute("call", { question: "Explain?", options, allowCustomResponse: true }, new AbortController().signal, undefined, {
+		mode: "tui",
+		ui: {
+			custom: async (factory: ChoiceCustomFactory) => {
+				let completed: unknown;
+				const choice = factory(
+					{ requestRender() {} },
+					{ fg: (_color, text) => text, bg: (_color, text) => text, bold: (text) => text },
+					{},
+					(value) => { completed = value; },
+				);
+				choice.handleInput("\x1b[B");
+				choice.handleInput("\x1b[B");
+				choice.handleInput("\r");
+				assert.match(choice.render(80).join("\n"), /Custom response/);
+				choice.handleInput("   ");
+				choice.handleInput("\r");
+				assert.equal(completed, undefined, "whitespace-only submission stays in the editor");
+				assert.match(choice.render(80).join("\n"), /Custom response/);
+				choice.handleInput("\x1b");
+				assert.match(choice.render(80).join("\n"), /Other…/);
+				choice.handleInput("\x1b");
+				return completed;
+			},
+		},
+	});
+	assert.deepEqual(result.details, { question: "Explain?", options, cancelled: true });
+});
+
+test("ask_user_choice renders Other only when custom response is explicitly enabled", async () => {
+	const { tool } = registerChoiceTool();
+	for (const allowCustomResponse of [undefined, false, true]) {
+		let rendered = "";
+		await tool.execute("call", { question: "Proceed?", options, ...(allowCustomResponse === undefined ? {} : { allowCustomResponse }) }, new AbortController().signal, undefined, {
+			mode: "tui",
+			ui: { custom: async (factory: ChoiceCustomFactory) => {
+				const component = factory(
+					{ requestRender() {} },
+					{ fg: (_color, text) => text, bg: (_color, text) => text, bold: (text) => text },
+					{}, () => {},
+				);
+				rendered = component.render(80).join("\n");
+				component.handleInput("\x1b");
+				return undefined;
+			} },
+		});
+		assert.equal(rendered.includes("Other…"), allowCustomResponse === true);
+	}
+});
+
 test("ask_user_choice handles a closed Kilo hash decision with an opaque envelope value", async () => {
 	const { tool } = registerChoiceTool(["read"]);
 	const rendered = { value: "" };

package/tests/asset-installation-runtime.test.ts

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+async function proveLazyDiscovery(): Promise<void> {
+	const {
+		createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices,
+		ModelRuntime, SessionManager, SettingsManager,
+	} = await import("@earendil-works/pi-coding-agent");
+	const cwd = process.cwd();
+	const agentDir = process.env.PI_CODING_AGENT_DIR!;
+	const shim = join(cwd, "extensions.ts");
+	const source = (name: string) => JSON.stringify(new URL(`../extensions/${name}.ts`, import.meta.url).href);
+	writeFileSync(shim, `
+import { createGentleAiExtension } from ${source("gentle-ai")};
+import gentleAgents from ${source("gentle-agents")};
+import sddInit from ${source("sdd-init")};
+export default function (pi) {
+  createGentleAiExtension({ nativeReviewCli: null, candidateViews: null, processEnv: {} })(pi);
+  gentleAgents(pi);
+  sddInit(pi);
+}
+`);
+	const modelRuntime = await ModelRuntime.create({
+		authPath: join(agentDir, "empty-auth.json"),
+		modelsPath: null,
+		modelsStorePath: join(agentDir, "models-store.json"),
+		allowModelNetwork: false,
+	});
+	const runtime = await createAgentSessionRuntime(async ({ cwd, sessionManager, sessionStartEvent }) => {
+		const services = await createAgentSessionServices({
+			cwd, agentDir, modelRuntime,
+			settingsManager: SettingsManager.inMemory({ retry: { enabled: false }, compaction: { enabled: false } }),
+			resourceLoaderOptions: {
+				noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true,
+				additionalExtensionPaths: [shim],
+			},
+		});
+		assert.deepEqual(services.resourceLoader.getExtensions().errors, []);
+		assert.deepEqual(services.diagnostics, []);
+		return {
+			...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent, tools: ["subagent_list_agents"] })),
+			services, diagnostics: services.diagnostics,
+		};
+	}, { cwd, agentDir, sessionManager: SessionManager.inMemory(cwd) });
+	try {
+		await runtime.session.bindExtensions({ mode: "print" });
+		const session = runtime.session;
+		const list = session.agent.state.tools.find(tool => tool.name === "subagent_list_agents");
+		assert.ok(list, "actual SDK must expose the wrapped discovery tool");
+		const names = async () => {
+			const result = await list.execute("asset-discovery", {});
+			return result.content.filter(part => part.type === "text").map(part => part.text).join("\n");
+		};
+		const before = await names();
+		assert.match(before, /- gentle-ai-explore \(global\)/);
+		assert.match(before, /- review-risk \(global\)/);
+		assert.doesNotMatch(before, /- sdd-/, "fresh startup must not install SDD definitions");
+		assert.equal(existsSync(join(agentDir, "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(agentDir, "gentle-ai", "support")), false);
+		await session.prompt("/gentle:install-sdd");
+		assert.strictEqual(runtime.session, session);
+		const after = await names();
+		for (const name of ["gentle-ai-explore", "review-risk", "sdd-init", "sdd-apply"]) {
+			assert.ok(after.includes(`- ${name} (global)`), `same-session discovery must include ${name}`);
+		}
+		for (const file of ["sdd-status-contract.md", "strict-tdd.md", "strict-tdd-verify.md"]) {
+			assert.ok(existsSync(join(agentDir, "gentle-ai", "support", file)), `missing support: ${file}`);
+		}
+		assert.ok(existsSync(join(agentDir, "chains", "sdd-full.chain.md")));
+		assert.equal(session.messages.length, 0, "slash activation must not start a model turn");
+		console.log("SDK discovery: delegation/review only -> /gentle:install-sdd -> same-session sdd-init/sdd-apply and support");
+	} finally {
+		await runtime.dispose();
+	}
+}
+
+if (process.env.GENTLE_PI_ASSET_PROOF_CHILD === "1") {
+	await proveLazyDiscovery();
+} else {
+	test("actual SDK discovers SDD only after explicit activation in the same session", () => {
+		const root = mkdtempSync(join(tmpdir(), "gentle-pi-assets-sdk-"));
+		try {
+			const home = join(root, "home");
+			const cwd = join(root, "project");
+			const agentDir = join(home, ".pi", "agent");
+			for (const path of [cwd, agentDir]) mkdirSync(path, { recursive: true });
+			const result = spawnSync(process.execPath, ["--experimental-strip-types", fileURLToPath(import.meta.url)], {
+				cwd, encoding: "utf8", timeout: 30_000,
+				env: {
+					PATH: `${dirname(process.execPath)}:/usr/bin:/bin`, HOME: home, TMPDIR: root,
+					PI_CODING_AGENT_DIR: agentDir, GENTLE_PI_AGENT_HOME: agentDir,
+					GENTLE_PI_CONFIG_HOME: join(home, "config"), XDG_CONFIG_HOME: join(home, ".config"),
+					PI_OFFLINE: "1", GENTLE_PI_ASSET_PROOF_CHILD: "1",
+				},
+			});
+			assert.ifError(result.error);
+			assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+			assert.match(result.stdout, /SDK discovery: delegation\/review only/);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+}

package/tests/autonomous-guard.test.ts

@@ -5,7 +5,7 @@ import { dirname, join } from "node:path";
 import test from "node:test";
 import { __testing } from "../extensions/gentle-ai.ts";
 
-const { classifyGuardedCommand } = __testing;
+const { classifyGuardedCommand, evaluateGuardedCommand, guardedCommandPreview, guardedCommandTitle } = __testing;
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -129,6 +129,121 @@ test("classifyGuardedCommand: git push plain allowed when autonomousMode=true an
 	assert.equal(result, "allow");
 });
 
+test("classifyGuardedCommand: configured push allow is remote-agnostic and unchanged", () => {
+	const config = { autonomousMode: true, guardedCommands: { gitPush: "allow" as const } };
+	for (const command of [
+		"git push origin feature/test",
+		"git push upstream feature/test",
+		"git push fork feature/test",
+		"git push",
+		"git push feature/test && git status",
+		"echo done || git push origin feature/test",
+	]) {
+		assert.equal(classifyGuardedCommand(command, config), "allow", command);
+	}
+	assert.equal(
+		classifyGuardedCommand("git push origin feature/test", { autonomousMode: true, guardedCommands: { gitPush: "block" } }),
+		"block",
+	);
+	for (const command of [
+		"git push -f origin feature/test",
+		"git push --force origin main",
+		"git push --force-with-lease origin feature/test",
+	]) {
+		assert.equal(classifyGuardedCommand(command, config), "block", command);
+	}
+});
+
+// ---------------------------------------------------------------------------
+// Guarded command preview — presentation-only centering
+// ---------------------------------------------------------------------------
+
+test("guardedCommandPreview: long late matched action stays visible in preview", () => {
+	const prefix = "noise ".repeat(80);
+	const command = `${prefix}git push origin feature/test`;
+	// Contract: the caller owns the trigger index. confirmCommand hands over
+	// evaluation.triggerIndex, so the preview always centers on the matched
+	// action supplied by the evaluator.
+	const triggerIndex = command.indexOf("git push");
+	const preview = guardedCommandPreview(command, triggerIndex);
+	assert.match(preview, /git push origin feature\/test/);
+	assert.ok(preview.startsWith("…"), "preview elides leading context near a late match");
+});
+
+test("guardedCommandPreview: late non-push action visible, elided, and width-bounded", () => {
+	const prefix = "noise ".repeat(80);
+	const command = `${prefix}npm publish --tag beta`;
+	const triggerIndex = command.indexOf("npm publish");
+	const preview = guardedCommandPreview(command, triggerIndex);
+	assert.match(preview, /npm publish --tag beta/);
+	assert.ok(preview.startsWith("…"), "preview elides leading context near a late match");
+	// Bounded visible width: 1 leading ellipsis + up to 179 content chars (budget 180).
+	assert.ok(preview.length <= 180, `preview exceeds bounded width: ${preview.length}`);
+});
+
+// ---------------------------------------------------------------------------
+// Guarded command title — presentation-only, action-specific
+// ---------------------------------------------------------------------------
+
+test("guardedCommandTitle: exact action-specific titles per guarded key", () => {
+	assert.equal(guardedCommandTitle("gitPush"), "Allow guarded git push?");
+	assert.equal(guardedCommandTitle("gitRebase"), "Allow guarded git rebase?");
+	assert.equal(
+		guardedCommandTitle("gitBranchDeleteForce"),
+		"Allow guarded forced git branch deletion?",
+	);
+	assert.equal(guardedCommandTitle("npmPublish"), "Allow guarded npm publish?");
+	assert.equal(guardedCommandTitle("piRemove"), "Allow guarded pi remove?");
+});
+
+test("guardedCommandTitle: unkeyed guarded command falls back to generic title", () => {
+	assert.equal(guardedCommandTitle(undefined), "Allow guarded command?");
+});
+
+test("evaluateGuardedCommand: collects guarded matches in command order and applies full-command precedence", () => {
+	const command = "npm publish && git push origin main && git rebase main";
+	const evaluation = evaluateGuardedCommand(command, {
+		autonomousMode: true,
+		guardedCommands: { gitPush: "allow", gitRebase: "confirm", npmPublish: "block" },
+	});
+	assert.deepEqual(evaluation.matches.map((match) => [match.key, match.action]), [
+		["npmPublish", "block"],
+		["gitPush", "allow"],
+		["gitRebase", "confirm"],
+	]);
+	assert.deepEqual(evaluation.matches.map((match) => command.slice(match.triggerIndex).split(/\s/, 1)[0]), ["publish", "push", "rebase"]);
+	assert.equal(evaluation.action, "block");
+
+	assert.equal(evaluateGuardedCommand("git rebase main && git push --force origin main", {
+		autonomousMode: true,
+		guardedCommands: { gitRebase: "allow", gitPush: "allow" },
+	}).action, "block", "a later hard deny overrides an earlier allowed action");
+});
+
+test("evaluateGuardedCommand: git -C stores the push token offset for bounded previews", () => {
+	const command = `git -C /${"very-long-path/".repeat(30)} push origin main`;
+	const evaluation = evaluateGuardedCommand(command, { autonomousMode: false, guardedCommands: {} });
+	assert.equal(command.slice(evaluation.triggerIndex, evaluation.triggerIndex + 4), "push");
+	assert.match(guardedCommandPreview(command, evaluation.triggerIndex), /push origin main/);
+});
+
+test("evaluateGuardedCommand: git -C path containing push still offsets the push action", () => {
+	const command = `git -C /${"push-path/".repeat(30)} push origin main`;
+	const evaluation = evaluateGuardedCommand(command, { autonomousMode: false, guardedCommands: {} });
+	assert.equal(evaluation.triggerIndex, command.lastIndexOf("push"));
+	assert.match(guardedCommandPreview(command, evaluation.triggerIndex), /push origin main/);
+});
+
+test("evaluateGuardedCommand: repeated forced branch deletions remain separate matches", () => {
+	const command = "git branch --delete --force old && git branch --delete --force older";
+	const evaluation = evaluateGuardedCommand(command, { autonomousMode: false, guardedCommands: {} });
+	assert.deepEqual(evaluation.matches.map((match) => match.key), ["gitBranchDeleteForce", "gitBranchDeleteForce"]);
+	assert.equal(
+		guardedCommandTitle(evaluation.key, evaluation.matches),
+		"Allow guarded actions: forced git branch deletion; forced git branch deletion?",
+	);
+});
+
 test("classifyGuardedCommand: git push plain still confirm when autonomousMode=false even with gitPush=allow in config", () => {
 	const result = classifyGuardedCommand("git push origin feature/test", {
 		autonomousMode: false,

package/tests/codegraph-tools.test.ts

@@ -191,7 +191,7 @@ test("CodeGraph tool rejects incomplete or oversized query requests before runni
 });
 
 test("CodeGraph tool registration exposes a single constrained custom tool", () => {
-	const tools: Array<{ name: string; parameters: Record<string, unknown> }> = [];
+	const tools: Array<{ name: string; renderShell?: string; parameters: Record<string, unknown> }> = [];
 	const pi = {
 		registerTool(tool: { name: string; parameters: Record<string, unknown> }) {
 			tools.push(tool);
@@ -202,6 +202,7 @@ test("CodeGraph tool registration exposes a single constrained custom tool", ()
 
 	assert.equal(tools.length, 1);
 	assert.equal(tools[0]?.name, "codegraph");
+	assert.equal(tools[0]?.renderShell, "self", "CodeGraph must not inherit Pi's painted Box");
 	assert.deepEqual(tools[0]?.parameters, {
 		type: "object",
 		additionalProperties: false,

package/tests/delegated-key-learnings-contract.test.ts

@@ -92,7 +92,7 @@ test("SDD executor coverage is exhaustive against actual agent files", () => {
 	// the allowlist matches reality so coverage cannot silently drift.
 	const expected = [
 		"sdd-apply.md", "sdd-archive.md", "sdd-design.md", "sdd-explore.md",
-		"sdd-init.md", "sdd-onboard.md", "sdd-proposal.md", "sdd-research.md",
+		"sdd-init.md", "sdd-onboard.md", "sdd-proposal.md", "sdd-remediate.md", "sdd-research.md",
 		"sdd-spec.md", "sdd-status.md", "sdd-sync.md", "sdd-tasks.md",
 		"sdd-verify.md",
 	];

package/tests/devbinary/native-review-parity.devtest.ts

@@ -306,6 +306,8 @@ test("dev-binary: v7 intended-untracked selection decodes both selected statuses
 	assert.equal("lineage_created" in result, false, "reconciled unknown mutation must not claim lineage creation");
 	assert.equal("mutation_performed" in result, false, "reconciled unknown mutation must not claim a mutation result");
 	assert.equal(result.mutation_outcome, "unknown", "the controller cannot prove mutation status after an intercepted launch");
+	assert.match(String(result.required_status_action), /Run target-scoped review\.status/, "ambiguous START must retain its executable-safe STATUS instruction");
+	assert.equal(result.next_action, "start", "the reconciled provider action remains visible without authoring a replay");
 	const after = await native.targetStatus({ cwd, agent: "pi" });
 	assert.equal(after.authority, undefined, "post-intercept STATUS must not expose authority");
 });

package/tests/feature-request-form.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import test from "node:test";
+
+// Reuse Pi's existing YAML dependency without adding a package dependency.
+const piRequire = createRequire(import.meta.resolve("@earendil-works/pi-coding-agent"));
+const { parseDocument } = piRequire("yaml");
+const formUrl = new URL("../.github/ISSUE_TEMPLATE/feature_request.yml", import.meta.url);
+
+function readForm() {
+	const document = parseDocument(readFileSync(formUrl, "utf8"), { uniqueKeys: true });
+	assert.deepEqual(document.errors, [], "the issue form must be valid, unambiguous YAML");
+	return document.toJS();
+}
+
+test("feature request form has supported structure and only intake labels", () => {
+	const form = readForm();
+	assert.deepEqual(Object.keys(form).sort(), ["body", "description", "labels", "name"]);
+	assert.equal(form.name, "Feature Request");
+	assert.equal(typeof form.description, "string");
+	assert.ok(form.description.trim().length > 0);
+	// Exact allowlist also rejects approval, exception, and other privileged labels.
+	assert.deepEqual(form.labels, ["enhancement", "status:needs-review"]);
+	assert.ok(Array.isArray(form.body));
+	assert.deepEqual(form.body.map((field) => field.id), [
+		"preflight", "problem", "outcome", "alternatives", "context",
+	]);
+	for (const field of form.body) {
+		assert.ok(["checkboxes", "textarea"].includes(field.type));
+		assert.match(field.id, /^[a-zA-Z0-9_-]+$/);
+		assert.equal(typeof field.attributes.label, "string");
+		assert.ok(field.attributes.label.trim().length > 0);
+		assert.deepEqual(Object.keys(field).sort(), field.type === "checkboxes"
+			? ["attributes", "id", "type"]
+			: ["attributes", "id", "type", "validations"]);
+	}
+});
+
+test("duplicate and privacy affirmations are individually required", () => {
+	const [preflight] = readForm().body;
+	assert.equal(preflight.type, "checkboxes");
+	assert.deepEqual(preflight.attributes.options, [
+		{
+			label: "I searched open and closed issues and did not find a request for this feature.",
+			required: true,
+		},
+		{
+			label: "I reviewed this request and removed credentials, tokens, private paths, hostnames, and other sensitive data.",
+			required: true,
+		},
+	]);
+});
+
+test("feature questions require problem and outcome but keep alternatives and context optional", () => {
+	const questions = readForm().body.slice(1);
+	assert.deepEqual(questions.map((field) => ({
+		type: field.type,
+		label: field.attributes.label,
+		validations: field.validations,
+	})), [
+		{ type: "textarea", label: "Problem or opportunity", validations: { required: true } },
+		{ type: "textarea", label: "Proposed outcome", validations: { required: true } },
+		{ type: "textarea", label: "Alternatives considered", validations: { required: false } },
+		{ type: "textarea", label: "Additional context", validations: { required: false } },
+	]);
+});

package/tests/fixtures/agents-messaging-child.mjs

@@ -0,0 +1,5 @@
+process.on("message", (message) => {
+	if (message?.kind !== "ack") return;
+	process.stdout.write(`${JSON.stringify({ accepted: message.accepted === true })}\n`, () => process.exit(0));
+});
+process.send({ id: "n1", kind: "notification", message: "fixture ready" });