@asterxsk/kiln 0.3.0 → 0.4.0

package/agent.bak.20260905-190020/extensions/todo/state/store.ts

@@ -1,82 +0,0 @@
-import type { Task } from "../tool/types.js";
-import { EMPTY_STATE, type TaskState } from "./state.js";
-
-/**
- * Per-session live state cells, keyed by session id.
- *
- * A single module-level cell was shared between the main session and any
- * in-process subagent session in the same Node process (the extension module
- * is loaded once and cached by URL), so both sessions read/wrote and replayed
- * into the same todos. Keying by `ctx.sessionManager.getSessionId()` gives
- * every session — main or subagent — its own independent state cell.
- *
- * The store remains the single mutation seam and the reducer stays pure.
- */
-const states = new Map<string, TaskState>();
-
-/** Fresh empty state (new array instance — never share EMPTY_STATE itself). */
-export function emptyState(): TaskState {
-	return { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
-}
-
-function cell(sessionId: string): TaskState {
-	let s = states.get(sessionId);
-	if (!s) {
-		s = emptyState();
-		states.set(sessionId, s);
-	}
-	return s;
-}
-
-/**
- * Live tasks accessor. Returned `readonly Task[]` so callers (overlay render
- * hook, `/todos` command) cannot mutate the live cell. Consumers must not cast
- * back.
- */
-export function getTodos(sessionId: string): readonly Task[] {
-	return cell(sessionId).tasks;
-}
-
-export function getNextId(sessionId: string): number {
-	return cell(sessionId).nextId;
-}
-
-/** Snapshot accessor used by reducer callers to pass canonical state in. */
-export function getState(sessionId: string): TaskState {
-	return cell(sessionId);
-}
-
-/**
- * Replay seam. Lifecycle handlers in `index.ts` call this on
- * `session_start` / `session_compact` / `session_tree` after
- * `replayFromBranch` decodes the latest snapshot.
- */
-export function replaceState(sessionId: string, next: TaskState): void {
-	states.set(sessionId, next);
-}
-
-/**
- * Post-reducer commit seam. Tool execute() calls this with the reducer's
- * `state` output to publish the new canonical state to live readers (overlay,
- * `/todos`).
- */
-export function commitState(sessionId: string, next: TaskState): void {
-	states.set(sessionId, next);
-}
-
-/**
- * Drop a session's cell (called on session_shutdown so cells for ended
- * subagent sessions don't accumulate for the life of the process).
- */
-export function dropState(sessionId: string): void {
-	states.delete(sessionId);
-}
-
-/**
- * Test-setup reset. Wired into the global `test/setup.ts` `beforeEach` via
- * the existing `__resetState` import path. Name preserved verbatim — see
- * Plan §Decisions §Decision 7.
- */
-export function __resetState(): void {
-	states.clear();
-}

package/agent.bak.20260905-190020/extensions/todo/state/task-graph.ts

@@ -1,57 +0,0 @@
-import type { Task } from "../tool/types.js";
-
-/**
- * Detect whether merging `newBlockedBy` into `taskId`'s `blockedBy` set would
- * introduce a cycle in the dependency graph.
- *
- * Pure of any module state; takes the existing `taskList` and the proposed
- * additions explicitly so the reducer can ask "would this update cycle?"
- * without mutating state first.
- */
-export function detectCycle(taskList: readonly Task[], taskId: number, newBlockedBy: readonly number[]): boolean {
-	const edges = new Map<number, number[]>();
-	for (const t of taskList) {
-		if (t.id === taskId) {
-			const merged = new Set([...(t.blockedBy ?? []), ...newBlockedBy]);
-			edges.set(t.id, [...merged]);
-		} else {
-			edges.set(t.id, t.blockedBy ? [...t.blockedBy] : []);
-		}
-	}
-
-	const visiting = new Set<number>();
-	const visited = new Set<number>();
-	const hasCycleFrom = (node: number): boolean => {
-		if (visiting.has(node)) return true;
-		if (visited.has(node)) return false;
-		visiting.add(node);
-		for (const nb of edges.get(node) ?? []) {
-			if (hasCycleFrom(nb)) return true;
-		}
-		visiting.delete(node);
-		visited.add(node);
-		return false;
-	};
-
-	for (const node of edges.keys()) {
-		if (hasCycleFrom(node)) return true;
-	}
-	return false;
-}
-
-/**
- * Build the inverse adjacency map: for each task `T`, which other tasks list
- * `T` in their `blockedBy`. Consumed by `selectShowTaskIds` (overlay gating)
- * and the `get` action's "blocks: #x, #y" suffix line.
- */
-export function deriveBlocks(taskList: readonly Task[]): Map<number, number[]> {
-	const blocks = new Map<number, number[]>();
-	for (const t of taskList) {
-		for (const dep of t.blockedBy ?? []) {
-			const arr = blocks.get(dep) ?? [];
-			arr.push(t.id);
-			blocks.set(dep, arr);
-		}
-	}
-	return blocks;
-}

package/agent.bak.20260905-190020/extensions/todo/todo-overlay.ts

@@ -1,204 +0,0 @@
-/**
- * todo-overlay.ts — Persistent widget showing todo list above the editor.
- *
- * Lifecycle controller for Pi's `setWidget` contract: factory-form
- * registration in widgetContainerAbove, register-once + requestRender()
- * refresh, 12-line collapse-not-scroll, auto-hide when empty.
- *
- * Reads live state via `getState()` at render time — NEVER `replayFromBranch`
- * from `tool_execution_end` (branch is stale; `message_end` runs after).
- */
-
-import type { ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
-import { type TUI, truncateToWidth } from "@earendil-works/pi-tui";
-import { selectOverlayLayout, selectShowTaskIds, selectTodoCounts } from "./state/selectors.js";
-import { getState } from "./state/store.js";
-import { formatOverlayTaskLine } from "./view/format.js";
-import { hideOrderedWidget, setOrderedWidget } from "./widget-order.js";
-
-const WIDGET_KEY = "rpiv-todos";
-// Budget for content rows (heading + tasks/overflow).
-// Reduced by 1 to account for the "Plan · X/Y" header.
-const MAX_WIDGET_LINES = 12;
-
-
-export class TodoOverlay {
-	private uiCtx: ExtensionUIContext | undefined;
-	/** Session whose todos this overlay renders (bound at session_start). */
-	private sessionId: string | undefined;
-	private widgetRegistered = false;
-	private tui: TUI | undefined;
-	private completedTaskIdsPendingHide = new Set<number>();
-	private hiddenCompletedTaskIds = new Set<number>();
-	private lastNextId: number | undefined;
-	private agentTurnActive = false;
-
-	/** Bind the overlay to a session's todo cell (re-bound on session switch). */
-	setSession(sessionId: string): void {
-		if (sessionId !== this.sessionId) {
-			this.sessionId = sessionId;
-			this.resetCompletedDisplayState();
-		}
-	}
-
-	setUICtx(ctx: ExtensionUIContext): void {
-		// Identity-compare so repeat session_start handlers are idempotent;
-		// on identity change (/reload) invalidate so update() re-registers.
-		if (ctx !== this.uiCtx) {
-			this.uiCtx = ctx;
-			this.widgetRegistered = false;
-			this.tui = undefined;
-		}
-	}
-
-	/** Mark agent turn as active — widget will be visible when todos exist. */
-	onAgentTurnStart(): void {
-		this.agentTurnActive = true;
-		this.update();
-	}
-
-	/** Mark agent turn as ended — hide the widget immediately. */
-	onAgentTurnEnd(): void {
-		this.agentTurnActive = false;
-		this.hideWidget();
-	}
-
-	update(): void {
-		if (!this.uiCtx) return;
-
-		// Widget only visible during active agent turns
-		if (!this.agentTurnActive) {
-			this.hideWidget();
-			return;
-		}
-
-		const snapshot = this.getSnapshot();
-		const visible = this.selectOverlayTasks(snapshot);
-
-		if (visible.length === 0) {
-			this.hideWidget();
-			return;
-		}
-
-		if (!this.widgetRegistered) {
-			// Ordered helper re-applies todos → background-terminals →
-			// subagents top-to-bottom, so todos stay furthest from the input
-			// no matter which widget updated last.
-			setOrderedWidget(
-				WIDGET_KEY,
-				(tui, theme) => {
-					this.tui = tui;
-					return {
-						render: (width: number) => this.renderWidget(theme, width),
-						invalidate: () => {
-							this.widgetRegistered = false;
-							this.tui = undefined;
-						},
-					};
-				},
-				{ placement: "aboveEditor" },
-			);
-			this.widgetRegistered = true;
-		} else {
-			this.tui?.requestRender();
-		}
-	}
-
-	/** Hide the widget if currently registered. */
-	private hideWidget(): void {
-		if (this.widgetRegistered && this.uiCtx) {
-			hideOrderedWidget(this.uiCtx, WIDGET_KEY);
-			this.widgetRegistered = false;
-			this.tui = undefined;
-		}
-	}
-
-	resetCompletedDisplayState(): void {
-		this.completedTaskIdsPendingHide.clear();
-		this.hiddenCompletedTaskIds.clear();
-		this.lastNextId = undefined;
-	}
-
-	hideCompletedTasksFromPreviousTurn(): void {
-		if (this.completedTaskIdsPendingHide.size === 0) return;
-		for (const taskId of this.completedTaskIdsPendingHide) {
-			this.hiddenCompletedTaskIds.add(taskId);
-		}
-		this.completedTaskIdsPendingHide.clear();
-		this.tui?.requestRender();
-	}
-
-	private getSnapshot() {
-		const state = this.sessionId ? getState(this.sessionId) : { tasks: [], nextId: 1 };
-		if (this.lastNextId !== undefined && state.nextId < this.lastNextId) {
-			this.resetCompletedDisplayState();
-		}
-		this.lastNextId = state.nextId;
-		const completedTaskIds = new Set(
-			state.tasks.filter((task) => task.status === "completed").map((task) => task.id),
-		);
-		for (const taskId of this.completedTaskIdsPendingHide) {
-			if (!completedTaskIds.has(taskId)) this.completedTaskIdsPendingHide.delete(taskId);
-		}
-		for (const taskId of this.hiddenCompletedTaskIds) {
-			if (!completedTaskIds.has(taskId)) this.hiddenCompletedTaskIds.delete(taskId);
-		}
-		return { tasks: [...state.tasks], nextId: state.nextId };
-	}
-
-	private selectOverlayTasks(snapshot: ReturnType<TodoOverlay["getSnapshot"]>) {
-		return snapshot.tasks.filter((task) => task.status !== "deleted" && !this.shouldHideCompletedTask(task));
-	}
-
-	private shouldHideCompletedTask(task: ReturnType<TodoOverlay["getSnapshot"]>["tasks"][number]): boolean {
-		return task.status === "completed" && this.hiddenCompletedTaskIds.has(task.id);
-	}
-
-	private renderWidget(theme: Theme, width: number): string[] {
-		const snapshot = this.getSnapshot();
-		const overlayTasks = this.selectOverlayTasks(snapshot);
-		if (overlayTasks.length === 0) return [];
-
-		const overlayState = { tasks: overlayTasks, nextId: snapshot.nextId };
-		const truncate = (line: string): string => truncateToWidth(line, width, "…");
-		const counts = selectTodoCounts(overlayState);
-		const showIds = selectShowTaskIds(overlayState);
-
-		const lines: string[] = [];
-		lines.push(truncate(theme.fg("dim", `Plan · ${counts.completed}/${counts.total}`)));
-		const layout = selectOverlayLayout(overlayState, MAX_WIDGET_LINES - 2);
-		for (let i = 0; i < layout.visible.length; i++) {
-			const prefix = "┃ ";
-			lines.push(truncate(formatOverlayTaskLine(layout.visible[i], theme, showIds, prefix)));
-		}
-
-		const newlyDisplayedCompletedTaskIds = overlayTasks
-			.filter(
-				(task) =>
-					task.status === "completed" &&
-					!this.completedTaskIdsPendingHide.has(task.id) &&
-					!this.hiddenCompletedTaskIds.has(task.id),
-			)
-			.map((task) => task.id);
-		for (const taskId of newlyDisplayedCompletedTaskIds) {
-			this.completedTaskIdsPendingHide.add(taskId);
-		}
-
-		if (layout.hiddenCompleted > 0 || layout.truncatedTail > 0) {
-			const totalHidden = layout.hiddenCompleted + layout.truncatedTail;
-			lines.push(truncate(`┃ ${theme.fg("dim", `(... ${totalHidden} more)`)}`));
-		}
-		return lines;
-	}
-
-
-
-	dispose(): void {
-		if (this.uiCtx) hideOrderedWidget(this.uiCtx, WIDGET_KEY);
-		this.widgetRegistered = false;
-		this.tui = undefined;
-		this.uiCtx = undefined;
-		this.agentTurnActive = false;
-		this.resetCompletedDisplayState();
-	}
-}

package/agent.bak.20260905-190020/extensions/todo/todo.ts

@@ -1,155 +0,0 @@
-/**
- * todo tool + /todos command — thin registration shell.
- *
- * Tool/command identity, schema, types, reducer, store, replay, response
- * envelope, selectors, and view formatters live in the layered modules under
- * `tool/`, `state/`, and `view/`. This file is the package-root registration
- * surface — it mirrors `packages/rpiv-ask-user-question/ask-user-question.ts`
- * which keeps the tool registration at the package root.
- *
- * Public re-exports below preserve the pre-refactor import surface so that
- * `index.ts`, `todo-overlay.ts`, and the global `test/setup.ts` `beforeEach`
- * continue to import from `./todo.js`.
- */
-
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { loadConfig, validateGuidanceFields } from "./config.js";
-import { formatStatusLabel, t } from "./state/i18n-bridge.js";
-import { replayFromBranch } from "./state/replay.js";
-import { selectTasksByStatus, selectTodoCounts, selectVisibleTasks } from "./state/selectors.js";
-import { applyTaskMutation } from "./state/state-reducer.js";
-import { commitState, getState, replaceState } from "./state/store.js";
-import { buildToolResult } from "./tool/response-envelope.js";
-import {
-	COMMAND_NAME,
-	ERR_REQUIRES_INTERACTIVE,
-	MSG_NO_TODOS,
-	type TaskMutationParams,
-	TOOL_LABEL,
-	TOOL_NAME,
-	TodoParamsSchema,
-} from "./tool/types.js";
-import { formatCommandTaskLine, renderTodoCall, renderTodoResult } from "./view/format.js";
-
-// English fallbacks for localized /todos section headers — the box-drawing
-// decoration is part of the localized string so translators can adjust spacing.
-const SECTION_PENDING = "── Pending ──";
-const SECTION_IN_PROGRESS = "── In Progress ──";
-const SECTION_COMPLETED = "── Completed ──";
-
-// ---------------------------------------------------------------------------
-// Public re-exports — pre-refactor consumers (overlay, tests, index.ts) keep
-// importing from `./todo.js`. New code may opt into deeper imports.
-// ---------------------------------------------------------------------------
-
-export { isTransitionValid } from "./state/invariants.js";
-export { applyTaskMutation } from "./state/state-reducer.js";
-export { __resetState, getNextId, getTodos } from "./state/store.js";
-
-/** Resolve the session id that scopes todo state for this ctx. */
-export function sessionIdOf(ctx: { sessionManager: { getSessionId(): string } }): string {
-	return ctx.sessionManager.getSessionId();
-}
-export { deriveBlocks, detectCycle } from "./state/task-graph.js";
-export type { Task, TaskAction, TaskDetails, TaskStatus } from "./tool/types.js";
-export { TOOL_NAME } from "./tool/types.js";
-
-/**
- * Backward-compat replay shim. Pre-refactor `reconstructTodoState(ctx)`
- * mutated module state directly; the new replay seam (`state/replay.ts`)
- * returns a `TaskState` and the caller commits via `replaceState`.
- */
-export function reconstructTodoState(
-	ctx: Parameters<typeof replayFromBranch>[0] & { sessionManager: { getSessionId(): string } },
-): void {
-	replaceState(sessionIdOf(ctx), replayFromBranch(ctx));
-}
-
-// ---------------------------------------------------------------------------
-// Tool registration
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_PROMPT_SNIPPET = "Manage a task list to track multi-step progress";
-export const DEFAULT_PROMPT_GUIDELINES: string[] = [
-	"Use `todo` for multi-step work (3+ steps), a user task list, or right after new instructions. Skip for trivial/single tasks and chit-chat.",
-	"Mark in_progress BEFORE work; mark completed IMMEDIATELY when done (never batch). Exactly one in_progress at a time. Never complete if tests fail or work is partial — keep in_progress and add a blocker task. Status: pending→in_progress→completed (+deleted tombstone); pass activeForm when in_progress.",
-	"Use blockedBy for dependencies; on update use addBlockedBy/removeBlockedBy (additive merge, don't resend the full array). Cycles rejected.",
-	"Subject short + imperative; description = long-form detail; activeForm = present-continuous label. list hides deleted by default (includeDeleted:true to show); pass status to filter.",
-	"batch = multiple create/update/delete/clear ops in one call, applied in order; if any fails, all abort. No list/get inside batch.",
-];
-
-export function registerTodoTool(pi: ExtensionAPI): void {
-	const guidance = validateGuidanceFields(loadConfig().guidance);
-	pi.registerTool({
-		name: TOOL_NAME,
-		label: TOOL_LABEL,
-		description:
-			"Manage a task list for multi-step work. Actions: create, update, list, get, delete (tombstone), clear, batch (atomic multi-op). Status: pending→in_progress→completed (+deleted tombstone).",
-		promptSnippet: guidance.promptSnippet ?? DEFAULT_PROMPT_SNIPPET,
-		promptGuidelines: guidance.promptGuidelines ?? DEFAULT_PROMPT_GUIDELINES,
-		parameters: TodoParamsSchema,
-
-		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			const sessionId = sessionIdOf(ctx);
-			const result = applyTaskMutation(getState(sessionId), params.action, params as TaskMutationParams);
-			commitState(sessionId, result.state);
-			return buildToolResult(params.action, params as TaskMutationParams, result.state, result.op);
-		},
-
-		renderShell: "self",
-
-		renderCall() {
-			return new Text("", 0, 0);
-		},
-
-		renderResult() {
-			return new Text("", 0, 0);
-		},
-	});
-}
-
-// ---------------------------------------------------------------------------
-// /todos slash command
-// ---------------------------------------------------------------------------
-
-export function registerTodosCommand(pi: ExtensionAPI): void {
-	pi.registerCommand(COMMAND_NAME, {
-		description: "Show all todos on the current branch, grouped by status",
-		handler: async (_args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify(t("command.requires_interactive", ERR_REQUIRES_INTERACTIVE), "error");
-				return;
-			}
-			const state = getState(ctx.sessionManager.getSessionId());
-			const visible = selectVisibleTasks(state);
-			if (visible.length === 0) {
-				ctx.ui.notify(t("command.no_todos", MSG_NO_TODOS), "info");
-				return;
-			}
-			const groups = selectTasksByStatus(state);
-			const counts = selectTodoCounts(state);
-
-			const header: string[] = [];
-			if (counts.completed > 0) header.push(`${counts.completed}/${counts.total} ${formatStatusLabel("completed")}`);
-			if (counts.inProgress > 0) header.push(`${counts.inProgress} ${formatStatusLabel("in_progress")}`);
-			if (counts.pending > 0) header.push(`${counts.pending} ${formatStatusLabel("pending")}`);
-
-			const lines: string[] = [header.join(" · ")];
-			if (groups.pending.length > 0) {
-				lines.push(t("command.section.pending", SECTION_PENDING));
-				for (const task of groups.pending) lines.push(formatCommandTaskLine(task, "○"));
-			}
-			if (groups.inProgress.length > 0) {
-				lines.push(t("command.section.in_progress", SECTION_IN_PROGRESS));
-				for (const task of groups.inProgress) lines.push(formatCommandTaskLine(task, "◐"));
-			}
-			if (groups.completed.length > 0) {
-				lines.push(t("command.section.completed", SECTION_COMPLETED));
-				for (const task of groups.completed) lines.push(formatCommandTaskLine(task, "✓"));
-			}
-
-			ctx.ui.notify(lines.join("\n"), "info");
-		},
-	});
-}

