@oh-my-pi/pi-tui 18.3.0 → 18.3.1

package/src/tools/read.ts

@@ -1,7 +1,9 @@
 import type { SummaryResult } from "@oh-my-pi/pi-natives";
 import { formatNumberedLine } from "./hashline-format";
 import { LINE_RANGE_CHUNK_SOURCE, parseLineRanges } from "./line-ranges";
+import * as os from "node:os";
 import * as path from "node:path";
+import { parseArchivePathCandidates } from "@oh-my-pi/pi-utils/ar";
 import type { Component } from "../tui";
 import { Text } from "../components/text";
 import type { RenderResultOptions, ToolActivityContext, ToolActivitySummary, ToolRenderer } from "./renderer";
@@ -17,6 +19,9 @@ import { formatBytes, sanitizeDisplayLines, shortenPath, wrapBrackets } from "..
 import type { OutputMeta } from "./output-meta";
 import type { TruncationResult } from "./streaming-output";
 import { renderProcRead, type ProcReadDetails } from "./proc-render";
+import { renderCfgRead, type CfgReadDetails } from "./cfg-render";
+import type { CardToolResult } from "./result-card";
+import { type InternalUrlSchemeSpec, internalUrlSchemeSpec, splitUrlScheme } from "./url-scheme-host";
 
 /** Read result metadata retains truncation statistics, not a second copy of the body. */
 export type ReadTruncationStats = Omit<TruncationResult, "content">;
