@xmoon76/dsh-pi-tui 0.5.0 → 0.5.2-rc.1

package/dist/context-summary-CxQnkDEN.mjs

@@ -0,0 +1,2478 @@
+import { ut as stripTerminalSequences } from "./extensions-VuoIE_Jc.mjs";
+import { normalize } from "node:path";
+//#region src/domain/transcript/content-blocks.ts
+/** Match the Web JsonBlock serialized-payload bound. */
+const FINALIZED_BLOCK_PAYLOAD_MAX_CHARS = 2e4;
+/** The flat marker for one known attachment occurrence. */
+function attachmentMarker(block) {
+	if (block.type === "image") return `🖼️ ${block.attachment.name ?? "image"}`;
+	if (block.type === "file") return `📄 ${block.attachment.name}`;
+}
+/**
+* Build the lightweight ordered text projection used by user transcript
+* search and loader-less rendering. Known attachments retain their positions;
+* other non-text blocks remain in their structured content only.
+*/
+function textWithAttachmentMarkers(blocks) {
+	let text = "";
+	let boundary = false;
+	for (const block of blocks) {
+		if (block.type === "text") {
+			if (boundary && text !== "" && !/\s$/.test(text) && !/^\s/.test(block.text)) text += " ";
+			boundary = false;
+			text += block.text;
+			continue;
+		}
+		const marker = attachmentMarker(block);
+		if (marker === void 0) continue;
+		if (text !== "" && !/\s$/.test(text)) text += " ";
+		text += marker;
+		boundary = true;
+	}
+	return text;
+}
+/** Sanitize and bound a provider-supplied block type for a heading. */
+function safeBlockTypeLabel(type) {
+	if (typeof type !== "string") return "unknown";
+	const safeType = type.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
+	if (safeType === "") return "unknown";
+	return safeType.length <= 120 ? safeType : `${safeType.slice(0, 119)}…`;
+}
+/** Read and bound the type tag for the explicit unknown-block heading. */
+function blockType(block) {
+	if (typeof block !== "object" || block === null) return "unknown";
+	return safeBlockTypeLabel(block.type);
+}
+/** Serialize one finalized block and keep its payload bounded. */
+function boundedSerializedBlock(block) {
+	const serialized = JSON.stringify(block, null, 2) ?? String(block);
+	if (serialized.length <= 2e4) return serialized;
+	return `${serialized.slice(0, FINALIZED_BLOCK_PAYLOAD_MAX_CHARS)}\n… block payload truncated (${serialized.length} characters)`;
+}
+/**
+* Explicit bounded fallback for a finalized block that has no first-class
+* renderer. Callers should route known text/image/file/reasoning/tool-call
+* blocks through their existing semantics before using this fallback.
+*/
+function finalizedBlockFallbackText(block) {
+	return `Unknown block: ${blockType(block)}\n${boundedSerializedBlock(block)}`;
+}
+/** Render an open opaque block without inventing an unfinished payload. */
+function openOpaqueBlockFallbackText(blockType) {
+	return `Unknown block: ${safeBlockTypeLabel(blockType)}\nnull`;
+}
+/** Whether a user message contains content the transcript should retain. */
+function userBlocksVisibleNow(blocks) {
+	return blocks.some((block) => block.type !== "text" || block.text.trim() !== "");
+}
+//#endregion
+//#region src/domain/transcript/semantics.ts
+/** Classify one current TranscriptMessage without consulting display text. */
+function classifyTranscriptMessage(message) {
+	switch (message.kind) {
+		case "user":
+		case "assistant": return { class: "conversation" };
+		case "thinking": return {
+			class: "process",
+			origin: "thinking"
+		};
+		case "tool":
+			if (message.origin === "turn-error" || message.origin === "turn-interrupted" || message.origin === "tool-not-started") return {
+				class: "attention",
+				origin: message.origin
+			};
+			return message.origin === void 0 ? { class: "process" } : {
+				class: "process",
+				origin: message.origin
+			};
+		case "system":
+			if (isSurfacedContext(message)) return {
+				class: "context",
+				origin: "injected-context"
+			};
+			if (message.origin === "turn-max-tokens") return {
+				class: "attention",
+				origin: message.origin
+			};
+			if (message.origin === "llm-retry") return {
+				class: "process",
+				origin: message.origin
+			};
+			return { class: "context" };
+		case "workflow": return {
+			class: "context",
+			origin: "workflow"
+		};
+		case "compaction": return {
+			class: "context",
+			origin: "compaction"
+		};
+		case "command": return {
+			class: "control",
+			origin: "command"
+		};
+		case "summary": return {
+			class: "context",
+			origin: "window-summary"
+		};
+	}
+}
+/**
+* Whether a system row is an injected context boundary that Focus keeps
+* visible when its Thought is collapsed. The fold's authoritative `context`
+* marker intentionally covers unknown/future injection producers too.
+*/
+function isSurfacedContext(message) {
+	return message.kind === "system" && message.context === true;
+}
+/**
+* The tool names whose SETTLED card is surfaced human-interaction evidence —
+* durable human decisions, not ordinary work. PR4's authoritative set is
+* exactly these two: `ask_user_question` (the user's answers) and
+* `exit_plan_mode` (the user's Plan review / approval result). Every other
+* tool stays Process regardless of how rich its card looks or whether its
+* execution happened to require an approval.
+*/
+const SURFACED_INTERACTION_TOOL_NAMES = /* @__PURE__ */ new Set(["ask_user_question", "exit_plan_mode"]);
+/** Whether one tool NAME belongs to the surfaced-interaction set, regardless of
+* settled state. The fold uses this to keep such calls out of the turn's work
+* accounting even while they are running. */
+function isSurfacedInteractionToolName(name) {
+	return SURFACED_INTERACTION_TOOL_NAMES.has(name);
+}
+/**
+* Whether one tool row is SETTLED human-interaction evidence rather than
+* ordinary work-process evidence. The decision is source/tool identity only
+* (kind + a name in {@link SURFACED_INTERACTION_TOOL_NAMES} + settled status) —
+* never the display title or the result wording. A RUNNING question / plan
+* review is owned by its active interaction panel and must NOT become a
+* duplicate surfaced card. This orthogonal projection role deliberately does
+* NOT add a fifth semantic class, and unknown tools stay Process.
+*/
+function isSurfacedInteractionTool(message) {
+	return message.kind === "tool" && isSurfacedInteractionToolName(message.name) && message.status !== "running";
+}
+/**
+* Post-turn replay evidence: the rows that MATERIALIZED after their owning
+* turn's authoritative `turn/end` (weakly held sidecar — the fact dies with
+* its row). The fold is the ONLY authority that can know this: a row's
+* `turn`/`kind` alone cannot distinguish a durable row of a settled turn from
+* a replay artifact that arrived afterwards.
+*
+* The provenance is exactly "this row was NEWLY created after the turn
+* completed" — NEVER "this row was touched by a post-`turn/end` event". A
+* `tool/result` that finds its own pending/running card still settles that
+* card normally and leaves it fully legal Action evidence; only a newly
+* created row (an orphan result or a fresh synthetic call card) earns the
+* mark.
+*
+* Consumers share this ONE predicate so no surface invents its own fence:
+* - the transcript keeps the row (search / Full / expanded Focus);
+* - it is never Process aggregation evidence: it is excluded from the Action
+*   classifier, from Work-span membership, and from consecutive-read
+*   grouping (a group card is a synthesized object that could otherwise
+*   launder the provenance back into an aggregate).
+*/
+const postTurnReplayEvidence = /* @__PURE__ */ new WeakSet();
+/** Whether one row materialized after its owning turn's `turn/end` (see
+* {@link postTurnReplayEvidence}). Presentation/persistence consumers use
+* this to keep the row as transcript evidence while excluding it from the
+* settled turn's Process/Action aggregates. */
+function isPostTurnReplayEvidence(message) {
+	return postTurnReplayEvidence.has(message);
+}
+/** Mark one newly materialized row as post-turn replay evidence
+* (fold-internal authority — called ONLY where a row is created while its
+* owning turn is already `completed`). */
+function markPostTurnReplayEvidence(message) {
+	postTurnReplayEvidence.add(message);
+}
+//#endregion
+//#region src/domain/transcript/context-semantics.ts
+/** One durable source narrowed to the readable-record shape; null for anything else. */
+function asRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	return value;
+}
+/** A record field read as a non-empty string, or null. */
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+/** Distinct non-empty `field` values of an array-valued source member, in first-seen order.
+* The `seen` Set keeps a foreign/legacy log with a very large member array
+* linear; an `includes()` scan here is an accidental O(n^2). */
+function collect(source, member, field) {
+	const list = source[member];
+	if (!Array.isArray(list)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const names = [];
+	for (const entry of list) {
+		const record = asRecord(entry);
+		const value = record === null ? null : readString(record, field);
+		if (value !== null && !seen.has(value)) {
+			seen.add(value);
+			names.push(value);
+		}
+	}
+	return names;
+}
+/** A collected name list rendered as one label; null when the list is empty. */
+function joined(names) {
+	return names.length > 0 ? names.join(", ") : null;
+}
+/**
+* Project one durable message source onto its transcript role and producer
+* name, exactly like the Web's contextProvenance: agent-instructions name
+* their changed file paths, plugins their plugin id, skill invocations their
+* skill name, session references their recalled labels; unknown kinds carry
+* the kind itself.
+* @param source - the logged user/message source, exactly as recorded.
+* @returns the role and producer name to present for this context.
+*/
+function contextProvenance(source) {
+	const record = asRecord(source);
+	const kind = record === null ? null : readString(record, "kind");
+	if (record === null || kind === null) return {
+		role: "inject",
+		label: null
+	};
+	switch (kind) {
+		case "session-reference": return {
+			role: "recall",
+			label: joined(collect(record, "references", "label")) ?? kind
+		};
+		case "agent-instructions": return {
+			role: "inject",
+			label: joined(collect(record, "changes", "path")) ?? kind
+		};
+		case "plugin": return {
+			role: "inject",
+			label: readString(record, "plugin") ?? kind
+		};
+		case "skill-invocation": return {
+			role: "inject",
+			label: readString(record, "name") ?? kind
+		};
+		default: return {
+			role: "inject",
+			label: kind
+		};
+	}
+}
+/** Whether a raw value is one of the declared context forms. */
+function isTranscriptContextForm(value) {
+	return value === "instructions" || value === "catalog" || value === "snapshot" || value === "notice" || value === "relay" || value === "recall";
+}
+/**
+* Project one logged context source onto the presentation-only metadata the
+* transcript fold retains: the producer-declared `form` (the authority for
+* presentation role and ambient clustering), the raw `kind`, a
+* relay/notice sender, and the inject/recall role. This is the SINGLE
+* parser of raw context sources; the fold and every projection consume its
+* result. An absent/unknown form stays undefined — the caller must present
+* the row as standalone generic Context.
+* @param source - the logged user/message source, exactly as recorded.
+*/
+function contextPresentation(source) {
+	const record = asRecord(source);
+	const role = contextProvenance(source).role;
+	if (record === null) return { role };
+	const kind = readString(record, "kind");
+	const form = record["form"];
+	const senderSessionId = readString(record, "senderSessionId");
+	return {
+		...isTranscriptContextForm(form) ? { form } : {},
+		...kind === null ? {} : { sourceKind: kind },
+		...senderSessionId === null ? {} : { senderSessionId },
+		role
+	};
+}
+/** The ambient foundation forms: their adjacent rows may cluster. */
+const AMBIENT_CONTEXT_FORMS = [
+	"instructions",
+	"catalog",
+	"snapshot"
+];
+/** One injected Context row's presentation provenance, or undefined. */
+function presentationOf(message) {
+	return message.kind === "system" ? message.contextPresentation : void 0;
+}
+/** The producer-declared form of one row, when recorded. */
+function contextFormOf(message) {
+	return presentationOf(message)?.form;
+}
+/** Whether one row is ambient foundation (instructions/catalog/snapshot). */
+function isAmbientContext(message) {
+	const form = contextFormOf(message);
+	return isSurfacedContext(message) && form !== void 0 && AMBIENT_CONTEXT_FORMS.includes(form);
+}
+/**
+* The card-header icon SEMANTIC for one context injection, keyed by source
+* kind so a reader can tell an instruction file from a skill catalog or a
+* recalled session at a glance (the Web renders one browse icon for all of
+* them). The glyph itself resolves through the concrete TUI palette at render
+* time — fold state stores the semantic, never a concrete emoji/symbol, so an
+* icon-style switch repaints ALREADY-FOLDED context cards immediately.
+* @param source - the logged user/message source.
+*/
+function contextIconSemantic(source) {
+	const record = asRecord(source);
+	switch (record === null ? null : readString(record, "kind")) {
+		case "agent-instructions": return "context-file";
+		case "skill-invocation": return "context-skill";
+		case "plugin": return readString(record ?? {}, "form") === "notice" ? "context-notice" : "context-plugin";
+		case "subagent-settled": return "context-notice";
+		case "session-reference": return "context-recall";
+		default: return "context-generic";
+	}
+}
+/** The producer's one-line notice summary, or null when absent. */
+function contextSummary(source) {
+	const record = asRecord(source);
+	if (record === null) return null;
+	const summary = record["summary"];
+	return typeof summary === "string" && summary !== "" ? summary : null;
+}
+//#endregion
+//#region src/runtime/process/disposal.ts
+/**
+* The ONE synchronous disposal primitive (M3-6 PR3 plan D1): attempt every
+* cleanup step in caller-provided order, then surface the collected failure.
+*
+* The helper answers exactly one question — "attempt every synchronous
+* cleanup step in this order, then surface collected failure(s)" — and owns
+* nothing else: no async support, no ownership state, no logging, no retries
+* and no fallback. Ownership slots stay inside the owning module; every
+* orchestrator (bootstrap, TuiApp, SurfaceRuntime, the per-owner dispose
+* methods) keeps its own order and passes it here.
+*
+* Failure contract:
+* - zero failures: return;
+* - exactly one failure: rethrow the EXACT original thrown value;
+* - two or more failures: throw `AggregateError(failures, label)`.
+*
+* A throwing step never truncates its siblings.
+* @module @xmoon76/dsh-pi-tui/runtime/process/disposal
+*/
+/** Attempt every synchronous disposal step in order, surfacing failures. */
+function runSyncDisposalSteps(label, steps) {
+	const failures = [];
+	for (const step of steps) try {
+		step();
+	} catch (error) {
+		failures.push(error);
+	}
+	if (failures.length === 1) throw failures[0];
+	if (failures.length > 1) throw new AggregateError(failures, label);
+}
+/**
+* The same non-truncating attempt, for a batch that rolls back a PRIMARY failure:
+* every rollback step is attempted in caller-provided order, then the PRIMARY
+* value is thrown — aggregated by IDENTITY with the collected rollback failures,
+* the primary first and the rollback values FLAT, in step order
+* (`AggregateError([primary, r1, r2])`). One rollback obligation must never be
+* skipped because an earlier one threw, and every value a step threw stays ONE
+* entry — a user `AggregateError` is never flattened into its `.errors`. The step
+* loop is inlined (not delegated to {@link runSyncDisposalSteps}, which would
+* nest its own aggregate one level down).
+*/
+function runSyncDisposalStepsWithPrimary(label, primary, steps) {
+	const failures = [];
+	for (const step of steps) try {
+		step();
+	} catch (error) {
+		failures.push(error);
+	}
+	if (failures.length === 0) throw primary;
+	throw new AggregateError([primary, ...failures], label);
+}
+//#endregion
+//#region src/domain/media/format.ts
+/**
+* Human byte-size formatting for media limit messages (1024-based).
+* @module @xmoon76/dsh-pi-tui/domain/media/format
+*/
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KiB`;
+	return `${(bytes / 1048576).toFixed(1)} MiB`;
+}
+//#endregion
+//#region src/tui/pickers/model-directory.ts
+const IDENTITY_SEP = "\0";
+const PROVIDER_DEFAULT = `${IDENTITY_SEP}provider-default`;
+/** Full logical identity of a model row. Model ids are not globally unique. */
+function modelIdentity(providerId, modelId) {
+	return `${providerId}${IDENTITY_SEP}${modelId}`;
+}
+/**
+* Project the Host directory into identity-complete presentation rows. Pure:
+* no terminal/component state, so the current/default/effort rules are unit
+* testable without a rendering snapshot.
+*/
+function projectModelDirectory(directory, current, sessionless) {
+	const models = [];
+	for (const group of directory.groups) for (const model of group.models) {
+		const matchesConfigured = current !== void 0 && current.provider === group.id && current.model === model.id;
+		const isCurrentModel = !sessionless && matchesConfigured;
+		const isDefault = directory.default.provider === group.id && directory.default.model === model.id;
+		models.push({
+			providerId: group.id,
+			providerName: group.name,
+			modelId: model.id,
+			modelName: model.name,
+			efforts: model.reasoning?.efforts ?? [],
+			...model.reasoning?.defaultEffort === void 0 ? {} : { defaultEffort: model.reasoning.defaultEffort },
+			isCurrent: isCurrentModel,
+			isDefault,
+			...isCurrentModel && current?.reasoningEffort !== void 0 ? { currentEffort: current.reasoningEffort } : {},
+			...matchesConfigured && current?.reasoningEffort !== void 0 ? { configuredEffort: current.reasoningEffort } : {}
+		});
+	}
+	return {
+		models,
+		failures: directory.failures.map((failure) => ({
+			providerId: failure.id,
+			providerName: failure.name,
+			message: failure.message
+		}))
+	};
+}
+/** The picker-local effort CHOICES for one model, in cycle order. A model with
+*  NO effort metadata has none — the effort keys must be a true no-op there.
+*  The synthetic `provider default` joins the cycle only when the model
+*  declares efforts but no concrete default. */
+function effortChoicesOf(row) {
+	if (row.efforts.length === 0) return [];
+	const efforts = row.efforts.map((effort) => ({
+		value: effort.id,
+		label: effort.name
+	}));
+	return row.defaultEffort === void 0 ? [{
+		value: PROVIDER_DEFAULT,
+		label: "Default"
+	}, ...efforts] : efforts;
+}
+/** The initial picker-local effort VALUE for one model: the configured/current
+*  explicit effort when advertised, else the model default, else the first
+*  candidate (provider default); `undefined` for a model with no effort
+*  metadata at all. */
+function initialEffortOf(row, choices) {
+	if (choices.length === 0) return void 0;
+	const advertised = (value) => value !== void 0 && choices.some((choice) => choice.value === value) ? value : void 0;
+	return advertised(row.configuredEffort) ?? advertised(row.defaultEffort) ?? choices[0].value;
+}
+//#endregion
+//#region src/tui/pickers/preset-display.ts
+/** The shipped-preset display copy, shared by every preset picker surface.
+*
+* Fixed in English — the web surface's `BUILT_IN_PRESET_KEYS` mapping
+* (`dsh-agent-preset-registry` display helpers), TUI-side. The shipped
+* declarations publish no `name` (the official built-in classification), and
+* their metadata language is not ours to control: mapping the known ids keeps
+* the pickers English regardless of what the declarations say; everything else
+* renders the declaration's own metadata. Names follow the upstream English
+* locale.
+* @module tui/pickers/preset-display
+*/
+const BUILT_IN_PRESET_COPY = {
+	standard: {
+		name: "Standard mode",
+		description: "Full coding agent with file editing, shell, file and web search, skills, planning, goals, subagents, and workflows."
+	},
+	ptc: {
+		name: "PTC mode",
+		description: "All Standard mode capabilities, with tools exposed through the PTC mode SDK so the model can combine multi-step operations in one TypeScript program."
+	},
+	minimal: {
+		name: "Minimal mode",
+		description: "Minimal coding agent with a persistent shell."
+	},
+	cordis: {
+		name: "Creator mode",
+		description: "Built for creating custom agent presets, with all Standard mode capabilities plus runtime inspection, plugin experiments, and preset-authoring guidance."
+	}
+};
+/** Whether one roster row is a SHIPPED preset under the official 0.1.7
+* classification: a known shipped id that publishes no `name` of its own.
+* A declaration that names itself — even with a shipped id — owns its
+* copy (the same rule as `isBuiltInPreset` upstream; kept local so the
+* display layer carries no runtime import). */
+function isBuiltInPresetRow(preset) {
+	return preset.name === void 0 && BUILT_IN_PRESET_COPY[preset.id] !== void 0;
+}
+/** Resolve one roster row's display copy: the TUI's fixed English copy for
+* a shipped preset (official classification above), otherwise the preset's
+* own published metadata — a user-authored copy is never translated. */
+function presetDisplayText(preset) {
+	const builtIn = isBuiltInPresetRow(preset) ? BUILT_IN_PRESET_COPY[preset.id] : void 0;
+	if (builtIn !== void 0) return {
+		name: builtIn.name,
+		description: builtIn.description
+	};
+	return {
+		name: preset.name ?? preset.id,
+		...preset.description === void 0 ? {} : { description: preset.description }
+	};
+}
+//#endregion
+//#region src/tui/keybindings/hints.ts
+/**
+* The TSP renderer's FIXED parked-Question inspection chord (PR3-B B3 §3.8).
+*
+* The TSP interaction seat is not a Host command and owns no keymap action —
+* `Alt+Q` is dispatched from the raw SDK key stream — so this label can never
+* come from `keyHint`/`keysFor`. It also cannot go stale under a remap,
+* because no remap exists for it. It lives HERE, with the key-label
+* vocabulary, because the host-keybindings gate only sanctions key labels
+* owned by this tree: a renderer module must not hard-code the chord itself.
+*/
+const TSP_CONTINUED_INSPECTION_LABEL = "Alt+Q";
+/**
+* The History editor-seat tenant's ONE fixed-chord table (Phase 3B / B3-B).
+*
+* The seat is a per-surface COMPONENT contract, not a Host command: it owns no
+* keymap action and no remap exists, so both the handler's KeyIds and the
+* footer / key-badge labels are fixed. Keeping them in ONE table (and in this
+* key-label authority, which is the sanctioned owner of fixed chords) means a
+* hint and the handler it names can never drift into two string authorities.
+*/
+const HISTORY_CHORDS = {
+	accept: {
+		keys: ["enter", "ctrl+j"],
+		label: "Enter"
+	},
+	scope: {
+		keys: ["tab"],
+		label: "Tab"
+	},
+	results: {
+		keys: [
+			"up",
+			"down",
+			"pageUp",
+			"pageDown"
+		],
+		label: "↑/↓"
+	},
+	preview: {
+		keys: [
+			"alt+up",
+			"alt+down",
+			"alt+pageUp",
+			"alt+pageDown",
+			"alt+home",
+			"alt+end"
+		],
+		label: "Alt+↑/↓"
+	},
+	copy: {
+		keys: ["alt+c"],
+		label: "Alt+C"
+	},
+	expand: {
+		keys: ["f2"],
+		label: "F2"
+	},
+	cancel: {
+		keys: ["escape", "ctrl+c"],
+		label: "Esc"
+	}
+};
+/** The display name of a bare (unmodified) key id. */
+const BASE_KEY_LABELS = {
+	enter: "Enter",
+	escape: "Esc",
+	tab: "Tab",
+	space: "Space",
+	backspace: "Backspace",
+	delete: "Delete",
+	insert: "Insert",
+	home: "Home",
+	end: "End",
+	pageUp: "PageUp",
+	pageDown: "PageDown",
+	pageup: "PageUp",
+	pagedown: "PageDown",
+	up: "Up",
+	down: "Down",
+	left: "Left",
+	right: "Right",
+	"ctrl+[": "Ctrl+["
+};
+/** Format one KeyId as a human label (`ctrl+shift+f` → `Ctrl+Shift+F`). */
+function formatKeyId(key) {
+	const parts = key.split("+");
+	const mods = [];
+	let base = "";
+	for (const part of parts) if (part === "ctrl") mods.push("Ctrl");
+	else if (part === "alt") mods.push("Alt");
+	else if (part === "shift") mods.push("Shift");
+	else if (part === "super") mods.push("Super");
+	else base = part;
+	const baseLabel = BASE_KEY_LABELS[base] ?? (base.length === 1 ? base.toUpperCase() : base);
+	return [...mods, baseLabel].join("+");
+}
+/** Format a `<leader>X` sequence label (`<leader>t` → `Leader T`). */
+function formatLeaderSequence(completingKey) {
+	return `Leader ${formatKeyId(completingKey)}`;
+}
+/** The Job workspace's FIXED local keys (B1-C/B1-D, the same category as the
+*  History editor seat's labels below): the workspace owns NO keymap action for
+*  them — the page toggle and the current page's exact copy are screen-local,
+*  deliberately non-rebindable semantics — so they cannot come from `keyHint`,
+*  and they cannot lie either because no remap exists for them. The **key ids**
+*  live in this authority and the panel imports them for BOTH the handler and
+*  the hint, so an advertised key can never drift from the key that really acts
+*  (design language §7.1). */
+const JOB_LOCAL_KEYS = {
+	/** Switch between the Output and Command pages, in both directions. */
+	switchPage: "tab",
+	/** Copy the current page's exact original. A BARE letter — the same key the
+	*  Settings workspace's copy uses and the one the `[C]` affordance badges name —
+	*  so the bar hint reads `c copy …` and badge and key agree (§4.1, §7.1). */
+	copy: "c"
+};
+/** Format one already-labelled key list for an ACTION-BAR HINT: a BARE
+*  unmodified letter stays lowercase (`s`, never `S`) because `S` reads as ⇧S in
+*  prose — the design language's key rule (§4.1). A modified chord keeps its
+*  formatted form (`Shift+S`), and a list keeps its OWN separator spacing
+*  (`s / Shift+S`, the same shape {@link formatKeyList} paints). */
+function formatHintKeys(keys) {
+	return keys.split("/").map((part) => {
+		const core = part.trim();
+		const lowered = /^[A-Za-z]$/u.test(core) ? core.toLowerCase() : core;
+		return part.replace(core, lowered);
+	}).join("/");
+}
+/** Canonicalize one user query for both metadata matching and Host search. */
+function sanitizeSessionSearchInput(value) {
+	const trimmed = value.replace(/\0/g, "").trim();
+	if (trimmed.length <= 500) return trimmed;
+	const truncated = trimmed.slice(0, 500);
+	const last = truncated.charCodeAt(499);
+	return last >= 55296 && last <= 56319 ? truncated.slice(0, 499) : truncated;
+}
+/** Metadata-only membership; content membership belongs to SessionReader.search(). */
+function sessionRowMatchesQuery(row, query) {
+	const needle = query.toLowerCase();
+	return row.id.toLowerCase().includes(needle) || (row.title ?? "").toLowerCase().includes(needle) || (row.cwd ?? "").toLowerCase().includes(needle) || (row.preset ?? "").toLowerCase().includes(needle);
+}
+/** Lexical workspace equality; absent and empty roots match nothing. */
+function sameWorkspace(a, b) {
+	if (a === void 0 || b === void 0 || a === "" || b === "") return false;
+	const strip = (path) => {
+		let end = path.length;
+		while (end > 1 && (path[end - 1] === "/" || path[end - 1] === "\\")) end -= 1;
+		return path.slice(0, end);
+	};
+	return normalize(strip(a)) === normalize(strip(b));
+}
+/** Parent-first lineage, preserving newest-first order at every level. */
+function buildSessionTree(rows) {
+	const known = new Set(rows.map((row) => row.id));
+	const children = /* @__PURE__ */ new Map();
+	const roots = [];
+	for (const row of rows) if (row.parentSession !== void 0 && known.has(row.parentSession)) {
+		const list = children.get(row.parentSession);
+		if (list === void 0) children.set(row.parentSession, [row]);
+		else list.push(row);
+	} else roots.push(row);
+	const result = [];
+	const placed = /* @__PURE__ */ new Set();
+	const place = (row, depth) => {
+		if (placed.has(row.id)) return;
+		placed.add(row.id);
+		result.push({
+			row,
+			depth
+		});
+		for (const child of children.get(row.id) ?? []) place(child, depth + 1);
+	};
+	for (const root of roots) place(root, 0);
+	for (const row of rows) if (!placed.has(row.id)) place(row, 0);
+	return result;
+}
+//#endregion
+//#region src/tui/pickers/sessions.ts
+/**
+* Session-picker support for `/sessions`: pure row assembly and
+* presentation. The row model mirrors the kimicode web session rail — a
+* short id, a relative age, an optional title, and a workspace group —
+* rendered as one line per session in the TUI picker.
+*
+* This module is PURE presentation: it never touches `$DSH_HOME`, never
+* stats or reads session logs, and never folds a title — Host-owned session
+* derived state (titles, presets) arrives through the `SessionReader`
+* projection port (`src/runtime/session-reader-port.ts`); the Direct
+* adapter in `src/runtime/direct/` owns the official DSH projection,
+* cache, and observation semantics.
+* @module @xmoon76/dsh-pi-tui/tui/pickers/sessions
+*/
+/** Strip the `session-` prefix and keep the first 8 characters, like the
+* kimicode card's short id. */
+function shortSessionId(id) {
+	return id.replace(/^session[-_]/i, "").slice(0, 8);
+}
+/** kimicode-style workspace key: the last two path segments, or a placeholder.
+* The cwd is a Host/persistence boundary value — the group header is
+* rendered straight to the terminal, so the output is sanitized here (the
+* single group-derivation point covers the browse AND search views). */
+function workspaceKey(cwd) {
+	if (cwd === void 0 || cwd === "") return "(no workspace)";
+	return sanitizeTerminalText(cwd.split("/").slice(-2).join("/"));
+}
+/** Compact relative age of a session ("now", "2m", "3h", "5d", "3mo", "1y"). */
+function formatSessionAge(createdAt, now = Date.now()) {
+	const diff = now - createdAt;
+	if (diff < 0) return "now";
+	const seconds = Math.floor(diff / 1e3);
+	if (seconds < 60) return "now";
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h`;
+	const days = Math.floor(hours / 24);
+	if (days < 30) return `${days}d`;
+	const months = Math.floor(days / 30);
+	if (months < 12) return `${months}mo`;
+	return `${Math.floor(months / 12)}y`;
+}
+/** Strip terminal control characters from untrusted text before it enters
+* the picker presentation. Complete ANSI/OSC/APC sequences are removed
+* first (the fork's parser), then every remaining C0 control (including a
+* lone ESC), DEL, and C1 control (U+0080–U+009F — CSI/OSC/APC in 8-bit
+* form) is dropped: the picker writes descriptions straight to the
+* terminal, and a terminal decoding UTF-8 interprets C1 code points as
+* control sequences, not text. Host snippets may carry persisted control
+* bytes (message/tool output) — a raw ESC/OSC would be interpreted, not
+* displayed. */
+function sanitizeTerminalText(value) {
+	return stripTerminalSequences(value).replace(/[\u0000-\u001f\u007f-\u009f]/gu, "");
+}
+/** Assemble one session row for the picker, marking the current session.
+* @param indent - tree depth for the "All" category: rows hang under their
+*   parent with a `└─` prefix so subagent lineage reads at a glance.
+* @param contentHit - optional Host content-search hit for this row: the
+*   snippet joins the description so the local filter (which matches
+*   descriptions) surfaces content-only hits.
+*/
+function sessionPickerItem(row, currentId, indent = 0, contentHit) {
+	const marker = row.id === currentId ? "● " : "";
+	const treePrefix = indent <= 0 ? "" : `${"  ".repeat(indent)}└─ `;
+	const meta = [shortSessionId(row.id), formatSessionAge(row.createdAt ?? row.updatedAt)];
+	if (row.origin === "subagent") meta.push("sub");
+	if (row.parentSession !== void 0) meta.push("fork");
+	if (row.preset !== void 0) meta.push(`preset:${row.preset}`);
+	if (row.live) meta.push("live");
+	if (contentHit !== void 0) meta.push(`…${sanitizeTerminalText(contentHit.snippet)}…`);
+	return {
+		value: row.id,
+		label: `${treePrefix}${marker}${row.title ?? shortSessionId(row.id)}`,
+		description: meta.join(" · "),
+		group: workspaceKey(row.cwd)
+	};
+}
+/** Assemble one SEARCH-projection row: the browse presentation plus the
+* workspace in the searchable description. The search projection's
+* membership considers cwd, and the SelectList's substring filter searches
+* value/label/description only (never the group header) — so the search
+* view must carry the cwd in the description, or a cwd query would match
+* the union yet stay invisible. */
+function sessionSearchItem(row, currentId, indent = 0, contentHit) {
+	const item = sessionPickerItem(row, currentId, indent, contentHit);
+	if (row.cwd !== void 0 && row.cwd !== "") item.description = `${item.description} · ${sanitizeTerminalText(row.cwd)}`;
+	return item;
+}
+/**
+* Split a session picker label into its FIXED presentation prefix (tree
+* connector + current-session marker) and the marqueeable title (plan
+* §7.7): the selected-row marquee scrolls only the title — the lineage
+* prefix and the `●` marker are layout regions that never move. The
+* derivation mirrors {@link sessionPickerItem}'s construction (never
+* guesses arbitrary prefixes).
+*/
+function sessionLabelParts(label) {
+	const tree = /^((?:  )+└─ )/.exec(label)?.[1] ?? "";
+	const rest = label.slice(tree.length);
+	const marker = rest.startsWith("● ") ? "● " : "";
+	return {
+		prefix: tree + marker,
+		title: rest.slice(marker.length)
+	};
+}
+/**
+* Resolve one session row for a resume query: an exact id, a
+* `session-`-prefixed prefix, or a short-id prefix. Rows are newest-first,
+* so the first match is the most recent candidate.
+* @param rows - the picker rows, newest first.
+* @param query - the resume query (trimmed).
+* @returns the matching row, or undefined.
+*/
+function findSessionMatch(rows, query) {
+	const bare = query.replace(/^session[-_]/i, "");
+	return rows.find((row) => row.id === query || row.id.startsWith(`session-${bare}`) || shortSessionId(row.id).startsWith(bare));
+}
+//#endregion
+//#region src/domain/media/file-summary.ts
+/**
+* Transport/UI-neutral textual summary of a durable file attachment (TS8-D
+* move out of the legacy root `src/content-block-presentation.ts`).
+*
+* The summary is media vocabulary, not transcript semantics, so it lives in
+* `domain/media/**` — that keeps `domain/transcript/**` from importing another
+* domain subtree while preserving ONE file-summary formatter for the PiTui
+* attachment card, pending presentation, tool presentation and the Markdown
+* exporter.
+* @module @xmoon76/dsh-pi-tui/domain/media/file-summary
+*/
+/** Render a FileBlock attachment without exposing its opaque storage id. */
+function fileAttachmentSummary(attachment) {
+	return `📄 ${attachment.name} · ${formatBytes(attachment.bytes)}`;
+}
+//#endregion
+//#region src/tui/transcript/tool-presentation.ts
+/** Figma row titles per variant (design literals, not translatable copy). */
+const VARIANT_TITLES = {
+	search: "Search",
+	read: "Read",
+	bash: "Bash",
+	write: "Write",
+	edit: "Edit",
+	code: "Code",
+	others: "Tool call"
+};
+/**
+* Known tool name -> variant (the Web's TOOL_VARIANTS; cordis_define is
+* deliberately absent there too - a keyed toolview replaces the generic row).
+*/
+const TOOL_VARIANTS = {
+	bash: "bash",
+	pwsh: "bash",
+	read: "read",
+	web_fetch: "read",
+	web_search: "search",
+	grep: "search",
+	glob: "search",
+	write: "write",
+	edit: "edit",
+	run_code: "code",
+	skill: "read",
+	cordis_package_inspect: "read",
+	cordis_runtime_inspect: "read",
+	cordis_run: "others",
+	cordis_stop: "others",
+	cordis_undefine: "others"
+};
+/** Tool-owned titles that refine a generic row variant without replacing it. */
+const TOOL_TITLES = {
+	cordis_package_inspect: "Inspect",
+	cordis_runtime_inspect: "Inspect",
+	cordis_run: "Run Cordis Plugin",
+	cordis_stop: "Stop Cordis Plugin",
+	cordis_undefine: "Remove Cordis Plugin",
+	pwsh: "Pwsh",
+	skill: "Load skill"
+};
+/**
+* TUI-local titles for synthetic cards the session log produces without a
+* registry definition (local `!` shell runs, workflow bookkeeping, failure
+* lines). Same refinement mechanism as TOOL_TITLES; without these the cards
+* would fall into the generic Tool call title and lose their identity.
+*/
+const TUI_TOOL_TITLES = {
+	shell: "Shell",
+	subagent: "Subagent",
+	workflow: "Workflow",
+	"workflow-member": "Workflow Agent",
+	error: "Error",
+	interrupted: "Interrupted",
+	ask_user_question: "Question",
+	get_goal: "Read Goal",
+	create_goal: "Create Goal",
+	update_goal: "Update Goal"
+};
+/** The goal tool family (all three share the `{"goal":…}` result shape). */
+const GOAL_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"get_goal",
+	"create_goal",
+	"update_goal"
+]);
+/**
+* Tools whose folded result preview must never leak the raw result JSON
+* (web parity: the web's folded row shows only the args summary, never the
+* result). The TUI keeps its result-preview row but shows a parsed summary
+* instead — and nothing at all when the result cannot be parsed.
+*
+* `ralph`'s render already leads with a friendly line ("Ralph worker
+* reported completion after N rounds.") before the JSON report, so its
+* summary IS that first line. The agent-team family is deliberately NOT in
+* the set: it is experimental (not in the production bundle) and two of its
+* tools (`send_message`, `interrupt_agent`) share names with subagent tools
+* whose render text is friendly — a name-keyed set cannot tell them apart.
+*/
+const FOLDED_JSON_RESULT_TOOLS = /* @__PURE__ */ new Set([
+	"ralph",
+	"schedule_create",
+	"schedule_list",
+	"schedule_delete",
+	"cordis_inspect_list",
+	"cordis_inspect_query",
+	"cordis_inspect_self"
+]);
+/** Parse a result text as JSON, tolerating a friendly prefix line before
+* the JSON document (e.g. ralph's "…\nFinal report:\n{…}"). */
+function parseJsonValue(text) {
+	try {
+		return JSON.parse(text);
+	} catch {}
+	const brace = text.indexOf("{");
+	const bracket = text.indexOf("[");
+	const start = bracket !== -1 && (brace === -1 || bracket < brace) ? bracket : brace;
+	if (start > 0) try {
+		return JSON.parse(text.slice(start));
+	} catch {
+		return;
+	}
+}
+/** A non-empty string field, or undefined. */
+function stringField(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/**
+* The folded preview summary for one of {@link FOLDED_JSON_RESULT_TOOLS}:
+* a short human phrase derived from the parsed result JSON. Returns
+* undefined when nothing useful can be derived — the caller then shows NO
+* folded result preview (web parity), never the raw JSON.
+* @param name - the tool name.
+* @param text - the settled result text.
+*/
+function foldedResultSummaryFor(name, text) {
+	if (name === "ralph") {
+		const line = firstLine(text);
+		if (line !== "" && !line.startsWith("{")) return line;
+		const parsed = parseJsonValue(text);
+		if (typeof parsed === "object" && parsed !== null) {
+			const record = parsed;
+			const status = stringField(record.status);
+			const rounds = typeof record.roundsStarted === "number" ? String(record.roundsStarted) : void 0;
+			const parts = [status, rounds === void 0 ? void 0 : `${rounds} rounds`].filter((part) => part !== void 0);
+			return parts.length === 0 ? void 0 : parts.join(" · ");
+		}
+		return;
+	}
+	const parsed = parseJsonValue(text);
+	if (name === "schedule_list") {
+		if (Array.isArray(parsed)) return parsed.length === 0 ? "no scheduled jobs" : `${parsed.length} scheduled`;
+		if (typeof parsed === "object" && parsed !== null) return stringField(parsed.code);
+		return;
+	}
+	if (name === "schedule_create") {
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const record = parsed;
+		const parts = [stringField(record.kind), stringField(record.state)].filter((part) => part !== void 0);
+		return parts.length === 0 ? void 0 : parts.join(" · ");
+	}
+	if (name === "schedule_delete") {
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const record = parsed;
+		if (record.deleted === true) return "deleted";
+		if (record.deleted === false) return "not found";
+		return stringField(record.code);
+	}
+	if (name === "cordis_inspect_list") {
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const providers = parsed.providers;
+		if (Array.isArray(providers)) return providers.length === 0 ? "no providers" : `${providers.length} providers`;
+		return;
+	}
+	if (name === "cordis_inspect_query") {
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const record = parsed;
+		const parts = [
+			stringField(record.platform),
+			stringField(record.provider),
+			stringField(record.method)
+		].filter((part) => part !== void 0);
+		return parts.length === 0 ? void 0 : parts.join(" · ");
+	}
+	if (name === "cordis_inspect_self") {
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const mode = stringField(parsed.mode);
+		return mode === void 0 ? void 0 : `mode ${mode}`;
+	}
+}
+function nonBlankString(value) {
+	return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+/** Parse standard and Agent Teams-compatible send_message arguments. */
+function sendMessageCallPresentation(argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const args = parsed;
+	const target = nonBlankString(args.agent_id) ?? nonBlankString(args.target);
+	if (target === void 0 || typeof args.message !== "string") return void 0;
+	return {
+		target,
+		message: args.message
+	};
+}
+/** Parse standard and Agent Teams-compatible interrupt_agent arguments. */
+function interruptAgentCallPresentation(argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const args = parsed;
+	const target = nonBlankString(args.agent_id) ?? nonBlankString(args.target);
+	return target === void 0 ? void 0 : { target };
+}
+/** Parse the terminal_send identity and payload. */
+function terminalSendCallPresentation(argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const args = parsed;
+	const sessionId = nonBlankString(args.sessionId);
+	if (sessionId === void 0 || typeof args.text !== "string") return void 0;
+	if (args.submit !== void 0 && typeof args.submit !== "boolean") return void 0;
+	if (args.run_in_background !== void 0 && typeof args.run_in_background !== "boolean") return void 0;
+	return {
+		sessionId,
+		text: args.text
+	};
+}
+/** Parse list_agents scope without consulting any live registry. */
+function listAgentsCallPresentation(argsRaw) {
+	const parsed = argsRaw.trim() === "" ? {} : parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const scope = parsed.scope;
+	if (scope === void 0) return { scope: "children" };
+	return scope === "children" || scope === "descendants" ? { scope } : void 0;
+}
+/** Parse the display-only file declarations from a `present` call. */
+function presentCallPresentation(argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const files = parsed.files;
+	if (!Array.isArray(files)) return void 0;
+	const presented = [];
+	for (const file of files) {
+		if (typeof file !== "object" || file === null || Array.isArray(file)) return void 0;
+		const value = file;
+		if (typeof value.path !== "string" || value.path.trim() === "") return void 0;
+		if (value.description !== void 0 && typeof value.description !== "string") return void 0;
+		presented.push({
+			path: value.path,
+			...value.description === void 0 ? {} : { description: value.description }
+		});
+	}
+	return { files: presented };
+}
+/** Count one structured list_agents snapshot. */
+function summarizeAgentEntries(entries) {
+	let running = 0;
+	let idle = 0;
+	let ready = 0;
+	let diagnostics = 0;
+	for (const entry of entries) {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+			diagnostics += 1;
+			continue;
+		}
+		const value = entry;
+		if (value.kind === "diagnostic") {
+			diagnostics += 1;
+			continue;
+		}
+		if (value.kind !== void 0 && value.kind !== "child" && value.kind !== "agent") {
+			diagnostics += 1;
+			continue;
+		}
+		switch (value.status) {
+			case "running":
+			case "provisioning":
+				running += 1;
+				break;
+			case "idle":
+				idle += 1;
+				break;
+			case "ready":
+			case "inactive":
+				ready += 1;
+				break;
+			default: diagnostics += 1;
+		}
+	}
+	return {
+		total: running + idle + ready + diagnostics,
+		running,
+		idle,
+		ready,
+		...diagnostics === 0 ? {} : { diagnostics }
+	};
+}
+/** Parse both the structured snapshot and the standard rendered text. */
+function summarizeAgentListResult(text) {
+	const parsed = parseJsonValue(text);
+	if (Array.isArray(parsed)) return summarizeAgentEntries(parsed);
+	const trimmed = text.trim();
+	if (trimmed === "(no subagents)") return {
+		total: 0,
+		running: 0,
+		idle: 0,
+		ready: 0
+	};
+	if (trimmed === "") return void 0;
+	let running = 0;
+	let idle = 0;
+	let ready = 0;
+	let diagnostics = 0;
+	let matched = 0;
+	for (const line of trimmed.split(/\r\n|\r|\n/)) {
+		if (/\[running\](?:\s|$)/.test(line)) {
+			running += 1;
+			matched += 1;
+			continue;
+		}
+		if (/\[idle\](?:\s|$)/.test(line)) {
+			idle += 1;
+			matched += 1;
+			continue;
+		}
+		if (/\[ready\](?:\s|$)/.test(line)) {
+			ready += 1;
+			matched += 1;
+			continue;
+		}
+		if (/\[diagnostic:[^\]]+\]/.test(line)) {
+			diagnostics += 1;
+			matched += 1;
+			continue;
+		}
+		if (/\[[a-z][^\]]*\]/.test(line)) {
+			diagnostics += 1;
+			matched += 1;
+		}
+	}
+	if (matched === 0) return void 0;
+	return {
+		total: running + idle + ready + diagnostics,
+		running,
+		idle,
+		ready,
+		...diagnostics === 0 ? {} : { diagnostics }
+	};
+}
+/** Format a list snapshot without treating diagnostics as agents. */
+function formatAgentListSummary(summary) {
+	if (summary.total === 0) return "no subagents";
+	const agents = summary.running + summary.idle + summary.ready;
+	const diagnostics = summary.diagnostics ?? 0;
+	const parts = [diagnostics > 0 ? `${summary.total} ${summary.total === 1 ? "entry" : "entries"}` : `${agents} ${agents === 1 ? "agent" : "agents"}`];
+	if (summary.running > 0) parts.push(`${summary.running} running`);
+	if (summary.idle > 0) parts.push(`${summary.idle} idle`);
+	if (summary.ready > 0) parts.push(`${summary.ready} ready`);
+	if (diagnostics > 0) parts.push(`${diagnostics} ${diagnostics === 1 ? "diagnostic" : "diagnostics"}`);
+	return parts.join(" · ");
+}
+/** A compact result line for a non-JSON action acknowledgement/error. */
+function firstActionResultDetail(text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return void 0;
+	const parsed = parseJsonValue(text);
+	if (typeof parsed === "string") return firstLine(parsed);
+	if (parsed !== void 0 || /^[\[{]/.test(trimmed)) return void 0;
+	return firstLine(trimmed);
+}
+/** Pull a human detail out of a structured action error without raw JSON. */
+function actionErrorDetail(text) {
+	const parsed = parseJsonValue(text);
+	if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+		const value = parsed;
+		const code = nonBlankString(value.code);
+		const message = nonBlankString(value.message ?? value.error ?? value.detail ?? value.reason);
+		if (code !== void 0 && message !== void 0) return `${code}: ${message}`;
+		return message ?? code;
+	}
+	return firstActionResultDetail(text) ?? (text.trim() === "" ? void 0 : firstLine(text.trim()));
+}
+/** Combine a structured error identity with any safe human detail. */
+function actionErrorResult(text, options) {
+	const identity = options.error === void 0 ? void 0 : `${options.error.name}: ${options.error.code}`;
+	const detail = actionErrorDetail(text);
+	return identity === void 0 ? detail : detail === void 0 ? identity : `${identity}: ${detail}`;
+}
+const ACKNOWLEDGEMENT_STATUSES = /* @__PURE__ */ new Set([
+	"accepted",
+	"completed",
+	"delivered",
+	"ok",
+	"sent",
+	"success"
+]);
+/** Derive a meaningful result for one action tool; receipt-only results vanish. */
+function actionResultSummary(kind, text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return void 0;
+	const parsed = parseJsonValue(text);
+	if (kind === "terminal_send") {
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+			const value = parsed;
+			if (nonBlankString(value.status)?.toLowerCase() === "queued") return "queued";
+			if (value.kind === "background") {
+				const jobId = nonBlankString(value.jobId);
+				return jobId === void 0 ? void 0 : `started background job ${jobId}`;
+			}
+			return;
+		}
+		const value = typeof parsed === "string" ? firstLine(parsed) : firstLine(trimmed);
+		if (/^started background job\b/i.test(value)) return value;
+		return /\bqueued\b/i.test(value) ? "queued" : void 0;
+	}
+	if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+		const value = parsed;
+		const status = nonBlankString(value.status)?.toLowerCase();
+		if (status === "queued") return "queued";
+		if (status !== void 0 && !ACKNOWLEDGEMENT_STATUSES.has(status)) return status;
+		if (kind === "interrupt_agent") {
+			const previous = nonBlankString(value.previousStatus);
+			if (previous !== void 0) return `was ${previous}`;
+		}
+		return;
+	}
+	const value = typeof parsed === "string" ? firstLine(parsed) : firstLine(trimmed);
+	if (value === "") return void 0;
+	if (kind === "send_message" && /^message\s+(?:delivered|sent|accepted)\b/i.test(value)) return /\bqueued\b/i.test(value) ? "queued" : void 0;
+	if (kind === "interrupt_agent" && /^interrupt\s+requested\s+for\s+agent\b/i.test(value)) return void 0;
+	if (/^(?:ok|accepted|done|success|succeeded|sent|delivered)$/i.test(value)) return void 0;
+	return firstActionResultDetail(value);
+}
+/**
+* Derive action semantics from the recorded call/result only. This is the
+* host fallback boundary: extension-owned renderers still take precedence in
+* the TUI, while replay remains deterministic and registry-independent.
+*/
+function compactToolPresentation(name, argsRaw, result = "", options = {}) {
+	if (name === "present") {
+		const call = presentCallPresentation(argsRaw);
+		const resultText = options.isError === true || options.error !== void 0 ? actionErrorResult(result, options) : void 0;
+		const count = call === void 0 ? void 0 : `${call.files.length} ${call.files.length === 1 ? "file" : "files"}`;
+		return {
+			title: "Present files",
+			...count === void 0 ? {} : { summary: count },
+			...resultText === void 0 ? {} : { result: resultText }
+		};
+	}
+	const send = name === "send_message" ? sendMessageCallPresentation(argsRaw) : void 0;
+	if (send !== void 0) {
+		const resultText = options.isError === true || options.error !== void 0 ? actionErrorResult(result, options) : actionResultSummary("send_message", result);
+		return {
+			title: "Send message",
+			summary: send.target,
+			payload: send.message,
+			...resultText === void 0 ? {} : { result: resultText }
+		};
+	}
+	const terminal = name === "terminal_send" ? terminalSendCallPresentation(argsRaw) : void 0;
+	if (terminal !== void 0) {
+		const resultText = options.isError === true || options.error !== void 0 ? actionErrorResult(result, options) : actionResultSummary("terminal_send", result);
+		return {
+			title: "Terminal",
+			summary: terminal.sessionId,
+			payload: terminal.text,
+			...resultText === void 0 ? {} : { result: resultText }
+		};
+	}
+	const interrupt = name === "interrupt_agent" ? interruptAgentCallPresentation(argsRaw) : void 0;
+	if (interrupt !== void 0) {
+		const resultText = options.isError === true || options.error !== void 0 ? actionErrorResult(result, options) : actionResultSummary("interrupt_agent", result);
+		return {
+			title: "Interrupt agent",
+			summary: interrupt.target,
+			...resultText === void 0 ? {} : { result: resultText }
+		};
+	}
+	const list = name === "list_agents" ? listAgentsCallPresentation(argsRaw) : void 0;
+	if (list !== void 0) {
+		const summary = options.isError === true || options.error !== void 0 ? actionErrorResult(result, options) : (() => {
+			const snapshot = summarizeAgentListResult(result);
+			return snapshot === void 0 ? void 0 : formatAgentListSummary(snapshot);
+		})();
+		return {
+			title: "List agents",
+			summary: list.scope,
+			...summary === void 0 ? {} : { result: summary }
+		};
+	}
+}
+/** Whether a valid action-tool call uses the compact semantic fallback. */
+function isCompactActionTool(name, argsRaw) {
+	return compactToolPresentation(name, argsRaw) !== void 0;
+}
+/** Expanded semantic lines for action cards; list_agents keeps its history snapshot. */
+function compactToolExpandedLines(name, argsRaw, result = "", options = {}) {
+	const presentation = compactToolPresentation(name, argsRaw, result, options);
+	if (presentation === void 0) return void 0;
+	if (name === "present") {
+		const lines = presentCallPresentation(argsRaw)?.files.map((file) => file.description === void 0 || file.description === "" ? file.path : `${file.path} — ${file.description}`) ?? [];
+		if (presentation.result !== void 0) lines.push(presentation.result);
+		return lines;
+	}
+	if (name === "list_agents" && options.isError !== true && options.error === void 0) {
+		const parsed = parseJsonValue(result);
+		if (Array.isArray(parsed)) return JSON.stringify(parsed, null, 2).split("\n");
+		if (result.trim() !== "") return result.split(/\r\n|\r|\n/);
+	}
+	const lines = presentation.payload === void 0 ? [] : presentation.payload.split(/\r\n|\r|\n/);
+	if (presentation.result !== void 0) lines.push(presentation.result);
+	return lines;
+}
+/** Summary key preference per variant (args-derived). */
+const SUMMARY_KEYS = {
+	bash: ["description", "command"],
+	read: [
+		"path",
+		"file_path",
+		"url"
+	],
+	search: [
+		"query",
+		"pattern",
+		"url"
+	],
+	write: ["path", "file_path"],
+	edit: ["path", "file_path"],
+	code: ["description"],
+	others: []
+};
+/** Return the formal Tool card's preferred argument summary keys. Preparing
+* extraction treats this order as the best available choice at extraction time. */
+function toolSummaryKeys(name) {
+	return SUMMARY_KEYS[classifyTool(name)] ?? [];
+}
+/** The first line of a text (the Web's ReasoningRow summary for settled rows). */
+function firstLine(text) {
+	const newline = text.indexOf("\n");
+	return newline === -1 ? text : text.slice(0, newline);
+}
+/**
+* Strip the workspace root from a workspace-rooted absolute path (display
+* only), exactly like the Web's relativizeToCwd: only the workspace-root
+* prefix is peeled, both `/` and `\` separators are handled, and a path
+* outside the root is returned unchanged.
+* @param text - the path to shorten.
+* @param cwd - session workspace root; absent or empty leaves the path unchanged.
+* @returns the path relative to the workspace root, or unchanged when it is not rooted there.
+*/
+function relativizeToCwd(text, cwd) {
+	if (cwd === void 0 || cwd === "") return text;
+	const root = cwd.replace(/[/\\]+$/, "");
+	if (text.startsWith(root + "/") || text.startsWith(root + "\\")) return text.slice(root.length + 1);
+	return text;
+}
+function parseArgs(argsRaw) {
+	try {
+		return JSON.parse(argsRaw);
+	} catch {
+		return;
+	}
+}
+function pickString(args, keys) {
+	for (const key of keys) {
+		const value = args[key];
+		if (typeof value === "string" && value !== "") return value;
+	}
+}
+/** The summary key preference for one row variant, falling back to the first
+* string arg value, then to the raw args text (Web deriveSummary). */
+function deriveSummary(name, argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null) return firstLine(argsRaw);
+	const args = parsed;
+	const picked = pickString(args, toolSummaryKeys(name));
+	if (picked !== void 0) return firstLine(picked);
+	for (const value of Object.values(args)) if (typeof value === "string" && value !== "") return firstLine(value);
+	return firstLine(argsRaw);
+}
+/**
+* Tool-specific args summaries for tools whose natural one-line identity is
+* not a raw arg value (Web TodoRow/AskQuestionRow parity): `todo_write`
+* reads `done/total done` plus the first active item, `ask_user_question`
+* reads the first question text. Returns undefined for every other tool,
+* letting the generic derivation own the summary.
+* @param name - the tool name.
+* @param argsRaw - the raw arguments JSON.
+* @returns the tool-specific summary, or undefined when none applies.
+*/
+function summarizeToolArgs(name, argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const args = parsed;
+	if (name === "ask_user_question") {
+		const questions = args.questions;
+		if (!Array.isArray(questions) || questions.length === 0) return void 0;
+		const first = questions[0];
+		if (typeof first !== "object" || first === null) return void 0;
+		const question = first.question;
+		if (typeof question !== "string" || question === "") return void 0;
+		return firstLine(question);
+	}
+	if (name === "create_goal") {
+		const objective = args.objective;
+		return typeof objective === "string" && objective !== "" ? firstLine(objective) : void 0;
+	}
+	if (name === "update_goal") {
+		const action = args.action;
+		return typeof action === "string" && action !== "" ? action : void 0;
+	}
+	if (name === "get_goal") return "";
+	if (name === "skill") {
+		const skillName = args.name;
+		return typeof skillName === "string" && skillName !== "" ? firstLine(skillName) : void 0;
+	}
+	if (name !== "todo_write") return void 0;
+	const todos = args.todos;
+	if (!Array.isArray(todos)) return void 0;
+	const done = todos.filter((todo) => typeof todo === "object" && todo !== null && todo.status === "completed").length;
+	const active = todos.find((todo) => typeof todo === "object" && todo !== null && todo.status !== "completed");
+	const content = active === void 0 ? "" : String(active.content ?? "");
+	return `${done}/${todos.length} done${content === "" ? "" : ` · ${firstLine(content)}`}`;
+}
+/** Classify a tool name into its row variant; unknown names are `others`. */
+function classifyTool(name) {
+	return Object.prototype.hasOwnProperty.call(TOOL_VARIANTS, name) ? TOOL_VARIANTS[name] : "others";
+}
+/** The structural icon semantic per exact tool name, for synthetic cards
+* without a registry entry (the glyph itself resolves through
+* src/tui/icons.ts — fold state never stores a concrete emoji/symbol). */
+const TOOL_SEMANTICS = {
+	shell: "tool-shell",
+	subagent: "subagent",
+	workflow: "workflow",
+	"workflow-member": "subagent",
+	error: "error",
+	interrupted: "interrupted",
+	ask_user_question: "question"
+};
+/** The icon semantic per row variant, applied to every registered tool of
+* that class. */
+const VARIANT_SEMANTICS = {
+	read: "tool-read",
+	search: "tool-search",
+	bash: "tool-shell",
+	write: "tool-write",
+	edit: "tool-edit",
+	code: "tool-code",
+	others: "tool-generic"
+};
+/**
+* The card header's leading icon semantic: exact-name entries first
+* (synthetic cards), then slash commands (a control action, not a tool),
+* then the tool's row-variant semantic, then the generic tool. The renderer
+* resolves the glyph through `iconFor(semantic, iconStyle)`.
+* @param name - the tool name.
+*/
+function toolIconSemantic(name) {
+	const exact = Object.prototype.hasOwnProperty.call(TOOL_SEMANTICS, name) ? TOOL_SEMANTICS[name] : void 0;
+	if (exact !== void 0) return exact;
+	if (name.startsWith("/")) return "slash-command";
+	return VARIANT_SEMANTICS[classifyTool(name)];
+}
+/**
+* The short title used by live tool-call presentations. Known names reuse the
+* same exact-title and variant tables as formal tool cards; an unknown tool is
+* intentionally generic rather than exposing its raw model-facing name.
+*/
+function toolTitle(name) {
+	if (name === "") return "tool";
+	const exact = Object.prototype.hasOwnProperty.call(TOOL_TITLES, name) ? TOOL_TITLES[name] : Object.prototype.hasOwnProperty.call(TUI_TOOL_TITLES, name) ? TUI_TOOL_TITLES[name] : void 0;
+	if (exact !== void 0) return exact;
+	const variant = classifyTool(name);
+	return variant === "others" ? "Tool" : VARIANT_TITLES[variant];
+}
+/** Derive the folded preview from a tool name and its raw args JSON. */
+function parseCallPreview(name, argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const args = parsed;
+	if (name === "bash" || name === "pwsh") {
+		const command = args.command;
+		if (typeof command !== "string" || command === "") return void 0;
+		const workdir = args.workdir;
+		return {
+			kind: "bash",
+			command,
+			...typeof workdir === "string" && workdir !== "" ? { workdir } : {}
+		};
+	}
+	if (name === "edit") {
+		const oldText = args.old_string;
+		const newText = args.new_string;
+		if (typeof oldText !== "string" || typeof newText !== "string") return void 0;
+		const path = typeof args.file_path === "string" && args.file_path !== "" ? args.file_path : args.path;
+		return {
+			kind: "diff",
+			diffs: [{
+				path: typeof path === "string" ? path : "",
+				oldText,
+				newText
+			}]
+		};
+	}
+	if (name === "write") {
+		const content = args.content;
+		if (typeof content !== "string" || content === "") return void 0;
+		const path = typeof args.file_path === "string" && args.file_path !== "" ? args.file_path : args.path;
+		return {
+			kind: "diff",
+			diffs: [{
+				path: typeof path === "string" ? path : "",
+				oldText: null,
+				newText: content
+			}]
+		};
+	}
+}
+/**
+* Parse the read tool's model-facing envelopes from a result: one
+* `<path>…</path> <type>…</type> <content>…numbered lines…</content>` block
+* per file read. A merged group card (groupConsecutiveReads) carries several
+* consecutive envelopes, hence the plural form; the single-envelope helper
+* below is the common-case convenience.
+* @param result - the tool result text.
+* @returns every parsed envelope; empty when the result is not a read envelope.
+*/
+function parseReadEnvelopes(result) {
+	const out = [];
+	const block = /<path>([\s\S]*?)<\/path>\s*<type>[^<]*<\/type>\s*<content>([\s\S]*?)<\/content>/g;
+	let match;
+	while ((match = block.exec(result)) !== null) {
+		const path = match[1] ?? "";
+		const body = match[2] ?? "";
+		const lines = [];
+		let totalLines;
+		for (const raw of body.split("\n")) {
+			const numbered = /^(\d+): (.*)$/.exec(raw);
+			if (numbered !== null) {
+				lines.push({
+					number: Number(numbered[1]),
+					text: numbered[2] ?? ""
+				});
+				continue;
+			}
+			const end = /^\(End of file - total (\d+) lines\)$/.exec(raw);
+			if (end !== null) {
+				totalLines = Number(end[1]);
+				continue;
+			}
+			const showing = /^\(Showing lines \d+-\d+ of (\d+) lines/.exec(raw);
+			if (showing !== null) totalLines = Number(showing[1]);
+		}
+		out.push({
+			path,
+			lines,
+			...totalLines === void 0 ? {} : { totalLines }
+		});
+	}
+	return out;
+}
+/**
+* Parse the write tool's XML confirmation envelope (`<path>…</path> <type>
+* …</type> <content>Created file</content>` — no file content is echoed).
+* The verb + path are the only material the envelope carries. A malformed
+* envelope — including a blank `<path>` — yields undefined, never a
+* partial parse (a whitespace path would surface as an invalid card row).
+* @param result - the tool result text.
+* @returns the envelope's verb and path, or undefined when the result is
+* not a well-formed write envelope.
+*/
+function parseWriteEnvelope(result) {
+	const match = /<path>([\s\S]*?)<\/path>\s*<type>[^<]*<\/type>\s*<content>([\s\S]*?)<\/content>/.exec(result);
+	if (match === null) return void 0;
+	const verb = /^\s*(Created|Updated)\s+file\s*$/.exec(match[2] ?? "")?.[1];
+	if (verb !== "Created" && verb !== "Updated") return void 0;
+	const path = (match[1] ?? "").trim();
+	if (path === "") return void 0;
+	return {
+		verb,
+		path
+	};
+}
+/**
+* The folded preview suffix for a write card: ` — Created` / ` — Updated`
+* when the result is the tool's XML confirmation envelope, empty otherwise.
+* The folded row must NEVER dump the raw envelope (the read-card no-XML
+* rule; a malformed envelope yields no preview at all, not the raw text).
+* @param result - the tool result text.
+* @returns the verb suffix, or '' when the result is not a write envelope.
+*/
+function writeFoldedPreview(result) {
+	const envelope = parseWriteEnvelope(result);
+	return envelope === void 0 ? "" : ` — ${envelope.verb}`;
+}
+/**
+* Parse the skill tool's XML instruction envelope (`<skill_content
+* name="…"> <skill_resources>…</skill_resources> <skill_instructions>…
+* </skill_instructions> </skill_content>`). The name attribute is XML-
+* escaped by the producer (escapeAttr: `&amp;`/`&quot;`/`&lt;`) and is
+* decoded here; the instructions body is embedded VERBATIM by the producer
+* (skills are trusted local content), so it is returned unmodified.
+*
+* The boundaries are OUTER-envelope-aware: the opener is the first
+* `<skill_content name="…">`, the instructions opener the first
+* `<skill_instructions>` after it, and the closers the last
+* `</skill_instructions>` / `</skill_content>` — so a body that itself
+* documents envelope-shaped XML (a complete nested block, or an unclosed
+* tag) never truncates the outer body. A MALFORMED first envelope never
+* borrows a later envelope's boundaries: a second `<skill_content name="…">`
+* opener between the first opener and its instructions opener means the
+* first envelope is incomplete, and the selected instructions body must
+* close every `<skill_content name="…">` opener it contains (unmatched
+* closing tags are tolerated) — without those guards, a first envelope
+* whose own boundaries are unclosed would cross-pair with a later
+* envelope's. An unclosed `<skill_content name="…">` example inside a body
+* is indistinguishable from such a malformed concatenation and degrades to
+* a header-only card, never raw tags.
+* @param result - the tool result text.
+* @returns the envelope's name and instruction body, or undefined when the
+* result is not a well-formed skill envelope (a blank name is malformed).
+*/
+function parseSkillEnvelope(result) {
+	const open = result.indexOf("<skill_content name=\"");
+	if (open < 0) return void 0;
+	const nameStart = open + 21;
+	const nameEnd = result.indexOf("\"", nameStart);
+	if (nameEnd < 0) return void 0;
+	const instrOpen = result.indexOf("<skill_instructions>", nameEnd);
+	if (instrOpen < 0) return void 0;
+	const nestedOpen = result.indexOf("<skill_content name=\"", nameEnd);
+	if (nestedOpen >= 0 && nestedOpen < instrOpen) return void 0;
+	const outerClose = result.lastIndexOf("</skill_content>");
+	if (outerClose < instrOpen) return void 0;
+	const instrClose = result.lastIndexOf("</skill_instructions>", outerClose);
+	if (instrClose <= instrOpen) return void 0;
+	const bodyRegion = result.slice(instrOpen, instrClose);
+	let contentDepth = 0;
+	for (const token of bodyRegion.matchAll(/<skill_content name="|<\/skill_content>/g)) if (token[0] === "<skill_content name=\"") contentDepth += 1;
+	else contentDepth = Math.max(0, contentDepth - 1);
+	if (contentDepth > 0) return void 0;
+	const rawName = result.slice(nameStart, nameEnd).trim();
+	if (rawName === "") return void 0;
+	const name = rawName.replaceAll("&quot;", "\"").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+	let body = result.slice(instrOpen + 20, instrClose);
+	if (body.startsWith("\n")) body = body.slice(1);
+	if (body.endsWith("\n")) body = body.slice(0, -1);
+	return {
+		name,
+		instructions: body
+	};
+}
+/**
+* The folded preview suffix for a skill card: ` — N lines` (the instruction
+* body's line count — the header already carries `skill · <name>`), empty
+* otherwise. The folded row never dumps the raw `<skill_content>` block.
+* @param result - the tool result text.
+* @returns the line-count suffix, or '' when the result is not a skill
+* envelope.
+*/
+function skillFoldedPreview(result) {
+	const envelope = parseSkillEnvelope(result);
+	if (envelope === void 0) return "";
+	const lines = envelope.instructions.split("\n").filter((line) => line !== "").length;
+	return lines === 0 ? "" : ` — ${lines} lines of instructions`;
+}
+/**
+* The human-facing body lines of one injected context row, derived from the
+* model-facing text so the expanded row never leaks the envelope's raw XML
+* (the same no-XML rule as the read/write/skill tool cards):
+*
+* - a well-formed skill envelope (`<skill_content …>` — the skill loader
+*   tool result and the user-explicit invocation injection share this
+*   shape) renders its instructions body;
+* - a `<system-reminder>`-wrapped producer (the skill catalog, workspace
+*   instructions — both bake their complete frame into the content,
+*   harness caller-owned framing) renders its content with the wrapper tag
+*   lines stripped; `<available_skills>` markers are stripped only when the
+*   pair is present, so a lone marker inside real content survives;
+* - any OTHER text returns undefined and the caller keeps its raw-body
+*   behavior (plain context rows are unchanged).
+*
+* A malformed skill envelope yields an EMPTY body, never the raw tags: the
+* header still names the producer, and the model-facing bytes are untouched
+* (presentation only).
+* @param text - the injected context message text, exactly as logged.
+* @returns the body lines to render, or undefined when no envelope shape
+* applies.
+*/
+function systemContextBody(text) {
+	const skill = parseSkillEnvelope(text);
+	if (skill !== void 0) return skill.instructions.split("\n");
+	if (text.trimStart().startsWith("<skill_content")) return [];
+	const lines = text.split("\n");
+	const first = lines[0]?.trim();
+	const last = lines[lines.length - 1]?.trim();
+	if (first !== "<system-reminder>" || last !== "</system-reminder>") return void 0;
+	const body = lines.slice(1, -1);
+	if (!(body.some((line) => line.trim() === "<available_skills>") && body.some((line) => line.trim() === "</available_skills>"))) return body;
+	return body.filter((line) => line.trim() !== "<available_skills>" && line.trim() !== "</available_skills>");
+}
+/**
+* Parse the read_image tool's XML confirmation envelope (`<path>…</path>
+* <type>image</type> <content>PNG image, 800x600 px, … bytes</content>`).
+* @param result - the tool result text.
+* @returns the envelope's path and the content summary line, or undefined
+* when the result is not a well-formed image envelope (blank path or blank
+* summary are malformed).
+*/
+function parseImageEnvelope(result) {
+	const match = /<path>([\s\S]*?)<\/path>\s*<type>image<\/type>\s*<content>\s*\n?\s*([\s\S]*?)\s*\n?\s*<\/content>/.exec(result);
+	if (match === null) return void 0;
+	const path = (match[1] ?? "").trim();
+	const summary = (match[2] ?? "").trim();
+	if (path === "" || summary === "") return void 0;
+	return {
+		path,
+		summary
+	};
+}
+/**
+* The folded preview suffix for a read_image card: ` — <summary>` (e.g.
+* `PNG image · 800x600 px`), empty otherwise. The folded row never dumps
+* the raw envelope (the read-card no-XML rule).
+* @param result - the tool result text.
+* @returns the summary suffix, or '' when the result is not an image
+* envelope.
+*/
+function imageFoldedPreview(result) {
+	const envelope = parseImageEnvelope(result);
+	return envelope === void 0 ? "" : ` — ${firstLine(envelope.summary)}`;
+}
+/**
+* The folded preview suffix for a read card: `— {N} lines` when the envelope
+* reports a total (or a line count), empty otherwise. A merged group card
+* (multiple envelopes) yields nothing — its head already carries "N files".
+*/
+function readFoldedPreview(result) {
+	const envelopes = parseReadEnvelopes(result);
+	if (envelopes.length !== 1) return "";
+	const envelope = envelopes[0];
+	const total = envelope.totalLines ?? (envelope.lines.length > 0 ? envelope.lines.length : void 0);
+	return total === void 0 ? "" : ` — ${total} lines`;
+}
+/**
+* The Web row-model header for one tool card: title = tool-owned title or the
+* variant design title; summary = SUMMARY_KEYS-derived args summary relativized
+* to the workspace root. Unknown variants carry the tool name alongside the
+* summary (the Web's `toolName · base` rule), with the separator dropped when
+* there is no summary text. Slash-command names render without their slash.
+* @param name - the tool name.
+* @param argsRaw - the raw arguments JSON string ('' when absent).
+* @param cwd - workspace root for relativization; optional.
+*/
+function toolCardHeader(name, argsRaw, cwd) {
+	const action = compactToolPresentation(name, argsRaw);
+	if (action !== void 0) return {
+		title: action.title,
+		summary: action.summary ?? ""
+	};
+	const variant = classifyTool(name);
+	const toolTitle = TOOL_TITLES[name] ?? TUI_TOOL_TITLES[name];
+	const toolSummary = summarizeToolArgs(name, argsRaw);
+	const base = argsRaw === "" ? "" : toolSummary ?? relativizeToCwd(deriveSummary(name, argsRaw), cwd);
+	const summary = variant === "others" && toolTitle === void 0 ? base === "" ? "" : name + " · " + base : base;
+	return {
+		title: toolTitle ?? (name.startsWith("/") ? name.slice(1) : VARIANT_TITLES[variant]),
+		summary
+	};
+}
+/**
+* Render a completed web retrieval as display lines (Web WebBlock parity):
+* a `search` shows the provider answer and the source list (title — url,
+* snippet under each), a `fetch` shows the URL and HTTP status. Truncation
+* is marked in the same place the Web marks it: under the list/status.
+* Colors are the caller's (the render layer owns the palette).
+* @param view - the web result view from presentResult.
+* @returns the display lines; empty when the view carries nothing to show.
+*/
+function webCardLines(view) {
+	if (view.kind === "search") {
+		const lines = [];
+		if (view.answer !== void 0 && view.answer !== "") lines.push(view.answer);
+		for (const source of view.sources) {
+			const head = source.title === void 0 || source.title === "" ? source.url : `${source.title} — ${source.url}`;
+			lines.push(`• ${head}`);
+			if (source.snippet !== void 0 && source.snippet !== "") lines.push(`  ${source.snippet}`);
+		}
+		if (view.truncated) lines.push("… truncated — more sources omitted");
+		return lines;
+	}
+	const lines = [`${view.url} — HTTP ${view.statusCode}`];
+	if (view.truncated) lines.push("… truncated — content capped");
+	return lines;
+}
+/**
+* Render a generic card's rawInput as display lines, structured per tool
+* where the payload has a natural one-line shape (web TodoRow parity for
+* `todo_write`, a session/terminal target line for the rest). Unknown
+* object payloads fall back to pretty JSON — the same fallback the Web's
+* generic body uses. A string rawInput renders verbatim.
+* @param name - the tool name.
+* @param rawInput - the presenter's salient raw input.
+* @returns the display lines.
+*/
+/** Checklist display lines for a todo list: `●` in progress, `○` pending,
+* `✓` completed (Web TodoRow parity). Malformed items are skipped. */
+function todoChecklistLines(todos) {
+	const lines = [];
+	for (const todo of todos) {
+		if (typeof todo !== "object" || todo === null) continue;
+		const item = todo;
+		const content = typeof item.content === "string" ? item.content : String(item.content ?? "");
+		const mark = item.status === "completed" ? "✓" : item.status === "in_progress" ? "●" : "○";
+		lines.push(`${mark} ${content}`);
+	}
+	return lines;
+}
+function genericRawInputLines(name, rawInput) {
+	if (typeof rawInput === "string") return rawInput === "" ? [] : [rawInput];
+	if (typeof rawInput !== "object" || rawInput === null) return rawInput === void 0 ? [] : [String(rawInput)];
+	if (name === "todo_write" && Array.isArray(rawInput)) return todoChecklistLines(rawInput);
+	const args = rawInput;
+	if (name === "todo_write") {
+		const todos = args.todos;
+		if (Array.isArray(todos)) return todoChecklistLines(todos);
+	}
+	if ((name === "terminal_read" || name === "terminal_signal" || name === "terminal_send") && typeof args.sessionId === "string") {
+		const line = `session ${args.sessionId}`;
+		return name === "terminal_send" && typeof args.text === "string" ? [`${line}: ${args.text}`] : [line];
+	}
+	if ((name === "session_event_trace" || name === "session_event_read" || name === "session_trace") && (args.seq !== void 0 || args.session_id !== void 0)) {
+		const parts = [];
+		if (args.session_id !== void 0) parts.push(String(args.session_id));
+		if (args.seq !== void 0) parts.push(`seq ${String(args.seq)}`);
+		return [parts.join(" · ")];
+	}
+	return JSON.stringify(rawInput, null, 2).split("\n");
+}
+/**
+* Flatten a settled result's content blocks to display lines, with the Web's
+* `resultText` semantics: text blocks verbatim, known file blocks as a
+* metadata-only row, images as a compact placeholder, and unknown finalized
+* blocks as an explicit bounded fallback. Empty content on a failed call
+* falls back to the structured error's `name: code` line.
+* @param blocks - the result content blocks.
+* @param error - the structured error, when the call failed.
+* @returns the display lines (may be empty).
+*/
+function resultTextLines(blocks, error) {
+	const lines = [];
+	for (const block of blocks) if (block.type === "text") lines.push(...block.text.split("\n"));
+	else if (block.type === "image") lines.push("[image]");
+	else if (block.type === "file") lines.push(fileAttachmentSummary(block.attachment));
+	else if (block.type === "reasoning" || block.type === "tool-call") lines.push(JSON.stringify(block, null, 2));
+	else lines.push(finalizedBlockFallbackText(block));
+	if (lines.length === 0 && error !== void 0) lines.push(`${error.name}: ${error.code}`);
+	return lines;
+}
+/**
+* Parse and normalize the tool's `{"answers":[…]}` render text. A
+* malformed entry (non-object) invalidates the WHOLE text — the Web's
+* `answeredSummary` checks `answers.every(isAnswer)` the same way, and a
+* half-valid set would make the count and the rendered rows disagree.
+* Non-string `selected` members are dropped; missing id/custom normalize
+* to empty.
+* @param text - the settled result text.
+* @returns the normalized entries, or undefined when unparseable/malformed.
+*/
+function parseAnswerEntries(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const answers = parsed.answers;
+	if (!Array.isArray(answers)) return void 0;
+	if (!answers.every((entry) => typeof entry === "object" && entry !== null)) return void 0;
+	return answers.map((entry) => {
+		const candidate = entry;
+		return {
+			id: typeof candidate.id === "string" ? candidate.id : "",
+			selected: Array.isArray(candidate.selected) ? candidate.selected.filter((item) => typeof item === "string") : [],
+			custom: typeof candidate.custom === "string" ? candidate.custom : ""
+		};
+	});
+}
+/**
+* The answered-count summary for a settled `ask_user_question` result
+* (Web AskQuestionRow parity): parses the tool's `{"answers":[…]}` render
+* text and counts the entries that actually carry an answer — a non-empty
+* `selected` list or a non-empty `custom` string (a skipped question has
+* neither and stays out of the count). Returns `N/M answered`, or undefined
+* when the text is not the expected answer JSON (the caller then falls back
+* to the generic presentation instead of inventing a count).
+* @param text - the settled result text.
+* @returns the answered-count summary, or undefined when unparseable.
+*/
+function askAnswersSummary(text) {
+	const entries = parseAnswerEntries(text);
+	if (entries === void 0) return void 0;
+	return `${entries.filter((entry) => entry.selected.length > 0 || entry.custom !== "").length}/${entries.length} answered`;
+}
+/**
+* The per-question display lines for a settled `ask_user_question` result
+* (the expanded card's body, complementing {@link askAnswersSummary}'s
+* count). Parses the tool's `{"answers":[…]}` render text and renders one
+* line per entry: `● <id> → <selected, custom>` for an answered question,
+* `○ <id> — skipped` when neither is present. Shares the normalization with
+* {@link askAnswersSummary}, so the rendered rows and the count always
+* agree; an unparseable/malformed text returns undefined.
+* @param text - the settled result text.
+* @returns the display lines, or undefined when unparseable/malformed.
+*/
+function askAnswersLines(text) {
+	const entries = parseAnswerEntries(text);
+	if (entries === void 0) return void 0;
+	return entries.map((entry) => {
+		if (entry.selected.length > 0) return {
+			text: `● ${entry.id} → ${entry.selected.join(", ")}`,
+			skipped: false
+		};
+		if (entry.custom !== "") return {
+			text: `● ${entry.id} → ${entry.custom}`,
+			skipped: false
+		};
+		return {
+			text: `○ ${entry.id} — skipped`,
+			skipped: true
+		};
+	});
+}
+/** Parse a settled goal-tool result text, or undefined when it is not the
+* expected `{"goal":…}` JSON (the caller then falls back to the generic
+* presentation). */
+function parseGoalResult(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const value = parsed;
+	if (value.goal === null) return { goal: null };
+	if (typeof value.goal !== "object" || value.goal === null) return void 0;
+	const goal = value.goal;
+	const blocked = typeof goal.blockedReason === "object" && goal.blockedReason !== null ? goal.blockedReason : void 0;
+	return {
+		goal: {
+			...typeof goal.id === "string" ? { id: goal.id } : {},
+			...typeof goal.revision === "number" ? { revision: goal.revision } : {},
+			...typeof goal.objective === "string" ? { objective: goal.objective } : {},
+			...typeof goal.phase === "string" ? { phase: goal.phase } : {},
+			...typeof goal.roundsStarted === "number" ? { roundsStarted: goal.roundsStarted } : {},
+			...typeof goal.maxGoalRounds === "number" ? { maxGoalRounds: goal.maxGoalRounds } : {},
+			...blocked !== void 0 ? { blockedReason: {
+				...typeof blocked.code === "string" ? { code: blocked.code } : {},
+				...typeof blocked.message === "string" ? { message: blocked.message } : {}
+			} } : {}
+		},
+		...typeof value.activation === "string" ? { activation: value.activation } : {}
+	};
+}
+/**
+* The one-line folded summary for a settled goal-tool result: `phase … ·
+* revision N · N/M rounds`, or `no goal set` for `{"goal":null}`.
+* Returns undefined when the text is not the expected result JSON (the
+* caller then falls back to the generic preview instead of inventing one).
+* @param text - the settled result text.
+*/
+function goalResultSummary(text) {
+	const value = parseGoalResult(text);
+	if (value === void 0) return void 0;
+	const goal = value.goal;
+	if (goal === null) return "no goal set";
+	const parts = [];
+	if (goal.phase !== void 0) parts.push(`phase ${goal.phase}`);
+	if (goal.revision !== void 0) parts.push(`revision ${goal.revision}`);
+	if (goal.roundsStarted !== void 0) parts.push(goal.maxGoalRounds === void 0 ? `${goal.roundsStarted} rounds` : `${goal.roundsStarted}/${goal.maxGoalRounds} rounds`);
+	return parts.length === 0 ? "goal" : parts.join(" · ");
+}
+/**
+* The expanded-card display lines for a settled goal-tool result: one field
+* per line (`● objective: …`, `● phase: … · revision N`, `● rounds: N/M`,
+* `● activation: …`, `● blocked: code — message`), or a single `no goal
+* set` line for `{"goal":null}`. Returns undefined when the text is not the
+* expected result JSON (the caller falls back to the generic presentation).
+* @param text - the settled result text.
+*/
+function goalResultLines(text) {
+	const value = parseGoalResult(text);
+	if (value === void 0) return void 0;
+	const goal = value.goal;
+	if (goal === null) return ["no goal set"];
+	const lines = [];
+	if (goal.objective !== void 0 && goal.objective !== "") lines.push(`● objective: ${goal.objective}`);
+	const identity = [];
+	if (typeof goal.phase === "string" && goal.phase !== "") identity.push(goal.phase);
+	if (goal.revision !== void 0) identity.push(`revision ${goal.revision}`);
+	if (identity.length > 0) lines.push(`● ${identity.join(" · ")}`);
+	if (goal.roundsStarted !== void 0) lines.push(goal.maxGoalRounds === void 0 ? `● rounds: ${goal.roundsStarted}` : `● rounds: ${goal.roundsStarted}/${goal.maxGoalRounds}`);
+	const blocked = goal.blockedReason;
+	if (blocked !== void 0 && (blocked.code !== void 0 || blocked.message !== void 0)) {
+		const detail = [blocked.code, blocked.message].filter((part) => typeof part === "string" && part !== "").join(" — ");
+		lines.push(`● blocked: ${detail}`);
+	}
+	if (value.activation !== void 0) lines.push(`● activation: ${value.activation}`);
+	return lines;
+}
+/**
+* The folded-card call preview for tools whose args carry a one-line
+* identity (Web TodoRow/WebRow folded parity): `todo_write` summarizes
+* `done/total` plus the first active item, `web_search`/`web_fetch` show
+* the query/URL. Empty for every other tool (their folded row keeps the
+* header + result preview).
+* @param name - the tool name.
+* @param argsRaw - the raw arguments JSON.
+* @returns the preview line, or '' when the tool has none.
+*/
+function foldedCallPreview(name, argsRaw) {
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null) return "";
+	const args = parsed;
+	if (name === "todo_write") {
+		const summary = summarizeToolArgs(name, argsRaw);
+		return summary === void 0 ? "" : ` — ${summary}`;
+	}
+	if (name === "web_search") {
+		const query = args.query;
+		return typeof query === "string" && query !== "" ? ` — ${firstLine(query)}` : "";
+	}
+	if (name === "web_fetch") {
+		const url = args.url;
+		return typeof url === "string" && url !== "" ? ` — ${firstLine(url)}` : "";
+	}
+	if (name === "skill") {
+		const skill = args.name;
+		return typeof skill === "string" && skill !== "" ? ` — ${firstLine(skill)}` : "";
+	}
+	return "";
+}
+/**
+* The Focus compact Tool line for one raw tool call: presenter-first,
+* static fallback second (plan §9.1/§9.4). The tool-owned presentCall
+* view wins when the live registry has one; otherwise the Web row-model
+* header (toolCardHeader) renders the same semantic. The fold stores the
+* RAW call facts — this helper is the ONLY place the compact line is
+* formatted, so the TranscriptFolder never bakes presentation strings.
+* @param tool - the raw call facts (name + raw arguments JSON).
+* @param options - the live presenter bridge and the workspace root for
+*   path relativization (both optional — replay degrades to the fallback).
+* @returns the one-line display, e.g. `Load skill session-review`,
+*   `Read src/index.ts`, `vendor_probe cache-01`.
+*/
+function focusToolDisplay(tool, options = {}) {
+	const owned = options.presenter?.call(tool.name, tool.args);
+	if (owned !== void 0) return formatOwnedCallForCompactFocus(tool.name, owned);
+	return focusToolFallbackDisplay(tool.name, tool.args, options.cwd);
+}
+/** The compact line from a tool-owned presentCall view. The official shell
+* presenters split the COMMAND (`title` / `rawInput`) from the human
+* `description` that is "shown in the UI"; the Focus Tool slot is a
+* description surface, so it prefers that description and never re-derives
+* the command from args. Because a description alone loses the tool's
+* identity, the two description-backed paths (foreground terminal and
+* background generic execute) prefix it with the human-facing tool title —
+* `Bash · Show working tree status`. Every other path keeps the previous
+* title / rawInput behavior, and the terminal title's FULL command still
+* renders in the expanded tool card — the compact row is exactly ONE
+* physical framebuffer row, so only a first logical line may surface here. */
+function formatOwnedCallForCompactFocus(name, view) {
+	if (view.card === "terminal") {
+		const description = firstLine((view.description ?? "").replace(/\r\n|\r/g, "\n")).trim();
+		if (description !== "") return `${compactFocusToolIdentity(name)} · ${description}`;
+		return firstLine(view.title.replace(/\r\n|\r/g, "\n"));
+	}
+	if (view.card === "diff") return firstLine(view.title.replace(/\r\n|\r/g, "\n"));
+	if (view.kind === "execute") {
+		const description = firstContentText(view);
+		if (description !== void 0) return `${compactFocusToolIdentity(name)} · ${description}`;
+	}
+	const raw = typeof view.rawInput === "string" ? view.rawInput.trim() : void 0;
+	if (raw === void 0 || raw === "") return view.title;
+	return view.title.endsWith(raw) ? view.title : `${view.title} ${firstLine(raw)}`;
+}
+/** The human-facing tool identity for a description-backed compact row.
+* Reuses the formal title mapping; a name it resolves only to the generic
+* `Tool`/`tool` keeps its raw name so a custom tool is never flattened to a
+* meaningless `Tool · description` (same unknown-tool identity principle as
+* the static fallback). */
+function compactFocusToolIdentity(name) {
+	const title = toolTitle(name);
+	return title === "Tool" || title === "tool" ? name : title;
+}
+/** The first meaningful text block of a call view's content as one logical
+* line — the official Bash background presenter puts its human description
+* in `content[0]`. Undefined when no non-blank text block exists. */
+function firstContentText(view) {
+	for (const block of view.content ?? []) {
+		if (block.type !== "text") continue;
+		const line = firstLine(block.text.replace(/\r\n|\r/g, "\n")).trim();
+		if (line !== "") return line;
+	}
+}
+/** The compact line from the static Web row-model header (replay /
+* registry-unavailable fallback). An unknown tool's header title is the
+* generic "Tool call" — the compact line names the actual tool instead
+* (plan §9.3: an unknown custom tool is still a Tool). */
+function focusToolFallbackDisplay(name, argsRaw, cwd) {
+	const action = compactToolPresentation(name, argsRaw);
+	if (action !== void 0) return `${action.summary === void 0 ? action.title : `${action.title} ${action.summary}`}${action.payload === void 0 || action.payload === "" ? "" : ` · ${firstLine(action.payload)}`}`;
+	const header = toolCardHeader(name, argsRaw, cwd);
+	if (!(classifyTool(name) !== "others" || TOOL_TITLES[name] !== void 0 || TUI_TOOL_TITLES[name] !== void 0)) return header.summary === "" ? name : header.summary.replace(" · ", " ");
+	return header.summary === "" ? header.title : `${header.title} ${header.summary}`;
+}
+/**
+* Build the presentation bridge over a tool-definition lookup (the runner
+* passes a scoped registry read, e.g. `ctx.get('tools')?.get(name, scope)`).
+* Mirrors the host apiproxy's presenter invocations: args are JSON-parsed and
+* the callbacks are guarded so a throwing tool presenter degrades to the
+* generic card. An absent registry yields no views, so the cards fall back to
+* the generic presentation instead of failing.
+* @param get - resolve one tool definition by name (scope already applied).
+*/
+function toolPresenterFrom(get) {
+	return {
+		call(name, argsRaw) {
+			const definition = get(name);
+			if (definition?.presentCall === void 0) return void 0;
+			const parsed = parseArgs(argsRaw);
+			if (parsed === void 0) return void 0;
+			try {
+				return definition.presentCall(parsed);
+			} catch {
+				return;
+			}
+		},
+		result(name, argsRaw, result) {
+			const definition = get(name);
+			if (definition?.presentResult === void 0) return void 0;
+			const parsed = parseArgs(argsRaw);
+			if (parsed === void 0) return void 0;
+			try {
+				return definition.presentResult(parsed, {
+					content: [...result.content],
+					isError: result.isError,
+					...result.meta === void 0 ? {} : { meta: result.meta }
+				});
+			} catch {
+				return;
+			}
+		}
+	};
+}
+/**
+* Subagent-family tool names whose call args may carry an explicit
+* model/provider override. Matched by REGISTERED name; unknown names are
+* ignored so third-party subagent-like tools keep their default rendering.
+*/
+const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"subagent",
+	"subagent_route",
+	"subagent_router",
+	"subagent_fork"
+]);
+/**
+* Extract the model · provider display line for a subagent-family tool call.
+*
+* COMPATIBILITY CONTRACT: the line renders ONLY when the call args actually
+* carry a model/provider — the top-level `model`/`provider` shape
+* (subagent_route / subagent_router) or the `agentOptions.model/provider`
+* shape. Every other call returns `undefined` and the card renders exactly
+* as before; unknown tool names and unparseable args are ignored. The
+* official `subagent` tool's model lives in deployment config (never in
+* the call args), so it naturally renders nothing.
+* @param name - the tool's registered name.
+* @param argsRaw - the raw tool-call arguments JSON ('' or malformed → none).
+* @returns `model · provider` (either part alone when only one is present),
+*   or undefined when the call carries no model/provider.
+*/
+function subagentModelDisplay(name, argsRaw) {
+	if (!SUBAGENT_TOOL_NAMES.has(name)) return void 0;
+	const parsed = parseArgs(argsRaw);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	const args = parsed;
+	const opts = typeof args.agentOptions === "object" && args.agentOptions !== null ? args.agentOptions : void 0;
+	const parts = [typeof args.model === "string" && args.model !== "" ? args.model : typeof opts?.model === "string" && opts.model !== "" ? opts.model : void 0, typeof args.provider === "string" && args.provider !== "" ? args.provider : typeof opts?.provider === "string" && opts.provider !== "" ? opts.provider : void 0].filter((part) => part !== void 0);
+	return parts.length === 0 ? void 0 : parts.join(" · ");
+}
+//#endregion
+//#region src/tui/transcript/context-structure.ts
+/**
+* Renderer-neutral ambient Context presentation structure.
+*
+* The semantic question "is this row an ambient Context fact?" belongs to the
+* canonical semantic source (`domain/transcript/context-semantics.ts`). THIS module owns the presentation question: "which
+* presentation role does one surfaced Context row take, and where do adjacent
+* ambient facts form ONE presentation container with ONE owner?".
+*
+* Clustering is computed from RAW transcript chronology. Hiding Process rows in
+* a projection must never merge two Context rows that were not adjacent in the
+* raw transcript. The module is deliberately renderer-free: it never reads
+* width, theme, icons, preset, disclosure state, search state or a component.
+* @module @xmoon76/dsh-pi-tui/tui/transcript/context-structure
+*/
+/** Whether one row is a standalone producer notice. */
+function isNoticeContext(message) {
+	return isSurfacedContext(message) && contextFormOf(message) === "notice";
+}
+/** Whether one row is another Agent's relayed message. */
+function isRelayContext(message) {
+	return isSurfacedContext(message) && contextFormOf(message) === "relay";
+}
+/** Whether one row is recalled material from another session. The legacy
+* session-reference role counts even when its producer did not declare the
+* form, so a recalled row is never clustered as ambient. The A-layer provenance
+* accessor is private to the transitional semantic source, so the legacy role
+* is read from the row's own field here. */
+function isRecallContext(message) {
+	if (!isSurfacedContext(message)) return false;
+	if (contextFormOf(message) === "recall") return true;
+	return message.kind === "system" && message.contextPresentation?.role === "recall";
+}
+/** The presentation role of one injected Context row; undefined when the row
+* is not surfaced Context. Unknown/missing forms fail open to `generic`
+* (standalone), never to ambient. */
+function contextPresentationKind(message) {
+	if (!isSurfacedContext(message)) return void 0;
+	if (isAmbientContext(message)) return "ambient";
+	if (isNoticeContext(message)) return "notice";
+	if (isRelayContext(message)) return "relay";
+	if (isRecallContext(message)) return "recall";
+	return "generic";
+}
+/**
+* Group raw-adjacent same-turn ambient Context rows into clusters.
+*
+* A cluster forms ONLY when every requirement holds: same turn, raw-adjacent
+* TranscriptMessage rows, each row surfaced Context, each row ambient form.
+* A single eligible row stays an ordinary ambient row (no cluster). Every
+* non-ambient boundary (Conversation, Process, Attention, notice, relay,
+* recall, unknown Context, workflow, compaction, window summary, turn
+* boundary) ends the current run.
+* @param messages - the transcript window in raw chronology.
+*/
+function clusterAdjacentAmbientContext(messages) {
+	const clusters = [];
+	let run = [];
+	const flush = () => {
+		const first = run[0];
+		if (first !== void 0 && run.length >= 2) clusters.push({
+			kind: "context-cluster",
+			turn: first.turn,
+			members: run,
+			owner: first
+		});
+		run = [];
+	};
+	for (const message of messages) {
+		if (isAmbientContext(message)) {
+			const first = run[0];
+			if (first !== void 0 && first.turn !== message.turn) flush();
+			run.push(message);
+			continue;
+		}
+		flush();
+	}
+	flush();
+	const byMember = /* @__PURE__ */ new Map();
+	for (const cluster of clusters) for (const member of cluster.members) byMember.set(member, cluster);
+	return {
+		clusters,
+		byMember
+	};
+}
+//#endregion
+//#region src/tui/transcript/structure.ts
+/**
+* Canonical preset-neutral transcript structure projection.
+*
+* This module owns the ONE semantic segmentation of a raw transcript window:
+* maximal contiguous same-turn Process runs become {@link TranscriptWorkSpan}s
+* and raw-adjacent same-turn ambient Context runs become
+* {@link ContextCluster}s (every other semantic boundary ends a run). It is
+* deliberately blind to the active preset, the surface, disclosure state,
+* search state, render width and the renderer registry: it answers only
+* "where does the raw chronology form Work, a Context cluster, or a
+* standalone row?".
+*
+* `projectCompact()` is the Compact materialization adapter over this
+* structure, Full materializes it with expanded-flat Work and the shared
+* cluster presentation, and expanded Focus consumes it for its process tail.
+* The same boundary identity is therefore never re-derived per preset.
+*
+* The projector is a single forward pass plus the linear ambient-clustering
+* pass (O(n)); wrappers are freshly allocated each call, but their
+* `owner`/`members` always reference the original `TranscriptMessage`
+* objects, so presentation caches can compare owner + member identity/order.
+* @module @xmoon76/dsh-pi-tui/tui/transcript/structure
+*/
+/**
+* Whether one row continues the current Work run. Process rows with a turn
+* number extend the run only while the turn is unchanged; turn-less rows
+* (window summaries, standalone control-plane commands) never enter Work by
+* construction — a `kind: 'command'` row has no turn and a `control` class.
+* A settled surfaced-interaction card (question / Plan review) is
+* human-decision evidence, not Process work — it never joins a span (and so
+* never counts toward its tool count/preview); it flushes the run and
+* renders standalone. Exported so the live Preparing ownership consumes the
+* SAME boundary authority as every projection: a settled interaction closes
+* the trailing run.
+*/
+function isTranscriptWorkMember(message) {
+	return "turn" in message && classifyTranscriptMessage(message).class === "process" && !isSurfacedInteractionTool(message) && !isPostTurnReplayEvidence(message);
+}
+/**
+* Segment one raw transcript window into canonical structural blocks.
+*
+* Ambient Context clusters are computed FIRST from raw adjacency, so a hidden
+* Process row can never merge two Context rows that were not adjacent, and a
+* cluster is a Work boundary exactly like a standalone Context row. A settled
+* surfaced-interaction card is its own boundary and belongs to neither the
+* preceding nor the following span. The result partitions `messages` exactly:
+* every input row appears once, in raw order, either as a `message` block, a
+* Work member, or a cluster member.
+* @param messages - the transcript window in raw chronology.
+*/
+function projectTranscriptStructure(messages) {
+	const clustering = clusterAdjacentAmbientContext(messages);
+	const out = [];
+	let run = [];
+	let runTurn;
+	const flush = () => {
+		const owner = run[0];
+		if (owner !== void 0 && runTurn !== void 0) out.push({
+			kind: "work",
+			span: {
+				kind: "work",
+				turn: runTurn,
+				members: run,
+				owner
+			}
+		});
+		run = [];
+		runTurn = void 0;
+	};
+	for (const message of messages) {
+		const cluster = clustering.byMember.get(message);
+		if (cluster !== void 0) {
+			flush();
+			if (message === cluster.owner) out.push({
+				kind: "context-cluster",
+				cluster
+			});
+			continue;
+		}
+		if (isSurfacedInteractionTool(message)) {
+			flush();
+			out.push({
+				kind: "message",
+				message
+			});
+			continue;
+		}
+		if (isTranscriptWorkMember(message)) {
+			if (run.length > 0 && runTurn !== message.turn) flush();
+			run.push(message);
+			runTurn = message.turn;
+			continue;
+		}
+		flush();
+		out.push({
+			kind: "message",
+			message
+		});
+	}
+	flush();
+	return out;
+}
+/**
+* Map every Work member to its canonical span in one linear pass. Disclosure,
+* search and pruning read Work ownership through THIS index instead of
+* scanning a preset materialization (or re-projecting Compact) merely to ask
+* "which Work span owns this row?".
+* @param structure - the canonical structural blocks for one window.
+*/
+function workByMemberOf(structure) {
+	const byMember = /* @__PURE__ */ new Map();
+	for (const block of structure) {
+		if (block.kind !== "work") continue;
+		for (const member of block.span.members) byMember.set(member, block.span);
+	}
+	return byMember;
+}
+/**
+* Map every Context-cluster member to its canonical cluster. Presentation
+* layers that reorder or hoist rows (collapsed/expanded Focus) consume THIS
+* identity instead of re-clustering the reordered sequence, so canonical
+* membership stays the only cluster authority.
+* @param structure - the canonical structural blocks for one window.
+*/
+function clusterByMemberOf(structure) {
+	const byMember = /* @__PURE__ */ new Map();
+	for (const block of structure) {
+		if (block.kind !== "context-cluster") continue;
+		for (const member of block.cluster.members) byMember.set(member, block.cluster);
+	}
+	return byMember;
+}
+//#endregion
+//#region src/tui/transcript/context-summary.ts
+/**
+* Renderer-neutral structured summary of one ambient Context cluster.
+*
+* The collapsed cluster header summarizes its members from STRUCTURED
+* provenance only — each row's producer label or its declared form, never
+* arbitrary payload text. Duplicate labels compress to `label ×N` for display
+* only: the underlying transcript rows are never deduplicated, reordered or
+* removed.
+*
+* This module derives strings only; the header chrome (disclosure marker,
+* identity icon, theme, width) belongs to the PiTui component in
+* `tui/components/transcript/context-cluster.ts`.
+* @module @xmoon76/dsh-pi-tui/tui/transcript/context-summary
+*/
+/** The structured display name of one ambient Context member: its producer
+* label, else its declared form, else the generic role name. Never payload
+* text. */
+function memberDisplayName(member) {
+	if (member.kind !== "system") return "Context";
+	if (member.label !== void 0 && member.label !== "") return member.label;
+	const form = contextFormOf(member);
+	return form === void 0 ? "Context" : form;
+}
+/**
+* The compressed summary parts of one cluster, in first-seen member order:
+* consecutive runs of the same display name become `name ×N`. Display-only —
+* the caller must not treat the parts as the member list.
+*/
+function contextClusterSummaryParts(cluster) {
+	const parts = [];
+	const counts = /* @__PURE__ */ new Map();
+	const order = [];
+	for (const member of cluster.members) {
+		const name = memberDisplayName(member);
+		const seen = counts.get(name);
+		if (seen === void 0) {
+			counts.set(name, 1);
+			order.push(name);
+		} else counts.set(name, seen + 1);
+	}
+	for (const name of order) {
+		const count = counts.get(name) ?? 1;
+		parts.push(count > 1 ? `${name} ×${count}` : name);
+	}
+	return parts;
+}
+//#endregion
+export { sessionRowMatchesQuery as $, resultTextLines as A, writeFoldedPreview as B, parseCallPreview as C, isSurfacedInteractionTool as Ct, parseWriteEnvelope as D, openOpaqueBlockFallbackText as Dt, parseSkillEnvelope as E, finalizedBlockFallbackText as Et, toolIconSemantic as F, sessionLabelParts as G, findSessionMatch as H, toolPresenterFrom as I, shortSessionId as J, sessionPickerItem as K, toolSummaryKeys as L, subagentModelDisplay as M, systemContextBody as N, readFoldedPreview as O, textWithAttachmentMarkers as Ot, toolCardHeader as P, sanitizeSessionSearchInput as Q, toolTitle as R, isCompactActionTool as S, isSurfacedContext as St, parseReadEnvelopes as T, markPostTurnReplayEvidence as Tt, formatSessionAge as U, fileAttachmentSummary as V, sanitizeTerminalText as W, buildSessionTree as X, workspaceKey as Y, sameWorkspace as Z, foldedResultSummaryFor as _, contextIconSemantic as _t, workByMemberOf as a, formatLeaderSequence as at, goalResultSummary as b, contextSummary as bt, FOLDED_JSON_RESULT_TOOLS as c, PROVIDER_DEFAULT as ct, askAnswersSummary as d, modelIdentity as dt, HISTORY_CHORDS as et, compactToolExpandedLines as f, projectModelDirectory as ft, foldedCallPreview as g, contextFormOf as gt, focusToolDisplay as h, runSyncDisposalStepsWithPrimary as ht, projectTranscriptStructure as i, formatKeyId as it, skillFoldedPreview as j, relativizeToCwd as k, userBlocksVisibleNow as kt, GOAL_TOOL_NAMES as l, effortChoicesOf as lt, firstLine as m, runSyncDisposalSteps as mt, clusterByMemberOf as n, TSP_CONTINUED_INSPECTION_LABEL as nt, contextPresentationKind as o, isBuiltInPresetRow as ot, compactToolPresentation as p, formatBytes as pt, sessionSearchItem as q, isTranscriptWorkMember as r, formatHintKeys as rt, isNoticeContext as s, presetDisplayText as st, contextClusterSummaryParts as t, JOB_LOCAL_KEYS as tt, askAnswersLines as u, initialEffortOf as ut, genericRawInputLines as v, contextPresentation as vt, parseImageEnvelope as w, isSurfacedInteractionToolName as wt, imageFoldedPreview as x, isPostTurnReplayEvidence as xt, goalResultLines as y, contextProvenance as yt, webCardLines as z };