package/agent.bak.20260905-190020/extensions/todo/tool/response-envelope.ts

@@ -1,109 +0,0 @@
-import type { TaskState } from "../state/state.js";
-import type { Op } from "../state/state-reducer.js";
-import { deriveBlocks } from "../state/task-graph.js";
-import type { Task, TaskAction, TaskDetails, TaskMutationParams } from "./types.js";
-
-/**
- * Format a single task as a `[status] #id subject [(activeForm)] [⛓ #dep,…]`
- * line. Used by the `list` content branch only — the overlay and `/todos`
- * formatting paths use `view/format.ts` for richer presentations.
- */
-function formatListLine(t: Task): string {
-	const block = t.blockedBy?.length ? ` ⛓ ${t.blockedBy.map((id) => `#${id}`).join(",")}` : "";
-	const form = t.status === "in_progress" && t.activeForm ? ` (${t.activeForm})` : "";
-	return `[${t.status}] #${t.id} ${t.subject}${form}${block}`;
-}
-
-/**
- * Multi-line presentation for the `get` action. Order of rows is pinned by
- * pre-refactor `todo.ts:354-376` — description, activeForm, blockedBy, blocks,
- * owner — so envelope-level snapshot tests stay byte-equivalent.
- */
-function formatGetLines(task: Task, state: TaskState): string {
-	const blocks = deriveBlocks(state.tasks).get(task.id) ?? [];
-	const lines = [`#${task.id} [${task.status}] ${task.subject}`];
-	if (task.description) lines.push(`  description: ${task.description}`);
-	if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);
-	if (task.blockedBy?.length) {
-		lines.push(`  blockedBy: ${task.blockedBy.map((id) => `#${id}`).join(", ")}`);
-	}
-	if (blocks.length) {
-		lines.push(`  blocks: ${blocks.map((id) => `#${id}`).join(", ")}`);
-	}
-	if (task.owner) lines.push(`  owner: ${task.owner}`);
-	return lines.join("\n");
-}
-
-/**
- * Pure formatter: `(op, state) → string`. Closed switch on `op.kind` —
- * adding a new `Op` variant fails to compile here until a branch is added.
- * The strings on each branch are byte-equivalent to pre-refactor `todo.ts`
- * reducer output.
- */
-export function formatContent(op: Op, state: TaskState): string {
-	switch (op.kind) {
-		case "create": {
-			const names = op.ids
-				.map((id) => {
-					const t = state.tasks.find((x) => x.id === id);
-					return t ? `#${t.id}: ${t.subject} (pending)` : `#${id}`;
-				})
-				.join(", ");
-			return `Created ${names}`;
-		}
-		case "update": {
-			return op.results
-				.map((r) => {
-					const transition = r.fromStatus !== r.toStatus ? ` (${r.fromStatus} → ${r.toStatus})` : "";
-					return `Updated #${r.id}${transition}`;
-				})
-				.join("\n");
-		}
-		case "delete":
-			return op.items.map((d) => `Deleted #${d.id}: ${d.subject}`).join("\n");
-		case "clear":
-			return `Cleared ${op.count} tasks`;
-		case "list": {
-			let view = state.tasks;
-			if (!op.includeDeleted) view = view.filter((t) => t.status !== "deleted");
-			if (op.statusFilter) view = view.filter((t) => t.status === op.statusFilter);
-			return view.length === 0 ? "No tasks" : view.map(formatListLine).join("\n");
-		}
-		case "get":
-			return op.tasks.map((t) => formatGetLines(t, state)).join("\n");
-		case "batch": {
-			if (op.results.length === 0) return "Batch: 0 operations";
-			const lines = [`Batch: ${op.results.length} operation${op.results.length !== 1 ? "s" : ""}:`];
-			for (const { index, op: sub } of op.results) {
-				lines.push(`  [${index}] ${formatContent(sub, state)}`);
-			}
-			return lines.join("\n");
-		}
-		case "error":
-			return `Error: ${op.message}`;
-	}
-}
-
-/**
- * Build the LLM-facing tool envelope after the store has committed the
- * reducer's new state. `details` is the persistence + replay snapshot —
- * `state/replay.ts` consumes this exact shape on session lifecycle events.
- *
- * Mirrors `packages/rpiv-ask-user-question/tool/response-envelope.ts:13-47`.
- */
-export function buildToolResult(
-	action: TaskAction,
-	params: TaskMutationParams,
-	state: TaskState,
-	op: Op,
-): { content: Array<{ type: "text"; text: string }>; details: TaskDetails } {
-	const text = formatContent(op, state);
-	const details: TaskDetails = {
-		action,
-		params: params as Record<string, unknown>,
-		tasks: state.tasks,
-		nextId: state.nextId,
-		...(op.kind === "error" ? { error: op.message } : {}),
-	};
-	return { content: [{ type: "text", text }], details };
-}