@zenodinh/pi-render 0.1.0 → 0.1.3

package/README.md

@@ -4,10 +4,13 @@ A render-only presentation layer for **pi**: styled tool rows and a richer answe
 canvas, with zero tool-name registrations. pi-render draws; the host and its peers
 execute.
 
-It registers one row renderer resolver and one markdown transformer, draws eight
-built-in tool rows collapsed to a single line, and renders tables, code/JSON
-panels, diagram fences, and images inside assistant answers. It adds no tool
-schema, no prompt text, and no execution wrapper.
+It registers one row renderer resolver and one markdown transformer — and no
+commands at all — draws eight built-in tool rows collapsed to a single line, and
+renders tables, code/JSON panels, diagram fences, and images inside assistant
+answers. It adds no tool schema, no prompt text, and no execution wrapper.
+
+It is on by default: install it and styled output appears, with nothing to
+configure and nothing to invoke.
 
 Replaces [pi-pretty-tui](https://github.com/zenodinh/pi-pretty-tui), fixing
 [#21](https://github.com/zenodinh/pi-pretty-tui/issues/21) (expand freeze) and
@@ -52,8 +55,19 @@ Every tool row renders collapsed to one line, with errors summarized on that lin
 `ctrl+o` — or a click — expands the row; expanding a call again reuses the cached
 render, so there is no re-parse and no freeze.
 
-`/canvas` reports the canvas surfaces and the artifact cache, and opens the
-artifact browser in a TUI host. In a non-TUI host it prints a summary instead.
+Nothing to invoke: pi-render registers no commands, so the `/canvas` status
+command is gone. The artifact surfaces it reported on are unchanged — the engines
+and the cache still warm at boot, and diagram fences still render as cards.
+
+### Turning a module off
+
+Every module is on by default. A module can still be disabled through the one
+settings document, `~/.pi/agent/pi-render/settings.json`; only that module's
+surface falls back to the host's own rendering, and the others are unaffected:
+
+```json
+{ "version": 1, "modules": { "content.table": { "enabled": false } } }
+```
 
 ## What you get, and what changes
 

package/index.ts

@@ -1,43 +1,37 @@
 /**
  * index.ts — the composition root: the package's only file that calls pi.*.
  *
- * Why one file: every lane ends in a plain value (a resolver, a transformer, a command), so boot is a
+ * Why one file: every lane ends in a plain value (a resolver, a transformer, a surface), so boot is a
  * table of contents — build the registry, compose the two tables, register once per seam, and warm the
  * engines the synchronous seams call. Each lane installs in its own try/catch: a broken lane costs
  * itself, never the session (SA §2). The predecessor's ordering lore does not port — with zero
  * registrations there is no inter-extension race left to sequence around.
  *
+ * The command surface is empty on purpose (Req 2): the whole host surface is one tool resolver, one
+ * markdown transformer and one `session_start` hook — nothing for the user to invoke.
+ *
  * Boundary: the host arrives as the parameter. Nothing here parses markdown, draws a row or decides
- * module state; the one adapter this file owns is the artifacts fence pass, which no lane supplies.
+ * module state; the one adapter this file owns is the artifacts pass — the fence walk and the local
+ * `.html` link walk — which no lane supplies.
  *
  * shape: none — wiring only: `piRender` is the runtime unit, and every install below is straight-line.
  */
 
 import { readFileSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
+import { basename, isAbsolute, resolve } from "node:path";
 import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { installCommands } from "./src/commands/canvas.ts";
 import { CODE_THEME_MODULE, createCodeTheme, createShikiEngine } from "./src/core/code-theme.ts";
 import { createLogger } from "./src/core/log.ts";
 import { createContentPaint, createRowPaint } from "./src/core/paint.ts";
 import { createRegistry } from "./src/core/registry.ts";
 import { createSettingsStore } from "./src/core/settings.ts";
-import type {
-	CommandContext,
-	ContentPaint,
-	ExtensionApi,
-	Logger,
-	ModuleDescriptor,
-	Registry,
-	Surface,
-} from "./src/core/types.ts";
+import type { ContentPaint, ExtensionApi, Logger, ModuleDescriptor, Registry, Surface } from "./src/core/types.ts";
 import { type ArtifactCache, createArtifactCache, renderCacheKey } from "./src/renderers/content/artifacts/cache.ts";
 import { artifactTitle, renderArtifactCard } from "./src/renderers/content/artifacts/cards.ts";
 import {
 	type DiagramForm,
 	type EngineStatus,
 	renderDiagram,
-	status,
 	warmup,
 } from "./src/renderers/content/artifacts/engines.ts";
 import { type ArtifactServer, createArtifactServer } from "./src/renderers/content/artifacts/server.ts";
@@ -45,6 +39,7 @@ import { createCodePanel, mapFencedBlocks, panelWidth } from "./src/renderers/co
 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 { createMasterResolver, type SpecEntry } from "./src/renderers/tool/index.ts";
 import { bashRow } from "./src/renderers/tool/specs/bash.ts";
@@ -107,7 +102,7 @@ function uniqueModules(descriptors: readonly ModuleDescriptor[]): ModuleDescript
 }
 
 // ---------------------------------------------------------------------------
-// The artifacts fence pass — the one adapter this file owns (SA §6)
+// The artifacts pass — the one adapter this file owns (SA §6)
 // ---------------------------------------------------------------------------
 
 /** Raster width the cache key is computed from; pi-tui's own image width (P transformer.ts:68). */
@@ -153,10 +148,21 @@ function createArtifactsSurface(cache: ArtifactCache, server: ArtifactServer, lo
 	return {
 		rewrite(markdown, ctx, paint) {
 			const width = panelWidth(ctx.availableWidth);
-			const { text, changed } = mapFencedBlocks(markdown, (lang, code) =>
+			const fenced = mapFencedBlocks(markdown, (lang, code) =>
 				isArtifactForm(lang) ? card(lang, code, width, paint) : undefined,
 			);
-			return changed ? text : markdown;
+			// The fence walk may have replaced a whole block, so the link walk runs on its output and the
+			// message itself is what it falls back to when neither pass matched.
+			const fencedText = fenced.changed ? fenced.text : markdown;
+			// A local `.html` named only by a link needs no inline bytes: the pass gates on existence and
+			// the server streams the file on click, so the render path never reads it.
+			const links = mapHtmlLinkCards(fencedText, {
+				projectDir: PROJECT_DIR,
+				log,
+				card: ({ path }) =>
+					renderArtifactCard(server, { typeLabel: "html", title: basename(path), path, width }, paint),
+			});
+			return links.changed ? links.text : fencedText;
 		},
 	};
 }
@@ -217,20 +223,6 @@ async function installContent(
 	);
 }
 
-/** The /canvas view: what the artifact engines can draw this session. The browser pane is T-32's. */
-function canvasView(ctx: CommandContext): Promise<void> {
-	const ready = Object.entries(status())
-		.filter(([, on]) => on)
-		.map(([id]) => id);
-	ctx.ui.notify(`canvas: artifact engines ready — ${ready.join(", ") || "none"}`);
-	return Promise.resolve();
-}
-
-/** Region 9: the one command, which reaches the rest of the package through the registry alone (SA §7). */
-function installCanvasCommand(pi: ExtensionApi, registry: Registry): void {
-	installCommands(pi, { registry, canvasView });
-}
-
 /** shape: none — one guarded call; a lane reports itself and boot carries on. */
 async function settle<T>(lane: string, log: Logger, install: () => T | Promise<T>): Promise<T | undefined> {
 	try {
@@ -272,8 +264,12 @@ export default async function piRender(pi: ExtensionApi, deps: BootDeps = {}): P
 	await settle("rows", log, () => installRows(pi, registry, log));
 	const artifacts = await settle("artifacts", log, () => installArtifacts(log, deps));
 	await settle("content", log, () => installContent(pi, registry, log, artifacts));
-	await settle("commands", log, () => installCanvasCommand(pi, registry));
 
 	// Collapse-first reading model (owner decision): every tool row starts on one line.
-	pi.setToolsExpanded(false);
+	// The host exposes this on the per-event UI context (ctx.ui), not on the pi API — only
+	// interactive mode implements it (the runner's non-UI fallback is a no-op stub), so the
+	// call rides session_start: real in TUI, harmless in text/rpc.
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui?.setToolsExpanded?.(false);
+	});
 }

package/package.json

@@ -10,7 +10,11 @@
 	"files": [
 		"index.ts",
 		"src",
-		"themes"
+		"themes",
+		"!src/**/*.test.ts",
+		"!src/**/__snapshots__",
+		"!test",
+		"!themes/*.test.ts"
 	],
 	"scripts": {
 		"check": "tsc --noEmit",
@@ -63,5 +67,5 @@
 		"typescript": "^7.0.2",
 		"vitest": "^5.0.3"
 	},
-	"version": "0.1.0"
+	"version": "0.1.3"
 }

