gentle-pi 3.7.0 → 4.0.0

package/tests/quiet-tool-rendering.test.ts

@@ -1,11 +1,13 @@
 import assert from "node:assert/strict";
-import { realpathSync } from "node:fs";
 import test from "node:test";
 import { initTheme, keyHint } from "@earendil-works/pi-coding-agent";
 import { imageFallback, visibleWidth } from "@earendil-works/pi-tui";
 import { cardBody, cardHint, cardTitle, cardTone } from "./gentle-card-text.ts";
+import { CARD_STYLE, cardStyle, setCardStyle } from "../lib/shell-card.ts";
+import { stripAnsi } from "../lib/terminal-theme.ts";
 import piPretty from "../extensions/pi-pretty.ts";
-import quietTools, {
+import productionQuietTools, {
+	createQuietToolRenderer,
 	countNonEmptyLines,
 	extractTextContent,
 	formatToolResultOutput,
@@ -50,10 +52,37 @@ function routineRenderContext(overrides: Record<string, unknown> = {}) {
 	};
 }
 
-function renderLines(component: { render(width: number): string[] }, width = 120): string[] {
+// Content assertions read the quiet tool card content: the top rule becomes its
+// call text (glyph, fill, and hint dropped), sides are stripped, and the closing
+// rule is dropped. Gentle AI cards keep their raw frame for the card-text
+// helpers, and the quiet card tests assert the raw frame via frameLines.
+// Legacy bash argument assertions drop its new identity prefix here; distinct
+// tool identity is asserted separately against the actual unmodified frame.
+// A pending call's `running…` row is frame chrome too, asserted separately.
+const TAG = "(?:</?[a-zA-Z]+>)*";
+const CARD_TOP = new RegExp(`^${TAG}╭─ ${TAG}[✿≡$⌕⌖☷✎+]${TAG} (.*?) ${TAG}─+${TAG}(?: .*? )?${TAG}╮${TAG}$`);
+const CARD_SIDE = new RegExp(`^${TAG}│${TAG} (.*) ${TAG}│${TAG}$`);
+const CARD_BOTTOM = new RegExp(`^${TAG}╰${TAG}─*${TAG}╯${TAG}$`);
+
+function frameLines(component: { render(width: number): string[] }, width = 120): string[] {
 	return component.render(width).map((line) => line.trimEnd());
 }
 
+const QUIET_CARD_COMPONENTS = new Set(["ToolCardTop", "ToolCardBody"]);
+
+function renderLines(component: { render(width: number): string[] }, width = 120): string[] {
+	if (!QUIET_CARD_COMPONENTS.has(component.constructor.name)) return component.render(width).map((line) => line.trimEnd());
+	const call = component.constructor.name === "ToolCardTop";
+	return component.render(width).flatMap((line) => {
+		if (CARD_BOTTOM.test(line)) return [];
+		const top = CARD_TOP.exec(line);
+		if (top) return [top[1]!.replace(/^(?:<[^>]+>)*bash(?:<[^>]+>)* /, "").trimEnd()];
+		const side = CARD_SIDE.exec(line);
+		const text = (side ? side[1]! : line).trimEnd();
+		return call && side && text.replace(/<\/?[a-zA-Z]+>/g, "") === "running…" ? [] : [text];
+	});
+}
+
 function renderToString(component: { render(width: number): string[] }, width = 120): string {
 	return renderLines(component, width).join("\n");
 }
@@ -141,6 +170,15 @@ async function withEnvAsync<T>(updates: Record<string, string | undefined>, run:
 	}
 }
 
+// Standalone rendering-only fixture for historical Bash formatting contracts.
+// No executor, shellPath, or claim of production native-Bash UI parity.
+function quietTools(pi: any, resolveOverride?: any) {
+	productionQuietTools(pi, resolveOverride);
+	if (process.env.GENTLE_PI_QUIET_TOOLS !== "0") {
+		pi.registerTool({ name: "bash", ...createQuietToolRenderer("bash", resolveOverride) });
+	}
+}
+
 function registeredQuietTools() {
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
@@ -161,17 +199,18 @@ function assertGenericBash(tool: any, command: string): void {
 	const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
 	const output = renderToolResult(tool, textResult("original command output"), { expanded: true, isPartial: false }, { args: { command } });
 	assert.equal(call.trimEnd(), `$ ${command}`, command);
-	assert.doesNotMatch(call, /🌹︎ Gentle AI/);
+	assert.doesNotMatch(call, /🌹/);
 	assert.match(output, /original command output/);
 }
 
-test("quiet tool rendering registers noisy built-in tools", () => {
+test("quiet tools register six overrides and codemode, never Bash", () => {
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => {
 		const { pi, tools } = createPi();
 
-		quietTools(pi as any);
+		productionQuietTools(pi as any);
 
-		for (const toolName of ["read", "bash", "grep", "find", "ls", "edit", "write"]) {
+		assert.equal(tools.has("bash"), false);
+		for (const toolName of ["read", "grep", "find", "ls", "edit", "write", "codemode"]) {
 			const tool = tools.get(toolName);
 			assert.ok(tool, `missing quiet renderer for ${toolName}`);
 			assert.equal(tool.renderShell, "self", `${toolName} must opt out of Pi's painted Box`);
@@ -181,24 +220,19 @@ test("quiet tool rendering registers noisy built-in tools", () => {
 	});
 });
 
-test("quiet tool execution uses the tool-call cwd", async () => {
-	const tool = registeredQuietTools().get("bash");
-	const context = {
-		cwd: "/tmp",
-		sessionManager: {
-			getSessionId: () => "quiet-tool-test",
-			getSessionFile: () => undefined,
-		},
-	};
-	const output = extractTextContent(
-		await tool.execute("tool-call", { command: "pwd" }, new AbortController().signal, undefined, context),
-	).trim();
-	// pwd prints the physical directory: on macOS /tmp is a symlink to /private/tmp.
-	assert.equal(output, realpathSync("/tmp"));
-	assert.notEqual(output, process.cwd());
+test("quiet tools never replace an existing native Bash tool", () => {
+	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => {
+		const { pi, tools } = createPi({ throwOnToolConflict: true });
+		const native = createSdkTool("bash");
+		pi.registerTool(native);
+		productionQuietTools(pi as any);
+		assert.strictEqual(tools.get("bash"), native);
+	});
 });
 
-test("quiet Bash rendering leaves configured shellPath outside its scope (#107)", () => {
+// Actual configured Bash execution is covered in quiet-bash-runtime.test.ts.
+
+test("standalone Bash rendering fixture does not interpret shellPath", () => {
 	const tool = registeredQuietTools().get("bash");
 	const render = (context: Record<string, unknown> = {}) => renderToString(tool.renderCall({ command: "printf output" }, passthroughTheme, routineRenderContext(context)));
 	const configured = render({ shellPath: "/configured/bash" });
@@ -210,7 +244,7 @@ test("quiet tool rendering can be disabled by env", () => {
 	withEnv({ GENTLE_PI_QUIET_TOOLS: "0" }, () => {
 		const { pi, tools } = createPi();
 
-		quietTools(pi as any);
+		productionQuietTools(pi as any);
 
 		assert.equal(tools.size, 0);
 	});
@@ -223,9 +257,10 @@ test("pi-pretty suppresses overlapping tools before quiet tools register", async
 			const { pi, tools } = createPi({ throwOnToolConflict: true });
 
 			await piPretty(pi as any, fakePiPrettyDeps as any);
-			quietTools(pi as any);
+			productionQuietTools(pi as any);
 
-			for (const toolName of ["read", "bash", "grep", "find", "ls", "edit", "write"]) {
+			assert.equal(tools.has("bash"), false);
+			for (const toolName of ["read", "grep", "find", "ls", "edit", "write"]) {
 				assert.ok(tools.has(toolName), `missing quiet tool ${toolName}`);
 			}
 			assert.equal(process.env.PRETTY_DISABLE_TOOLS, "multi_grep,read,bash,ls,find,grep");
@@ -288,9 +323,10 @@ test("quiet tool rendering uses bounded previews while preserving search summari
 	);
 	assert.match(read, /first line\nsecond line/);
 	assert.match(bash, /stdout line\nstderr line/);
+	// The expand key rides the call card's top rule, never the result body.
 	const configuredHint = keyHint("app.tools.expand", "to expand");
-	assert.ok(read.includes(configuredHint));
-	assert.ok(bash.includes(configuredHint));
+	assert.ok(!read.includes(configuredHint));
+	assert.ok(!bash.includes(configuredHint));
 
 	for (const [tool, text, label] of [
 		["grep", "src/a.ts:1:match\nsrc/b.ts:2:match", "2 matches"],
@@ -304,7 +340,7 @@ test("quiet tool rendering uses bounded previews while preserving search summari
 			tools.get(tool).renderResult(textResult(text), { expanded: true, isPartial: false }, passthroughTheme, {}),
 		);
 		assert.match(collapsed, new RegExp(label));
-		assert.doesNotMatch(collapsed, /src\/a\.ts|file-a\.ts/);
+		assert.match(collapsed, /src\/a\.ts|file-a\.ts/);
 		assert.match(expanded, new RegExp(text.split("\n")[1]!));
 	}
 });
@@ -343,18 +379,18 @@ test("quiet search and placeholder summaries preserve exact-result behavior", as
 	const tools = registeredQuietTools();
 	const hint = keyHint("app.tools.expand", "to expand");
 	const cases = [
-		["grep", "context rows count only match rows", "grep", contextText, { context: 1 }, " → 5 matches", undefined, /5 matches/, /15 matches/, 1],
+		["grep", "context rows count only match rows", "grep", contextText, { context: 1 }, " → 5 matches", undefined, /5 matches[\s\S]*first match/, /15 matches/, 1],
 		["grep", "no-context output counts every non-empty row", "grep", "src/a.ts:1:match\nsrc/b.ts:2:match", {}, " → 2 matches", undefined, /2 matches/, undefined, 1],
 		["exact", "current empty-directory marker", "ls", "(empty directory)", {}, "", undefined, /^$/, /entries|to expand/, 0],
 		["exact", "legacy empty-directory marker", "ls", "Directory is empty", {}, "", undefined, /^$/, /entries|to expand/, 0],
 		["exact", "no-output marker", "bash", "(no output)", { command: "true" }, "\n(no output)", undefined, /^\(no output\)$/, /to expand/, 0],
-		["collision", "empty-directory marker with a real entry", "ls", lsCollisionText, {}, " → 2 entries", `\n${lsCollisionText}`, /2 entries/, /empty directory|real-entry\.txt/, 1],
+		["collision", "empty-directory marker with a real entry", "ls", lsCollisionText, {}, " → 2 entries", `\n${lsCollisionText}`, /2 entries[\s\S]*real-entry\.txt/, undefined, 1],
 		["collision", "no-output marker with real output", "bash", bashCollisionText, { command: "printf output" }, `\n${bashCollisionText}`, `\n${bashCollisionText}`, /\(no output\)\nreal output/, undefined, 1],
 	] as const;
 	assert.equal(cases.length, 7);
 
 	const assertSummaryCase = (current: (typeof cases)[number]) => {
-		const [, name, toolName, text, args, collapsed, expanded, rendered, forbidden, hintCount] = current;
+		const [, name, toolName, text, args, collapsed, expanded, rendered, forbidden] = current;
 		const result = textResult(text) as any;
 		const tool = tools.get(toolName);
 		assert.ok(tool, `${name}: missing ${toolName} renderer`);
@@ -363,7 +399,7 @@ test("quiet search and placeholder summaries preserve exact-result behavior", as
 		const output = renderToolResult(tool, result, { expanded: false, isPartial: false }, { args });
 		assert.match(output, rendered, name);
 		if (forbidden) assert.doesNotMatch(output, forbidden, name);
-		assert.equal(output.split(hint).length - 1, hintCount, `${name}: hint count`);
+		assert.equal(output.split(hint).length - 1, 0, `${name}: the expand key rides the call card, not the result`);
 	};
 
 	for (const [section, count] of [["grep", 2], ["exact", 3], ["collision", 2]] as const) await t.test(section, () => {
@@ -408,9 +444,9 @@ test("quiet Bash errors preserve meaningful rows for both public output ordering
 		assert.ok(collapsedLines.length <= 4, `${name}: expected at most 4 visual rows, got ${collapsedLines.length}`);
 		assert.deepEqual(collapsedLines.slice(0, 3), previewRows, `${name}: preview rows`);
 		assert.equal(collapsedLines.filter((line) => line.trim().length === 0).length, 0, `${name}: no blank preview rows`);
-		assert.equal(collapsedLines.filter((line) => line.includes(hint)).length, 1, `${name}: one expansion hint`);
+		assert.equal(collapsedLines.filter((line) => line.includes(hint)).length, 0, `${name}: the expand key rides the call card`);
 		const expanded = renderToString(renderResult(result, true), 1000);
-		assert.equal(expanded, `\n${renderedExpandedText}`, `${name}: complete expanded sanitized text`);
+		assert.equal(expanded, renderedExpandedText, `${name}: complete expanded sanitized text`);
 		assert.doesNotMatch(expanded, /\x1b\[/, `${name}: expanded output is ANSI-free`);
 	}
 });
@@ -439,20 +475,38 @@ test("quiet Bash normalizes compact JSON for bounded previews while keeping expa
 	assert.equal(previewRows.length, 3);
 	assert.ok(collapsedLines.length <= 4, `expected at most 4 visual rows, got ${collapsedLines.length}`);
 	assert.deepEqual(collapsedLines.slice(0, 3), previewRows);
-	assert.equal(collapsedLines.filter((line) => line.includes(keyHint("app.tools.expand", "to expand"))).length, 1);
+	assert.equal(collapsedLines.filter((line) => line.includes(keyHint("app.tools.expand", "to expand"))).length, 0);
 	assert.doesNotMatch(collapsed, /longTail|this must stay out of the collapsed preview|deeper/);
 
 	const expanded = renderToString(tool.renderResult(result, { expanded: true, isPartial: false }, passthroughTheme, { args: commandArgs }), 1000);
-	assert.equal(expanded, `\n${compactJson}`);
+	assert.equal(expanded, compactJson);
+});
+
+test("retired SDD commands use generic bash rendering while review remains private", () => {
+	const { pi, tools } = createPi();
+	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
+	const bash = tools.get("bash");
+	for (const command of [
+		"gentle-ai sdd-status rose --json",
+		"env FOO=bar gentle-ai sdd-continue rose",
+		"gentle-ai sdd-attempt grant --authorization-root /root",
+		"./.gentle-ai/v2.2.0/gentle-ai sdd-status rose --json",
+		"C:\\package\\.gentle-ai\\v2.2.0\\gentle-ai.exe sdd-continue rose",
+	]) {
+		assert.equal(gentleAiRoutineCommand({ command }), undefined, command);
+		const call = renderToString(bash.renderCall({ command }, passthroughTheme, { args: { command } }));
+		assert.equal(call, `$ ${command}`);
+		const result = renderToString(bash.renderResult(textResult("ordinary output"), { expanded: false, isPartial: false }, passthroughTheme, { args: { command } }));
+		assert.match(result, /ordinary output/);
+	}
+	const review = "gentle-ai review status --next-transition";
+	assert.equal(gentleAiRoutineCommand({ command: review }), "review");
+	assert.equal(cardTitle(renderToString(bash.renderCall({ command: review }, passthroughTheme, { args: { command: review } }))), "🌹 rdd running · status");
 });
 
-test("quiet tool rendering identifies only routine Gentle AI SDD and RDD commands", () => {
-	assert.equal(gentleAiRoutineCommand({ command: "gentle-ai sdd-status fix-rose --json" }), "sdd-status");
-	assert.equal(gentleAiRoutineCommand({ command: "env FOO=bar gentle-ai sdd-continue fix-rose" }), "sdd-continue");
+test("quiet tool rendering identifies only routine Gentle AI review commands", () => {
 	assert.equal(gentleAiRoutineCommand({ command: "/package/.gentle-ai/v2.2.0/gentle-ai review status --next-transition" }), "review");
-	assert.equal(gentleAiRoutineCommand({ command: "./.gentle-ai/v2.2.0/gentle-ai sdd-status rose --json" }), "sdd-status");
 	assert.equal(gentleAiRoutineCommand({ command: ".\\.gentle-ai\\v2.2.0\\gentle-ai.exe review status --next-transition" }), "review");
-	assert.equal(gentleAiRoutineCommand({ command: "C:\\package\\.gentle-ai\\v2.2.0\\gentle-ai.exe sdd-continue rose" }), "sdd-continue");
 	assert.equal(gentleAiRoutineCommand({ command: "gentle-ai sdd-attempt acquire --change fix-rose" }), undefined);
 	assert.equal(gentleAiRoutineCommand({ command: "gentle-ai sdd-attempt settle --change fix-rose" }), undefined);
 	assert.equal(gentleAiRoutineCommand({ command: "gentle-ai review status --next-transition" }), "review");
@@ -492,11 +546,11 @@ test("quiet tool rendering refuses to compact composed Gentle AI shell commands"
 	}
 });
 
-test("quiet tool rendering hides every collapsed direct Gentle AI result and preserves expanded errors", () => {
+test("quiet tool rendering previews direct Gentle AI results and preserves expanded errors", () => {
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
 	const command = "gentle-ai review status --next-transition";
-	const textRose = "\u{1F339}\uFE0E";
+	const rose = "\u{1F339}";
 	const tool = tools.get("bash");
 	const failureText = "review status failed: authority unavailable\x1b[31m\nlineage=secret";
 	const expandHint = keyHint("app.tools.expand", "to expand");
@@ -509,16 +563,15 @@ test("quiet tool rendering hides every collapsed direct Gentle AI result and pre
 	const empty = renderToString(tool.renderResult(textResult(""), { expanded: false, isPartial: false }, passthroughTheme, { args: { command } }));
 	const nonText = renderToString(tool.renderResult({ content: [{ type: "image", data: "opaque", mimeType: "image/png" }] }, { expanded: false, isPartial: false }, passthroughTheme, { args: { command } }));
 
-	assert.equal([...textRose].length, 2);
-	assert.equal(cardTitle(call), `🌹︎ Gentle AI · running · review status`);
-	assert.match(cardBody(collapsed), /\d+ lines?\b/);
-	assert.match(cardBody(collapsed), /\d+ lines?\b/);
-	assert.doesNotMatch(collapsed, /next_transition|stop/);
-	assert.equal(cardBody(expanded).split("\n")[0], '{"next_transition":"stop"}');
-	assert.match(expanded, /"next_transition":"stop"/);
+	assert.equal([...rose].length, 1, "the rose is a plain emoji, no presentation selector");
+	assert.equal(visibleWidth(rose), 2);
+	assert.equal(cardTitle(call), `🌹 rdd running · status`);
+	assert.equal(cardBody(collapsed), "stop", "a JSON envelope collapses to its readable summary");
+	assert.doesNotMatch(collapsed, /\{"|next_transition/);
+	assert.equal(cardBody(expanded), '{\n  "next_transition": "stop"\n}', "expanded JSON is pretty-printed");
 	assert.doesNotMatch(expanded, /to expand/);
-	assert.match(cardBody(failure), /\d+ lines?\b/);
-	assert.doesNotMatch(failure, /review status failed|authority unavailable|lineage=secret/);
+	assert.match(cardBody(failure), /review status failed.*authority unavailable/);
+	assert.match(failure, /lineage=secret/);
 	assert.match(expandedFailure, /review status failed: authority unavailable/);
 	assert.match(expandedFailure, /lineage=secret/);
 	assert.doesNotMatch(expandedFailure, /to expand/);
@@ -566,16 +619,16 @@ test("quiet tool rendering transitions one Gentle AI header through lifecycle st
 	assert.strictEqual(initial, running);
 	assert.strictEqual(running, completed);
 	assert.strictEqual(completed, failed);
-	assert.equal(cardTitle(initialText), "🌹︎ Gentle AI · running · review status"); assert.equal(cardTone(initialText), "warning");
-	assert.equal(cardTitle(runningText), "🌹︎ Gentle AI · running · review status"); assert.equal(cardTone(runningText), "warning");
-	assert.equal(cardTitle(completedText), "🌹︎ Gentle AI · completed · review status"); assert.equal(cardTone(completedText), "success");
-	assert.equal(cardTitle(failedText), "🌹︎ Gentle AI · failed · review status"); assert.equal(cardTone(failedText), "error");
+	assert.equal(cardTitle(initialText), "🌹 rdd running · status"); assert.equal(cardTone(initialText), "warning");
+	assert.equal(cardTitle(runningText), "🌹 rdd running · status"); assert.equal(cardTone(runningText), "warning");
+	assert.equal(cardTitle(completedText), "🌹 rdd status"); assert.equal(cardTone(completedText), "success");
+	assert.equal(cardTitle(failedText), "🌹 rdd failed · status"); assert.equal(cardTone(failedText), "error");
 	assert.doesNotMatch(failedText, /private-change/);
 });
 
 test("quiet Bash keeps direct Gentle AI calls seamless while streaming", () => {
 	const tool = registeredQuietTools().get("bash");
-	const rose = /🌹︎ Gentle AI/;
+	const rose = /🌹/;
 	const render = (command: string, state: Record<string, unknown>, overrides: Record<string, unknown> = {}) => {
 		const component = tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, state, argsComplete: false, ...overrides }));
 		return [component, renderToString(component)] as const;
@@ -583,14 +636,14 @@ test("quiet Bash keeps direct Gentle AI calls seamless while streaming", () => {
 	const command = "gentle-ai review status --token 'lineage-secret";
 	const state = {};
 	const [preparing, collapsed] = render(command, state);
-	assert.equal(cardTitle(collapsed), "🌹︎ Gentle AI · preparing · review status");
+	assert.equal(cardTitle(collapsed), "🌹 rdd preparing · status");
 	assert.doesNotMatch(collapsed, /token|lineage-secret/);
 	const expanded = render(command, state, { expanded: true, lastComponent: preparing })[1];
-	assert.equal(cardTitle(expanded), "🌹︎ Gentle AI · preparing · review status"); assert.equal(cardBody(expanded), "$ gentle-ai review status --token 'lineage-secret");
+	assert.equal(cardTitle(expanded), "🌹 rdd preparing · status"); assert.equal(cardBody(expanded), "$ gentle-ai review status --token 'lineage-secret");
 
 	const direct = "gentle-ai review status";
 	const [running, runningText] = render(direct, state, { argsComplete: true, executionStarted: true, lastComponent: preparing });
-	assert.strictEqual(running, preparing); assert.equal(cardTitle(runningText), "🌹︎ Gentle AI · running · review status");
+	assert.strictEqual(running, preparing); assert.equal(cardTitle(runningText), "🌹 rdd running · status");
 	const genericState = {};
 	const [generic, genericText] = render("gentle-ai review status | cat", genericState);
 	assert.doesNotMatch(genericText, rose); assert.match(genericText, /\| cat/);
@@ -607,19 +660,14 @@ test("quiet Bash keeps direct Gentle AI calls seamless while streaming", () => {
 	assert.equal(genericResult.split("\n")[0], "generic result");
 	const directState = {}; render(direct, directState, { argsComplete: true });
 	const directResult = renderToolResult(tool, textResult("direct result"), { expanded: false, isPartial: false }, { args: { command: direct }, state: directState, argsComplete: true });
-	assert.match(cardBody(directResult), /\d+ lines?\b/);
+	assert.match(cardBody(directResult), /direct result/);
 });
 
 test("quiet tool rendering displays only finite safe Gentle AI operation paths", () => {
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
 	const tool = tools.get("bash");
-	const rose = "🌹︎";
 	const cases = [
-		["gentle-ai sdd-status change-123 --cwd /repo/private", "sdd status"],
-		["gentle-ai sdd-continue change-123 --json", "sdd continue"],
-		["gentle-ai sdd-attempt acquire --change change-123", "sdd attempt"],
-		["gentle-ai sdd-attempt settle --change change-123 --actor maintainer", "sdd attempt"],
 		["gentle-ai review capabilities --cwd /repo/private", "review capabilities"],
 		["gentle-ai review start --target sha256:secret --path src/private.ts", "review start"],
 		["gentle-ai review finalize --lineage lineage-secret --payload '{\"secret\":true}'", "review finalize"],
@@ -673,7 +721,7 @@ test("quiet tool rendering displays only finite safe Gentle AI operation paths",
 				routineRenderContext({ args: { command } }),
 			),
 		);
-		assert.equal(cardTitle(rendered), `🌹︎ Gentle AI · running · ${path}`, command);
+		assert.equal(cardTitle(rendered), path === "review" ? "🌹 rdd running" : `🌹 rdd running · ${path.slice("review ".length)}`, command);
 		assert.doesNotMatch(rendered, /change-123|private|secret|lineage|sha256|result\.json|incident\.json/);
 	}
 });
@@ -682,22 +730,20 @@ test("quiet tool rendering covers version and future standalone Gentle AI comman
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
 	const tool = tools.get("bash");
-	const rose = "🌹︎";
 	const cases = [
-		["gentle-ai version", "version"],
-		["gentle-ai future-command --authorization-root /repo/private", "command"],
-		["gentle-ai sdd-attempt future-verb --change secret-change", "sdd attempt"],
-		["gentle-ai review future-operation --path /repo/private", "review"],
-		["/package/.gentle-ai/v2.2.0/gentle-ai version", "version"],
-		["C:\\package\\.gentle-ai\\v2.2.0\\gentle-ai.exe future-command --root C:\\private", "command"],
+		["gentle-ai version", "gentle-ai running · version"],
+		["gentle-ai future-command --authorization-root /repo/private", "gentle-ai running · command"],
+		["gentle-ai review future-operation --path /repo/private", "rdd running"],
+		["/package/.gentle-ai/v2.2.0/gentle-ai version", "gentle-ai running · version"],
+		["C:\\package\\.gentle-ai\\v2.2.0\\gentle-ai.exe future-command --root C:\\private", "gentle-ai running · command"],
 	] as const;
 
 	for (const [command, path] of cases) {
 		const rendered = renderToString(
 			tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command } })),
 		);
-		assert.equal(cardTitle(rendered), `🌹︎ Gentle AI · running · ${path}`, command);
-		assert.doesNotMatch(rendered, /authorization-root|secret-change|private|C:\\\\private/);
+		assert.equal(cardTitle(rendered), `🌹 ${path}`, command);
+		assert.doesNotMatch(rendered, /authorization-root|private|C:\\\\private/);
 	}
 });
 
@@ -724,13 +770,13 @@ test("quiet tool rendering recognizes exact quoted, escaped, Windows, and comman
 
 	for (const command of routineCommands) {
 		const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
-		assert.equal(cardTitle(call), "🌹︎ Gentle AI · running · version", command);
+		assert.equal(cardTitle(call), "🌹 gentle-ai running · version", command);
 	}
 
 	for (const command of ["'gentle-ai-copy' version", '"gentle-ai-copy.exe" version', "'gentle-ai' version && echo done"] as const) {
 		const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
 		assert.equal(call.trimEnd(), `$ ${command}`);
-		assert.doesNotMatch(call, /🌹︎ Gentle AI/);
+		assert.doesNotMatch(call, /🌹/);
 	}
 });
 
@@ -743,35 +789,33 @@ test("quiet tool rendering recognizes only the exact resolved dev binary", () =>
 	});
 	const tool = tools.get("bash");
 	const cases = [
-		[`${devPath} review validate --gate pre-commit --cwd /repo/private`, "review validate pre commit"],
-		[`'${devPath}' review status --lineage secret`, "review status"],
-		[`"${devPath}" version`, "version"],
-		[`env FOO='a b' ${devPath} review capabilities`, "review capabilities"],
-		[`command -- "${devPath}" sdd-status hidden`, "sdd status"],
+		[`${devPath} review validate --gate pre-commit --cwd /repo/private`, "rdd running · validate pre commit"],
+		[`'${devPath}' review status --lineage secret`, "rdd running · status"],
+		[`"${devPath}" version`, "gentle-ai running · version"],
+		[`env FOO='a b' ${devPath} review capabilities`, "rdd running · capabilities"],
 	] as const;
 	for (const [command, operationPath] of cases) {
 		const call = renderToString(tool.renderCall({ command }, statusTheme, routineRenderContext({ args: { command } })));
-		assert.equal(cardTitle(call), `🌹︎ Gentle AI · running · ${operationPath}`, command); assert.equal(cardTone(call), "warning", command);
+		assert.equal(cardTitle(call), `🌹 ${operationPath}`, command); assert.equal(cardTone(call), "warning", command);
 		assert.doesNotMatch(call, /gentle-ai-main|private|secret|hidden/);
 	}
 	const command = `${devPath} review status --prompt hidden-prompt --lineage lineage-secret --body private-body`;
 	const lifecycleContext = routineRenderContext({ args: { command }, state: {} });
-	assert.match(renderToString(tool.renderCall({ command }, passthroughTheme, lifecycleContext)), /Gentle AI · running · review status/);
+	assert.match(renderToString(tool.renderCall({ command }, passthroughTheme, lifecycleContext)), /rdd running · status/);
 	devPath = "/new/dev/gentle-ai-main";
 	const refreshedCommand = `${devPath} review status --token token-secret`;
-	assert.match(renderToString(tool.renderCall({ command: refreshedCommand }, passthroughTheme, routineRenderContext({ args: { command: refreshedCommand } }))), /Gentle AI · running · review status/);
+	assert.match(renderToString(tool.renderCall({ command: refreshedCommand }, passthroughTheme, routineRenderContext({ args: { command: refreshedCommand } }))), /rdd running · status/);
 	assertGenericBash(tool, cases[2][0]);
 	const text = "error: private failure\nlineage=secret body=hidden\x1b[31m";
 	const collapsed = renderToolResult(tool, textResult(text), { expanded: false, isPartial: false, isError: true }, lifecycleContext);
 	const expanded = renderToolResult(tool, textResult(text), { expanded: true, isPartial: false, isError: true }, lifecycleContext);
 	const refreshed = renderToolResult(tool, textResult("result-secret"), { expanded: false, isPartial: false }, { args: { command: refreshedCommand } });
 	const hint = keyHint("app.tools.expand", "to expand");
-	assert.match(cardBody(collapsed), /\d+ lines?\b/);
+	assert.match(cardBody(collapsed), /private failure/);
 	assert.equal(cardBody(collapsed).split(hint).length - 1, 0);
-	assert.doesNotMatch(collapsed, /private|lineage|secret|hidden|error/);
 	assert.match(expanded, /private failure|lineage=secret body=hidden/);
 	assert.doesNotMatch(cardBody(expanded), /to expand|\x1b\[/);
-	assert.doesNotMatch(refreshed, /result-secret/);
+	assert.match(refreshed, /result-secret/);
 	assert.ok(resolutions > 1);
 });
 test("quiet tool rendering keeps unregistered dev lookalikes and composed calls generic", () => {
@@ -792,7 +836,7 @@ test("quiet tool rendering keeps unregistered dev lookalikes and composed calls
 	assertGenericBash(throwing!.get("bash"), unresolved);
 	assertGenericBash(registeredQuietToolsWithResolver(() => ({ path: "relative/gentle-ai-main" })).get("bash"), unresolved);
 });
-test("quiet tool rendering hides the routine partial result because the header owns state", () => {
+test("quiet tool rendering previews routine partial content while the header owns state", () => {
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
 	const tool = tools.get("bash");
@@ -832,12 +876,12 @@ test("quiet tool rendering hides the routine partial result because the header o
 		),
 	);
 
-	assert.match(cardBody(partial), /\d+ lines?\b/);
+	assert.equal(cardBody(partial), "running");
 	assert.equal(cardBody(partial).split(expandHint).length - 1, 0);
-	assert.match(partialExpanded, /"status":"running"/);
+	assert.match(partialExpanded, /"status": "running"/);
 	assert.doesNotMatch(partialExpanded, /to expand/);
-	assert.match(cardBody(partialFailure), /\d+ lines?\b/);
-	assert.match(cardBody(completed), /\d+ lines?\b/);
+	assert.match(cardBody(partialFailure), /authority unavailable/);
+	assert.equal(cardBody(completed), "running");
 
 	const partialExpandedFailure = renderToString(
 		tool.renderResult(
@@ -851,62 +895,7 @@ test("quiet tool rendering hides the routine partial result because the header o
 	assert.doesNotMatch(cardBody(partialExpandedFailure), /\x1b\[/);
 });
 
-test("quiet tool rendering collapses grant calls to action and authorization-root cardinality", () => {
-	const { pi, tools } = createPi();
-	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
-	const tool = tools.get("bash");
-	const command = "gentle-ai sdd-attempt grant --authorization-root /repo/root --authorization-root /other/root --change secret-change\x1b[31m";
-
-	const initial = tool.renderCall(
-		{ command },
-		statusTheme,
-		routineRenderContext({ args: { command } }),
-	);
-	const running = tool.renderCall(
-		{ command },
-		statusTheme,
-		routineRenderContext({ args: { command }, executionStarted: true, lastComponent: initial }),
-	);
-	const completed = tool.renderCall(
-		{ command },
-		statusTheme,
-		routineRenderContext({ args: { command }, executionStarted: true, isPartial: false, lastComponent: running }),
-	);
-	const failed = tool.renderCall(
-		{ command },
-		statusTheme,
-		routineRenderContext({ args: { command }, executionStarted: true, isPartial: false, isError: true, lastComponent: completed }),
-	);
-
-	assert.strictEqual(initial, running);
-	assert.strictEqual(running, completed);
-	assert.strictEqual(completed, failed);
-	const rendered = renderToString(failed);
-	assert.equal(cardTitle(rendered), "🌹︎ Gentle AI · failed · sdd attempt grant · 2 roots"); assert.equal(cardTone(rendered), "error");
-	assert.doesNotMatch(rendered.split(keyHint("app.tools.expand", "to expand")).join(""), /authorization-root|secret-change|repo\/root|other\/root|audit:|\x1b\[/);
-});
-
-test("quiet tool rendering counts grant authorization roots without rendering values", () => {
-	const { pi, tools } = createPi();
-	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
-	const tool = tools.get("bash");
-	const cases = [
-		["gentle-ai sdd-attempt grant --change change", "sdd attempt grant"],
-		["gentle-ai sdd-attempt grant --authorization-root /repo/root", "sdd attempt grant · 1 root"],
-		["gentle-ai sdd-attempt grant --authorization-root=/repo/root", "sdd attempt grant · 1 root"],
-		["gentle-ai sdd-attempt grant --authorization-root --change change", "sdd attempt grant"],
-		["gentle-ai sdd-attempt grant --authorization-root /one --authorization-root=/two --authorization-root /three", "sdd attempt grant · 3 roots"],
-		["gentle-ai sdd-attempt grant --authorization-root= --authorization-root /one", "sdd attempt grant · 1 root"],
-	] as const;
-
-	for (const [command, expected] of cases) {
-		const rendered = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
-		assert.equal(cardTitle(rendered), `🌹︎ Gentle AI · running · ${expected}`, command);
-		assert.doesNotMatch(rendered, /authorization-root|\/repo\/root|\/one|\/two|\/three|change/);
-	}
-});
-
-test("quiet tool rendering hides invocation secrets from collapsed Gentle AI calls and results", () => {
+test("quiet tool rendering hides invocation arguments but previews result content without redaction", () => {
 	const { pi, tools } = createPi();
 	withEnv({ GENTLE_PI_QUIET_TOOLS: undefined }, () => quietTools(pi as any));
 	const tool = tools.get("bash");
@@ -921,11 +910,11 @@ test("quiet tool rendering hides invocation secrets from collapsed Gentle AI cal
 		),
 	);
 
-	assert.equal(cardTitle(call), "🌹︎ Gentle AI · running · review finalize");
-	assert.match(cardBody(collapsed), /\d+ lines?\b/);
+	assert.equal(cardTitle(call), "🌹 rdd running · finalize");
+	assert.match(cardBody(collapsed), /audit:/);
 	for (const forbidden of ["hidden-prompt", "lineage-secret", "private-body", "/private/root", "audit:"]) {
 		assert.doesNotMatch(call, new RegExp(forbidden));
-		assert.doesNotMatch(collapsed, new RegExp(forbidden));
+		assert.match(collapsed, new RegExp(forbidden), "result preview is not secret redaction");
 	}
 });
 
@@ -952,7 +941,7 @@ test("quiet tool rendering keeps shell compositions, expansions, and lookalikes
 			tool.renderResult(textResult("original command output"), { expanded: true, isPartial: false }, passthroughTheme, { args: { command } }),
 		);
 		assert.equal(call.trimEnd(), `$ ${command}`);
-		assert.doesNotMatch(call, /🌹︎ Gentle AI/);
+		assert.doesNotMatch(call, /🌹/);
 		assert.match(output, /original command output/);
 	}
 });
@@ -977,11 +966,11 @@ test("quiet Bash previews semantic lines for generic JSON output", () => {
 	const collapsed = renderToolResult(tool, textResult(object), { expanded: false, isPartial: false }, { args: { command } });
 	const expanded = renderToolResult(tool, textResult(object), { expanded: true, isPartial: false }, { args: { command } });
 	assert.equal(call.trimEnd(), `$ ${command}`);
-	assert.doesNotMatch(call, /🌹︎ Gentle AI/);
+	assert.doesNotMatch(call, /🌹/);
 	assert.doesNotMatch(collapsed, /^\n\s*[}\]]/);
 	const expandHint = keyHint("app.tools.expand", "to expand");
-	assert.equal(collapsed.split(expandHint).length - 1, 1);
-	assert.equal(expanded, `\n${object}`);
+	assert.equal(collapsed.split(expandHint).length - 1, 0);
+	assert.equal(expanded, object);
 	assert.doesNotMatch(expanded, /to expand/);
 });
 
@@ -1044,19 +1033,21 @@ test("quiet tool rendering limits collapsed visual rows at the actual width", ()
 	const tools = registeredQuietTools();
 	const bash = tools.get("bash");
 	const hint = keyHint("app.tools.expand", "to expand");
-	const narrowWidth = 12;
+	// Twelve content columns inside the four-column card sides.
+	const narrowWidth = 16;
 	const cases = [
-		[textResult("x".repeat(80)), { expanded: false, isPartial: true }, { args: { command: "printf output" } }, 4],
+		// Preview rows plus the closing rule; a partial result adds its label row.
+		[textResult("x".repeat(80)), { expanded: false, isPartial: true }, { args: { command: "printf output" } }, 5],
 		[textResult("界".repeat(40)), { expanded: false, isPartial: false }, { args: { command: "printf output" } }, 4],
 		[textResult("e\u0301".repeat(40)), { expanded: false, isPartial: false, isError: true }, { args: { command: "false" }, isError: true }, 4],
 	] as const;
 	for (const [result, options, context, maxRows] of cases) {
-		const lines = renderLines(bash.renderResult(result, options, passthroughTheme, context), narrowWidth);
+		const lines = frameLines(bash.renderResult(result, options, passthroughTheme, context), narrowWidth);
 		assert.ok(lines.length <= maxRows, `expected at most ${maxRows} rows, got ${lines.length}`);
 		assert.ok(lines.every((line) => visibleWidth(line) <= narrowWidth));
 	}
-	const completed = renderLines(bash.renderResult(textResult("😀".repeat(40)), { expanded: false, isPartial: false }, passthroughTheme, { args: { command: "printf output" } }), narrowWidth);
-	assert.equal(completed.filter((line) => line.includes(hint)).length, 1);
+	const completed = frameLines(bash.renderResult(textResult("😀".repeat(40)), { expanded: false, isPartial: false }, passthroughTheme, { args: { command: "printf output" } }), narrowWidth);
+	assert.equal(completed.filter((line) => line.includes(hint)).length, 0);
 	assert.ok(completed.every((line) => visibleWidth(line) <= narrowWidth));
 });
 
@@ -1069,8 +1060,8 @@ test("quiet tool rendering classifies quoted and escaped literal shell metachara
 	]) {
 		const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
 		const collapsed = renderToolResult(tool, textResult("private output"), { expanded: false, isPartial: false }, { args: { command } });
-		assert.match(call, /🌹︎ Gentle AI · running · review status/, command);
-		assert.doesNotMatch(collapsed, /private output/, command);
+		assert.match(call, /🌹 rdd running · status/, command);
+		assert.match(collapsed, /private output/, command);
 	}
 });
 
@@ -1102,9 +1093,9 @@ test("quiet tool rendering recognizes a quoted exact dev override path containin
 	const command = `"${devPath}" review status "literal \\$|#;"`;
 	const call = renderToString(tool.renderCall({ command }, passthroughTheme, { args: { command } }));
 	const collapsed = renderToolResult(tool, textResult("private result"), { expanded: false, isPartial: false }, { args: { command } });
-	assert.equal(cardTitle(call), "🌹︎ Gentle AI · running · review status");
+	assert.equal(cardTitle(call), "🌹 rdd running · status");
 	assert.doesNotMatch(call, /\/opt\/Gentle AI\/gentle-ai|literal/);
-	assert.doesNotMatch(collapsed, /private result/);
+	assert.match(collapsed, /private result/);
 });
 
 test("quiet tool rendering bounds and sanitizes partial text without a completion hint", () => {
@@ -1142,20 +1133,20 @@ test("quiet tool rendering bounds completed previews, errors, and edit/write sum
 		const rendered = renderToolResult(tools.get(toolName), textResult(text), { expanded: false, isPartial: false }, context);
 		assert.doesNotMatch(rendered, new RegExp(hidden));
 		assert.match(rendered, new RegExp(visible));
-		assert.match(rendered, /to expand/);
+		assert.doesNotMatch(rendered, /to expand/);
 	}
 
 	for (const toolName of ["read", "bash", "grep", "find", "ls", "edit", "write"] as const) {
 		const rendered = renderToolResult(tools.get(toolName), textResult("error one\nerror two\nerror three\nerror four"), { expanded: false, isPartial: false, isError: true }, { args: toolName === "bash" ? { command: "false" } : {} });
 		assert.doesNotMatch(rendered, /error one/);
 		assert.match(rendered, /error two\nerror three\nerror four/);
-		assert.match(rendered, /to expand/);
+		assert.doesNotMatch(rendered, /to expand/);
 	}
 
 	const edit = renderToolResult(tools.get("edit"), textResult("Applied", { diff: "@@\n-old\n+new" }), { expanded: false, isPartial: false }, { args: { path: "file.ts", edits: [] } });
 	const write = renderToolResult(tools.get("write"), textResult("Successfully wrote 4 bytes\nbody"), { expanded: false, isPartial: false }, { args: { path: "file.ts", content: "body" } });
 	assert.match(edit, /\+1 \/ -1/);
-	assert.doesNotMatch(edit, /Applied|old|new/);
+	assert.match(edit, /-old[\s\S]*\+new/);
 	assert.match(write, /wrote 4 bytes/);
 	assert.doesNotMatch(write, /body/);
 });
@@ -1184,7 +1175,8 @@ test("quiet tool rendering preserves directional visual preview rows at narrow w
 	const tools = registeredQuietTools();
 	const bash = tools.get("bash");
 	const readTool = tools.get("read");
-	const narrowWidth = 12;
+	// Twelve content columns inside the four-column card sides.
+	const narrowWidth = 16;
 	const renderCollapsed = (
 		text: string,
 		options: { expanded: false; isPartial: boolean; isError?: boolean },
@@ -1213,7 +1205,7 @@ test("quiet tool rendering preserves directional visual preview rows at narrow w
 		assert.match(lines.join("\n"), new RegExp(marker));
 	}
 	assert.match(partial[0] ?? "", /… bash/);
-	assert.match(completedBash.join("\n"), /to expand/);
+	assert.doesNotMatch(completedBash.join("\n"), /to expand/);
 
 	const read = renderRead(`READ-FIRST\n${oldText}\nREAD-NEW`);
 	const semanticJson = renderCollapsed(
@@ -1259,8 +1251,8 @@ test("quiet tool rendering fails closed on unquoted shell expansions", () => {
 		const call = renderToString(bash.renderCall({ command }, passthroughTheme, { args: { command } }));
 		const collapsed = renderToolResult(bash, textResult("dummy-secret"), { expanded: false, isPartial: false }, { args: { command } });
 		assert.equal(gentleAiRoutineCommand({ command }), "review", command);
-		assert.match(call, /🌹︎ Gentle AI · running · review status/, command);
-		assert.doesNotMatch(collapsed, /dummy-secret/, command);
+		assert.match(call, /🌹 rdd running · status/, command);
+		assert.match(collapsed, /dummy-secret/, command);
 	}
 });
 
@@ -1275,9 +1267,9 @@ test("quiet tool rendering redacts only exact package-local executable paths wit
 		const call = renderToString(bash.renderCall({ command }, passthroughTheme, { args: { command } }));
 		const collapsed = renderToolResult(bash, textResult("dummy-secret"), { expanded: false, isPartial: false }, { args: { command } });
 		assert.equal(gentleAiRoutineCommand({ command }), "review", command);
-		assert.match(call, /🌹︎ Gentle AI · running · review status/, command);
+		assert.match(call, /🌹 rdd running · status/, command);
 		assert.doesNotMatch(call, /Gentle Package|secret/, command);
-		assert.doesNotMatch(collapsed, /dummy-secret/, command);
+		assert.match(collapsed, /dummy-secret/, command);
 	}
 
 	for (const command of [
@@ -1304,8 +1296,8 @@ test("quiet tool rendering respects command and env wrapper order", () => {
 		const call = renderToString(bash.renderCall({ command }, passthroughTheme, { args: { command } }));
 		const collapsed = renderToolResult(bash, textResult("dummy-secret"), { expanded: false, isPartial: false }, { args: { command } });
 		assert.equal(gentleAiRoutineCommand({ command }), "review", command);
-		assert.match(call, /🌹︎ Gentle AI · running · review status/, command);
-		assert.doesNotMatch(collapsed, /dummy-secret/, command);
+		assert.match(call, /🌹 rdd running · status/, command);
+		assert.match(collapsed, /dummy-secret/, command);
 	}
 
 	const command = "env FOO=bar command -- gentle-ai review status";
@@ -1325,20 +1317,20 @@ test("quiet tool rendering lets a final result promote a replayed call card to i
 	const replayed = routineRenderContext({ args: { command }, state, argsComplete: false, executionStarted: false, isPartial: false, invalidate: () => { invalidations += 1; } });
 
 	const call = tool.renderCall({ command }, statusTheme, replayed);
-	assert.equal(cardTitle(renderToString(call)), "🌹︎ Gentle AI · preparing · review status");
+	assert.equal(cardTitle(renderToString(call)), "🌹 rdd preparing · status");
 	renderToString(tool.renderResult(textResult("done"), { expanded: false, isPartial: false }, statusTheme, replayed));
 	assert.equal(invalidations, 0, "never reentrant");
 	await flush();
 	assert.equal(invalidations, 1);
 	const promoted = tool.renderCall({ command }, statusTheme, { ...replayed, lastComponent: call });
 	assert.strictEqual(promoted, call);
-	assert.equal(cardTitle(renderToString(promoted)), "🌹︎ Gentle AI · completed · review status");
+	assert.equal(cardTitle(renderToString(promoted)), "🌹 rdd status");
 	assert.equal(cardTone(renderToString(promoted)), "success");
 
 	renderToString(tool.renderResult(textResult("boom"), { expanded: false, isPartial: false }, statusTheme, { ...replayed, isError: true }));
 	await flush();
 	assert.equal(invalidations, 2);
-	assert.equal(cardTitle(renderToString(tool.renderCall({ command }, statusTheme, { ...replayed, lastComponent: call }))), "🌹︎ Gentle AI · failed · review status");
+	assert.equal(cardTitle(renderToString(tool.renderCall({ command }, statusTheme, { ...replayed, lastComponent: call }))), "🌹 rdd failed · status");
 	renderToString(tool.renderResult(textResult("boom"), { expanded: false, isPartial: false }, statusTheme, { ...replayed, isError: true }));
 	await flush();
 	assert.equal(invalidations, 2, "an unchanged outcome must not request another render");
@@ -1353,11 +1345,244 @@ test("quiet tool rendering puts the expand key in the finished call card's top r
 	assert.equal(cardHint(running), undefined, "a running call has nothing to expand yet");
 	const completed = renderToString(tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, executionStarted: true, isPartial: false, expanded: false })));
 	assert.match(cardHint(completed) ?? "", /to expand$/);
-	assert.equal(cardTitle(completed), "🌹︎ Gentle AI · completed · review status");
+	assert.equal(cardTitle(completed), "🌹 rdd status");
 	const expanded = renderToString(tool.renderCall({ command }, passthroughTheme, routineRenderContext({ args: { command }, executionStarted: true, isPartial: false, expanded: true })));
 	assert.match(cardHint(expanded) ?? "", /to collapse$/);
 	const collapsedResult = renderToolResult(tool, textResult("{\"next_transition\":\"stop\"}"), { expanded: false, isPartial: false }, { args: { command } });
-	assert.equal(cardBody(collapsedResult), "1 line");
-	assert.equal(cardBody(renderToolResult(tool, textResult("a\nb\nc"), { expanded: false, isPartial: false }, { args: { command } })), "3 lines");
+	assert.equal(cardBody(collapsedResult), "stop");
+	assert.equal(cardBody(renderToolResult(tool, textResult("a\nb\nc"), { expanded: false, isPartial: false }, { args: { command } })), "a\nb\nc");
 	assert.match(collapsedResult.split("\n").pop() ?? "", /╰─+╯$/);
 });
+
+test("long finished quiet headings retain the applicable expansion hint and complete command", () => {
+	const tool = registeredQuietTools().get("bash");
+	const command = "printf alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mike november oscar papa quebec romeo sierra tango";
+	const args = { command };
+	for (const expanded of [false, true]) {
+		const hint = keyHint("app.tools.expand", expanded ? "to collapse" : "to expand").replace(/\x1b\[[\d;]*m/g, "");
+		const ctx = routineRenderContext({ args, executionStarted: true, isPartial: false, expanded });
+		for (const width of [80, 120]) {
+			const rows = frameLines(tool.renderCall(args, passthroughTheme, ctx), width);
+			assert.ok(rows[0].endsWith(` ${hint} ╮`), `width ${width}: applicable hint must survive heading wrapping`);
+			assert.ok(rows.length > 1);
+			assert.ok(rows.every((row) => visibleWidth(row) <= width));
+			const first = rows[0].slice("╭─ $ ".length).split(" ─")[0];
+			const rest = rows.slice(1).map((row) => row.replace(/^│ /, "").replace(/ +│$/, ""));
+			assert.equal([first, ...rest].join(" ").replace(/\s+/g, " ").trim(), `bash $ ${command}`);
+		}
+	}
+});
+
+test("quiet components repaint after theme invalidation and retain transparent error frames", (t) => {
+	const found = cardStyle();
+	t.after(() => setCardStyle(found));
+	setCardStyle(CARD_STYLE.NEON);
+	const bash = registeredQuietTools().get("bash");
+	let paint = "\x1b[31m";
+	const theme = { bold: (text: string) => text, fg: (_role: string, text: string) => `${paint}${text}\x1b[0m`, bg: (_role: string, text: string) => `\x1b[44m${text}\x1b[49m` };
+	const args = { command: "printf failure" };
+	const context = routineRenderContext({ args, isError: true, isPartial: false });
+	const components = [bash.renderCall(args, theme, context), bash.renderResult(textResult("denied\nreason"), { expanded: false, isPartial: false }, theme, context)];
+	const first = components.flatMap((component) => component.render(80)).join("\n");
+	paint = "\x1b[35m";
+	for (const component of components) component.invalidate();
+	const changed = components.flatMap((component) => component.render(80)).join("\n");
+	assert.match(first, /\x1b\[31m/);
+	assert.doesNotMatch(changed, /\x1b\[31m|\x1b\[44m/);
+	assert.match(changed, /\x1b\[35m/);
+	assert.equal(first.replace(/\x1b\[[\d;]*m/g, ""), changed.replace(/\x1b\[[\d;]*m/g, ""));
+});
+
+test("six quiet cards and standalone Bash fixture retain distinct identity and bounded results", () => {
+	const tools = registeredQuietTools();
+	for (const [name, glyph] of [["read", "≡"], ["bash", "$"], ["grep", "⌕"], ["find", "⌖"], ["ls", "☷"], ["edit", "✎"], ["write", "+"]] as const) {
+		const tool = tools.get(name);
+		const args = { command: "printf hello", path: "src/example.ts", pattern: "needle" };
+		const ctx = routineRenderContext({ args, isPartial: false, executionStarted: true });
+		const header = frameLines(tool.renderCall(args, passthroughTheme, ctx), 120).join("\n");
+		assert.ok(header.startsWith(`╭─ ${glyph} ${name} `), `${name} retains its distinct icon and actual identity`);
+		assert.match(header, /to expand/);
+		const value = textResult("useful row\nsecond row", name === "edit" ? { diff: "-before\n+after" } : undefined);
+		const body = frameLines(tool.renderResult(value, { expanded: false, isPartial: false }, passthroughTheme, ctx), 120).join("\n");
+		if (name !== "write") assert.match(body, name === "edit" ? /before|after/ : /useful row/);
+		for (const width of [0, 1, 2, 3, 4, 5, 6, 7, 8, 24]) {
+			const rows = frameLines(tool.renderResult(textResult("界e\u0301🌹".repeat(80)), { expanded: false, isPartial: false }, passthroughTheme, ctx), width);
+			assert.ok(rows.length <= 4);
+			assert.ok(rows.every((row) => visibleWidth(row) <= width));
+			assert.equal(rows.filter((row) => row.startsWith("╰")).length, width ? 1 : 0);
+		}
+	}
+});
+
+test("quiet tool calls draw a rounded petal card in the lifecycle tone", () => {
+	const tools = registeredQuietTools();
+	const bash = tools.get("bash");
+	const args = { command: "printf output" };
+	const width = 30;
+
+	const header = bash.renderCall(args, passthroughTheme, routineRenderContext({ args, isPartial: false })).render(width);
+	assert.deepEqual(header, [`╭─ $ bash $ printf output ${"─".repeat(3)}╮`]);
+	const running = bash.renderCall(args, statusTheme, routineRenderContext({ args, executionStarted: true, isPartial: true })).render(width);
+	assert.match(running[0] ?? "", /^<warning>╭<\/warning><warning>─ <\/warning><warning>\$ (?:<toolTitle>)?bash/);
+	assert.match(bash.renderCall(args, statusTheme, routineRenderContext({ args, isPartial: false, isError: true })).render(width)[0] ?? "", /^<error>╭<\/error>/);
+
+	const expanded = bash.renderResult(textResult("alpha\nbeta"), { expanded: true, isPartial: false }, passthroughTheme, { args }).render(width);
+	assert.deepEqual(expanded, [
+		`│ alpha${" ".repeat(21)} │`,
+		`│ beta${" ".repeat(22)} │`,
+		`╰${"─".repeat(28)}╯`,
+	]);
+	const failed = bash.renderResult(textResult("boom"), { expanded: true, isPartial: false, isError: true }, statusTheme, { args, isError: true }).render(width);
+	assert.match(failed.at(-1) ?? "", /^<error>╰<\/error><error>─+╯<\/error>$/);
+	assert.ok(failed.slice(0, -1).every((line) => line.startsWith("<error>│</error> ")), failed.join("\n"));
+
+	const empty = tools.get("grep").renderResult(textResult("No matches found"), { expanded: false, isPartial: false }, passthroughTheme, {}).render(width);
+	assert.deepEqual(empty, [`╰${"─".repeat(28)}╯`], "an empty result still closes the card");
+
+	// The expand key rides the top rule once the call finished, like the Gentle AI card.
+	const wide = 80;
+	const expandKey = keyHint("app.tools.expand", "to expand").replace(/\x1b\[[0-9;]*m/g, "");
+	const finishedTop = bash.renderCall(args, passthroughTheme, routineRenderContext({ args, executionStarted: true, isPartial: false })).render(wide)[0] ?? "";
+	assert.ok(finishedTop.endsWith(` ${expandKey} ╮`), finishedTop);
+	const expandedTop = bash.renderCall(args, passthroughTheme, routineRenderContext({ args, executionStarted: true, isPartial: false, expanded: true })).render(wide)[0] ?? "";
+	assert.match(expandedTop, /to collapse ╮$/);
+	const runningTop = bash.renderCall(args, passthroughTheme, routineRenderContext({ args, executionStarted: true, isPartial: true })).render(wide)[0] ?? "";
+	assert.ok(!runningTop.includes("to expand"), runningTop);
+	const collapsedBody = bash.renderResult(textResult("alpha\nbeta"), { expanded: false, isPartial: false }, passthroughTheme, { args }).render(wide);
+	assert.ok(!collapsedBody.some((line) => line.includes("to expand")), "the body no longer carries the expand key");
+
+	for (const narrow of [1, 2, 3, 4, 5, 8]) {
+		const lines = [
+			...bash.renderCall({ command: "printf " + "x".repeat(80) }, passthroughTheme, routineRenderContext({ args, isPartial: false })).render(narrow),
+			...bash.renderResult(textResult("😀".repeat(40)), { expanded: true, isPartial: false }, passthroughTheme, { args }).render(narrow),
+		];
+		for (const line of lines) assert.ok(visibleWidth(line) <= narrow, `width ${narrow}: ${JSON.stringify(line)}`);
+	}
+});
+
+// Pi builds the call component, then the result component once a result
+// exists, and only then renders them; both share one row state.
+function piToolRow(tool: any, args: Record<string, unknown>, value: unknown, context: Record<string, unknown>, width: number, theme: object = passthroughTheme): string[] {
+	const call = tool.renderCall(args, theme, context);
+	const body = value ? tool.renderResult(value, { expanded: context.expanded === true, isPartial: context.isPartial === true }, theme, context) : undefined;
+	return [...call.render(width), ...(body?.render(width) ?? [])];
+}
+
+test("a running quiet card closes its own frame with one running row until a result exists", () => {
+	const tools = registeredQuietTools();
+	const read = tools.get("read");
+	const args = { path: "a.md" };
+	const pending = () => routineRenderContext({ args, executionStarted: true, isPartial: true, state: {} });
+	const running = piToolRow(read, args, undefined, pending(), 40);
+	assert.deepEqual(running, [
+		`╭─ ≡ read a.md ${"─".repeat(24)}╮`,
+		`│ running…${" ".repeat(28)} │`,
+		`╰${"─".repeat(38)}╯`,
+	]);
+	const painted = piToolRow(read, args, undefined, pending(), 40, statusTheme).join("\n");
+	assert.match(painted, /<muted>running…<\/muted>/);
+	assert.match(painted, /<warning>╰<\/warning>/);
+	for (const width of [0, 1, 2, 3, 4, 5, 6, 7, 8]) {
+		const rows = piToolRow(read, args, undefined, pending(), width);
+		assert.ok(rows.every((row) => visibleWidth(row) <= width), `width ${width}`);
+		// Narrow headings may continue on rows below the top rule; the frame still closes once.
+		assert.equal(rows.filter((row) => row.startsWith("╰")).length, width === 0 ? 0 : 1);
+		if (width > 0) assert.ok(rows.at(-1)!.startsWith("╰"), `width ${width}: ${rows.join("\n")}`);
+	}
+
+	// A partial result below the call closes the frame instead: one bottom rule, no running row.
+	const bash = tools.get("bash");
+	const bashArgs = { command: "printf output" };
+	const partial = piToolRow(bash, bashArgs, textResult("out"), routineRenderContext({ args: bashArgs, executionStarted: true, isPartial: true, state: {} }), 40);
+	assert.equal(partial.filter((row) => row.startsWith("╭")).length, 1);
+	assert.equal(partial.filter((row) => row.startsWith("╰")).length, 1);
+	assert.match(partial.at(-1)!, /^╰─+╯$/);
+	assert.doesNotMatch(partial.join("\n"), /running…/);
+
+	// A finished call keeps its open top rule; the result closes the card.
+	const finished = piToolRow(read, args, textResult("one"), routineRenderContext({ args, executionStarted: true, isPartial: false, state: {} }), 40);
+	assert.equal(finished.length, 3);
+	assert.match(finished[0]!, /^╭─ ≡ read a\.md .*╮$/);
+	assert.match(finished[1]!, /^│ one +│$/);
+	assert.match(finished[2]!, /^╰─+╯$/);
+});
+
+
+
+// Float style: the call and result components of one quiet card read as one
+// borderless panel. The heading owns the blank row above it; the result owns
+// the separator below the heading and the blank closing row.
+const floatToolTheme = {
+	bold(value: string) {
+		return value;
+	},
+	fg(_color: string, value: string) {
+		return `\x1b[38;5;114m${value}\x1b[39m`;
+	},
+	bg(color: string, value: string) {
+		return `\x1b[48;5;${color === "toolErrorBg" ? 52 : color === "toolPendingBg" ? 58 : 22}m${value}\x1b[49m`;
+	},
+};
+
+function withFloatCards<T>(run: () => T): T {
+	setCardStyle(CARD_STYLE.FLOAT);
+	try {
+		return run();
+	} finally {
+		setCardStyle(CARD_STYLE.NEON);
+	}
+}
+
+test("float quiet cards render the call and result as one panel with a single separator", () => {
+	const tools = registeredQuietTools();
+	const read = tools.get("read");
+	const context = routineRenderContext({ args: { path: "package.json" }, isPartial: false, executionStarted: true });
+	const width = 60;
+	const rows = withFloatCards(() => [
+		...read.renderCall({ path: "package.json" }, floatToolTheme, context).render(width),
+		...read.renderResult(textResult("{\n  \"name\": \"gentle-pi\""), { expanded: false, isPartial: false }, floatToolTheme, context).render(width),
+	]);
+	const plain = rows.map(stripAnsi);
+	for (const line of rows) {
+		assert.equal(visibleWidth(line), width);
+		assert.ok(line.startsWith(" \x1b[48;5;22m"), JSON.stringify(line));
+		assert.ok(line.endsWith("\x1b[49m "), JSON.stringify(line));
+	}
+	assert.doesNotMatch(plain.join("\n"), /[╭╮╰╯│─]/);
+	assert.match(plain[0]!, /^ ▎ +$/);
+	assert.match(plain[1]!, /^ ▎ ≡ read package\.json +.*to expand {4}$/);
+	assert.match(plain[2]!, /^ ▎ +$/);
+	assert.match(plain[3]!, /^ ▎ \{ +$/);
+	assert.match(plain[4]!, /^ ▎ {3}"name": "gentle-pi" +$/);
+	assert.match(plain.at(-1)!, /^ ▎ +$/);
+	assert.equal(plain.length, 6);
+	assert.equal(plain[1]!.indexOf("≡"), plain[3]!.indexOf("{"), "the glyph starts in the body text column");
+});
+
+test("float quiet cards close a running call as one panel and add no separator without result rows", () => {
+	const tools = registeredQuietTools();
+	const read = tools.get("read");
+	const running = withFloatCards(() => read.renderCall({ path: "a.md" }, floatToolTheme, routineRenderContext({ args: { path: "a.md" }, state: {} })).render(40)).map(stripAnsi);
+	assert.equal(running.length, 5, "blank row, heading, separator, running row, closing row");
+	assert.match(running[0]!, /^ ▎ +$/);
+	assert.match(running[1]!, /^ ▎ ≡ read a\.md +$/);
+	assert.match(running[2]!, /^ ▎ +$/);
+	assert.match(running[3]!, /^ ▎ running… +$/);
+	assert.match(running[4]!, /^ ▎ +$/);
+	assert.doesNotMatch(running.join("\n"), /[╭╮╰╯│─]/);
+	const empty = withFloatCards(() => read.renderResult(textResult(""), { expanded: false, isPartial: false }, floatToolTheme, routineRenderContext({ isPartial: false })).render(40)).map(stripAnsi);
+	assert.deepEqual(empty, [` ▎${" ".repeat(37)} `], "an empty result only closes the panel");
+});
+
+test("quiet cards stay outlined in the neon style with a background-capable theme", () => {
+	const tools = registeredQuietTools();
+	const read = tools.get("read");
+	const context = routineRenderContext({ args: { path: "a.md" }, isPartial: false, executionStarted: true });
+	const rows = [
+		...read.renderCall({ path: "a.md" }, floatToolTheme, context).render(40),
+		...read.renderResult(textResult("one"), { expanded: false, isPartial: false }, floatToolTheme, context).render(40),
+	].map(stripAnsi);
+	assert.match(rows[0]!, /^╭─ ≡ read a\.md/);
+	assert.match(rows.at(-1)!, /^╰─+╯$/);
+	assert.doesNotMatch(rows.join("\n"), /▎/);
+});