@zenodinh/pi-render 0.1.0 → 0.1.3

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

@@ -15,16 +15,16 @@
  */
 
 import type { CodeTheme, ContentPaint, Logger } from "../../core/types.ts";
-import { mapFencedBlocks, panelWidth, renderPanel, toMarkdownRows } from "./code-panel.ts";
+import { blockWidth, mapFencedBlocks, renderPanel, toMarkdownRows } from "./code-panel.ts";
+import { hrefExtension, isLocalRef, standaloneLinkHref } from "./link-paragraph.ts";
 import type { Surface } from "./types.ts";
 
 /** JSON's content is what the reader wants up to here; past it the file stays one click away (P transformer.ts:265). */
 const MAX_PANE_LINES = 40;
 /** A fence spelling that still highlights as JSON (P transformer.ts:264). */
 const JSON_LANGS = new Set(["json", "jsonc", "jsonl"]);
-/** A paragraph that is nothing but a link, captured as its href (P transformer.ts:270-275). */
-const LINK_ONLY = /^\[[^\]]*\]\(([^)\s]+)\)$/;
-const JSON_EXTENSION = /\.(jsonc?|jsonl)$/i;
+/** The extensions the pane claims; `hrefExtension` tests one at a time, so the table spells them out. */
+const JSON_EXTENSIONS = ["json", "jsonc", "jsonl"] as const;
 
 /** The collaborators the pane reads through: the file reader and the optional diagnostics sink. */
 export interface JsonPanelDeps {
@@ -34,12 +34,6 @@ export interface JsonPanelDeps {
 	log?: Pick<Logger, "logOnce">;
 }
 
-/** A scheme-bearing, protocol-relative or fragment href is not a local file (P transformer.ts:110-112). */
-// shape: none — one classification, no branch on a discriminator.
-function isLocalRef(href: string): boolean {
-	return !/^[a-z][a-z0-9+.-]*:/i.test(href) && !href.startsWith("//") && !href.startsWith("#");
-}
-
 /** The pane markdown for one readable JSON file, or undefined when the reader could not produce content. */
 // shape: none — one guarded call plus a footer choice; no discriminator.
 function jsonFilePane(
@@ -82,13 +76,11 @@ function mapJsonFileLinks(
 	let changed = false;
 	for (let i = 0; i < lines.length; i += 1) {
 		const line = lines[i] ?? "";
-		const href = LINK_ONLY.exec(line.trim())?.[1];
-		const alone =
-			line.trim() !== "" &&
-			(i === 0 || (lines[i - 1] ?? "").trim() === "") &&
-			(i === lines.length - 1 || (lines[i + 1] ?? "").trim() === "");
+		// A standalone link paragraph, recognised once in link-paragraph.ts: the same rule the artifact
+		// pass applies to a local `.html` link.
+		const href = standaloneLinkHref(lines, i);
 		const pane =
-			href !== undefined && alone && isLocalRef(href) && JSON_EXTENSION.test(href.replace(/[?#].*$/, ""))
+			href !== undefined && isLocalRef(href) && JSON_EXTENSIONS.some((extension) => hrefExtension(href, extension))
 				? jsonFilePane(href, width, paint, codeTheme, deps)
 				: undefined;
 		if (pane === undefined) {
@@ -105,7 +97,7 @@ function mapJsonFileLinks(
 export function createJsonPanel(codeTheme: CodeTheme, deps: JsonPanelDeps): Surface {
 	return {
 		rewrite(markdown, ctx, paint) {
-			const width = panelWidth(ctx.availableWidth);
+			const width = blockWidth(ctx.availableWidth);
 			const fences = mapFencedBlocks(markdown, (lang, code) =>
 				JSON_LANGS.has(lang) ? toMarkdownRows(renderPanel(code, "json", width, paint, codeTheme)) : undefined,
 			);

package/src/renderers/content/link-paragraph.ts

@@ -0,0 +1,153 @@
+// ported from pi-pretty-tui/src/features/canvas/transformer.ts:110-112 (isLocalRef) and :270-275
+// (LINK_ONLY) — survives because: "a paragraph that is nothing but a link to a local file names that
+// file" is the recognition the JSON pane and the artifact link pass both need, and it is what lets a
+// large .html page be carded without its bytes ever entering the message. Promoted out of json-panel.ts
+// when the second consumer arrived; carries no registration claim and reads no file.
+
+/**
+ * link-paragraph.ts — what a link paragraph is, and the pass that cards a local `.html` one.
+ *
+ * Boundary: markdown is untrusted, so it is walked line by line and never parsed; this module reads no
+ * file — `fileExists` is one injected existence check per candidate, and the card itself is drawn by
+ * the caller. A missing file keeps the raw link and reports one keyed line through the injected sink; a
+ * remote href, a bare fragment, or another extension is left byte-identical. Nothing here throws and
+ * nothing here writes stdout or stderr.
+ *
+ * shape: none — pure recognition helpers plus one line walk over injected collaborators; there is no
+ * discriminator to dispatch on and no resource to hold.
+ */
+
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import type { Logger } from "../../core/types/log.ts";
+
+/** Diagnostics scope for the pass; the artifacts surface owns its keyed lines. */
+const SCOPE = "content.artifacts";
+
+/** The one extension this pass cards (owner decision 2026-10-07); `.svg`/`.dot`/`.puml` by path are a follow-up. */
+const HTML_EXTENSION = "html";
+
+/** A paragraph that is nothing but a link, captured as its href (P transformer.ts:270-275). */
+const LINK_ONLY = /^\[[^\]]*\]\(([^)\s]+)\)$/;
+
+/**
+ * The href of a paragraph that is nothing but a markdown link, or `undefined` when the line is
+ * anything else.
+ *
+ * A line qualifies only when the whole line — ignoring leading and trailing whitespace — is one link;
+ * a link that shares its line with prose is not a link paragraph.
+ */
+// shape: none — one anchored match, no branch on a discriminator.
+export function linkOnlyHref(line: string): string | undefined {
+	return LINK_ONLY.exec(line.trim())?.[1];
+}
+
+/**
+ * True when the href names a local file: it carries no URI scheme (`https:`, `data:`, `mailto:`), is
+ * not protocol-relative (`//host/path`), and is not a bare fragment (`#section`) (P transformer.ts:110-112).
+ */
+// shape: none — one classification, no branch on a discriminator.
+export function isLocalRef(href: string): boolean {
+	return !/^[a-z][a-z0-9+.-]*:/i.test(href) && !href.startsWith("//") && !href.startsWith("#");
+}
+
+/** The part of an href that names a file: a query and a fragment address a location inside that file. */
+// shape: none — one string cut, no state.
+function withoutQuery(href: string): string {
+	return href.replace(/[?#].*$/, "");
+}
+
+/**
+ * True when the file part of the href ends in the named extension. The comparison is case-insensitive
+ * and ignores any query or fragment, so `hrefExtension("Guide.HTML#page=3", "html")` is true while
+ * `hrefExtension("guide.htm", "html")` is false.
+ *
+ * `extension` is written without its leading dot — `"html"`, `"jsonl"`.
+ */
+// shape: none — one string test, no branch on a discriminator.
+export function hrefExtension(href: string, extension: string): boolean {
+	return withoutQuery(href).toLowerCase().endsWith(`.${extension.toLowerCase()}`);
+}
+
+/**
+ * The href of a standalone link paragraph — a link-only line that its blank neighbours set off — or
+ * `undefined` when the line is blank, prose, or part of a paragraph.
+ *
+ * `lines` is the message split on "\n" and `index` is the line being tested; the first and last lines of
+ * a message are standalone when their only existing neighbour is blank.
+ */
+// shape: none — one link match plus one neighbour test; no discriminator.
+export function standaloneLinkHref(lines: readonly string[], index: number): string | undefined {
+	if ((lines[index] ?? "").trim() === "") return undefined;
+	if ((lines[index - 1] ?? "").trim() !== "") return undefined;
+	if ((lines[index + 1] ?? "").trim() !== "") return undefined;
+	return linkOnlyHref(lines[index] ?? "");
+}
+
+/** One standalone link the pass decided to card. */
+export interface HtmlLinkMatch {
+	/** The href exactly as the message wrote it — the value a diagnostic names. */
+	readonly href: string;
+	/** The file the href resolves to, absolute; a relative href resolves against the project directory. */
+	readonly path: string;
+}
+
+/** Draws one match into transcript markdown; the composition root passes `renderArtifactCard`. */
+export type HtmlLinkCard = (match: HtmlLinkMatch) => string;
+
+/** What the pass reads through: where relative hrefs start, how existence is checked, how to report. */
+export interface HtmlLinkPassDeps {
+	/** Base for a relative href — the launch directory, the same rule the JSON pane's reader uses. */
+	projectDir: string;
+	/** Builds the card for one existing file; called once per match, never for a miss. */
+	card: HtmlLinkCard;
+	/** Existence gate, called at most once per candidate. Defaults to node's `existsSync`. */
+	fileExists?: (absPath: string) => boolean;
+	/** Keyed diagnostics for a link that names a missing file. Optional; absent is silent. */
+	log?: Pick<Logger, "logOnce">;
+}
+
+/** The pass's outcome: the rewritten markdown, and whether anything changed. */
+export interface HtmlLinkPass {
+	/** The message with every carded link replaced; the message itself when `changed` is false. */
+	readonly text: string;
+	/** True when at least one line became a card. */
+	readonly changed: boolean;
+}
+
+/**
+ * Rewrites every standalone link paragraph that names an existing local `.html` file into a card, and
+ * returns the message itself when none matched.
+ *
+ * A local `.html` link whose file is missing keeps its raw line and reports one keyed line, because a
+ * card whose Open link 404s is worse than the link the model wrote. The render path reads no file: per
+ * candidate there is one `fileExists` call, no size cap and no engine call — the server streams the
+ * bytes on click.
+ *
+ * shape: none — one line walk with a single injected card callback, mirroring `mapFencedBlocks`; no
+ * dispatch on a value.
+ */
+export function mapHtmlLinkCards(markdown: string, deps: HtmlLinkPassDeps): HtmlLinkPass {
+	const exists = deps.fileExists ?? existsSync;
+	const lines = markdown.split("\n");
+	const out: string[] = [];
+	let changed = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index] ?? "";
+		const href = standaloneLinkHref(lines, index);
+		if (href === undefined || !isLocalRef(href) || !hrefExtension(href, HTML_EXTENSION)) {
+			out.push(line);
+			continue;
+		}
+		const file = withoutQuery(href);
+		const path = isAbsolute(file) ? file : resolve(deps.projectDir, file);
+		if (!exists(path)) {
+			deps.log?.logOnce(`artifact:html-link:${href}`, SCOPE, `could not card ${href} — no file at ${path}`);
+			out.push(line);
+			continue;
+		}
+		out.push(deps.card({ href, path }));
+		changed = true;
+	}
+	return { text: changed ? out.join("\n") : markdown, changed };
+}

package/src/renderers/content/table.ts

@@ -17,6 +17,7 @@
 import { Marked, type Token, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { TransformContext } from "../../core/types/host.ts";
 import type { ContentPaint } from "../../core/types/paint.ts";
+import { blockWidth } from "./code-panel.ts";
 import type { Surface } from "./types.ts";
 
 type InlineToken = { type?: string; text?: string; raw?: string; tokens?: InlineToken[] };
@@ -157,7 +158,9 @@ export const table: Surface = { rewrite };
 function rewrite(markdown: string, ctx: TransformContext, paint: ContentPaint): string {
 	// Every table block contains a pipe, so a block without one never pays for a lex.
 	if (!markdown.includes("|")) return markdown;
-	const width = Math.max(24, Math.floor(ctx.availableWidth));
+	// The shared reading column (FIX-12): the solver and every cell wrap against this one width, never
+	// the raw offered width, so a table's edges line up with the panels and cards above it.
+	const width = blockWidth(ctx.availableWidth);
 	// Unchanged tokens are spliced back by their own raw text; only table blocks are rebuilt.
 	const parts: string[] = [];
 	let changed = false;

package/src/renderers/tool/runtime.ts

@@ -6,8 +6,10 @@
  * runtime.ts — a declarative RowSpec in, host tool renderers out: parse once, project per invocation.
  *
  * Boundary: one runtime per row, created by the master resolver. It owns the protocol every spec would
- * otherwise re-implement — memo, args gate, never-throw degradation, async decorate. Host shapes arrive
- * as parameters (ctx, theme) and stay structural, so a unit test needs no pi runtime.
+ * otherwise re-implement — memo, args gate, never-throw degradation, async decorate, and the collapsed
+ * summary handoff: the result slot stores its one line in ctx.state and the call slot appends it, so a
+ * collapsed row is one line even though the host stacks two components. Host shapes arrive as parameters
+ * (ctx, theme) and stay structural, so a unit test needs no pi runtime.
  *
  * shape: closure returning an object literal — trigger #4: the per-row memo/token live behind the
  * renderCall/renderResult methods, with no subclassing.
@@ -32,6 +34,8 @@ const LOG_SCOPE = "tool.row";
 const MEMO_KEY = "piRender.memo";
 const TOKEN_KEY = "piRender.token";
 const DECORATED_KEY = "piRender.decorated";
+/** The collapsed result line the call slot appends, written by renderResult and read by renderCall. */
+const SUMMARY_KEY = "piRender.summary";
 /** A session reaches 1,400+ rows, so cross-row parsed models are bounded by count and by size. */
 const CACHE_MAX_ENTRIES = 512;
 const CACHE_MAX_CHARS = 16_000_000;
@@ -71,6 +75,12 @@ function writeMemo(ctx: RenderContext, src: ResultContent | undefined, len: numb
 	ctx.state[MEMO_KEY] = { src, len, model };
 }
 
+/** The collapsed summary the result slot has settled, or undefined when it has not run yet. */
+function readSummary(ctx: RenderContext): string | undefined {
+	const value: unknown = ctx.state[SUMMARY_KEY];
+	return typeof value === "string" ? value : undefined;
+}
+
 /** The engine's text verbatim, collapsed to one line: the degradation contract's body. */
 function textOf(result: ToolResult): string {
 	const content = result.content;
@@ -165,6 +175,23 @@ function textFor(ctx: RenderContext, body: string): UiComponent {
 	};
 }
 
+/**
+ * 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
+ * array adds nothing — the call line above is the whole collapsed row. Stateless, so one shared instance
+ * serves every row and every frame.
+ *
+ * shape: object literal — trigger #7, a fixed two-method UiComponent with no state of its own.
+ */
+const EMPTY_COMPONENT: UiComponent = {
+	render(_width: number): string[] {
+		return [];
+	},
+	invalidate(): void {
+		// The host tracks staleness; this component caches no frame.
+	},
+};
+
 function nextToken(ctx: RenderContext): number {
 	const current = ctx.state[TOKEN_KEY];
 	const next = typeof current === "number" ? current + 1 : 1;
@@ -238,7 +265,10 @@ export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory
 			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);
-			return textFor(ctx, paint.title(model.title));
+			const title = paint.title(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}`);
 		} catch (err) {
 			logFailure(deps.log, ctx, err);
 			return textFor(ctx, "");
@@ -254,8 +284,17 @@ export function createRowRenderers(spec: RowSpec, deps: { paint: RowPaintFactory
 		try {
 			const paint = deps.paint(theme);
 			const model = modelFor(result, ctx);
-			const body = model === UNKNOWN ? rawBody(result, paint) : spec.project(model, viewOf(options, ctx), paint);
-			return textFor(ctx, body);
+			// A degraded row keeps today's one raw line and settles no summary for the call slot to adopt.
+			if (model === UNKNOWN) return textFor(ctx, rawBody(result, paint));
+			const body = spec.project(model, viewOf(options, ctx), paint);
+			if (options.expanded) return textFor(ctx, body);
+			// Collapsed: hand the one-line summary to the call slot through the shared state bag and draw no
+			// line here. Redraw only when it changed — an unchanged summary is not a new frame.
+			if (readSummary(ctx) !== body) {
+				ctx.state[SUMMARY_KEY] = body;
+				ctx.invalidate?.();
+			}
+			return EMPTY_COMPONENT;
 		} catch (err) {
 			// The paint may itself be the thrower, so the degraded row is built without it.
 			logFailure(deps.log, ctx, err);

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

@@ -303,23 +303,31 @@ function annotation(value: string | undefined, paint: RowPaint): string {
 }
 
 function project(m: SearchModel, view: RowView, paint: RowPaint): string {
-	const tail = m.notices.length ? `\n${paint.warning(`[${m.notices.join(". ")}]`)}` : "";
+	const notice = m.notices.length ? paint.warning(`[${m.notices.join(". ")}]`) : "";
+	// A collapsed row is exactly one line (FIX-09): the notice joins the summary inline, never its own
+	// line. An expanded row keeps it as a trailer under the body.
+	const trailer = notice === "" ? "" : `\n${notice}`;
 	switch (m.kind) {
 		case "empty":
-			return `${paint.muted(`0 ${m.noun}`)}${tail}`;
+			return inline(`${paint.muted(`0 ${m.noun}`)}`, notice);
 		case "files": {
 			const count = m.files.length;
-			const label = `${count} file${count === 1 ? "" : "s"}`;
-			if (!view.expanded) return `${paint.muted(label)}${tail}`;
-			return `${paint.muted(label)}\n${renderFiles(m.files, paint)}${tail}`;
+			const label = `${paint.muted(`${count} file${count === 1 ? "" : "s"}`)}`;
+			if (!view.expanded) return inline(label, notice);
+			return `${label}\n${renderFiles(m.files, paint)}${trailer}`;
 		}
 		case "matches": {
 			const fileCount = m.blocks.length;
-			const label = `${m.matchCount} match${m.matchCount === 1 ? "" : "es"} in ${fileCount} file${
-				fileCount === 1 ? "" : "s"
-			}`;
-			if (!view.expanded) return `${paint.muted(label)}${tail}`;
-			return `${paint.muted(label)}\n${renderBlocks(m.blocks, m.highlight, paint)}${tail}`;
+			const label = `${paint.muted(
+				`${m.matchCount} match${m.matchCount === 1 ? "" : "es"} in ${fileCount} file${fileCount === 1 ? "" : "s"}`,
+			)}`;
+			if (!view.expanded) return inline(label, notice);
+			return `${label}\n${renderBlocks(m.blocks, m.highlight, paint)}${trailer}`;
 		}
 	}
 }
+
+/** Joins a notice onto a collapsed summary with a separator, so the row stays one line. */
+function inline(label: string, notice: string): string {
+	return notice === "" ? label : `${label} · ${notice}`;
+}

package/src/renderers/tool/types.ts

@@ -38,7 +38,12 @@ export interface RowSpec<M = unknown> {
 	buildCall(args: Record<string, unknown>, ctx: RenderContext): CallModel;
 	/** Parses the result once per result, memoized in ctx.state. Required; returns "unknown" when unrecognized. */
 	build(result: ToolResult, ctx: RenderContext): M | "unknown";
-	/** Draws the collapsed-line body; re-runs on every frame, so it stays allocation-light. Required. */
+	/**
+	 * Draws the row body for the current view. While `view.expanded` is false it MUST return exactly
+	 * one line (notices joined inline with " · ") — the runtime hands that line to the call slot so a
+	 * collapsed invocation occupies one transcript line; expanded, it returns the summary header plus
+	 * the body. Re-runs on every frame, so it stays allocation-light. Required.
+	 */
 	project(m: M, view: RowView, paint: RowPaint): string;
 	/** Enriches M, e.g. with a resolved link target, then asks the host to redraw. Optional. */
 	decorate?(m: M, ctx: RenderContext): Promise<Partial<M>>;

package/src/commands/canvas.test.ts

@@ -1,150 +0,0 @@
-/**
- * canvas through its seam — installCommands(pi, deps) on the recording host API, its handler driven
- * with a host-shaped context and the REAL registry (the command's only channel to the package).
- *
- * invented: the settings documents and the content.artifacts descriptor below are hand-built to the
- *   SA §3 literal (version + modules map) keyed on SA §6's artifacts module — T-25/T-26 own the real
- *   descriptor and T-07 the on-disk file, so there is no recorded payload to reuse; the documents are
- *   what drives the enabled/disabled state this command reports.
- * invented: the context double and the view recorder stand in for the host and for the browser T-28
- *   injects — the command's own seam is exactly these two collaborators.
- */
-
-import { readFileSync } from "node:fs";
-import { describe, expect, test } from "vitest";
-import type { RecordedApiCall, RecordedCommandRegistration } from "../../test/fakes/index.ts";
-import { recordingExtensionApi } from "../../test/fakes/index.ts";
-import { createRegistry } from "../core/registry.ts";
-import type { CommandContext, Logger, ModuleDescriptor, SettingsDoc } from "../core/types.ts";
-import { installCommands } from "./canvas.ts";
-
-const ARTIFACTS: ModuleDescriptor = { key: "content.artifacts", name: "Artifacts", defaultEnabled: true, settings: [] };
-const ENABLED: SettingsDoc = { version: 1, modules: { "content.artifacts": { enabled: true } } };
-const DISABLED: SettingsDoc = { version: 1, modules: { "content.artifacts": { enabled: false } } };
-const NON_TUI = ["rpc", "json", "print"] as const;
-
-/** The registry's own diagnostics are T-09's concern, not this seam's. */
-const SILENT: Logger = { logLine: () => {}, logOnce: () => {}, drain: () => [] };
-
-/** Every `from "<specifier>"` in a source file. */
-const IMPORT_SPECIFIER = /from\s+"([^"]+)"/g;
-
-interface Harness {
-	/** Every registration the install made, in order. */
-	readonly calls: readonly RecordedApiCall[];
-	/** The command registrations, in order. */
-	readonly commands: readonly RecordedCommandRegistration[];
-	/** Every ctx the injected view opened with. */
-	readonly opened: CommandContext[];
-	/** Every document the registry saved — a /canvas run must leave this empty (SA §7). */
-	readonly saved: SettingsDoc[];
-}
-
-function harness(doc: SettingsDoc): Harness {
-	const pi = recordingExtensionApi();
-	const opened: CommandContext[] = [];
-	const saved: SettingsDoc[] = [];
-	const registry = createRegistry({ load: () => structuredClone(doc), save: (next) => void saved.push(next) }, SILENT);
-	registry.defineModule(ARTIFACTS);
-	installCommands(pi, {
-		registry,
-		canvasView: async (ctx) => {
-			// One macrotask, like the real panel open: an implementation that drops the await leaves
-			// `opened` empty when the test asserts (ASY-1), so the assertion pins the await too.
-			await new Promise((resolve) => setImmediate(resolve));
-			opened.push(ctx);
-		},
-	});
-	return { calls: pi.calls, commands: pi.commands, opened, saved };
-}
-
-interface Run {
-	/** The context the host handed the handler. */
-	readonly ctx: CommandContext;
-	/** Every notify message the handler produced, in order. */
-	readonly notices: readonly string[];
-}
-
-/** Enters where the host enters: the registered handler, with a host-shaped context, awaited. */
-async function runCanvas(h: Harness, mode: CommandContext["mode"]): Promise<Run> {
-	const handler = h.commands[0]?.options.handler;
-	if (handler === undefined) throw new Error("no canvas command registered");
-	const notices: string[] = [];
-	const ctx: CommandContext = {
-		mode,
-		ui: {
-			notify: (message) => {
-				notices.push(message);
-			},
-		},
-	};
-	await handler("", ctx);
-	return { ctx, notices };
-}
-
-describe("canvas command", () => {
-	// spec: installCommands(pi, deps) -> exactly one registerCommand call, named "canvas", handler callable.
-	// fails_when: zero, duplicate, or extra commands (a second site, a renamed or missing command).
-	test("AC-1 installCommands registers exactly one command named canvas", () => {
-		const h = harness(ENABLED);
-
-		expect(h.commands.map((command) => command.name)).toEqual(["canvas"]);
-		expect(typeof h.commands[0]?.options.handler).toBe("function");
-		// The command lane touches its own seam only — no setToolsExpanded, no resolver, no transformer.
-		expect(h.calls.map((call) => call.method)).toEqual(["registerCommand"]);
-	});
-
-	// spec: /canvas in a non-TUI host (rpc/json/print) -> one notify carrying the status summary; the
-	//   view never opens and nothing throws.
-	// fails_when: a non-TUI host crashes, goes silent, or opens a view it cannot draw.
-	test("AC-2 a non-TUI host gets a notify summary and never the view", async () => {
-		for (const mode of NON_TUI) {
-			const h = harness(ENABLED);
-
-			const run = await runCanvas(h, mode);
-
-			expect(run.notices).toEqual([
-				`canvas: content.artifacts is enabled — the artifact browser needs a TUI host (mode: ${mode})`,
-			]);
-			expect(h.opened).toEqual([]);
-		}
-	});
-
-	// spec: the module's imports -> exactly ["../core/types.ts"]; status comes from the registry, not a lane.
-	// fails_when: the command reaches into a renderer lane for state instead of the registry (SA §1 rule 3).
-	test("AC-3 the command reaches the package only through core", () => {
-		const source = readFileSync(new URL("./canvas.ts", import.meta.url), "utf8");
-
-		const specifiers = [...source.matchAll(IMPORT_SPECIFIER)].map((match) => match[1] ?? "");
-
-		expect(specifiers).toEqual(["../core/types.ts"]);
-	});
-
-	// spec: content.artifacts disabled in the registry + a TUI host -> one notify reporting the disabled
-	//   state, the view never opens, the registry is never written.
-	// fails_when: a disabled module's command acts anyway, or the report stays silent.
-	test("AC-4 a disabled content.artifacts reports instead of opening the view", async () => {
-		const h = harness(DISABLED);
-
-		const run = await runCanvas(h, "tui");
-
-		expect(run.notices).toEqual(["canvas: content.artifacts is disabled — enable it to open the artifact browser"]);
-		expect(h.opened).toEqual([]);
-		expect(h.saved).toEqual([]);
-	});
-
-	// spec: content.artifacts enabled + a TUI host -> the injected view opens once, with the host's own
-	//   ctx, no notify, and no registry write (SA §7: /canvas reads state, never writes it).
-	// fails_when: the view never opens, opens twice, gets a rebuilt ctx, or the command writes settings —
-	//   the positive control that keeps AC-4 from passing on a command that never acts at all.
-	test("AC-4 positive control: an enabled TUI host opens the injected view", async () => {
-		const h = harness(ENABLED);
-
-		const run = await runCanvas(h, "tui");
-
-		expect(h.opened).toHaveLength(1);
-		expect(h.opened[0]).toBe(run.ctx);
-		expect(run.notices).toEqual([]);
-		expect(h.saved).toEqual([]);
-	});
-});

package/src/commands/canvas.ts

@@ -1,57 +0,0 @@
-// ported from pi-pretty-tui/src/features/canvas/index.ts:90-100 — survives because: the predecessor's
-// /canvas registerCommand shape — a thin handler that opens the artifact through an injected seam and
-// notifies instead of throwing when it cannot — is exactly the command contract pi-render needs. Its
-// shortcuts, cmux routing, warmup and cache-dir plumbing stay behind (registration-adjacent chrome).
-
-/**
- * canvas.ts — the package's one command: /canvas opens the artifact browser, or reports its status.
- *
- * Boundary: `ctx` arrives from the host and is read as core/types/host.ts declares it — nothing here
- * narrows or re-declares a host shape. The injected `deps.registry` is the command's ONLY channel to
- * the rest of the package (SA §7), and it is read-only: /canvas reports module state and never writes
- * it, so a disabled module's command cannot act anyway.
- *
- * Why `canvasView` is injected: `index.ts` (T-28) is the only file that composes lanes, so the real
- * browser arrives as a parameter; this module never imports a renderer and its tests drive a fake view.
- *
- * shape: none — trigger #1 dispatch object does not apply: one command, two guards (host mode, module
- * enabled) resolved in sequence, no per-kind handler table.
- */
-
-import type { CommandContext, ExtensionApi, Registry } from "../core/types.ts";
-
-/**
- * The content lane's artifacts module key (SA §6). A literal, not an import: `commands/` may not
- * reach into a renderer lane for its constant (SA §1 rule 3).
- */
-const ARTIFACTS_KEY = "content.artifacts";
-
-/** What /canvas needs from its callers: module state to report, and the view to open. */
-export interface CommandsDeps {
-	/** Registry the command reads, e.g. isEnabled("content.artifacts"). Required; never written here. */
-	readonly registry: Registry;
-	/** Opens the artifact browser. Required; index.ts injects the real view, tests a fake one. */
-	readonly canvasView: (ctx: CommandContext) => Promise<void>;
-}
-
-/** shape: none — one interpolated line; a status table would restate the same registry read. */
-function summarize(mode: CommandContext["mode"], enabled: boolean): string {
-	if (!enabled) return "canvas: content.artifacts is disabled — enable it to open the artifact browser";
-	return `canvas: content.artifacts is enabled — the artifact browser needs a TUI host (mode: ${mode})`;
-}
-
-/** shape: none — one guarded registration; the handler below is this module's only command. */
-export function installCommands(pi: ExtensionApi, deps: CommandsDeps): void {
-	pi.registerCommand("canvas", {
-		description: "canvas: open the artifact browser, or report its status",
-		handler: async (_args, ctx) => {
-			const enabled = deps.registry.isEnabled(ARTIFACTS_KEY);
-			// A non-TUI host cannot draw the view and a disabled module has nothing to open: both report.
-			if (ctx.mode !== "tui" || !enabled) {
-				ctx.ui.notify(summarize(ctx.mode, enabled));
-				return;
-			}
-			await deps.canvasView(ctx);
-		},
-	});
-}