@zenodinh/pi-render 0.1.5 → 0.1.7

package/index.ts

@@ -47,11 +47,13 @@ import {
 } from "./src/renderers/content/artifacts/engines.ts";
 import { type ArtifactServer, createArtifactServer } from "./src/renderers/content/artifacts/server.ts";
 import { createCodePanel, mapFencedBlocks, panelWidth } from "./src/renderers/content/code-panel.ts";
+import { heading } from "./src/renderers/content/heading.ts";
 import { createImageCardSurface } from "./src/renderers/content/image-card.ts";
 import { type ContentSurfaces, createContentTransformer } from "./src/renderers/content/index.ts";
 import { createJsonPanel } from "./src/renderers/content/json-panel.ts";
 import { mapHtmlLinkCards } from "./src/renderers/content/link-paragraph.ts";
 import { table } from "./src/renderers/content/table.ts";
+import { FALLBACK_MODULE } from "./src/renderers/tool/fallback.ts";
 import { createMasterResolver, type SpecEntry } from "./src/renderers/tool/index.ts";
 import { bashRow } from "./src/renderers/tool/specs/bash.ts";
 import {
@@ -91,6 +93,7 @@ const ROW_SPECS: Record<string, SpecEntry> = Object.fromEntries(
  * SA §6). The surface lanes export `rewrite` only, so their descriptors live here.
  */
 const CONTENT_MODULES: readonly ModuleDescriptor[] = [
+	{ key: "content.heading", name: "Heading levels", defaultEnabled: true, settings: [] },
 	{ key: "content.table", name: "Table blocks", defaultEnabled: true, settings: [] },
 	{ key: "content.codePanel", name: "Code panels", defaultEnabled: true, settings: [] },
 	{ key: "content.jsonPanel", name: "JSON panels", defaultEnabled: true, settings: [] },
@@ -102,6 +105,9 @@ const CONTENT_MODULES: readonly ModuleDescriptor[] = [
 const MODULES: readonly ModuleDescriptor[] = uniqueModules([
 	...ROW_RECORDS.map((row) => row.descriptor),
 	CODE_THEME_MODULE,
+	// The fallback row's key: a name-less module beside the code theme. Not a content surface and not a
+	// ROW_RECORDS entry — the resolver's catch-all is keyed on no tool name.
+	FALLBACK_MODULE,
 	...CONTENT_MODULES,
 ]);
 
@@ -265,7 +271,7 @@ async function installArtifacts(log: Logger, deps: BootDeps, holder: ArtifactsHo
 }
 
 /**
- * Region 2's synchronous half: five surfaces over lazy holders, then the one registerMarkdownTransformer
+ * Region 2's synchronous half: six surfaces over lazy holders, then the one registerMarkdownTransformer
  * call. It runs before piRender's first await, so the host's restored-message construction sees the
  * transformer (see `piRender`); the shiki theme and the artifact cache/server stay cold until the
  * awaited lanes fill them.
@@ -278,6 +284,7 @@ function registerContentSeam(
 	artifacts: ArtifactsHolder,
 ): void {
 	const surfaces: ContentSurfaces = {
+		heading,
 		table,
 		codePanel: createCodePanel(codeTheme),
 		jsonPanel: createJsonPanel(codeTheme, { read: readLinkedFile, log }),
@@ -289,7 +296,10 @@ function registerContentSeam(
 	};
 	// The host's markdown theme is live per call, so its closures are captured once, here.
 	pi.registerMarkdownTransformer(
-		createContentTransformer(registry, surfaces, { paint: createContentPaint(getMarkdownTheme()), log }),
+		createContentTransformer(registry, surfaces, {
+			paint: createContentPaint(getMarkdownTheme()),
+			log,
+		}),
 	);
 }
 

package/package.json

@@ -67,5 +67,5 @@
 		"typescript": "^7.0.2",
 		"vitest": "^5.0.3"
 	},
-	"version": "0.1.5"
+	"version": "0.1.7"
 }

package/src/core/paint.ts

@@ -3,10 +3,11 @@
  *
  * Boundary: renderers call role methods and never emit an escape (AGENTS: every escape originates
  * here); both theme inputs are structural, so a plain-object fixture drives either factory with no
- * host import.
+ * host import. The band's background ink is the one input that arrives late — through the theme
+ * holder — so it is read per call and falls back to reverse video when nothing was fed.
  *
- * shape: none — dispatch object does not apply: no discriminator, every role is a token lookup. The
- * two closure factories below declare their own shape.
+ * shape: none at module level — a role is a token lookup with no discriminator. The two closure
+ * factories and the band-style dispatch inside the second one declare their own shape.
  *
  * ported from pi-pretty-tui/src/config.ts:71-100 — survives because: "read the theme token, degrade to
  * default when it is absent" is what resolveBaseBackground did; its dead links (`toolBg`,
@@ -49,15 +50,17 @@ function tryStyle(fn: ((text: string) => string) | undefined, text: string): str
 	}
 }
 /** Region 1 — the tool-row factory. Reads `theme` live, so the next call paints the current theme. */
-// shape: closure returning an object literal — trigger #4, eight stateless row roles over the captured theme.
+// shape: closure returning an object literal — trigger #4, thirteen stateless row roles over the captured theme.
 export function createRowPaint(theme: HostTheme): RowPaint {
 	return {
 		title: (text) => fgOrPlain(theme, "toolTitle", text),
 		output: (text) => fgOrPlain(theme, "toolOutput", text),
 		muted: (text) => fgOrPlain(theme, "muted", text),
+		dim: (text) => fgOrPlain(theme, "dim", text),
 		accent: (text) => fgOrPlain(theme, "accent", text),
 		error: (text) => fgOrPlain(theme, "error", text),
 		warning: (text) => fgOrPlain(theme, "warning", text),
+		success: (text) => fgOrPlain(theme, "success", text),
 		gutter: (text) => fgOrPlain(theme, "muted", text),
 		match: (text) => matchOrAccent(theme, text),
 		diffAdded: (text) => fgOrPlain(theme, "toolDiffAdded", text),
@@ -67,30 +70,33 @@ export function createRowPaint(theme: HostTheme): RowPaint {
 }
 
 /**
- * How the header band fills its cell: `"reverse"` swaps the cell's ink and background (SGR reverse
- * video), `"none"` leaves the bare header. Picked once at construction, so a side-by-side can sweep it.
+ * The header band: the header ink with its cell's foreground and background swapped — SGR reverse video.
+ * Reversal is what makes the band safe on any theme: it preserves the theme's own ink-on-background
+ * contrast ratio instead of pairing an ink with a fill that was picked for something else, and it keeps
+ * the band theme-driven, because the header ink is the theme's own. No token, no construction-time
+ * choice (owner ruling 2026-10-09; issue #52).
  */
-export type BandStyle = "reverse" | "none";
-
 /**
- * SGR reverse video, on and off. The band is the ONE escape pair that originates here rather than in a
- * theme: no background token is reachable on the content seam, so the band is built from reverse video,
- * which needs none and therefore survives a restore that happens before any theme is known.
+ * SGR reverse video, on and off — the ONE escape pair that originates here rather than in a theme.
+ * Reverse video needs no token, so it works on any theme and on a frame rendered before one arrives.
  */
 const REVERSE_ON = "\x1b[7m";
 const REVERSE_OFF = "\x1b[27m";
 
+/** The band: reverse video over the header ink — the cell's own ink and background swapped. */
+function reverseBand(text: string): string {
+	return `${REVERSE_ON}${text}${REVERSE_OFF}`;
+}
+
 /**
  * Region 2 — the content factory. `rule` degrades hr → quoteBorder → plain; every role ends in plain.
  *
  * The markdown theme's own closures supply the emphasis ink: `bold`/`italic` for inline spans, and its
  * `code` closure (the `mdCode` token, identical to `accent` in both stock themes) for the header ink.
- * `bandStyle` picks the header band — `"reverse"` (the default) composes reverse video over the header,
- * `"none"` leaves it bare — so the one band reachable on this seam is a construction-time choice.
  */
 // shape: closure returning an object literal — trigger #4, eight stateless content roles over the
-//   captured markdown theme and the band style.
-export function createContentPaint(mdTheme: MarkdownTheme, bandStyle: BandStyle = "reverse"): ContentPaint {
+//   captured markdown theme, band style and theme holder.
+export function createContentPaint(mdTheme: MarkdownTheme): ContentPaint {
 	// The header ink: the theme's `code` closure under its `bold` closure. Each link is optional and
 	// degrades on its own, so a theme missing one still stamps whatever the other gives.
 	const header = (text: string): string => {
@@ -105,6 +111,6 @@ export function createContentPaint(mdTheme: MarkdownTheme, bandStyle: BandStyle
 		strong: (text) => tryStyle(mdTheme.bold, text) ?? text,
 		em: (text) => tryStyle(mdTheme.italic, text) ?? text,
 		header,
-		headerBand: (text) => (bandStyle === "reverse" ? `${REVERSE_ON}${header(text)}${REVERSE_OFF}` : header(text)),
+		headerBand: (text) => reverseBand(header(text)),
 	};
 }

package/src/core/types/host.ts

@@ -20,6 +20,18 @@ export interface HostTheme {
 	bold(text: string): string;
 }
 
+/**
+ * The background-capable theme slice the header band reads. Structural host shape: the host's live
+ * theme is a proxy over the active theme, so any object answering `bg` qualifies.
+ *
+ * Declared apart from {@link HostTheme} on purpose — that type is what every row renderer and every
+ * golden fixture constructs, so a background member there would break call sites that draw no band.
+ */
+export interface HostBackgroundTheme {
+	/** Wraps text in a background token's escape, e.g. bg("selectedBg", "x"). Required. */
+	bg(key: string, text: string): string;
+}
+
 /** Live markdown-theme closures the content painter wraps. Structural host shape — no host import. */
 export interface MarkdownTheme {
 	/** Horizontal-rule escape wrapper. Optional: a host without this token degrades to plain text. */
@@ -78,6 +90,12 @@ export interface RenderContext {
 	isError?: boolean;
 	/** True while the result is still streaming; the row must stay cheap. Optional. */
 	isPartial?: boolean;
+	/**
+	 * Horizontal padding the host's own shell would have applied, in character cells. Optional: a row
+	 * that asks for the "self" shell applies it itself, and the pinned host's render context does not
+	 * carry it — so an absent value means no padding, never a guessed one.
+	 */
+	outputPad?: number;
 }
 
 /** One result content block; only text blocks are rendered. Structural host shape. */
@@ -157,5 +175,10 @@ export interface EventContext {
 	ui?: {
 		/** Collapses (false) / expands (true) every tool row. The collapse-first default rides this. Optional. */
 		setToolsExpanded?(expanded: boolean): void;
+		/**
+		 * The live theme handle — a getter over the host's theme proxy, so one read sees every later
+		 * switch. Optional: it is the band ink's only reach, and the extension API carries no theme.
+		 */
+		theme?: HostBackgroundTheme;
 	};
 }

package/src/core/types/paint.ts

@@ -1,5 +1,6 @@
 /**
- * paint.ts — the painting contract: the two role sets every renderer draws through.
+ * paint.ts — the painting contract: the two role sets every renderer draws through, plus the theme
+ * reach the header band reads.
  *
  * Boundary: region 1 is the tool row, region 2 is markdown content. Renderers call role methods
  * and never emit an escape sequence themselves (AGENTS: escapes originate in core/paint.ts).
@@ -7,7 +8,7 @@
  * shape: none — declaration-only module (no runtime unit), so no DSG-1 shape trigger applies.
  */
 
-import type { HostTheme } from "./host.ts";
+import type { HostBackgroundTheme, HostTheme } from "./host.ts";
 
 /** Region 1 — the tool-row roles. Text in, theme-derived escape-wrapped text out. */
 export interface RowPaint {
@@ -17,12 +18,16 @@ export interface RowPaint {
 	output(text: string): string;
 	/** De-emphasized metadata such as durations and counts. Required. */
 	muted(text: string): string;
+	/** The pending ink: a name still in flight, quieter than {@link muted}. Required. */
+	dim(text: string): string;
 	/** Accent for the active or highlighted element. Required. */
 	accent(text: string): string;
 	/** Error text on a failed call. Required. */
 	error(text: string): string;
 	/** Warning text for a degraded or partial result. Required. */
 	warning(text: string): string;
+	/** The success ink: a settled call that did not fail. Required. */
+	success(text: string): string;
 	/** The row's left gutter marker. Required. */
 	gutter(text: string): string;
 	/** A matched substring highlighted inside a result line. Required. */
@@ -41,6 +46,19 @@ export type RowPaintFactory = (
 	theme: HostTheme,
 ) => RowPaint;
 
+/**
+ * The band's theme reach: one long-lived handle, fed from the per-event UI context and read per frame.
+ *
+ * The HANDLE is what travels, never a resolved colour: the host's theme is a proxy over the active
+ * theme, so a cached escape would freeze the band on the theme selected at load.
+ */
+export interface ThemeHolder {
+	/** Stores a live theme handle; a value that cannot paint a background is stored as no theme. */
+	set(theme: unknown): void;
+	/** The handle for this frame, or undefined when none was fed — the band's fallback state. */
+	get(): HostBackgroundTheme | undefined;
+}
+
 /** Region 2 — the markdown-content roles. */
 export interface ContentPaint {
 	/** Horizontal rule; falls back hr → quoteBorder → plain rather than throw. Required. */
@@ -61,8 +79,9 @@ export interface ContentPaint {
 	 */
 	header(text: string): string;
 	/**
-	 * One header-band cell: {@link header} carrying the band style — reverse video by default, so the
-	 * cell's own ink becomes its background. Required.
+	 * One header-band cell: {@link header} carrying the band's own background ink, read from the ACTIVE
+	 * theme through the holder and therefore refreshed per render. Reverse video is the fallback for a
+	 * frame with no theme reachable. Required.
 	 */
 	headerBand(text: string): string;
 }

package/src/renderers/content/artifacts/server.ts

@@ -44,7 +44,8 @@ export type ArtifactServerState =
 	| { readonly ok: false; readonly reason: string };
 
 export interface ArtifactServer {
-	/** Binds once on the loopback interface; a bind failure is reported, never thrown. */
+	/** Binds once on the loopback interface; a bind failure is reported, never thrown. The listener
+	 * never holds the process open — a headless run must be able to exit (#46). */
 	start(): Promise<ArtifactServerState>;
 	/** Releases the port and resets the state; idempotent. */
 	stop(): Promise<void>;
@@ -145,6 +146,10 @@ export function createArtifactServer(options: ArtifactServerOptions = {}): Artif
 				await listen(bound);
 				const address = bound.address();
 				if (address === null || typeof address === "string") throw new Error("no port was assigned");
+				// The listener serves the session; it must never be the reason the process outlives it. Bound but
+				// unref'd, it answers requests while anything else holds the loop, and a headless run exits the
+				// moment the prompt resolves (#46: `pi -p` printed its answer and then never exited).
+				bound.unref();
 				server = bound;
 				baseUrl = `http://${HOST}:${address.port}`;
 				return { ok: true, url: baseUrl };

package/src/renderers/content/heading.ts

@@ -0,0 +1,105 @@
+/**
+ * heading.ts — the heading surface: levels 1–3 numbered at depth 2, level 4 and deeper demoted to bold.
+ *
+ * The message's shallowest heading is level 1; every heading's level is its depth relative to that, so
+ * a message opening at `###` still numbers from `1.` Levels 1–3 receive `1.` / `1.1.` / `1.1.1.` and are
+ * rewritten to depth 2; level 4 and deeper lose the number and the `#` markers and become bold text.
+ * The numbering is the substitute for a per-level heading token the host theme does not have: it carries
+ * exactly one heading token, and the host renderer re-inserts literal `#` characters from depth 3
+ * downward, so depth 2 is the cap that removes the marks (SA §1.3). Ink is the host's own job — this
+ * surface rewrites markdown text and never calls paint, or the line would be inked twice.
+ *
+ * Boundary: lane-local. The transformer passes markdown in and splices the returned markdown back out;
+ * a message with no heading token returns the identical reference, so the host's render cache survives.
+ *
+ * shape: module-scope const object — trigger #3, one stateless Surface per process; the token walk and
+ * the counters hide behind `rewrite` (deep module) and are born per call, so no state crosses messages.
+ */
+
+import { Marked, type Token } from "@earendil-works/pi-tui";
+import type { TransformContext } from "../../core/types/host.ts";
+import type { ContentPaint } from "../../core/types/paint.ts";
+import type { Surface } from "./types.ts";
+
+interface HeadingLike {
+	depth: number;
+	text: string;
+}
+
+/** The depth every numbered heading is rewritten to — the cap that removes the host's `#` marks (SA §1.3). */
+const NUMBERED_PREFIX = "##";
+
+/** The last level that receives a number; deeper levels are demoted to bold text. */
+const LAST_NUMBERED_LEVEL = 3;
+
+const markdownParser = new Marked();
+
+/** Marked parses untrusted markdown and its Token union carries a Generic member — the shape narrows, never `type` alone (BND-1). */
+function isHeadingToken(token: Token): token is Token & HeadingLike {
+	return (
+		token.type === "heading" &&
+		"depth" in token &&
+		typeof token.depth === "number" &&
+		"text" in token &&
+		typeof token.text === "string"
+	);
+}
+
+/**
+ * The hierarchical number for one relative level: siblings increment, deeper levels reset, a level
+ * skipped on the way down reads as 1, and a return to a shallower level resumes that level's counter
+ * (PRD 7.1 extensions 3a/3b). `counters` is per message and never shared between calls.
+ */
+function levelNumber(counters: number[], level: number): string {
+	for (let skipped = 0; skipped < level - 1; skipped++) {
+		if (counters[skipped] === 0) counters[skipped] = 1;
+	}
+	counters[level - 1] = (counters[level - 1] ?? 0) + 1;
+	for (let deeper = level; deeper < counters.length; deeper++) counters[deeper] = 0;
+	return `${counters.slice(0, level).join(".")}.`;
+}
+
+/** shape: module-scope const object — trigger #3, one stateless heading surface per process. */
+export const heading: Surface = { rewrite };
+
+/**
+ * WHY a token walk and never a line scan: the parser emits a fenced block as ONE code token and emits
+ * no heading token for a `#` inside a table cell, so both hazards are unreachable by construction; a
+ * line scanner would have to re-implement fence tracking to reach the same safety. Setext headings are
+ * heading tokens and are numbered like any other — the source form does not decide the treatment.
+ *
+ * Markdown-position rule (the non-obvious one): unchanged tokens are spliced back by their own raw
+ * text, and a heading token's raw carries its trailing newline only at end of input — the blank line
+ * between blocks lives in the following space token's raw — so the replacement keeps that newline and
+ * every untouched block stays at its own position, byte-identical.
+ */
+function rewrite(markdown: string, _ctx: TransformContext, _paint: ContentPaint): string {
+	const tokens = markdownParser.lexer(markdown);
+	const depths = tokens.filter(isHeadingToken).map((token) => token.depth);
+	// No heading token: the input itself returns, by reference — an equal copy would invalidate the
+	// host's render cache, and joining raw text is not byte-exact anyway (Marked eats CRLF).
+	if (depths.length === 0) return markdown;
+
+	// Numbering is message-local: the shallowest heading present is level 1, and the counters are born
+	// inside this call, so nothing survives to the next message.
+	const minDepth = Math.min(...depths);
+	const counters = [0, 0, 0];
+	const parts: string[] = [];
+	for (const token of tokens) {
+		if (!isHeadingToken(token)) {
+			parts.push(token.raw);
+			continue;
+		}
+		const level = token.depth - minDepth + 1;
+		const trailing = /\n+$/.exec(token.raw)?.[0] ?? "";
+		// `token.text` holds the heading's inline markup as source, so prefixing the number keeps
+		// code spans and bold alive (PRD 7.1 extension 4b); the demoted form is markdown bold, which
+		// the host inks on its own — no escape may originate here.
+		parts.push(
+			level <= LAST_NUMBERED_LEVEL
+				? `${NUMBERED_PREFIX} ${levelNumber(counters, level)}${token.text === "" ? "" : ` ${token.text}`}${trailing}`
+				: `**${token.text}**${trailing}`,
+		);
+	}
+	return parts.join("");
+}

package/src/renderers/content/index.ts

@@ -1,22 +1,25 @@
 /**
- * index.ts — the markdown transformer: final-assistant gate, per-surface registry check, per-surface
+ * index.ts — the markdown transformer: per-surface gate, per-surface registry check, per-surface
  * isolation, dispatch, identity return, and one keyed line for every skip.
  *
+ * The gate is per-surface (owner D5): the heading pass runs on a settled assistant or user message; the
+ * four markdown surfaces and the late fence pass stay assistant-only, so a user's pasted markdown is not
+ * restyled by them. A disabled surface is skipped; a surface that throws is isolated to itself and the
+ * message keeps every other rewrite; the input string returns by reference whenever no surface changed it
+ * — the host's own caching reads that reference. What the pass cannot do, it names: a closed gate and a
+ * table that comes out unboxed each leave one line keyed on the reason.
+ *
  * Boundary: the host calls this on the transcript render path, so nothing here throws and nothing
- * allocates per message. A disabled surface is skipped; a surface that throws is isolated to itself and
- * the message keeps every other rewrite; the input string returns by reference whenever no surface
- * changed it — the host's own caching reads that reference. What the pass cannot do, it names: a closed
- * gate and a table that comes out unboxed each leave one line keyed on the reason, so a live report
- * reads its own cause instead of a screenshot.
+ * allocates per message.
  *
  * shape: closure returning a function — trigger #4, the factory captures its injected collaborators
  * (registry, surfaces, paint, log) and holds no state to classify.
  *
- * ported from pi-pretty-tui/src/features/canvas/transformer.ts — survives because: the final-assistant
- * gate, the degrade-to-the-input-verbatim fallback, and mermaid staying with the host's own transformer
- * are the host-aligned behaviors that file got right. Its parser, settings load, and per-form render
- * code do not port: each surface owns one rewrite here, and the registry owns every toggle. Its single
- * try/catch around the whole pass does not port either: a failure belongs to the surface that threw.
+ * ported from pi-pretty-tui/src/features/canvas/transformer.ts — survives because: the degrade-to-the-input-verbatim
+ * fallback and mermaid staying with the host's own transformer are the host-aligned behaviors that file got
+ * right. Its parser, settings load, and per-form render code do not port: each surface owns one rewrite here,
+ * and the registry owns every toggle. Its single try/catch around the whole pass does not port either: a
+ * failure belongs to the surface that threw.
  */
 
 import type { TransformContext } from "../../core/types/host.ts";
@@ -28,8 +31,9 @@ import type { Surface, SurfaceKey } from "./types.ts";
 /** Registry key of the artifacts fence pass — T-28 injects its surface when artifacts land (T-25/T-26). */
 const ARTIFACTS_KEY = "artifacts";
 
-/** Dispatch order: the four markdown surfaces, then the fence pass over their output. */
-const SURFACE_ORDER: readonly SurfaceKey[] = ["table", "codePanel", "jsonPanel", "imageCard"];
+/** Dispatch order: the heading pass first (it rewrites text, so it must not see an already-boxed table),
+ * then the four markdown surfaces; the artifacts fence pass runs last, over their output. */
+const SURFACE_ORDER: readonly SurfaceKey[] = ["heading", "table", "codePanel", "jsonPanel", "imageCard"];
 
 const SCOPE = "content";
 
@@ -87,36 +91,43 @@ export function createContentTransformer(
 	};
 
 	return (markdown, ctx) => {
-		// The predecessor's gate, unchanged: only a settled assistant message is rewritten. The key carries
-		// the messageType alone (three possible values), so a whole session reports each gate reason once.
-		if (ctx.messageType !== "assistant" || ctx.isStreaming) {
-			if (TABLE_SHAPE.test(markdown)) {
-				log.logOnce(
-					`content:gate:${ctx.messageType}`,
-					SCOPE,
-					`table-shaped content skipped: messageType=${ctx.messageType} isStreaming=${ctx.isStreaming}`,
-				);
-			}
-			return markdown;
+		// Per-surface gate (owner D5): the heading pass admits a settled user message — the host already
+		// delivers it (user-message.js builds its transform with messageType: "user") — while the four
+		// markdown surfaces and the late fence pass stay assistant-only. The key carries the messageType
+		// alone (three values), so a whole session reports each gate reason once.
+		const settled = !ctx.isStreaming;
+		const assistant = settled && ctx.messageType === "assistant";
+		const headingOnly = settled && ctx.messageType === "user";
+		// The gate line explains the table surface, which is skipped on every non-assistant input.
+		if (!assistant && TABLE_SHAPE.test(markdown)) {
+			log.logOnce(
+				`content:gate:${ctx.messageType}`,
+				SCOPE,
+				`table-shaped content skipped: messageType=${ctx.messageType} isStreaming=${ctx.isStreaming}`,
+			);
 		}
+		if (!assistant && !headingOnly) return markdown;
 
 		let out = markdown;
 		// The step that last changed the text: the surface a table should have come from, named by the
 		// decline line below. Undefined means every surface passed its input straight through.
 		let lastTouched: string | undefined;
 		for (const key of SURFACE_ORDER) {
+			// The heading pass is the one surface a settled user message runs; the rest stay assistant-only.
+			if (key !== "heading" && !assistant) continue;
 			const step = run(`content.${key}`, surfaces[key], out, ctx);
 			if (step !== out) lastTouched = `content.${key}`;
 			out = step;
 		}
-		const fenced = run(`content.${ARTIFACTS_KEY}`, artifacts, out, ctx);
+		const fenced = assistant ? run(`content.${ARTIFACTS_KEY}`, artifacts, out, ctx) : out;
 		if (fenced !== out) lastTouched = `content.${ARTIFACTS_KEY}`;
 		out = fenced;
 
 		// A table that reaches the end of the pass without a box rule was declined by every surface that saw
 		// it — the one case where the pipeline succeeded and the box still did not draw. The key carries the
-		// input length, so a channel that keeps repeating one table declines once.
-		if (TABLE_SHAPE.test(markdown) && !out.includes(TABLE_BOX_RULE)) {
+		// input length, so a channel that keeps repeating one table declines once. Assistant-only, because it
+		// is only on that branch that the table surface could have drawn the box.
+		if (assistant && TABLE_SHAPE.test(markdown) && !out.includes(TABLE_BOX_RULE)) {
 			log.logOnce(
 				`content:decline:table:${markdown.length}`,
 				SCOPE,

package/src/renderers/content/table.ts

@@ -7,9 +7,11 @@
 /**
  * table.ts — the table surface: a markdown table becomes a banded box.
  *
- * The header row is stamped through the header-band role — bold over the accent ink inside a band — or,
- * when the header row is empty (`| | |`), that stamp moves onto the first column so no blank band is
- * spent. `**strong**` and `*em*` cells route through their own roles.
+ * The header row is stamped through the header-band role — bold over the accent ink inside a
+ * full-bleed band spanning each cell's whole interior plus its trailing separator, so the header
+ * reads as one bar (FP-11) — or, when the header row is empty (`| | |`), that stamp moves onto the
+ * first column so no blank band is spent. `**strong**` and `*em*` cells route through their own
+ * roles.
  *
  * Boundary: lane-local. The transformer passes markdown in and splices the returned markdown back
  * out, so every escape in the output originates in the injected ContentPaint (T-08) — the #22 fix.
@@ -36,8 +38,6 @@ interface TableToken {
 
 /** Per-cell padding plus the bars: below this a column cannot hold its own frame. */
 const MIN_COLUMN = 6;
-/** A column wider than this is a paragraph, not a table cell. */
-const MAX_COLUMN = 60;
 
 const markdownParser = new Marked();
 
@@ -100,7 +100,7 @@ function padCell(content: string, width: number): string {
 	return fit + " ".repeat(Math.max(0, width - visibleWidth(fit)));
 }
 
-/** shape: none — one greedy width solve; a table is small and the rule is exact. */
+/** shape: none — one greedy width solve plus a largest-remainder fill; a table is small and the rule is exact. */
 function renderTable(token: TableToken, width: number, paint: ContentPaint): string[] {
 	const header = token.header.map((cell) => cellText(cell, paint));
 	const rows = token.rows.map((row) => row.map((cell) => cellText(cell, paint)));
@@ -108,7 +108,7 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 	const natural: number[] = [];
 	for (let index = 0; index < columns; index++) {
 		const cells = [header[index] ?? "", ...rows.map((row) => row[index] ?? "")];
-		natural.push(Math.min(MAX_COLUMN, Math.max(MIN_COLUMN, ...cells.map((cell) => visibleWidth(cell)))));
+		natural.push(Math.max(MIN_COLUMN, ...cells.map((cell) => visibleWidth(cell))));
 	}
 	const widths = [...natural];
 	// Width budget: per-cell padding (2 each), the column bars, and the two outer bars.
@@ -119,6 +119,28 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 		widths[widest] = (widths[widest] ?? 0) - 1;
 	}
 
+	// Fill the reading column: a short table grows to the clamp so its frame edge lines up with the
+	// block above it. Slack spreads in proportion to natural width — largest remainder, ties by column
+	// order. Invariant that keeps this safe: a shrink step lowers the total by exactly one and the loop
+	// exits the moment the total equals the offer, while its other exit leaves every column at
+	// MIN_COLUMN with the total still above it — so a positive slack proves the shrink loop never
+	// iterated, and fill and shrink can never both run.
+	const slack = width - total();
+	if (slack > 0) {
+		const naturalTotal = natural.reduce((sum, column) => sum + column, 0);
+		const shares = natural.map((column, index) => {
+			const exact = (slack * column) / naturalTotal;
+			return { index, floor: Math.floor(exact), remainder: exact - Math.floor(exact) };
+		});
+		for (const { index, floor } of shares) widths[index] = (widths[index] ?? 0) + floor;
+		let leftover = slack - shares.reduce((sum, { floor }) => sum + floor, 0);
+		for (const { index } of shares.sort((a, b) => b.remainder - a.remainder)) {
+			if (leftover <= 0) break;
+			widths[index] = (widths[index] ?? 0) + 1;
+			leftover--;
+		}
+	}
+
 	// An all-empty header (`| | |`) means the table carries its labels in the first column: the blank
 	// header row and its separator are dropped, and the band moves onto that first column instead.
 	const keyColumn = header.every((cell) => cell === "");
@@ -137,9 +159,13 @@ function renderTable(token: TableToken, width: number, paint: ContentPaint): str
 		for (let line = 0; line < height; line++) {
 			const parts = wrapped.map((lines, index) => {
 				const padded = padCell(lines[line] ?? "", widths[index] ?? MIN_COLUMN);
-				return banded(index) ? ` ${paint.headerBand(padded)} ` : ` ${padded} `;
+				// Full-bleed unit (FP-11): the cell's whole interior — both padding columns — plus its
+				// trailing separator (the bar keeps its rule ink inside the band), so banded cells form one
+				// unbroken bar; the last cell has no trailing separator, so its band ends at its own padding.
+				const unit = index < cells.length - 1 ? ` ${padded} ${bar}` : ` ${padded} `;
+				return banded(index) ? paint.headerBand(unit) : unit;
 			});
-			physical.push(`${bar}${parts.join(bar)}${bar}`);
+			physical.push(`${bar}${parts.join("")}${bar}`);
 		}
 	};
 

package/src/renderers/content/types.ts

@@ -11,7 +11,7 @@ import type { TransformContext } from "../../core/types/host.ts";
 import type { ContentPaint } from "../../core/types/paint.ts";
 
 /** Surface registry keys. The module key is "content." + the key, e.g. "content.table". */
-export type SurfaceKey = "table" | "codePanel" | "jsonPanel" | "imageCard";
+export type SurfaceKey = "heading" | "table" | "codePanel" | "jsonPanel" | "imageCard";
 
 /** One markdown rewrite stage: the input string returns by reference whenever nothing matched. */
 export interface Surface {

package/src/renderers/tool/fallback.ts

@@ -0,0 +1,136 @@
+/**
+ * fallback.ts — the fallback row: one collapsed line in the package's own style for any tool name
+ * neither the table nor the chain draws.
+ *
+ * Boundary: the master resolver composes this when the chain's answer has no usable slot, gated on
+ * the row.fallback key; this module registers nothing and claims no name — it answers inside the
+ * resolver chain. Arguments and result blocks are host payloads, narrowed field by field. An argument
+ * shape with no string value degrades to the name alone and logs one line keyed on the call id.
+ *
+ * shape: closure returning the row runtime's renderers — trigger #4: the private spec captures the
+ * tool name and the keyed logger, and drawing reuses createRowRenderers, so no second renderer path
+ * and no spec file exist for it.
+ */
+
+import type { RenderContext, ToolRenderers, ToolResult } from "../../core/types/host.ts";
+import type { Logger } from "../../core/types/log.ts";
+import type { RowPaint, RowPaintFactory } from "../../core/types/paint.ts";
+import type { ModuleDescriptor } from "../../core/types/registry.ts";
+import { createRowRenderers } from "./runtime.ts";
+import type { CallModel, RowSpec, RowView } from "./types.ts";
+
+const INDENT = "  ";
+const HINT = "ctrl+o to expand";
+/** The hint stays short: the collapsed row is one line, and the host's own default already shows more. */
+const HINT_MAX = 60;
+/** read.ts's one-metadata-line cap: a longer message is the expanded body's job. */
+const SUMMARY_MAX = 120;
+const SCOPE = "tool.fallback";
+
+/** The descriptor the composition root registers for the /render panel; exported here, never registered here. */
+// shape: object literal — trigger #7, fields known statically (the CODE_THEME_MODULE precedent).
+export const FALLBACK_MODULE: ModuleDescriptor = {
+	key: "row.fallback",
+	name: "Fallback row",
+	defaultEnabled: true,
+	settings: [],
+};
+
+/** What build parses once: the result's text plus the wrapper's own failure flag. */
+interface FallbackModel {
+	/** The result's text blocks joined in host order, newlines normalized; "" when it carries none. */
+	text: string;
+	/** The result wrapper's failure flag; ctx's flag reaches project fresh through view.isError. */
+	failed: boolean;
+}
+
+/** boundary: content blocks are host payloads; only "text" blocks with a string body are read. */
+function textOf(result: ToolResult): string {
+	const blocks = result.content;
+	if (!Array.isArray(blocks)) return "";
+	const parts: string[] = [];
+	for (const block of blocks) {
+		if (typeof block !== "object" || block === null) continue;
+		if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+	}
+	return parts.join("\n").replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+
+/**
+ * boundary: arguments are host payloads; only a non-empty string value is hint text. The hint draws
+ * from the argument text the host itself displays — never from a file the arguments merely name.
+ */
+function hintOf(args: Record<string, unknown>): string | undefined {
+	for (const value of Object.values(args)) {
+		if (typeof value !== "string") continue;
+		const flat = value.replace(/\s+/g, " ").trim();
+		if (flat === "") continue;
+		return flat.length > HINT_MAX ? `${flat.slice(0, HINT_MAX - 1)}…` : flat;
+	}
+	return undefined;
+}
+
+/** The call id when the host gave one; the tool name keeps a nameless row's line once-per-name. */
+function logKey(ctx: RenderContext, toolName: string): string {
+	return typeof ctx.toolCallId === "string" ? ctx.toolCallId : `args:${toolName}`;
+}
+
+function capSummary(text: string): string {
+	return text.length > SUMMARY_MAX ? `${text.slice(0, SUMMARY_MAX - 1)}…` : text;
+}
+
+/** The failure summary's head: the first non-blank line, or one word when the result carried none. */
+function failureHead(lines: readonly string[]): string {
+	return capSummary(lines.find((line) => line.trim() !== "") ?? "failed");
+}
+
+// shape: closure returning an object literal — trigger #4: buildCall captures the tool name and the
+// keyed logger; the three contract fields keep no per-row state beyond that capture.
+function createFallbackSpec(toolName: string, log: Logger): RowSpec<FallbackModel> {
+	return {
+		buildCall(args, ctx): CallModel {
+			// The runtime's args gate hands buildCall {} until a host flag says the arguments are final,
+			// so zero keys covers a gated row and a genuinely argument-less tool alike — neither is an
+			// unexpected shape, so neither logs.
+			if (Object.keys(args).length === 0) return { title: toolName };
+			const hint = hintOf(args);
+			if (hint === undefined) {
+				log.logOnce(logKey(ctx, toolName), SCOPE, `unrecognized argument shape for ${toolName} — name alone`);
+				return { title: toolName };
+			}
+			return { title: `${toolName}: ${hint}` };
+		},
+
+		build(result): FallbackModel {
+			return { text: textOf(result), failed: result.isError === true };
+		},
+
+		project(m: FallbackModel, view: RowView, paint: RowPaint): string {
+			// Either failure flag means an error row (read.ts's contract): the wrapper's is parsed
+			// once, ctx's arrives fresh per frame through the view.
+			const failed = m.failed || view.isError;
+			// Trailing whitespace is a terminator, not a line — the count and the body agree on that.
+			const body = m.text.replace(/\s+$/, "");
+			const lines = body === "" ? [] : body.split("\n");
+			const stats = `${lines.length} ${lines.length === 1 ? "line" : "lines"}`;
+			if (!view.expanded) {
+				// Collapse-first: exactly one line, which the runtime hands to the call slot.
+				if (!failed) return paint.muted(`${stats} · ${HINT}`);
+				return `${paint.error(failureHead(lines))}${paint.muted(` · ${HINT}`)}`;
+			}
+			if (lines.length === 0) return failed ? paint.error("failed") : paint.muted(stats);
+			const painted = lines.map((line) =>
+				line.trim() === "" ? "" : `${INDENT}${failed ? paint.error(line) : paint.output(line)}`,
+			);
+			return [paint.muted(stats), "", ...painted].join("\n");
+		},
+	};
+}
+
+/** The fallback row's two slots, built by the shared row runtime; the resolver composes the shell. */
+export function createFallbackRenderers(
+	toolName: string,
+	deps: { paint: RowPaintFactory; log: Logger },
+): ToolRenderers {
+	return createRowRenderers(createFallbackSpec(toolName, deps.log), deps);
+}

package/src/renderers/tool/index.ts

@@ -1,6 +1,7 @@
 /**
- * index.ts — the master resolver: the tool-name table, the captured host base, and one registry check
- * per invocation — the pluggable toggle for every tool row.
+ * index.ts — the master resolver: the tool-name table, the captured host base, one registry check
+ * per invocation — the pluggable toggle for every tool row — and the gated fallback row for names
+ * neither the table nor the chain draws.
  *
  * Boundary: the host consults this ONCE per row component construction, keyed on tool name alone, and
  * `next()` exists only at that moment; the base renderers it hands back are captured here and reused for
@@ -26,11 +27,17 @@ import type {
 	ToolResult,
 	UiComponent,
 } from "../../core/types.ts";
+import { createFallbackRenderers, FALLBACK_MODULE } from "./fallback.ts";
 import { createRowRenderers } from "./runtime.ts";
 import type { RowSpec } from "./types.ts";
 
-/** The host's own shell frame: chrome belongs to pi-zentui, so a row never asks for a custom one. */
-const SHELL = "default";
+/**
+ * The shell every row asks the host for: "self" skips the host's Box(1,1) padding rows around our
+ * content, so a row is the lines we compose (#51) — which is also why the horizontal pad is ours to
+ * apply (runtime.ts reads it off the ctx). The host still prepends one blank line of its own, and
+ * closing that last blank is the upstream grouping ask (ADR-0004), not something a renderer reaches.
+ */
+const SHELL = "self";
 const SCOPE = "tool.resolve";
 
 /** The resolver's injected collaborators — the row paint factory, plus the keyed diagnostic sink. */
@@ -61,6 +68,11 @@ function withoutComponent(ctx: RenderContext): RenderContext {
 	return { ...ctx, lastComponent: undefined };
 }
 
+/** A chain answer the host can draw: either slot suffices; a definition with neither is a peer shape the host defaults. */
+function hasUsableSlot(base: ToolRenderers | undefined): base is ToolRenderers {
+	return base !== undefined && (base.renderCall !== undefined || base.renderResult !== undefined);
+}
+
 // shape: closure returning a resolver function — trigger #4: one runtime binding per spec is captured by
 // the factory; the resolver allocates only what a single row construction needs.
 export function createMasterResolver(
@@ -85,13 +97,28 @@ export function createMasterResolver(
 
 	return (toolName, next) => {
 		const entry = runtimes.get(toolName);
-		if (entry === undefined) return next(); // not our table: the host chain answers, verbatim
+		if (entry === undefined) {
+			// Delegation is load-bearing: the chain answers FIRST, so a peer or the host still wins a
+			// name it owns; the gate is consulted only at the point the fallback would answer.
+			const base = next();
+			// Two-shape trigger: the host draws its own default both for a name with no definition and
+			// for a definition shipping neither slot — the second is the shape an installed peer's tool
+			// takes, which an emptiness-only test would miss and leave the reported symptom in place.
+			if (hasUsableSlot(base) || !registry.isEnabled(FALLBACK_MODULE.key)) return base;
+			return { renderShell: SHELL, ...createFallbackRenderers(toolName, deps) };
+		}
 		const base = next(); // captured here and only here — next() is gone once this resolver returns
 		const key = entry.key; // explicit: search's four names share "row.search" (T-20 ruling)
 		const runtime = entry.renderers;
 
 		return {
-			renderShell: SHELL,
+			// A row the base draws wears the BASE's shell: our "self" would strip the Box(1,1) whose padding
+			// and background the base's own lines were composed for. Read once, at resolution — the host
+			// binds the shell's container in the component's constructor and never re-parents it
+			// (tool-execution.js:52-54, against :200 which only picks the container to fill), so a shell
+			// that tracked the registry per frame would fill one container while the tree still held the
+			// other. The slots keep polling; the shell cannot.
+			renderShell: registry.isEnabled(key) || !hasUsableSlot(base) ? SHELL : base.renderShell,
 			renderCall(args: Record<string, unknown>, theme: HostTheme, ctx: RenderContext): UiComponent {
 				const baseCall = base?.renderCall;
 				if (registry.isEnabled(key) || baseCall === undefined) return runtime.renderCall(args, theme, ctx);

package/src/renderers/tool/runtime.ts

@@ -149,21 +149,38 @@ function logFailure(log: Logger, ctx: RenderContext, err: unknown): void {
 	log.logOnce(key, LOG_SCOPE, `row degraded: ${text}`);
 }
 
+/** The horizontal pad a row applies itself, in cells; a host that hands none means no padding. */
+function padOf(ctx: RenderContext): number {
+	const pad = ctx.outputPad;
+	return typeof pad === "number" && Number.isFinite(pad) && pad > 0 ? Math.floor(pad) : 0;
+}
+
+/**
+ * A text component wearing this runtime's pad. The pad arrives on the ctx (once per invocation) while
+ * the indent is applied in render(width) (once per frame), so the component carries it across the two —
+ * and `setPad` is thereby the marker that says "this one is ours to reuse". The host spells its own
+ * padding setter `setPaddingX`, so a component the base renderer left in the slot never answers it.
+ */
+interface PaddedText extends UiComponent {
+	/** Replaces the displayed body. Required: the reuse protocol the host's lastComponent enables. */
+	setText(body: string): void;
+	/** Re-reads the row's indent, so a host padding change lands on the next frame. Required. */
+	setPad(pad: number): void;
+}
+
+/** `in`-narrowed, never cast: a recorded component is the host's until it answers this protocol. */
+function isPaddedText(component: UiComponent): component is PaddedText {
+	return "setPad" in component && typeof component.setPad === "function";
+}
+
 /** shape: closure returning an object literal — trigger #4: one stored text behind render/invalidate. */
-function textFor(ctx: RenderContext, body: string): UiComponent {
-	const reuse = ctx.lastComponent;
-	if (reuse !== undefined) {
-		const setText = reuse.setText;
-		if (setText !== undefined) {
-			setText.call(reuse, body);
-			return reuse;
-		}
-	}
+function textComponent(body: string): UiComponent {
 	let current = body;
 	return {
 		render(_width: number): string[] {
 			// One entry per line; an empty body still yields one line, so a degraded row never vanishes.
 			// Width is the component's own: renderResult receives none, so nothing here is width-keyed.
+			// The offer minus the indent is handed down by the pad wrapper around this component.
 			return current.split("\n");
 		},
 		invalidate(): void {
@@ -175,9 +192,64 @@ function textFor(ctx: RenderContext, body: string): UiComponent {
 	};
 }
 
+/**
+ * The pad wrapper: every line the inner component draws takes the indent, and the inner component gets
+ * the offer minus it.
+ *
+ * Both halves are ours because a row asks the host for the "self" shell (#51), and that shell skips the
+ * Box(1,1) which used to indent each line and render its child at `width - paddingX * 2` (pi-tui
+ * box.js:83 → :91 → :115). The budget half is what a reused host `Text` needs: it wraps at the width it
+ * is given (pi-tui text.js:53-56), so a full-width title would wrap at the whole offer and then be
+ * pushed one column past it by the indent.
+ *
+ * shape: closure returning an object literal — trigger #4: one stored pad behind render/setPad.
+ */
+function padComponent(inner: UiComponent, pad: number): PaddedText {
+	let indent = pad;
+	return {
+		render(width: number): string[] {
+			const lines = inner.render(Math.max(0, width - indent));
+			if (indent === 0) return lines;
+			const spaces = " ".repeat(indent);
+			return lines.map((line) => spaces + line);
+		},
+		invalidate(): void {
+			inner.invalidate();
+		},
+		setText(body: string): void {
+			inner.setText?.(body);
+		},
+		setPad(value: number): void {
+			indent = value;
+		},
+	};
+}
+
+function textFor(ctx: RenderContext, body: string): UiComponent {
+	const pad = padOf(ctx);
+	const reuse = ctx.lastComponent;
+	// Only a component this runtime wrapped can be told a new pad, so it is the only one it reuses. A
+	// foreign one — the base renderer's, after a module toggle handed the row back — is replaced once;
+	// the host records what we return, so every later frame takes this branch.
+	if (reuse !== undefined && isPaddedText(reuse)) {
+		reuse.setText(body);
+		reuse.setPad(pad);
+		return reuse;
+	}
+	// A host text component in the slot is still worth mutating in place: it caches its own frame, and
+	// it is the one inner whose wrap the reduced budget reaches.
+	const setText = reuse?.setText;
+	if (reuse !== undefined && setText !== undefined) {
+		setText.call(reuse, body);
+		return padComponent(reuse, pad);
+	}
+	return padComponent(textComponent(body), pad);
+}
+
 /**
  * The collapsed result slot's component: it draws no lines. The host stacks the call slot and the result
- * slot inside one Box, and the Box concatenates each child's lines (pi-tui box.js render), so an empty
+ * slot inside the self shell's container, and that container concatenates each child's lines at the whole
+ * offer (pi-tui tui.js:129-140 — no padding of its own, which is why the pad is ours, #51), so an empty
  * array adds nothing — the call line above is the whole collapsed row. Stateless, so one shared instance
  * serves every row and every frame.
  *
@@ -235,6 +307,35 @@ function scheduleDecorate(
 	);
 }
 
+/**
+ * The host sets this the moment a call starts executing (host `core/extensions/types.d.ts`). The repo's
+ * declared seam omits it, so the undeclared field is `in`-narrowed before it is read — never asserted.
+ */
+function isExecutionStarted(ctx: RenderContext): boolean {
+	return "executionStarted" in ctx && ctx.executionStarted === true;
+}
+
+/**
+ * The runtime's one args rule, three arms — each one a host writer that settles when the arguments
+ * can be trusted:
+ *
+ * - `argsComplete === true`: the host flips it on the live streaming path (`setArgsComplete`).
+ * - `isPartial === false`: the host starts a component at `isPartial = true` and clears it only in
+ *   `updateResult` (tool-execution.js:26/:130-132), so a false means a result was delivered and the
+ *   arguments behind it are final — with one exception: on the abort path the host restores the row
+ *   through `updateResult({errorMessage}, isError: true)`, whose default `isPartial = false` lands
+ *   with the arguments still incomplete (interactive-mode.js:2873-2878 live / :3256 restore), so the
+ *   arm may title from partial args. Strictly `=== false`, so an absent flag opens nothing.
+ * - `executionStarted === true`: the host starts executing a call only after its arguments are complete.
+ *
+ * A call rebuilt from a stored session runs none of those writers: it is constructed from the stored
+ * toolCall and `updateResult(message)`d (interactive-mode.js:3238-3273), so `argsComplete` and
+ * `executionStarted` stay false for its whole life and only the middle arm titles its row.
+ */
+function argsUsable(ctx: RenderContext): boolean {
+	return ctx.argsComplete === true || ctx.isPartial === false || isExecutionStarted(ctx);
+}
+
 export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory; log: Logger }): ToolRenderers {
 	const modelFor = (result: ToolResult, ctx: RenderContext): unknown => {
 		const content = Array.isArray(result.content) ? result.content : undefined;
@@ -263,9 +364,15 @@ export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory
 	const renderCall = (args: Record<string, unknown>, theme: HostTheme, ctx: RenderContext): UiComponent => {
 		try {
 			const paint = deps.paint(theme);
-			// A partial argument set is not a title: buildCall sees {} until the host says argsComplete.
-			const model = spec.buildCall(ctx.argsComplete === true ? args : {}, ctx);
-			const title = paint.title(model.title);
+			// A partial argument set is not a title. The spec is handed the args and the gate resolved
+			// together, so its own argsComplete check cannot shut the gate the runtime just opened; with
+			// the args unusable it sees {} behind a shut gate — a half-streamed value never titles.
+			const usable = argsUsable(ctx);
+			const model = spec.buildCall(usable ? args : {}, usable ? { ...ctx, argsComplete: true } : ctx);
+			// The name carries the call's three-state ink, and the order is the mapping's point: a failed call
+			// is never merely pending, so isError outranks isPartial; with neither flag the call is settled.
+			const ink = ctx.isError === true ? paint.error : ctx.isPartial === true ? paint.dim : paint.success;
+			const title = ink(model.title);
 			// Collapsed rows are one line: the summary the result slot settled rides this title line.
 			const summary = ctx.expanded === true ? undefined : readSummary(ctx);
 			return textFor(ctx, summary === undefined ? title : `${title} · ${summary}`);

package/src/renderers/tool/specs/codemode.ts

@@ -53,13 +53,22 @@ const MAX_ERROR_SUMMARY = 80;
 /** The host writes the header as its own text block, ending at "Output:" — dist/extensions/codemode/renderer.js:14. */
 const SCRIPT_HEADER = /^Script (completed|failed)\nWall time [\d.]+ seconds\nOutput:\n/;
 
-// shape: dispatch object — trigger #1, four stateless icon handlers on one status discriminator.
-// `accent` carries "ok": RowPaint has no success role, and `muted` would read as metadata.
-const STATUS_ICON: Record<CallStatus, (paint: RowPaint) => string> = {
-	running: (paint) => paint.warning("…"),
-	ok: (paint) => paint.accent("✓"),
-	error: (paint) => paint.error("✗"),
-	cancelled: (paint) => paint.muted("⊘"),
+/** One status's two marks: the icon glyph, the ink the glyph takes, and the state role the name takes. */
+type StatusMark = {
+	readonly glyph: string;
+	/** Brighter than the state role, because a glyph reads as a mark, not as text. */
+	readonly glyphInk: (paint: RowPaint) => (text: string) => string;
+	/** The line's name ink: the state vocabulary's role for this status (issue #41). */
+	readonly nameInk: (paint: RowPaint) => (text: string) => string;
+};
+
+// shape: dispatch object — trigger #1, four stateless mark handlers on one status discriminator.
+// One table holds both marks, so a line cannot show a finished call beside a pending name (issue #41).
+const STATUS_MARK: Record<CallStatus, StatusMark> = {
+	running: { glyph: "…", glyphInk: (paint) => paint.warning, nameInk: (paint) => paint.dim },
+	ok: { glyph: "✓", glyphInk: (paint) => paint.accent, nameInk: (paint) => paint.success },
+	error: { glyph: "✗", glyphInk: (paint) => paint.error, nameInk: (paint) => paint.error },
+	cancelled: { glyph: "⊘", glyphInk: (paint) => paint.muted, nameInk: (paint) => paint.muted },
 };
 
 // shape: fixed-shape record — trigger #7, three pure stages over the model above, no state.
@@ -156,6 +165,8 @@ function errorRow(model: CodemodeModel, view: RowView, paint: RowPaint): string
 }
 
 function expandedBody(model: CodemodeModel, view: RowView, paint: RowPaint): string {
+	// R3-07 + issue #41: each nested line states its own call's status, so a finished call never takes
+	// the row's pending ink beside its own "✓".
 	const rows: string[] = [];
 	for (const call of model.calls) rows.push(...callLines(call, paint));
 	// A streaming script's output is not final: its calls stream, its body waits (the host's contract).
@@ -170,7 +181,7 @@ function expandedBody(model: CodemodeModel, view: RowView, paint: RowPaint): str
 }
 
 function callLines(call: NestedCall, paint: RowPaint): string[] {
-	let line = `${statusIcon(call.status, paint)} ${paint.title(call.name)}`;
+	let line = `${statusIcon(call.status, paint)} ${callInk(call.status, paint)(call.name)}`;
 	if (call.args !== "") line += ` ${paint.muted(clip(call.args, MAX_ARGS_PREVIEW))}`;
 	const duration = formatDuration(call.durationMs);
 	if (duration !== "") line += ` ${paint.muted(duration)}`;
@@ -198,8 +209,20 @@ function aggregateStatus(model: CodemodeModel, isPartial: boolean): CallStatus {
 	return isPartial ? "running" : "ok";
 }
 
+/** A status's mark, or undefined for a status the host did not declare. */
+function statusMark(status: string): StatusMark | undefined {
+	return isCallStatus(status) ? STATUS_MARK[status] : undefined;
+}
+
+/** The status icon, its glyph inked. An unknown status reads as the muted "?". */
 function statusIcon(status: string, paint: RowPaint): string {
-	return isCallStatus(status) ? STATUS_ICON[status](paint) : paint.muted("?");
+	const mark = statusMark(status);
+	return mark === undefined ? paint.muted("?") : mark.glyphInk(paint)(mark.glyph);
+}
+
+/** The name ink on a nested line: the call's own status, not the row's (issue #41). */
+function callInk(status: string, paint: RowPaint): (text: string) => string {
+	return statusMark(status)?.nameInk(paint) ?? paint.muted;
 }
 
 /** A switch, not a table lookup: an inherited member such as "toString" must not read as a status. */

package/src/renderers/tool/specs/read.ts

@@ -61,11 +61,11 @@ const SUMMARY_MAX = 120;
 /** The host's user-limit notice — the one trailer it appends with no details.truncation block (read.js:132-137). */
 const MORE_LINES_NOTICE = /^\[\d+ more lines in file\. Use offset=\d+ to continue\.\]$/;
 
-/** The lead text per classification, one stateless painter each. */
+/** The lead text per classification: a name-like lead takes the state ink, the marker keeps accent. */
 // shape: dispatch object — trigger #1, three branches on `header`, handlers stateless.
-const HEADER: Record<HeaderKind, (paint: RowPaint) => string> = {
-	path: (paint) => paint.title("→ read"),
-	docs: (paint) => paint.title("→ read docs"),
+const HEADER: Record<HeaderKind, (paint: RowPaint, ink: (text: string) => string) => string> = {
+	path: (_paint, ink) => ink("→ read"),
+	docs: (_paint, ink) => ink("→ read docs"),
 	skill: (paint) => paint.accent("[skill]"),
 };
 
@@ -104,23 +104,25 @@ function build(result: ToolResult, ctx: RenderContext): ReadModel | "unknown" {
 }
 
 function project(m: ReadModel, view: RowView, paint: RowPaint): string {
-	if (m.kind === "error") return view.expanded ? errorBody(m, paint) : errorSummary(m, paint);
-	return view.expanded ? fileBody(m, paint) : fileSummary(m, paint);
+	// R3-07: a name-like label takes the row name's state ink, so one line never shows two inks for it.
+	const ink = view.isError ? paint.error : view.isPartial ? paint.dim : paint.success;
+	if (m.kind === "error") return view.expanded ? errorBody(m, paint) : errorSummary(m, paint, ink);
+	return view.expanded ? fileBody(m, paint, ink) : fileSummary(m, paint, ink);
 }
 
 /** `→ read <label>` / `→ read docs <label>` / `[skill] <name>`, with the range when the read starts late. */
-function header(m: FileModel, paint: RowPaint): string {
+function header(m: FileModel, paint: RowPaint, ink: (text: string) => string): string {
 	const range = m.offset > 1 ? paint.muted(`:${m.offset}`) : "";
-	const label = m.label === "" ? "" : ` ${paint.title(m.label)}`;
-	return `${HEADER[m.header](paint)}${label}${range}`;
+	const label = m.label === "" ? "" : ` ${ink(m.label)}`;
+	return `${HEADER[m.header](paint, ink)}${label}${range}`;
 }
 
-function fileSummary(m: FileModel, paint: RowPaint): string {
+function fileSummary(m: FileModel, paint: RowPaint, ink: (text: string) => string): string {
 	const lines = m.lines.length;
-	return `${header(m, paint)} ${paint.muted(`${lines} ${lines === 1 ? "line" : "lines"} — ctrl+o to expand`)}`;
+	return `${header(m, paint, ink)} ${paint.muted(`${lines} ${lines === 1 ? "line" : "lines"} — ctrl+o to expand`)}`;
 }
 
-function fileBody(m: FileModel, paint: RowPaint): string {
+function fileBody(m: FileModel, paint: RowPaint, ink: (text: string) => string): string {
 	// A fixed gutter width keeps the numbers aligned across frames; 3 is the predecessor's floor.
 	const width = Math.max(3, String(m.offset + m.lines.length - 1).length);
 	const numbered = m.lines.map(
@@ -129,13 +131,13 @@ function fileBody(m: FileModel, paint: RowPaint): string {
 	);
 	const hint = m.header === "skill" ? ` ${paint.muted("ctrl+o to collapse")}` : "";
 	const notice = m.notice === undefined ? [] : [paint.warning(m.notice)];
-	return [header(m, paint) + hint, ...numbered, ...notice].join("\n");
+	return [header(m, paint, ink) + hint, ...numbered, ...notice].join("\n");
 }
 
-function errorSummary(m: ErrorModel, paint: RowPaint): string {
+function errorSummary(m: ErrorModel, paint: RowPaint, ink: (text: string) => string): string {
 	const first = m.lines.find((line) => line.trim() !== "") ?? "failed";
 	const message = first.length > SUMMARY_MAX ? `${first.slice(0, SUMMARY_MAX - 1)}…` : first;
-	const label = m.label === "" ? "" : ` ${paint.title(m.label)}`;
+	const label = m.label === "" ? "" : ` ${ink(m.label)}`;
 	return `${paint.error("→ read")}${label} ${paint.error(message)}`;
 }
 

package/src/renderers/tool/specs/write.ts

@@ -76,8 +76,12 @@ function firstLine(text: string): string {
 }
 
 /** shape: none — a two-value expansion branch with one string body each. */
-function writtenLine(m: Extract<WriteModel, { kind: "written" }>, paint: RowPaint): string {
-	const head = m.display ? `${ICON} ${paint.title(m.display)}` : ICON;
+function writtenLine(
+	m: Extract<WriteModel, { kind: "written" }>,
+	paint: RowPaint,
+	ink: (text: string) => string,
+): string {
+	const head = m.display ? `${ICON} ${ink(m.display)}` : ICON;
 	// No content yet (args still streaming) is the pinned special case: no fabricated counts.
 	if (m.content === undefined) return `${head} ${paint.muted("· writing…")}`;
 	return `${head} ${paint.muted(`(${m.lines} lines · ${m.bytes} bytes)`)}`;
@@ -94,8 +98,8 @@ function writtenBody(m: Extract<WriteModel, { kind: "written" }>, paint: RowPain
 }
 
 /** shape: none — a single collapsed line; error text is truncated, never re-wrapped. */
-function errorLine(m: Extract<WriteModel, { kind: "error" }>, paint: RowPaint): string {
-	const head = m.display ? `${ICON} ${paint.title(m.display)} ` : "";
+function errorLine(m: Extract<WriteModel, { kind: "error" }>, paint: RowPaint, ink: (text: string) => string): string {
+	const head = m.display ? `${ICON} ${ink(m.display)} ` : "";
 	return `${head}${paint.error(`${ERROR_MARK} ${firstLine(m.error)}`)}`;
 }
 
@@ -127,8 +131,10 @@ function build(result: ToolResult, ctx: RenderContext): WriteModel | "unknown" {
 
 /** shape: none — two straight-line branches (state, then model kind); no dispatch object. */
 function project(m: WriteModel, view: RowView, paint: RowPaint): string {
-	if (m.kind === "error") return view.expanded ? errorBody(m, paint) : errorLine(m, paint);
-	return view.expanded ? writtenBody(m, paint) : writtenLine(m, paint);
+	// R3-07: the path is name-like text, so it takes the row name's state ink (error / dim / success).
+	const ink = view.isError ? paint.error : view.isPartial ? paint.dim : paint.success;
+	if (m.kind === "error") return view.expanded ? errorBody(m, paint) : errorLine(m, paint, ink);
+	return view.expanded ? writtenBody(m, paint) : writtenLine(m, paint, ink);
 }
 
 export const writeRow: {

package/themes/dracula-soft.json

@@ -37,9 +37,9 @@
 		"customMessageBg": "#403d53",
 		"customMessageText": "muted",
 		"customMessageLabel": "purple",
-		"toolPendingBg": "#2e313e",
-		"toolSuccessBg": "#324c44",
-		"toolErrorBg": "#4c353f",
+		"toolPendingBg": "",
+		"toolSuccessBg": "",
+		"toolErrorBg": "",
 		"toolTitle": "text",
 		"toolOutput": "muted",
 		"mdHeading": "purple",

package/themes/one-dark.json

@@ -36,9 +36,9 @@
 		"customMessageBg": "#41384f",
 		"customMessageText": "muted",
 		"customMessageLabel": "purple",
-		"toolPendingBg": "#323842",
-		"toolSuccessBg": "#3c4740",
-		"toolErrorBg": "#493840",
+		"toolPendingBg": "",
+		"toolSuccessBg": "",
+		"toolErrorBg": "",
 		"toolTitle": "text",
 		"toolOutput": "muted",
 		"mdHeading": "red",