package/src/core/paint.ts

@@ -5,7 +5,7 @@
  * here); both theme inputs are structural, so a plain-object fixture drives either factory with no
  * host import.
  *
- * shape: none — dispatch object does not apply: no discriminator, each role is one token lookup. The
+ * shape: none — dispatch object does not apply: no discriminator, every role is a token lookup. The
  * two closure factories below declare their own shape.
  *
  * ported from pi-pretty-tui/src/config.ts:71-100 — survives because: "read the theme token, degrade to
@@ -25,6 +25,21 @@ function fgOrPlain(theme: HostTheme, key: string, text: string): string {
 	}
 }
 
+/**
+ * The match ink: the theme's `searchMatchText`, or `accent` when that ink is the line's own body ink.
+ *
+ * The `system` theme resolves both tokens into its `neutral` family (its bundled palettes do the same),
+ * so a match painted with `searchMatchText` is invisible inside the line it belongs to. Styling the
+ * same text with both tokens compares the two inks directly; a collision — including a `searchMatchText`
+ * that is absent or throws, where `fgOrPlain` degrades it to plain — falls to `accent`, which every
+ * theme keeps distinct from body text. Never throws: each lookup already ends in plain text.
+ */
+function matchOrAccent(theme: HostTheme, text: string): string {
+	const own = fgOrPlain(theme, "searchMatchText", text);
+	const body = fgOrPlain(theme, "toolOutput", text);
+	return own === body ? fgOrPlain(theme, "accent", text) : own;
+}
+
 /** Region-2 closures read the live theme proxy; a missing or throwing token falls to the next link. */
 function tryStyle(fn: ((text: string) => string) | undefined, text: string): string | undefined {
 	try {
@@ -45,7 +60,7 @@ export function createRowPaint(theme: HostTheme): RowPaint {
 		error: (text) => fgOrPlain(theme, "error", text),
 		warning: (text) => fgOrPlain(theme, "warning", text),
 		gutter: (text) => fgOrPlain(theme, "muted", text),
-		match: (text) => fgOrPlain(theme, "searchMatchText", text),
+		match: (text) => matchOrAccent(theme, text),
 		diffAdded: (text) => fgOrPlain(theme, "toolDiffAdded", text),
 		diffRemoved: (text) => fgOrPlain(theme, "toolDiffRemoved", text),
 		diffContext: (text) => fgOrPlain(theme, "toolDiffContext", text),

package/src/core/types/host.ts

@@ -130,31 +130,28 @@ export interface TransformContext {
 	availableWidth: number;
 }
 
-/** The command-handler context slice /canvas reads. Structural host shape — no host import. */
-export interface CommandContext {
-	/** Host output mode. Required: "tui" | "rpc" | "json" | "print". */
-	mode: "tui" | "rpc" | "json" | "print";
-	/** Host notification seam for user-facing feedback. Required. */
-	ui: {
-		/** Shows one message to the user, e.g. notify("Canvas closed"). Required. */
-		notify(message: string): void;
-	};
-}
-
 /**
  * The host surface the extension registers through. Structural host shape: the host arrives as the
  * composition root's parameter, never as a module import, so this file stays pi-free.
+ *
+ * The command seam and its handler context are deliberately absent (Req 2): pi-render registers no
+ * command, and a declaration it never calls is a claim it does not make. A future settings panel
+ * re-declares both here, in one place (PRD Q1).
  */
 export interface ExtensionApi {
 	/** Adds one resolver to the tool-render chain. Required; called exactly once, in index.ts. */
 	registerToolRenderer(resolver: ToolRendererResolver): void;
 	/** Adds one markdown rewrite stage. Required; called exactly once, in index.ts. */
 	registerMarkdownTransformer(transformer: (markdown: string, ctx: TransformContext) => string): void;
-	/** Registers one slash command, e.g. name "canvas". Required; one call per command. */
-	registerCommand(
-		name: string,
-		options: { description?: string; handler: (args: string, ctx: CommandContext) => Promise<void> },
-	): void;
-	/** Collapses every tool row to one line at boot. Required; the render-only default is false. */
-	setToolsExpanded(expanded: boolean): void;
+	/** Subscribes to a host event, e.g. "session_start". Required; the per-event ctx carries ui. */
+	on(event: string, handler: (event: unknown, ctx: EventContext) => void): void;
+}
+
+/** The context a host event handler receives. Structural host shape. */
+export interface EventContext {
+	/** The host's UI surface for this event — present in interactive mode, a no-op stub otherwise. Optional. */
+	ui?: {
+		/** Collapses (false) / expands (true) every tool row. The collapse-first default rides this. Optional. */
+		setToolsExpanded?(expanded: boolean): void;
+	};
 }

package/src/core/types.ts

@@ -14,7 +14,6 @@ export type { Surface, SurfaceKey } from "../renderers/content/types.ts";
 export type { CallModel, RowSpec, RowView } from "../renderers/tool/types.ts";
 export type { CodeTheme, HighlightEngine } from "./types/code-theme.ts";
 export type {
-	CommandContext,
 	ExtensionApi,
 	HostTheme,
 	MarkdownTheme,

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

@@ -18,15 +18,13 @@
 import { pathToFileURL } from "node:url";
 import { calculateImageRows, getImageDimensions, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { ContentPaint } from "../../../core/types/paint.ts";
+import { blockWidth } from "../code-panel.ts";
 import type { ArtifactServer } from "./server.ts";
 
 const OPEN_LABEL = "Open (⌘click)";
 const COPY_LABEL = "Copy path (⌥C)";
 /** The rendered link occupies brackets around the label. */
 const OPEN_WIDTH = visibleWidth(OPEN_LABEL) + 2;
-/** Cards read best narrow; the offered width is clamped into these bounds. */
-const CARD_MIN_WIDTH = 24;
-const CARD_MAX_WIDTH = 64;
 /** pi-tui's default image width; the reference for a raster artifact's transcript row count. */
 const DEFAULT_WIDTH_CELLS = 60;
 
@@ -70,9 +68,15 @@ export function artifactTitle(form: string, source: string): string {
 	return form;
 }
 
-/** shape: none — one box; every line's visible width is arithmetically bounded. */
+/**
+ * shape: none — one box; every line's DRAWN width is arithmetically bounded.
+ *
+ * Drawn, not raw: the host paints a markdown link as its label, so the pad filling the line to the
+ * right edge charges OPEN_LABEL's cells. `linkFits` and `titleBudget` still measure the RAW link —
+ * that is the width the host's wrap sees when it decides whether the token survives.
+ */
 function renderCard(spec: ArtifactCardSpec & { openUrl: string; pathLabel: string }, paint: ContentPaint): string {
-	const width = Math.max(CARD_MIN_WIDTH, Math.min(Math.floor(spec.width), CARD_MAX_WIDTH));
+	const width = blockWidth(spec.width);
 	const inner = width - 2;
 	const contentWidth = Math.max(OPEN_WIDTH + 2, inner - 2);
 	const label = spec.typeLabel.toLowerCase();
@@ -89,7 +93,10 @@ function renderCard(spec: ArtifactCardSpec & { openUrl: string; pathLabel: strin
 	const titleBudget = contentWidth - (linkFits ? visibleWidth(link) : visibleWidth(OPEN_LABEL)) - 1;
 	const titleFitted = clampWidth(title, Math.max(1, titleBudget));
 	const actionText = linkFits ? link : OPEN_LABEL;
-	const titlePad = " ".repeat(Math.max(1, contentWidth - visibleWidth(titleFitted) - visibleWidth(actionText)));
+	// Charge the DRAWN affordance, not the markdown: the host draws `[label](url)` as its label, so a
+	// pad built on the raw link width stopped (raw link − label) cells short of the frame's right edge
+	// — the title row was the one ragged line of the box (issue #8).
+	const titlePad = " ".repeat(Math.max(1, contentWidth - visibleWidth(titleFitted) - visibleWidth(OPEN_LABEL)));
 	// No escape codes inside the brackets: anything there breaks the link token.
 	const titleLine = `${paint.rule("│")} ${paint.quote(titleFitted)}${titlePad}${actionText} ${paint.rule("│")}`;
 	const copyPad = " ".repeat(Math.max(0, contentWidth - visibleWidth(COPY_LABEL)));

package/src/renderers/content/code-panel.ts

@@ -1,15 +1,17 @@
 // ported from pi-pretty-tui/src/features/canvas/code-panel.ts — survives because: the bordered panel
-// with a language header, the content-hugging width, the ANSI-aware truncation and the sync highlight
-// path are the owner's reading surface for a fence; only the color source changed (paint roles plus the
-// injected CodeTheme instead of module-level globals and hardcoded escapes).
+// with a language header, the ANSI-aware body wrap and the sync highlight path are the owner's reading
+// surface for a fence (the content-hugging width does not survive: FIX-12 replaced it with the shared
+// reading column); only the color source changed (paint roles plus the injected CodeTheme instead of
+// module-level globals and hardcoded escapes).
 
 /**
  * code-panel.ts — a fenced block becomes a bordered, themed panel; the JSON pane reuses the same frame,
- * the same fence scan and the same markdown embedding.
+ * the same fence scan, the same block-width clamp (24–140, the owner's revised reading column) and the
+ * same markdown embedding.
  *
  * Boundary: markdown is untrusted and is scanned line-by-line, never handed to a parser; the CodeTheme
  * is injected, so no renderer imports shiki. Width math is pi-tui's own ANSI-aware visibleWidth /
- * truncateToWidth — the one host utility the panel needs, and what keeps columns aligned when truecolor
+ * wrapTextWithAnsi — the host utilities the panel needs, and what keeps columns aligned when truecolor
  * escapes sit inside the content (CJK included). A failing highlighter degrades to plain source; the
  * panel never throws.
  *
@@ -17,30 +19,51 @@
  * declares its own shape below.
  */
 
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { CodeTheme, ContentPaint } from "../../core/types.ts";
 import type { Surface } from "./types.ts";
 
-/** The panel is never narrower than this, so a one-word snippet still reads as a block (P code-panel.ts:20). */
-const MIN_PANEL_WIDTH = 24;
-/** A body row is `│ text │`, so the text budget is width-4 (P code-panel.ts:75). */
-const ROW_CHROME = 4;
+/** The floor of the reading column, so a narrow terminal still reads a block as a block. */
+const BLOCK_MIN_WIDTH = 24;
+/** The ceiling of the reading column. Raised 64 → 140 by the owner (2026-10-07): 64 cells were too
+ *  narrow for a table cell, and 140/190 ≈ 74% keeps the proportion the original reference width set
+ *  (64/80 ≈ 80%), so a wide terminal or a two-way split still reads as one column. */
+const BLOCK_MAX_WIDTH = 140;
+/** A body row is `│␣␣text␣␣│` — two blank cells each side so the frame never touches the code — so the
+ *  text budget is width-6 (P code-panel.ts:75). */
+const ROW_CHROME = 6;
 /** Languages left as raw fences: mermaid is the host's own renderer, and the four diagram forms
  *  belong to the artifact pass that runs AFTER surfaces (SA §6) — consuming them here would
  *  regress every diagram to a plain panel. */
 const RAW_FENCES = new Set(["mermaid", "plantuml", "svg", "dot", "html"]);
 
-/** The offered transcript width, clamped to the panel minimum (P transformer.ts:319-320). */
-// shape: none — one clamp, no branch on a discriminator.
-export function panelWidth(availableWidth: number): number {
-	return Math.max(MIN_PANEL_WIDTH, Math.floor(availableWidth) || 80);
+/**
+ * The reading column: the one width every framed block shares (GLOSSARY "reading column"). The offered
+ * transcript width is clamped into [BLOCK_MIN_WIDTH, BLOCK_MAX_WIDTH], so at 140 columns and above a
+ * block holds 140 cells, and below 140 it takes the FULL offered width — a narrow terminal is never
+ * under-filled. Zero or a non-numeric offer falls back to 80 columns.
+ *
+ * shape: none — one clamp, no branch on a discriminator.
+ */
+export function blockWidth(availableWidth: number): number {
+	const offered = Math.floor(availableWidth) || 80;
+	return Math.min(BLOCK_MAX_WIDTH, Math.max(BLOCK_MIN_WIDTH, offered));
 }
 
-/** Highlighted body lines, truncated by visible width; a throwing theme degrades to the plain source. */
-// shape: none — one guarded call plus a one-line fallback; no discriminator.
-function bodyLines(code: string, lang: string, width: number, codeTheme: CodeTheme): string[] {
+/**
+ * The composition root's historical name for {@link blockWidth} (index.ts imports it and is outside
+ * FIX-12's file set). Same function, same clamp — kept so the root keeps compiling.
+ */
+export const panelWidth = blockWidth;
+
+/**
+ * Highlighted body lines, wrapped to `textWidth` visible cells; a line past the budget continues on the
+ * next row (ANSI-aware) rather than being cut. A throwing theme degrades to the plain source.
+ *
+ * shape: none — one guarded call plus a one-line fallback; no discriminator.
+ */
+function bodyLines(code: string, lang: string, textWidth: number, codeTheme: CodeTheme): string[] {
 	const source = code.replace(/\n+$/, "");
-	const budget = Math.max(8, width - ROW_CHROME);
 	let lines: string[];
 	try {
 		lines = codeTheme.highlightSync(source, lang).split("\n");
@@ -48,11 +71,15 @@ function bodyLines(code: string, lang: string, width: number, codeTheme: CodeThe
 		// A cold core or an unloadable grammar: the panel degrades, the answer render never dies.
 		lines = source.split("\n");
 	}
-	return lines.map((line) => truncateToWidth(line, budget));
+	return lines.flatMap((line) => wrapTextWithAnsi(line, textWidth));
 }
 
 /**
- * One framed block: header label, hugged width, padded rows. Shared by the code and JSON panels.
+ * One framed block at the shared reading column: header label and body rows, all `blockWidth(width)`
+ * cells wide. Each body row is `│␣␣text␣␣pad␣␣│`, i.e. the line begins two cells inside the opening
+ * border and its own padding fills the rest of a `panelSize - 6` text budget, so the frame never crowds
+ * the code. A line wider than that budget was already wrapped by {@link bodyLines}, so the panel shows
+ * the whole line over further rows and pads the last. Shared by the code and JSON panels.
  *
  * shape: none — one box; every row's visible width is arithmetically bounded to the panel width.
  */
@@ -63,22 +90,17 @@ export function renderPanel(
 	paint: ContentPaint,
 	codeTheme: CodeTheme,
 ): string[] {
-	const maxWidth = Math.max(MIN_PANEL_WIDTH, Math.floor(width));
+	const panelSize = blockWidth(width);
+	const textWidth = Math.max(8, panelSize - ROW_CHROME);
 	const label = lang.toLowerCase() || "code";
-	const body = bodyLines(code, lang, maxWidth, codeTheme);
-	const contentWidth = Math.max(1, ...body.map((line) => visibleWidth(line)));
-	const prefix = `─ ${label} `;
-	const panelSize = Math.min(
-		maxWidth,
-		Math.max(MIN_PANEL_WIDTH, Math.max(contentWidth + ROW_CHROME, visibleWidth(prefix) + ROW_CHROME)),
-	);
+	const body = bodyLines(code, lang, textWidth, codeTheme);
 	const inner = panelSize - 2;
-	const textWidth = Math.max(8, panelSize - ROW_CHROME);
+	const prefix = `─ ${label} `;
 	const dashes = Math.max(0, inner - visibleWidth(prefix));
 	const rows: string[] = [paint.codeBlockBorder(`╭${prefix}${"─".repeat(dashes)}╮`)];
 	for (const line of body) {
 		const pad = " ".repeat(Math.max(0, textWidth - visibleWidth(line)));
-		rows.push(`${paint.codeBlockBorder("│")} ${line}${pad} ${paint.codeBlockBorder("│")}`);
+		rows.push(`${paint.codeBlockBorder("│")}  ${line}${pad}  ${paint.codeBlockBorder("│")}`);
 	}
 	rows.push(paint.codeBlockBorder(`╰${"─".repeat(inner)}╯`));
 	return rows;
@@ -151,7 +173,7 @@ export function mapFencedBlocks(
 export function createCodePanel(codeTheme: CodeTheme): Surface {
 	return {
 		rewrite(markdown, ctx, paint) {
-			const width = panelWidth(ctx.availableWidth);
+			const width = blockWidth(ctx.availableWidth);
 			const { text, changed } = mapFencedBlocks(markdown, (lang, code) =>
 				lang && !RAW_FENCES.has(lang) ? toMarkdownRows(renderPanel(code, lang, width, paint, codeTheme)) : undefined,
 			);

package/src/renderers/content/index.ts

@@ -1,10 +1,13 @@
 /**
- * index.ts — the markdown transformer: final-assistant gate, per-surface registry check, dispatch,
- * identity return.
+ * index.ts — the markdown transformer: final-assistant gate, per-surface registry check, per-surface
+ * isolation, dispatch, identity return, and one keyed line for every skip.
  *
  * Boundary: the host calls this on the transcript render path, so nothing here throws and nothing
- * allocates per message. A disabled surface is skipped, and the input string returns by reference
- * whenever no surface changed it — the host's own caching reads that reference.
+ * 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.
  *
  * shape: closure returning a function — trigger #4, the factory captures its injected collaborators
  * (registry, surfaces, paint, log) and holds no state to classify.
@@ -12,7 +15,8 @@
  * 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.
+ * 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,7 +32,16 @@ const ARTIFACTS_KEY = "artifacts";
 const SURFACE_ORDER: readonly SurfaceKey[] = ["table", "codePanel", "jsonPanel", "imageCard"];
 
 const SCOPE = "content";
-const LOG_KEY = "content:transform";
+
+/**
+ * What this file calls a table: a row holding a pipe, then a delimiter row of dashes, colons and pipes.
+ * It is the shape the table surface parses (T-22), spelled for the raw markdown the transformer receives,
+ * so prose that merely quotes a pipe — or an already-boxed frame — never matches.
+ */
+const TABLE_SHAPE = /\|[^\n]*\n\|[ :-]*-[-| :]*\|/;
+
+/** The tee in the table box's top rule (T-22): present in an output exactly when a table was boxed. */
+const TABLE_BOX_RULE = "┬";
 
 /** The surface table T-28 composes: one entry per SurfaceKey, plus the optional fence pass. */
 export type ContentSurfaces = Record<SurfaceKey, Surface> & {
@@ -40,7 +53,7 @@ export type ContentSurfaces = Record<SurfaceKey, Surface> & {
 export interface ContentTransformerDeps {
 	/** Live content paint; surfaces receive it per invocation. Required. */
 	paint: ContentPaint;
-	/** Keyed diagnostics; the never-throw path logs exactly one line. Required. */
+	/** Keyed diagnostics: one line per surface failure, gate skip and declined table — a healthy input logs nothing. Required. */
 	log: Logger;
 }
 
@@ -54,26 +67,62 @@ export function createContentTransformer(
 	const { paint, log } = deps;
 	const artifacts = surfaces.artifacts;
 
-	/** One dispatch step: an absent or disabled slot is skipped, otherwise it rewrites the current text. */
+	/**
+	 * One dispatch step: an absent or disabled slot is skipped, otherwise it rewrites the current text.
+	 * Per-surface isolation lives here — a surface that throws logs one line keyed on its own name and
+	 * returns the text it was handed, so the failure costs that surface alone and never the message.
+	 */
 	const run = (key: string, surface: Surface | undefined, input: string, ctx: TransformContext): string => {
 		if (surface === undefined || !registry.isEnabled(key)) return input;
-		const next = surface.rewrite(input, ctx, paint);
-		// A surface signals "nothing matched" by returning its input; comparing by value also discards an
-		// equal copy, so a no-op pass keeps the reference the host handed us.
-		return next === input ? input : next;
+		try {
+			const next = surface.rewrite(input, ctx, paint);
+			// A surface signals "nothing matched" by returning its input; comparing by value also discards an
+			// equal copy, so a no-op pass keeps the reference the host handed us.
+			return next === input ? input : next;
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			log.logOnce(`content:fail:${key}`, SCOPE, `${key} failed: ${detail}`);
+			return input;
+		}
 	};
 
 	return (markdown, ctx) => {
-		// The predecessor's gate, unchanged: only a settled assistant message is rewritten.
-		if (ctx.messageType !== "assistant" || ctx.isStreaming) return markdown;
-		try {
-			let out = markdown;
-			for (const key of SURFACE_ORDER) out = run(`content.${key}`, surfaces[key], out, ctx);
-			return run(`content.${ARTIFACTS_KEY}`, artifacts, out, ctx);
-		} catch (error) {
-			// One failing surface must not cost the answer: the original input returns untouched.
-			log.logOnce(LOG_KEY, SCOPE, `transform failed: ${error instanceof Error ? error.message : String(error)}`);
+		// 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;
 		}
+
+		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) {
+			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);
+		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)) {
+			log.logOnce(
+				`content:decline:table:${markdown.length}`,
+				SCOPE,
+				`table-shaped content left unboxed: last surface that touched the text=${lastTouched ?? "none"}`,
+			);
+		}
+		return out;
 	};
 }