@@ -25,6 +30,7 @@ export type ReadTruncationStats = Omit<TruncationResult, "content">;
 export interface ReadToolDetails {
 	kind?: "file" | "url";
 	proc?: ProcReadDetails;
+	cfg?: CfgReadDetails;
 	/** Filesystem hyperlink target resolved by the executing tool. */
 	displayTarget?: string;
 	truncation?: ReadTruncationStats;
@@ -77,37 +83,6 @@ const INTERNAL_URL_SELECTOR_PART_RE = new RegExp(
 	String.raw`^(?:raw|conflicts|img|${RANGE_LIST_SRC}|-\d+(?:[-+]\d+)?)$`,
 	"i",
 );
-// Schemes whose host grammar is identifier-shaped, so any trailing
-// `:<selector-chunk>` is unambiguously a read-tool selector. `mcp://` is
-// excluded because mcp resource URIs may legitimately contain colons. `ssh://`
-// is included despite an optional `:port`; `splitInternalUrlSel` skips the peel
-// for an `ssh://host:port` that has no `/path`, so the port colon is never
-// mistaken for a selector (a real ssh selector trails the `/path`, e.g.
-// `ssh://h/f:1-5`).
-const INTERNAL_SCHEMES_WITH_SELECTORS: Record<string, true> = {
-	agent: true,
-	artifact: true,
-	issue: true,
-	history: true,
-	local: true,
-	memory: true,
-	omp: true,
-	pr: true,
-	proc: true,
-	rule: true,
-	security: true,
-	skill: true,
-	ssh: true,
-	vault: true,
-};
-// Schemes whose resource URIs are server-defined and may legitimately end
-// with selector-shaped tails (e.g. `:raw`, `:conflicts`, `:1-50`, `/:raw`).
-// `McpProtocolHandler` resolves by exact URI match (`r.uri === uri`), so
-// peeling syntactically can make valid resources unreachable. Keep these
-// schemes opaque; selector support for them needs a resolver-aware path that
-// tries the exact URI before interpreting any suffix as a read selector.
-const OPAQUE_RESOURCE_SCHEMES: ReadonlySet<string> = new Set(["mcp"]);
-const INTERNAL_URL_SCHEME_RE = /^([a-z][a-z0-9+.-]*):\/\//i;
 /** Split a filesystem path from its trailing read selector. */
 export function splitPathAndSel(rawPath: string): { path: string; sel?: string } {
 	const colon = rawPath.lastIndexOf(":");
@@ -151,30 +126,28 @@ export function splitPathAndSel(rawPath: string): { path: string; sel?: string }
  * This function iteratively peels selector-shaped chunks (well-formed plus
  * common malformed shapes like `:-N-M`) so the rest of the read tool can pass a
  * clean URL to the protocol handler and surface selector errors via parseSel
- * instead of as misleading "host invalid" errors from the handler. Schemes
- * whose resource URIs may legitimately contain colons (`mcp://`) are skipped.
+ * instead of as misleading "host invalid" errors from the handler.
+ *
+ * Only schemes whose spec declares `lines` selectors peel; server-defined URIs
+ * (`opaque`), selector-free schemes, and unregistered schemes pass through
+ * verbatim. `specOf` defaults to the installed scheme host, so nothing peels
+ * before a host is installed.
  *
  * Falls back to the input unchanged when nothing matches.
  */
-
-export function splitInternalUrlSel(rawPath: string): { path: string; sel?: string } {
-	const schemeMatch = rawPath.match(INTERNAL_URL_SCHEME_RE);
-	if (!schemeMatch) return { path: rawPath };
-	const scheme = schemeMatch[1].toLowerCase();
-	// Opaque schemes (mcp://, etc.) carry server-defined resource URIs that may
-	// legitimately end in selector-shaped tails. Forward verbatim — see
-	// OPAQUE_RESOURCE_SCHEMES.
-	if (OPAQUE_RESOURCE_SCHEMES.has(scheme)) return { path: rawPath };
-	if (!INTERNAL_SCHEMES_WITH_SELECTORS[scheme]) return { path: rawPath };
-
-	const schemeEnd = schemeMatch[0].length;
-	// ssh:// authority carries an optional `:port`; with no `/path` after the
-	// authority, a trailing `:NNNN` is the port, not a read selector
-	// (e.g. ssh://host:2222). Other schemes' authority-trailing selectors
-	// (artifact://5:1-50) still peel, so this guard is ssh-specific.
-	if (scheme === "ssh" && rawPath.indexOf("/", schemeEnd) === -1) {
-		return { path: rawPath };
-	}
+export function splitInternalUrlSel(
+	rawPath: string,
+	specOf: (scheme: string) => InternalUrlSchemeSpec | undefined = internalUrlSchemeSpec,
+): { path: string; sel?: string } {
+	const url = splitUrlScheme(rawPath);
+	if (!url) return { path: rawPath };
+	const spec = specOf(url.scheme);
+	if (spec?.selectors !== "lines") return { path: rawPath };
+	// With no `/path` after the authority, a trailing `:N` is the port
+	// (ssh://host:2222), not a read selector.
+	if (spec.portAuthority && !url.rest.includes("/")) return { path: rawPath };
+
+	const schemeEnd = rawPath.length - url.rest.length;
 	let path = rawPath;
 	const chunks: string[] = [];
 	while (true) {
@@ -218,10 +191,77 @@ export interface ReadRenderArgs {
 	raw?: boolean;
 }
 
-const INTERNAL_URL_LIKE_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+/** Transcript card for reads of a scheme with its own UI (process table, settings tree). */
+interface ReadUrlCard {
+	/** Activity label, e.g. `Process · web`. */
+	readonly label: string;
+	/** Activity detail when the URL names no target. */
+	readonly rootDetail: string;
+	/** Result details field whose presence identifies this card. */
+	readonly detailsKey: "proc" | "cfg";
+	/** Pending call card when `result` is undefined, else the finished result card. */
+	render(
+		url: string,
+		target: string,
+		result: CardToolResult | undefined,
+		details: ReadToolDetails | undefined,
+		options: RenderResultOptions,
+		uiTheme: Theme,
+	): Component;
+}
+
+/** Read cards keyed by URL scheme. */
+const READ_URL_CARDS: Record<string, ReadUrlCard> = {
+	proc: {
+		label: "Process",
+		rootDetail: "jobs & services",
+		detailsKey: "proc",
+		render: (_url, target, result, details, options, uiTheme) =>
+			renderProcRead(target, result, details?.proc, options, uiTheme),
+	},
+	cfg: {
+		label: "Config",
+		rootDetail: "all settings",
+		detailsKey: "cfg",
+		render: (url, _target, result, details, options, uiTheme) =>
+			renderCfgRead(splitInternalUrlSel(url).path, result, details?.cfg, options, uiTheme),
+	},
+};
+
+/**
+ * Card that renders a read of `rawPath` with the text after `scheme://` as its target.
+ * Result details identify the card before the URL scheme does.
+ */
+function readUrlCard(rawPath: string, details?: ReadToolDetails): { card: ReadUrlCard; target: string } | undefined {
+	const url = splitUrlScheme(rawPath);
+	const target = url?.rest ?? "";
+	if (details) {
+		for (const scheme in READ_URL_CARDS) {
+			const card = READ_URL_CARDS[scheme];
+			if (details[card.detailsKey] !== undefined) return { card, target };
+		}
+	}
+	if (!url || !Object.hasOwn(READ_URL_CARDS, url.scheme)) return undefined;
+	return { card: READ_URL_CARDS[url.scheme], target };
+}
+
+// A scheme-less host followed by a slash can be a web target. Do not force a
+// file: link onto it; explicit relative paths (./host/path) remain filesystem paths.
+const BARE_WEB_HOST_RE = /^(?:(?:[a-z][a-z0-9-]*|\[[0-9a-f:]+\])(?::\d+)|(?:[a-z0-9-]+\.)+[a-z0-9-]+(?::\d+)?)\//i;
+
+/** Local file a pending read/write input points at, before the tool resolves it:
+ * expands `~` and drops archive-member / SQLite-row selectors so the link opens
+ * the containing file. */
+export function pendingFileLinkPath(inputPath: string): string {
+	const expanded = inputPath.replace(/^~(?=$|[\\/])/, os.homedir());
+	if (!expanded.includes(":")) return path.resolve(expanded);
+	const archive = parseArchivePathCandidates(expanded).find(candidate => candidate.archivePath !== expanded);
+	const sqlite = expanded.match(/^(.+\.(?:sqlite3?|db3?))(?=[:?])/i);
+	return path.resolve(archive?.archivePath ?? sqlite?.[1] ?? expanded);
+}
 
 function splitReadRenderPath(rawPath: string): { path: string; sel?: string } {
-	if (INTERNAL_URL_LIKE_RE.test(rawPath)) {
+	if (splitUrlScheme(rawPath)) {
 		const internal = splitInternalUrlSel(rawPath);
 		if (internal.sel) return internal;
 	}
@@ -259,8 +299,14 @@ function formatReadPathLink(
 	const plainDisplayPath = options.suffixResolution
 		? shortenPath(options.suffixResolution.to)
 		: shortenPath(basePath || options.resolvedPath || options.fallbackLabel || rawPath);
-	const absoluteInputPath = path.isAbsolute(basePath) ? basePath : undefined;
-	const target = options.resolvedPath ?? options.sourcePath ?? absoluteInputPath;
+	// Calls render before the tool has resolved a filesystem target. Preserve
+	// protocol resources as plain text, but resolve direct relative file paths
+	// so terminals receive an explicit file: link rather than guessing HTTPS.
+	const inputPath =
+		basePath && !splitUrlScheme(basePath) && !BARE_WEB_HOST_RE.test(basePath)
+			? pendingFileLinkPath(basePath)
+			: undefined;
+	const target = options.resolvedPath ?? options.sourcePath ?? inputPath;
 	const line = firstReadSelectorLine(split.sel) ?? options.offset;
 	const linkOptions = line !== undefined ? { line } : undefined;
 	const linkedPath = target ? fileHyperlink(target, plainDisplayPath, linkOptions) : plainDisplayPath;
@@ -273,15 +319,15 @@ export const readToolRenderer = {
 		const input = args as ReadRenderArgs | undefined;
 		const rawPath =
 			typeof input?.file_path === "string" ? input.file_path : typeof input?.path === "string" ? input.path : "";
-		if (/^proc:\/\//i.test(rawPath))
-			return { label: "Process", detail: rawPath.slice("proc://".length) || "jobs & services" };
+		const routed = readUrlCard(rawPath);
+		if (routed) return { label: routed.card.label, detail: routed.target || routed.card.rootDetail };
 		return { label: "Read", detail: shortenPath(rawPath) };
 	},
 	renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const rawPath =
 			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
-		if (/^proc:\/\//i.test(rawPath))
-			return renderProcRead(rawPath.slice("proc://".length), undefined, undefined, _options, uiTheme);
+		const routed = readUrlCard(rawPath);
+		if (routed) return routed.card.render(rawPath, routed.target, undefined, undefined, _options, uiTheme);
 		if (isReadableUrlPath(rawPath)) {
 			return renderReadUrlCall({ path: rawPath, raw: args.raw }, _options, uiTheme);
 		}
@@ -309,14 +355,9 @@ export const readToolRenderer = {
 		const urlDetails = result.details as ReadUrlToolDetails | undefined;
 		const baseRawPathForKind =
 			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
-		if (/^proc:\/\//i.test(baseRawPathForKind))
-			return renderProcRead(
-				baseRawPathForKind.slice("proc://".length),
-				result,
-				result.details?.proc,
-				options,
-				uiTheme,
-			);
+		const routed = readUrlCard(baseRawPathForKind, result.details);
+		if (routed)
+			return routed.card.render(baseRawPathForKind, routed.target, result, result.details, options, uiTheme);
 		if (urlDetails?.kind === "url" || isReadableUrlPath(baseRawPathForKind)) {
 			return renderReadUrlResult(
 				result as {

package/src/tools/result-card.ts

@@ -0,0 +1,36 @@
+/**
+ * Line-based status cards shared by the internal-URL renderers (`proc://`,
+ * `agent://`, `cfg://`): a header plus sanitized, width-truncated body lines.
+ */
+import type { Component } from "../tui";
+import { createCachedComponent, Ellipsis, truncateToWidth } from "../render";
+import { replaceTabs } from "../render/render-utils";
+import type { RenderResultOptions } from "./renderer";
+
+/** Tool result fields the card renderers read. */
+export interface CardToolResult {
+	content: Array<{ type: string; text?: string }>;
+	isError?: boolean;
+}
+
+/** First text block of a tool result, or `""`. */
+export function firstText(result: CardToolResult): string {
+	return result.content.find(item => item.type === "text")?.text ?? "";
+}
+
+/** Sanitize one display line: tabs become spaces, carriage returns are dropped. */
+export function safe(value: string): string {
+	return replaceTabs(value).replace(/\r/g, "");
+}
+
+/** Padded card whose lines are sanitized and truncated, re-rendered when the expanded state flips. */
+export function card(lines: (width: number, expanded: boolean) => string[], options: RenderResultOptions): Component {
+	return createCachedComponent(
+		() => Boolean(options.expanded),
+		(width, expanded) =>
+			lines(width, expanded)
+				.flatMap(line => line.split("\n"))
+				.map(line => truncateToWidth(safe(line), width, Ellipsis.Unicode)),
+		{ paddingX: 1 },
+	);
+}

package/src/tools/url-scheme-host.ts

@@ -0,0 +1,42 @@
+/**
+ * Scheme facts supplied by the internal URL host. pi-tui cannot import the
+ * coding-agent router, so the router installs this bridge when it loads;
+ * selector peeling and transcript renderers consult it instead of hardcoding
+ * scheme names.
+ */
+
+/** Renderer-relevant subset of a registered scheme's declared spec. */
+export interface InternalUrlSchemeSpec {
+	/** `lines`: a trailing `:<selector>` chain is a read selector; `none`/`opaque`: never peel. */
+	readonly selectors: "lines" | "none" | "opaque";
+	/** A trailing `:N` with no path after the authority is a port, not a selector (ssh://host:2222). */
+	readonly portAuthority?: boolean;
+	/** Read cards collapse into the compact read group like plain files instead of expanding. */
+	readonly compactTranscript?: boolean;
+}
+
+/** Scheme registry capabilities installed by the internal URL host. */
+export interface InternalUrlSchemeHost {
+	/** Declared spec of a registered scheme (case-insensitive); undefined when unregistered. */
+	spec(scheme: string): InternalUrlSchemeSpec | undefined;
+}
+
+let schemeHost: InternalUrlSchemeHost | undefined;
+
+/** Install the scheme registry. Until one is installed, no URL counts as an internal scheme. */
+export function setInternalUrlSchemeHost(host: InternalUrlSchemeHost): void {
+	schemeHost = host;
+}
+
+/** Declared spec of `scheme`; undefined when it is unregistered or no host is installed. */
+export function internalUrlSchemeSpec(scheme: string): InternalUrlSchemeSpec | undefined {
+	return schemeHost?.spec(scheme);
+}
+
+const URL_SCHEME_RE = /^([a-z][a-z0-9+.-]*):\/\//i;
+
+/** Split a hierarchical `scheme://rest` URL into its lowercased scheme and the text after `://`. */
+export function splitUrlScheme(input: string): { scheme: string; rest: string } | undefined {
+	const match = URL_SCHEME_RE.exec(input);
+	return match ? { scheme: match[1].toLowerCase(), rest: input.slice(match[0].length) } : undefined;
+}

package/src/tools/write.ts

@@ -23,9 +23,12 @@ import {
 } from "../render/render-utils";
 import type { CoordinationDetails } from "./wait";
 import { renderAgentWrite, renderProcWrite, type ProcWriteAction, type ProcWriteDetails } from "./proc-render";
+import { renderCfgWrite, type CfgWriteDetails } from "./cfg-render";
 import type { FileDiagnosticsResult } from "./lsp";
 import type { OutputMeta } from "./output-meta";
+import type { CardToolResult } from "./result-card";
 import type { RenderResultOptions, ToolActivityContext, ToolActivitySummary, ToolRenderer } from "./renderer";
+import { splitUrlScheme } from "./url-scheme-host";
 import { couldBecomeXdUrl, parseXdUrl } from "./xd-url";
 import {
 	renderXdevCall,
@@ -36,6 +39,7 @@ import {
 } from "./xdev";
 import { isResolutionDeviceName, renderResolutionDeviceCall } from "./resolve";
 import { REPORT_ISSUE_DEVICE_NAME, renderReportIssueDeviceCall } from "./report-tool-issue";
+import { pendingFileLinkPath } from "./read";
 
 /** Details returned by the write tool for transcript rendering. */
 export interface WriteToolDetails {
@@ -50,6 +54,7 @@ export interface WriteToolDetails {
 	xdev?: XdevRenderDispatch;
 	message?: CoordinationDetails;
 	proc?: ProcWriteDetails;
+	cfg?: CfgWriteDetails;
 }
 
 interface WriteRenderArgs {
@@ -318,13 +323,99 @@ export interface WriteRenderContext {
 	resolveXdevMounted?: (name: string) => XdevMountedRenderer | undefined;
 }
 
-function procWriteTarget(path: string): { id: string; action: ProcWriteAction } {
-	const target = path.slice("proc://".length);
+/** Process id and operation named by the text after `proc://`. */
+function procWriteTarget(target: string): { id: string; action: ProcWriteAction } {
 	if (target.endsWith("/kill")) return { id: target.slice(0, -5), action: "kill" };
 	if (target.endsWith("/mode")) return { id: target.slice(0, -5), action: "mode" };
 	return { id: target, action: "stdin" };
 }
 
+/** Transcript card for writes to a scheme with its own UI (peer message, process control, setting change). */
+interface WriteUrlCard {
+	/** Result details field whose presence identifies this card. */
+	readonly detailsKey: "message" | "proc" | "cfg";
+	/** Compact activity line for the text after `scheme://`. */
+	activity(target: string): ToolActivitySummary;
+	/** Pending call card when `result` is undefined, else the finished result card. */
+	render(
+		url: string,
+		target: string,
+		content: unknown,
+		result: CardToolResult | undefined,
+		details: WriteToolDetails | undefined,
+		options: RenderResultOptions,
+		uiTheme: Theme,
+	): Component;
+}
+
+/** Write cards keyed by URL scheme. */
+const WRITE_URL_CARDS: Record<string, WriteUrlCard> = {
+	agent: {
+		detailsKey: "message",
+		activity: target => ({ label: "Message", detail: target === "all" ? "broadcast" : target }),
+		render: (_url, target, content, result, details, options, uiTheme) =>
+			renderAgentWrite(
+				target,
+				typeof content === "string" ? content : "",
+				result,
+				details?.message,
+				options,
+				uiTheme,
+			),
+	},
+	proc: {
+		detailsKey: "proc",
+		activity: target => {
+			const { id, action } = procWriteTarget(target);
+			return { label: "Process", detail: `${action} ${shortenPath(id)}` };
+		},
+		render: (_url, target, content, result, details, options, uiTheme) => {
+			const { id, action } = procWriteTarget(target);
+			return renderProcWrite(
+				id,
+				action,
+				typeof content === "string" ? content : undefined,
+				result,
+				details?.proc,
+				options,
+				uiTheme,
+			);
+		},
+	},
+	cfg: {
+		detailsKey: "cfg",
+		activity: target => ({ label: "Config", detail: target }),
+		render: (url, _target, content, result, details, options, uiTheme) =>
+			renderCfgWrite(url, typeof content === "string" ? content : undefined, result, details?.cfg, options, uiTheme),
+	},
+};
+
+/**
+ * Card that renders a write to `rawPath` with the text after `scheme://` as its target.
+ * Result details identify the card before the URL scheme does.
+ */
+function writeUrlCard(rawPath: string, details?: WriteToolDetails): { card: WriteUrlCard; target: string } | undefined {
+	const url = splitUrlScheme(rawPath);
+	const target = url?.rest ?? "";
+	if (details) {
+		for (const scheme in WRITE_URL_CARDS) {
+			const card = WRITE_URL_CARDS[scheme];
+			if (details[card.detailsKey] !== undefined) return { card, target };
+		}
+	}
+	if (!url || !Object.hasOwn(WRITE_URL_CARDS, url.scheme)) return undefined;
+	return { card: WRITE_URL_CARDS[url.scheme], target };
+}
+
+/** Whether a streaming lowercased path is, or could still become, a URL with its own write card. */
+function couldBecomeWriteCardUrl(lowerPath: string): boolean {
+	for (const scheme in WRITE_URL_CARDS) {
+		const prefix = `${scheme}://`;
+		if (prefix.startsWith(lowerPath) || lowerPath.startsWith(prefix)) return true;
+	}
+	return false;
+}
+
 /** Render file writes and delegated tool-device calls. */
 export const writeToolRenderer = {
 	/** Compact one-line activity: device writes read as the mounted tool (`LSP · references foo`), file writes as `Write · <path>`. */
@@ -337,16 +428,8 @@ export const writeToolRenderer = {
 					? writeArgs.path
 					: "";
 		if (!rawPath) return { label: "Write" };
-		if (/^agent:\/\//i.test(rawPath)) {
-			return {
-				label: "Message",
-				detail: rawPath.slice("agent://".length) === "all" ? "broadcast" : rawPath.slice("agent://".length),
-			};
-		}
-		if (/^proc:\/\//i.test(rawPath)) {
-			const { id, action } = procWriteTarget(rawPath);
-			return { label: "Process", detail: `${action} ${shortenPath(id)}` };
-		}
+		const routed = writeUrlCard(rawPath);
+		if (routed) return routed.card.activity(routed.target);
 		const xdev = parseXdUrl(rawPath);
 		if (xdev?.name) {
 			const resolveMounted = (context.renderContext as WriteRenderContext | undefined)?.resolveXdevMounted;
@@ -370,36 +453,10 @@ export const writeToolRenderer = {
 		if (args.path === undefined && args.file_path === undefined) return undefined;
 		const pathSettled = args.content !== undefined || options.argsComplete === true;
 		const hasStringPath = typeof args.file_path === "string" || typeof args.path === "string";
-		if (
-			hasStringPath &&
-			!pathSettled &&
-			("agent://".startsWith(rawPath.toLowerCase()) ||
-				"proc://".startsWith(rawPath.toLowerCase()) ||
-				/^(?:agent|proc):\/\//i.test(rawPath))
-		)
-			return undefined;
-		if (/^agent:\/\//i.test(rawPath)) {
-			return renderAgentWrite(
-				rawPath.slice("agent://".length),
-				typeof args.content === "string" ? args.content : "",
-				undefined,
-				undefined,
-				options,
-				uiTheme,
-			);
-		}
-		if (/^proc:\/\//i.test(rawPath)) {
-			const { id, action } = procWriteTarget(rawPath);
-			return renderProcWrite(
-				id,
-				action,
-				typeof args.content === "string" ? args.content : undefined,
-				undefined,
-				undefined,
-				options,
-				uiTheme,
-			);
-		}
+		if (hasStringPath && !pathSettled && couldBecomeWriteCardUrl(rawPath.toLowerCase())) return undefined;
+		const routed = writeUrlCard(rawPath);
+		if (routed)
+			return routed.card.render(rawPath, routed.target, args.content, undefined, undefined, options, uiTheme);
 		if (rawPath && couldBecomeXdUrl(rawPath)) {
 			const xdev = parseXdUrl(rawPath);
 			// The path string is settled once the content field started streaming.
@@ -412,7 +469,11 @@ export const writeToolRenderer = {
 		const filePath = shortenPath(rawPath);
 		const lang = rawPath ? (getLanguageFromPath(rawPath) ?? "text") : "text";
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
-		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+		const styledPath = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
+		// The result has not resolved its target yet. Link the containing file
+		// rather than an archive member or database row selector.
+		const pathDisplay =
+			filePath && args.content !== undefined ? fileHyperlink(pendingFileLinkPath(rawPath), styledPath) : styledPath;
 		// No status icon on the head row: it's the head of the framed block, and
 		// native-scrollback commits are prefix-only — an animated glyph would pin
 		// the commit boundary at the top, and the pending hourglass just adds
@@ -465,29 +526,11 @@ export const writeToolRenderer = {
 		uiTheme: Theme,
 		args?: WriteRenderArgs,
 	): Component {
-		const messagePath = typeof args?.path === "string" ? args.path : args?.file_path;
-		if (typeof messagePath === "string" && /^agent:\/\//i.test(messagePath)) {
-			return renderAgentWrite(
-				messagePath.slice("agent://".length),
-				typeof args?.content === "string" ? args.content : "",
-				result,
-				result.details?.message,
-				options,
-				uiTheme,
-			);
-		}
-		if (typeof messagePath === "string" && /^proc:\/\//i.test(messagePath)) {
-			const { id, action } = procWriteTarget(messagePath);
-			return renderProcWrite(
-				id,
-				action,
-				typeof args?.content === "string" ? args.content : undefined,
-				result,
-				result.details?.proc,
-				options,
-				uiTheme,
-			);
-		}
+		const cardPath =
+			typeof args?.path === "string" ? args.path : typeof args?.file_path === "string" ? args.file_path : "";
+		const routed = writeUrlCard(cardPath, result.details);
+		if (routed)
+			return routed.card.render(cardPath, routed.target, args?.content, result, result.details, options, uiTheme);
 		// xd:// dispatch results render as the mounted tool's own result.
 		const xdev = result.details?.xdev;
 		if (xdev) {

package/src/tools/xdev.ts

@@ -15,10 +15,18 @@ export interface XdevMountedRenderer {
 	mergeCallAndResult?: boolean;
 }
 
-/** Mounted tool presentation state supplied by the host's canonical tool map. */
+/** Tool presentation state supplied by the host's canonical tool map. */
 export interface XdevMountedState {
 	readonly mountedNames: ReadonlySet<string>;
 	readonly tools: ReadonlyMap<string, XdevMountedRenderer>;
+	/**
+	 * Canonical renderer for a device name, supplied by the host with the same
+	 * predicate as dispatch (`resolveXdevTool`: mounted devices plus active
+	 * top-level tools, which the `write` transport also accepts). The TUI keeps
+	 * no predicate copy of its own — a second copy is what dropped a top-level
+	 * dispatch to the generic card.
+	 */
+	readonly resolve?: (name: string) => XdevMountedRenderer | undefined;
 }
 
 function isComponent(value: unknown): value is Component {

package/dist/types/chat/read-target.d.ts

@@ -1,4 +0,0 @@
-/** Host-owned internal protocol classifier used by compact read cards. */
-export declare let internalReadTargetPredicate: ((target: string) => boolean) | undefined;
-/** Supply protocol classification without loading the host router in a renderer. */
-export declare function setInternalReadTargetPredicate(predicate: (target: string) => boolean): void;

package/src/chat/read-target.ts

@@ -1,7 +0,0 @@
-/** Host-owned internal protocol classifier used by compact read cards. */
-export let internalReadTargetPredicate: ((target: string) => boolean) | undefined;
-
-/** Supply protocol classification without loading the host router in a renderer. */
-export function setInternalReadTargetPredicate(predicate: (target: string) => boolean): void {
-	internalReadTargetPredicate = predicate;
-}