@danypops/papyrus 0.11.4 → 0.13.0

package/extension/src/task-focus-events.ts

@@ -0,0 +1,57 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { PAPYRUS_TASK_FOCUS_CHANNEL, PAPYRUS_TASK_FOCUS_SCHEMA } from "../../src/constants.ts";
+
+export type TaskFocusStatus = "focused" | "paused" | "unpaused" | "cleared";
+
+export interface TaskFocusEvent {
+	schema: typeof PAPYRUS_TASK_FOCUS_SCHEMA;
+	taskId: string | null;
+	sessionId?: string;
+	status: TaskFocusStatus;
+	observedAt: number;
+}
+
+export interface TaskFocusEventInput {
+	taskId: string | null;
+	sessionId?: string;
+	status: TaskFocusStatus;
+	observedAt?: number;
+}
+
+/**
+ * Pure event builder, mirroring buildContextInjection's shape: no task title, body, or any other
+ * artifact content -- only the id, session, lifecycle status, and timestamp, which are already
+ * public metadata a caller with the id could look up directly. This is the payload emitted on
+ * papyrus.task-focus.v1, the analogue of papyrus.context-injection.v1, so extensions such as a
+ * token-cost router can correlate their own telemetry with the currently focused task without
+ * Papyrus depending on them.
+ */
+export function buildTaskFocusEvent(input: TaskFocusEventInput): TaskFocusEvent {
+	if (input.status !== "cleared" && input.taskId === null) throw new Error(`task-focus event of status "${input.status}" requires a taskId`);
+	return {
+		schema: PAPYRUS_TASK_FOCUS_SCHEMA,
+		taskId: input.taskId,
+		status: input.status,
+		observedAt: input.observedAt ?? Date.now(),
+		...(input.sessionId === undefined ? {} : { sessionId: input.sessionId }),
+	};
+}
+
+type EventBusHost = Pick<ExtensionAPI, "events">;
+
+let bus: EventBusHost | undefined;
+
+/** Call once from the extension entry point so call sites that only receive `ctx` (not `pi`) can still emit. */
+export function setTaskFocusEventBus(host: EventBusHost): void {
+	bus = host;
+}
+
+export function resetTaskFocusEventBusForTests(): void {
+	bus = undefined;
+}
+
+/** Best-effort broadcast: never throws, since a missing bus (e.g. an uninitialized test harness) must not break the focus operation it accompanies. */
+export function emitTaskFocusEvent(input: TaskFocusEventInput): void {
+	if (!bus) return;
+	bus.events.emit(PAPYRUS_TASK_FOCUS_CHANNEL, buildTaskFocusEvent(input));
+}

package/extension/src/task-widget.ts

@@ -8,6 +8,18 @@ export interface TaskWidgetRow {
 	hasOpenChildren: boolean;
 	active: boolean;
 	focusStatus?: "active" | "paused";
+	/**
+	 * Task containment is a DAG, not a tree: a task may have more than one parent (design
+	 * decision -- see decide-and-execute... no single-parent enforcement was ever wanted).
+	 * This bounded widget still renders one spanning tree (it only has room for one position
+	 * per task), so a multi-parent task is only ever shown once, under whichever parent this
+	 * walk reaches first -- exactly the git-log-graph / npm-ls-dedup pattern of picking one
+	 * canonical position and flagging the rest, rather than silently dropping the information.
+	 * parentCount > 1 means "this task also lives under other parents not shown here" --
+	 * the full DAG (every parent edge, not just one) is always available via the task graph's
+	 * composition view, which renders true multi-parent edges through Mermaid's flowchart layout.
+	 */
+	parentCount: number;
 }
 
 export interface TaskWidgetProjection {
@@ -36,7 +48,7 @@ export function buildTaskWidgetProjection(
 		if (!node) return;
 		visited.add(id);
 		const open = isOpen(node.task);
-		if (open) ordered.push({ task: node.task, depth: openDepth, hasOpenChildren: false, active: node.active === true, focusStatus: node.focusStatus });
+		if (open) ordered.push({ task: node.task, depth: openDepth, hasOpenChildren: false, active: node.active === true, focusStatus: node.focusStatus, parentCount: node.parentIds.length });
 		const childDepth = open ? openDepth + 1 : openDepth;
 		for (const childId of node.childIds) visit(childId, childDepth);
 	};

package/extension/src/tasks.ts

@@ -7,6 +7,7 @@ import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder, rawKeyHint } from "@earendil-works/pi-coding-agent";
 import { Container, Input, Spacer, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { callService } from "./service-client.ts";
+import { emitTaskFocusEvent } from "./task-focus-events.ts";
 import { showTaskDetails } from "./task-detail-view.ts";
 import { showTaskGraph } from "./task-graph.ts";
 
@@ -56,10 +57,11 @@ export function buildTaskHierarchy(graph: TaskGraph): TaskHierarchyRow[] {
 	return result;
 }
 
-async function loadTaskGraph(projectRoot: string, scope?: "project" | "graph" | "all", rootTaskId?: string): Promise<TaskGraph> {
+async function loadTaskGraph(projectRoot: string, sessionId: string, scope?: "project" | "graph" | "all", rootTaskId?: string): Promise<TaskGraph> {
 	return callService<Record<string, unknown>, TaskGraph>("tasks.graph", {
 		limit: 200,
 		project_root: projectRoot,
+		session_id: sessionId,
 		...(scope ? { scope } : {}),
 		...(rootTaskId ? { root_task_id: rootTaskId } : {}),
 	});
@@ -70,14 +72,17 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 		ctx.ui.notify("/tasks requires interactive mode", "warning");
 		return;
 	}
-	let graph = await loadTaskGraph(ctx.cwd);
+	// Scopes this panel's "active"/Focus reads and writes to this Pi session, so a second
+	// concurrent agent working the same project never appears as (or is overridden by) this one.
+	const sessionId = ctx.sessionManager.getSessionId();
+	let graph = await loadTaskGraph(ctx.cwd, sessionId);
 	if (graph.nodes.length === 0) {
 		const create = await ctx.ui.select("No tasks yet", ["Create a task", "Cancel"]);
 		if (create === "Create a task") {
 			const title = await ctx.ui.input("Task title:", "");
 			if (title) {
-				await callService("tasks.create", { title, project_root: ctx.cwd, actor: "user", source: "tasks-tui" });
-				graph = await loadTaskGraph(ctx.cwd);
+				await callService("tasks.create", { title, project_root: ctx.cwd, actor: "user", source: "tasks-tui", session_id: sessionId });
+				graph = await loadTaskGraph(ctx.cwd, sessionId);
 			}
 		}
 		if (graph.nodes.length === 0) return;
@@ -86,14 +91,14 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 	for (;;) {
 		const action = await renderPanel(ctx, graph);
 		if (!action) return;
-		if (action.type === "refresh") { graph = await loadTaskGraph(ctx.cwd); continue; }
+		if (action.type === "refresh") { graph = await loadTaskGraph(ctx.cwd, sessionId); continue; }
 		if (action.type === "scope") {
 			const choice = await ctx.ui.select("Task scope", ["Current project", "Focused graph", "All projects"]);
 			if (!choice) continue;
 			const scope: "project" | "graph" | "all" = choice === "Current project" ? "project" : choice === "All projects" ? "all" : "graph";
 			let rootTaskId: string | undefined;
 			if (scope === "graph") {
-				const projectGraph = await loadTaskGraph(ctx.cwd, "project");
+				const projectGraph = await loadTaskGraph(ctx.cwd, sessionId, "project");
 				const roots = projectGraph.rootIds.map((id) => projectGraph.nodes.find((node) => node.task.id === id)?.task).filter((task): task is Artifact => task !== undefined);
 				const selected = await ctx.ui.select("Focused root or epic", roots.map((task) => `${task.title} · ${task.id}`));
 				if (!selected) continue;
@@ -101,25 +106,49 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 				if (!rootTaskId) continue;
 			}
 			await callService("tasks.set_scope", { project_root: ctx.cwd, scope, ...(rootTaskId ? { root_task_id: rootTaskId } : {}) });
-			graph = await loadTaskGraph(ctx.cwd);
+			graph = await loadTaskGraph(ctx.cwd, sessionId);
 			continue;
 		}
 		if (action.type === "graph") { await showTaskGraph(ctx, graph); continue; }
 		if (action.type !== "action" || !action.row) continue;
 
-		const active = graph.nodes.find((node) => node.task.id === action.row!.id)?.active === true;
-		const focusStatus = graph.nodes.find((node) => node.task.id === action.row!.id)?.focusStatus;
+		const node = graph.nodes.find((entry) => entry.task.id === action.row!.id);
+		const active = node?.active === true;
+		const focusStatus = node?.focusStatus;
 		const choices = [
 			"Show details",
 			"Edit task",
 			...(!active && action.row.status !== "done" && action.row.status !== "canceled" ? ["Make active"] : []),
 			...(active ? [focusStatus === "paused" ? "Resume focus" : "Pause focus", "Clear focus"] : []),
 			...(action.row.status === "review" ? ["Run gates"] : []),
+			...((node?.dependencyIds.length ?? 0) > 0 ? ["Remove dependency"] : []),
+			...((node?.parentIds.length ?? 0) > 0 ? ["Remove from parent"] : []),
 			...(STATUS_ACTIONS[action.row.status] ?? []),
 		];
 		const choice = await ctx.ui.select(action.row.title, choices);
 		if (!choice) continue;
 
+		if (choice === "Remove dependency" || choice === "Remove from parent") {
+			const relatedIds = choice === "Remove dependency" ? node!.dependencyIds : node!.parentIds;
+			const relatedTitles = relatedIds.map((relatedId) => `${graph.nodes.find((entry) => entry.task.id === relatedId)?.task.title ?? relatedId} · ${relatedId}`);
+			const selected = await ctx.ui.select(choice === "Remove dependency" ? "Remove which dependency?" : "Remove from which parent?", relatedTitles);
+			if (!selected) continue;
+			const relatedId = relatedIds[relatedTitles.indexOf(selected)]!;
+			try {
+				if (choice === "Remove dependency") {
+					await callService("tasks.undepend", { id: action.row.id, dependency_id: relatedId, actor: "user", source: "tasks-tui", session_id: sessionId });
+					ctx.ui.notify(`Removed dependency on ${relatedId}`, "info");
+				} else {
+					await callService("tasks.uncontain", { parent_id: relatedId, child_id: action.row.id, actor: "user", source: "tasks-tui", session_id: sessionId });
+					ctx.ui.notify(`Removed from parent ${relatedId}`, "info");
+				}
+			} catch (error) {
+				ctx.ui.notify(`Relationship removal failed: ${error instanceof Error ? error.message : error}`, "error");
+			}
+			graph = await loadTaskGraph(ctx.cwd, sessionId);
+			continue;
+		}
+
 		if (choice === "Show details") {
 			const art = await callService<Record<string, unknown>, Artifact | null>("tasks.show", { id: action.row.id });
 			if (!art) { ctx.ui.notify("Not found", "error"); continue; }
@@ -146,15 +175,22 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 			}
 		} else if (choice === "Make active") {
 			try {
-				await callService<Record<string, unknown>, Artifact>("tasks.focus", { id: action.row.id, actor: "user", source: "tasks-tui" });
+				const focused = await callService<Record<string, unknown>, Artifact>("tasks.focus", { id: action.row.id, actor: "user", source: "tasks-tui", session_id: sessionId });
+				emitTaskFocusEvent({ taskId: focused.id, sessionId, status: "focused" });
 				ctx.ui.notify(`Active: ${action.row.title}`, "info");
 			} catch (error) {
 				ctx.ui.notify(`Focus failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
 		} else if (choice === "Pause focus" || choice === "Resume focus" || choice === "Clear focus") {
 			try {
-				const operation = choice === "Pause focus" ? "tasks.pause" : choice === "Resume focus" ? "tasks.unpause" : "tasks.clear_focus";
-				await callService(operation, { actor: "user", source: "tasks-tui" });
+				if (choice === "Clear focus") {
+					await callService("tasks.clear_focus", { actor: "user", source: "tasks-tui", session_id: sessionId });
+					emitTaskFocusEvent({ taskId: null, sessionId, status: "cleared" });
+				} else {
+					const operation = choice === "Pause focus" ? "tasks.pause" : "tasks.unpause";
+					const result = await callService<Record<string, unknown>, { artifact: Artifact; status: string }>(operation, { actor: "user", source: "tasks-tui", session_id: sessionId });
+					emitTaskFocusEvent({ taskId: result.artifact.id, sessionId, status: choice === "Pause focus" ? "paused" : "unpaused" });
+				}
 				ctx.ui.notify(choice === "Clear focus" ? "Task focus cleared" : choice, "info");
 			} catch (error) {
 				ctx.ui.notify(`Focus action failed: ${error instanceof Error ? error.message : error}`, "error");
@@ -180,7 +216,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 									? "tasks.cancel"
 									: "tasks.complete";
 				if (operation === "tasks.complete") {
-					const result = await callService<Record<string, unknown>, TaskCompletion>(operation, { id: action.row.id, actor: "user", source: "tasks-tui" });
+					const result = await callService<Record<string, unknown>, TaskCompletion>(operation, { id: action.row.id, actor: "user", source: "tasks-tui", session_id: sessionId });
 					action.row.status = result.artifact.status;
 					const gates = result.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.gate.type}: ${gate.gate.target}`).join("\n");
 					const checklist = result.checklist.map((item) => `${item.accepted ? "✓" : "✗"} proof: ${item.item}`).join("\n");
@@ -195,7 +231,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 						result.completed ? "info" : "warning",
 					);
 				} else {
-					const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: action.row.id, actor: "user", source: "tasks-tui" });
+					const updated = await callService<Record<string, unknown>, Artifact>(operation, { id: action.row.id, actor: "user", source: "tasks-tui", session_id: sessionId });
 					action.row.status = updated.status;
 					ctx.ui.notify(`${updated.id} → [${updated.status}]`, "info");
 				}
@@ -203,7 +239,7 @@ export async function showTasks(ctx: ExtensionCommandContext): Promise<void> {
 				ctx.ui.notify(`Task action failed: ${error instanceof Error ? error.message : error}`, "error");
 			}
 		}
-		graph = await loadTaskGraph(ctx.cwd);
+		graph = await loadTaskGraph(ctx.cwd, sessionId);
 	}
 }
 

package/extension/src/tool-rendering/artifact-card.ts

@@ -0,0 +1,117 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { ArtifactToolDetails } from "./render-model.ts";
+
+const KIND_GLYPHS: Readonly<Record<string, string>> = {
+	task: "◇",
+	doc: "▤",
+	rule: "◆",
+	skill: "✦",
+};
+
+const STATUS_GLYPHS: Readonly<Record<string, string>> = {
+	done: "✓",
+	active: "●",
+	"in-progress": "●",
+	review: "◐",
+	rejected: "✗",
+	canceled: "×",
+	todo: "○",
+	draft: "○",
+	archived: "·",
+	deprecated: "·",
+};
+
+type SemanticColor = "success" | "error" | "warning" | "accent" | "muted";
+
+function statusColor(status: string): SemanticColor {
+	if (status === "done" || status === "active") return "success";
+	if (status === "rejected" || status === "canceled") return "error";
+	if (status === "review") return "warning";
+	if (status === "in-progress") return "accent";
+	return "muted";
+}
+
+export function kindGlyph(kind: string): string {
+	return KIND_GLYPHS[kind] ?? "•";
+}
+
+export function statusGlyph(status: string): string {
+	return STATUS_GLYPHS[status] ?? "•";
+}
+
+export function countSummary(returned: number, total: number): string {
+	return returned === total ? String(total) : `${returned} of ${total}`;
+}
+
+export function emptyState(noun: string): string {
+	return `No ${noun}.`;
+}
+
+export function treeConnector(last: boolean): string {
+	return last ? "└─" : "├─";
+}
+
+export function expandHint(): string {
+	return "expand for details";
+}
+
+/** Reusable width-safe artifact card for native tool result rows. */
+export class ArtifactCard implements Component {
+	private details: ArtifactToolDetails;
+	private theme: Theme;
+	private expanded: boolean;
+	private cachedWidth: number | undefined;
+	private cachedLines: string[] | undefined;
+
+	constructor(details: ArtifactToolDetails, theme: Theme, expanded: boolean) {
+		this.details = details;
+		this.theme = theme;
+		this.expanded = expanded;
+	}
+
+	update(details: ArtifactToolDetails, theme: Theme, expanded: boolean): void {
+		this.details = details;
+		this.theme = theme;
+		this.expanded = expanded;
+		this.invalidate();
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		if (this.cachedLines && this.cachedWidth === safeWidth) return this.cachedLines;
+
+		const artifact = this.details.artifact;
+		const status = `${statusGlyph(artifact.status)} ${artifact.status}`;
+		const header = [
+			this.theme.fg("toolTitle", this.theme.bold(`${kindGlyph(artifact.kind)} ${artifact.kind.toUpperCase()}`)),
+			this.theme.fg("accent", artifact.id),
+			this.theme.fg(statusColor(artifact.status), status),
+		].join("  ");
+		const lines = [truncateToWidth(header, safeWidth)];
+		lines.push(truncateToWidth(this.theme.fg("text", artifact.title), safeWidth));
+
+		if (this.expanded) {
+			const metadata = [artifact.subtype, ...artifact.labels].filter(Boolean).join(" · ");
+			if (metadata) lines.push(truncateToWidth(this.theme.fg("muted", metadata), safeWidth));
+			if (artifact.body) lines.push(...wrapTextWithAnsi(artifact.body, safeWidth));
+			if (this.details.completeness.truncated) {
+				lines.push(truncateToWidth(
+					this.theme.fg("warning", `[truncated ${this.details.completeness.omitted} characters]`),
+					safeWidth,
+				));
+			}
+		} else if (artifact.body || artifact.labels.length > 0) {
+			lines.push(truncateToWidth(this.theme.fg("dim", expandHint()), safeWidth));
+		}
+
+		this.cachedWidth = safeWidth;
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}

package/extension/src/tool-rendering/artifact-list.ts

@@ -0,0 +1,179 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, truncateToWidth } from "@earendil-works/pi-tui";
+import { TOOL_COLLAPSED_ROW_LIMIT } from "../../../src/constants.ts";
+import { countSummary, expandHint, kindGlyph, statusGlyph, treeConnector } from "./artifact-card.ts";
+import type {
+	ArtifactListToolDetails,
+	GraphToolDetails,
+	ToolArtifactSummary,
+} from "./render-model.ts";
+
+function pluralKind(rows: readonly ToolArtifactSummary[]): string {
+	const kind = rows[0]?.kind ?? "artifact";
+	if (kind === "task") return "tasks";
+	if (kind === "doc") return "documents";
+	if (kind === "skill") return "skills";
+	if (kind === "rule") return "rules";
+	return "artifacts";
+}
+
+function statusSummary(rows: readonly ToolArtifactSummary[]): string {
+	const counts = new Map<string, number>();
+	for (const row of rows) counts.set(row.status, (counts.get(row.status) ?? 0) + 1);
+	return [...counts.entries()].map(([status, count]) => `${status} ${count}`).join(" · ");
+}
+
+function rowLine(row: ToolArtifactSummary, expanded: boolean, theme: Theme): string {
+	const identity = expanded ? `${row.id}  ` : "";
+	return [
+		theme.fg("muted", `${statusGlyph(row.status)} ${row.status}`),
+		theme.fg("accent", identity),
+		theme.fg("text", row.title),
+	].join("  ");
+}
+
+function rowMetadata(row: ToolArtifactSummary): string {
+	return [row.subtype, ...row.labels].filter(Boolean).join(" · ");
+}
+
+/** Bounded collapsed/expanded artifact collection presentation. */
+export class ArtifactListCard implements Component {
+	private details: ArtifactListToolDetails;
+	private theme: Theme;
+	private expanded: boolean;
+	private cachedWidth: number | undefined;
+	private cachedLines: string[] | undefined;
+
+	constructor(details: ArtifactListToolDetails, theme: Theme, expanded: boolean) {
+		this.details = details;
+		this.theme = theme;
+		this.expanded = expanded;
+	}
+
+	update(details: ArtifactListToolDetails, theme: Theme, expanded: boolean): void {
+		this.details = details;
+		this.theme = theme;
+		this.expanded = expanded;
+		this.invalidate();
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		if (this.cachedLines && this.cachedWidth === safeWidth) return this.cachedLines;
+		const rows = this.details.rows;
+		const noun = pluralKind(rows);
+		const lines = [truncateToWidth(
+			this.theme.fg("toolTitle", this.theme.bold(`${countSummary(rows.length, this.details.total)} ${noun}`)),
+			safeWidth,
+		)];
+		if (rows.length === 0) {
+			lines.push(truncateToWidth(this.theme.fg("dim", `No ${noun}.`), safeWidth));
+		} else {
+			lines.push(truncateToWidth(this.theme.fg("muted", statusSummary(rows)), safeWidth));
+			const display = this.expanded ? rows : rows.slice(0, TOOL_COLLAPSED_ROW_LIMIT);
+			for (const row of display) {
+				lines.push(truncateToWidth(rowLine(row, this.expanded, this.theme), safeWidth));
+				if (this.expanded) {
+					const metadata = rowMetadata(row);
+					if (metadata) lines.push(truncateToWidth(this.theme.fg("dim", `  ${metadata}`), safeWidth));
+				}
+			}
+			const omitted = Math.max(0, this.details.total - display.length);
+			if (omitted > 0) lines.push(truncateToWidth(this.theme.fg("dim", `${omitted} more · ${expandHint()}`), safeWidth));
+		}
+		this.cachedWidth = safeWidth;
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}
+
+interface HierarchyRow {
+	node: ToolArtifactSummary;
+	prefix: string;
+	connector: string;
+}
+
+function hierarchyRows(details: GraphToolDetails): HierarchyRow[] {
+	const byId = new Map(details.nodes.map((node) => [node.id, node]));
+	const childIds = new Map<string, string[]>();
+	const contained = new Set<string>();
+	for (const edge of details.edges) {
+		if (edge.relation !== "contains" || !byId.has(edge.from) || !byId.has(edge.to)) continue;
+		const children = childIds.get(edge.from) ?? [];
+		children.push(edge.to);
+		childIds.set(edge.from, children);
+		contained.add(edge.to);
+	}
+	const roots = details.nodes.filter((node) => !contained.has(node.id));
+	const rows: HierarchyRow[] = [];
+	const visited = new Set<string>();
+	const visit = (node: ToolArtifactSummary, prefix: string, connector: string): void => {
+		if (visited.has(node.id)) return;
+		visited.add(node.id);
+		rows.push({ node, prefix, connector });
+		const children = (childIds.get(node.id) ?? []).map((id) => byId.get(id)).filter((child): child is ToolArtifactSummary => child !== undefined);
+		children.forEach((child, index) => {
+			const last = index === children.length - 1;
+			visit(child, `${prefix}${connector ? (connector === "└─" ? "  " : "│ ") : ""}`, treeConnector(last));
+		});
+	};
+	for (const root of roots) visit(root, "", "");
+	for (const node of details.nodes) visit(node, "", "");
+	return rows;
+}
+
+/** Bounded task containment preview; dependency graphs use the dedicated graph renderer. */
+export class TaskHierarchyPreview implements Component {
+	private details: GraphToolDetails;
+	private theme: Theme;
+	private expanded: boolean;
+	private cachedWidth: number | undefined;
+	private cachedLines: string[] | undefined;
+
+	constructor(details: GraphToolDetails, theme: Theme, expanded: boolean) {
+		this.details = details;
+		this.theme = theme;
+		this.expanded = expanded;
+	}
+
+	update(details: GraphToolDetails, theme: Theme, expanded: boolean): void {
+		this.details = details;
+		this.theme = theme;
+		this.expanded = expanded;
+		this.invalidate();
+	}
+
+	render(width: number): string[] {
+		const safeWidth = Math.max(1, width);
+		if (this.cachedLines && this.cachedWidth === safeWidth) return this.cachedLines;
+		const rows = hierarchyRows(this.details);
+		const lines = [truncateToWidth(
+			this.theme.fg("toolTitle", this.theme.bold(`${this.details.nodes.length} tasks · ${this.details.edges.length} edges`)),
+			safeWidth,
+		)];
+		for (const row of rows) {
+			const identity = this.expanded ? `${row.node.id}  ` : "";
+			lines.push(truncateToWidth(
+				`${row.prefix}${row.connector}${row.connector ? " " : ""}${this.theme.fg("accent", kindGlyph(row.node.kind))} ${this.theme.fg("muted", statusGlyph(row.node.status))} ${this.theme.fg("accent", identity)}${this.theme.fg("text", row.node.title)}`,
+				safeWidth,
+			));
+			if (this.expanded) {
+				const metadata = rowMetadata(row.node);
+				if (metadata) lines.push(truncateToWidth(this.theme.fg("dim", `${row.prefix}   ${metadata}`), safeWidth));
+			}
+		}
+		this.cachedWidth = safeWidth;
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}

package/extension/src/tool-rendering/index.ts

@@ -0,0 +1,107 @@
+import type {
+	AgentToolResult,
+	Theme,
+	ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, Text } from "@earendil-works/pi-tui";
+import { ArtifactCard } from "./artifact-card.ts";
+import { ArtifactListCard, TaskHierarchyPreview } from "./artifact-list.ts";
+import { parsePapyrusToolDetails, type PapyrusToolDetails } from "./render-model.ts";
+
+const CALL_VALUE_MAX_CHARACTERS = 80;
+
+export interface PapyrusToolRenderContext {
+	lastComponent: Component | undefined;
+	isError: boolean;
+}
+
+function primaryArgument(args: Record<string, unknown>): string | undefined {
+	for (const key of ["id", "title", "text", "query", "kind", "template_id"]) {
+		const value = args[key];
+		if (typeof value === "string" && value.trim()) return value.slice(0, CALL_VALUE_MAX_CHARACTERS);
+	}
+	return undefined;
+}
+
+/** Compact native call header that never echoes bodies or structured payloads. */
+export function renderPapyrusToolCall(label: string, args: Record<string, unknown>, theme: Theme): Component {
+	const action = typeof args.action === "string" ? args.action : "call";
+	const primary = primaryArgument(args);
+	const text = [
+		theme.fg("toolTitle", theme.bold(label)),
+		theme.fg("muted", action),
+		...(primary ? [theme.fg("accent", primary)] : []),
+	].join("  ");
+	return new Text(text, 0, 0);
+}
+
+function textContent(result: AgentToolResult<unknown>): string {
+	return result.content
+		.filter((entry): entry is { type: "text"; text: string } => entry.type === "text")
+		.map((entry) => entry.text)
+		.join("\n");
+}
+
+function simpleDetailsText(details: Exclude<PapyrusToolDetails, { kind: "artifact" | "artifact-list" | "graph" }>): string {
+	switch (details.kind) {
+		case "transition":
+			return `✓ ${details.artifact.id}  ${details.fromStatus} → ${details.toStatus}\n${details.artifact.title}`;
+		case "gate-run": {
+			const passed = details.gates.filter((gate) => gate.passed).length;
+			return [
+				`${passed}/${details.gates.length} gates passed for ${details.artifactId}`,
+				...details.gates.map((gate) => `${gate.passed ? "✓" : "✗"} ${gate.type}: ${gate.target}${gate.output ? ` — ${gate.output}` : ""}`),
+			].join("\n");
+		}
+		case "invocation":
+			return [
+				`✓ Run ${details.runId}`,
+				`${details.created.tasks.length} tasks · ${details.created.docs.length} docs · ${details.created.rules.length} rules`,
+				...(details.created.roots.length ? [`Roots: ${details.created.roots.join(", ")}`] : []),
+			].join("\n");
+		case "preview":
+			return `${details.title}\n${details.content}${details.completeness.truncated ? `\n[truncated ${details.completeness.omitted} characters]` : ""}`;
+		case "error":
+			return `${details.code}: ${details.message}`;
+	}
+}
+
+/** Render structured details for humans while preserving compact model content as fallback. */
+export function renderPapyrusToolResult(
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	context: PapyrusToolRenderContext,
+): Component {
+	if (options.isPartial) return new Text(theme.fg("warning", "Working…"), 0, 0);
+	const details = parsePapyrusToolDetails(result.details);
+	if (!details) return new Text(theme.fg("toolOutput", textContent(result)), 0, 0);
+
+	if (details.kind === "artifact") {
+		const previous = context.lastComponent instanceof ArtifactCard ? context.lastComponent : undefined;
+		if (previous) {
+			previous.update(details, theme, options.expanded);
+			return previous;
+		}
+		return new ArtifactCard(details, theme, options.expanded);
+	}
+	if (details.kind === "artifact-list") {
+		const previous = context.lastComponent instanceof ArtifactListCard ? context.lastComponent : undefined;
+		if (previous) {
+			previous.update(details, theme, options.expanded);
+			return previous;
+		}
+		return new ArtifactListCard(details, theme, options.expanded);
+	}
+	if (details.kind === "graph") {
+		const previous = context.lastComponent instanceof TaskHierarchyPreview ? context.lastComponent : undefined;
+		if (previous) {
+			previous.update(details, theme, options.expanded);
+			return previous;
+		}
+		return new TaskHierarchyPreview(details, theme, options.expanded);
+	}
+
+	const color = details.kind === "error" || context.isError ? "error" : "toolOutput";
+	return new Text(theme.fg(color, simpleDetailsText(details)), 0, 0);
+}