@nklisch/pi-enhanced 0.1.0

package/node_modules/@juicesharp/rpiv-todo/state/task-graph.ts

@@ -0,0 +1,57 @@
+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/node_modules/@juicesharp/rpiv-todo/todo-overlay.ts

@@ -0,0 +1,230 @@
+/**
+ * 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, configurable collapse-not-scroll (default 12 content rows via
+ * getMaxWidgetLines(); plus a trailing spacer row so the widget renders up
+ * to 13 lines), auto-hide when empty.
+ *
+ * Reads live state via `getRenderState()` (the ctx-less foreground slot) 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 { COLLAPSE_KEY_OFF, getMaxWidgetLines, resolveCollapseKey } from "./config.js";
+import { formatStatusLabel, t } from "./state/i18n-bridge.js";
+import { selectHasActive, selectOverlayLayout, selectShowTaskIds, selectTodoCounts } from "./state/selectors.js";
+import { getRenderState } from "./state/store.js";
+import { formatOverlayTaskLine } from "./view/format.js";
+
+const WIDGET_KEY = "rpiv-todos";
+
+// English fallbacks for localized overlay chrome strings.
+const OVERLAY_HEADING = "Todos";
+const OVERLAY_MORE = "more";
+const OVERLAY_EXPAND_HINT = "{key} to expand";
+const OVERLAY_COLLAPSED = "collapsed";
+
+export class TodoOverlay {
+	private uiCtx: ExtensionUIContext | undefined;
+	private widgetRegistered = false;
+	private tui: TUI | undefined;
+	private completedTaskIdsPendingHide = new Set<number>();
+	private hiddenCompletedTaskIds = new Set<number>();
+	private lastNextId: number | undefined;
+	private collapsed = false;
+
+	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;
+		}
+	}
+
+	update(): void {
+		if (!this.uiCtx) return;
+		const snapshot = this.getSnapshot();
+		const visible = this.selectOverlayTasks(snapshot);
+
+		if (visible.length === 0) {
+			if (this.widgetRegistered) {
+				this.uiCtx.setWidget(WIDGET_KEY, undefined);
+				this.widgetRegistered = false;
+				this.tui = undefined;
+			}
+			return;
+		}
+
+		if (!this.widgetRegistered) {
+			this.uiCtx.setWidget(
+				WIDGET_KEY,
+				(tui, factoryTheme) => {
+					this.tui = tui;
+					return {
+						render: (width: number) => this.renderWidget(this.uiCtx?.theme ?? factoryTheme, width),
+						invalidate: () => {
+							// No rendered strings are cached. Pi invalidates on theme changes;
+							// the next render reads uiCtx.theme.
+						},
+					};
+				},
+				{ placement: "aboveEditor" },
+			);
+			this.widgetRegistered = true;
+		} else {
+			this.tui?.requestRender();
+		}
+	}
+
+	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();
+	}
+
+	toggleCollapse(): void {
+		this.collapsed = !this.collapsed;
+		// Forced full redraw on the collapsed↔expanded height step, mirroring the
+		// lane-dock's requestRender(shapeChanged); distinct from the non-forced
+		// requestRender() refresh paths in update()/hideCompletedTasksFromPreviousTurn().
+		this.tui?.requestRender(true);
+	}
+
+	isRegistered(): boolean {
+		return this.widgetRegistered;
+	}
+
+	private getSnapshot() {
+		const state = getRenderState();
+		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 hasActive = selectHasActive(overlayState);
+		const showIds = selectShowTaskIds(overlayState);
+
+		const headingColor = hasActive ? "accent" : "dim";
+		const headingIcon = hasActive ? "●" : "○";
+		const headingText = `${t("overlay.heading", OVERLAY_HEADING)} (${counts.completed}/${counts.total})`;
+		const heading = truncate(`${theme.fg(headingColor, headingIcon)} ${theme.fg(headingColor, headingText)}`);
+
+		// Collapsed view: just the heading + a dim "└─" expand hint, then the
+		// trailing spacer. Short-circuit before the budget math and the completed-
+		// display tracking — nothing is shown to track, and skipping the tracking
+		// when nothing is rendered is correctness, not optimization. The hint splices
+		// the resolved key into the {key} placeholder (per-render, like the row
+		// budget); a config edit needs /reload to re-bind the actual shortcut. The
+		// "off" sentinel is reachable here mid-session (config edited after the
+		// shortcut was bound and the overlay collapsed) — render a static collapsed
+		// label instead of splicing the sentinel into the placeholder.
+		if (this.collapsed) {
+			const key = resolveCollapseKey();
+			const hint =
+				key === COLLAPSE_KEY_OFF
+					? t("overlay.collapsed", OVERLAY_COLLAPSED)
+					: t("overlay.expandHint", OVERLAY_EXPAND_HINT).replace("{key}", key);
+			return this.withTrailingSpacer([heading, truncate(`${theme.fg("dim", "└─")} ${theme.fg("dim", hint)}`)]);
+		}
+
+		const lines: string[] = [heading];
+		// Budget for content rows (heading + tasks/summary). The rendered widget is
+		// one line taller — withTrailingSpacer() appends a blank row below the panel.
+		const layout = selectOverlayLayout(overlayState, getMaxWidgetLines() - 1);
+		for (const task of layout.visible) {
+			lines.push(truncate(`${theme.fg("dim", "├─")} ${formatOverlayTaskLine(task, theme, showIds)}`));
+		}
+
+		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 last = lines.length - 1;
+			lines[last] = lines[last].replace("├─", "└─");
+			return this.withTrailingSpacer(lines);
+		}
+
+		const totalHidden = layout.hiddenCompleted + layout.truncatedTail;
+		const overflowParts: string[] = [];
+		if (layout.hiddenCompleted > 0) overflowParts.push(`${layout.hiddenCompleted} ${formatStatusLabel("completed")}`);
+		if (layout.truncatedTail > 0) overflowParts.push(`${layout.truncatedTail} ${formatStatusLabel("pending")}`);
+		const more = t("overlay.more", OVERLAY_MORE);
+		const summary =
+			overflowParts.length > 0 ? `+${totalHidden} ${more} (${overflowParts.join(", ")})` : `+${totalHidden} ${more}`;
+		lines.push(truncate(`${theme.fg("dim", "└─")} ${theme.fg("dim", summary)}`));
+		return this.withTrailingSpacer(lines);
+	}
+
+	/**
+	 * Append a trailing blank line so the overlay isn't flush against the
+	 * editor box. Pi's host adds a leading spacer above the widget but none
+	 * below, which leaves the last "└─" row (or the "+N more" summary) glued
+	 * to the input box. The empty string gives the "Todos" panel a little
+	 * breathing room.
+	 */
+	private withTrailingSpacer(lines: string[]): string[] {
+		if (lines.length === 0) return lines;
+		lines.push("");
+		return lines;
+	}
+
+	dispose(): void {
+		if (this.uiCtx) this.uiCtx.setWidget(WIDGET_KEY, undefined);
+		this.widgetRegistered = false;
+		this.tui = undefined;
+		this.uiCtx = undefined;
+		this.collapsed = false;
+		this.resetCompletedDisplayState();
+	}
+}

package/node_modules/@juicesharp/rpiv-todo/todo.ts

@@ -0,0 +1,144 @@
+/**
+ * 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 { loadConfig, validateGuidanceFields } from "./config.js";
+import { formatStatusLabel, t } from "./state/i18n-bridge.js";
+import { selectTasksByStatus, selectTodoCounts, selectVisibleTasks } from "./state/selectors.js";
+import { applyTaskMutation } from "./state/state-reducer.js";
+import { commitState, getRenderState, getState, sid } 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, setActiveRenderSession, sid } from "./state/store.js";
+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";
+
+// ---------------------------------------------------------------------------
+// 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 complex work with 3+ steps, when the user gives you a list of tasks, or immediately after receiving new instructions to capture requirements. Skip it for single trivial tasks and purely conversational requests.",
+	"When starting any task, mark it in_progress BEFORE beginning work. Mark it completed IMMEDIATELY when done — never batch completions. Exactly one task should be in_progress at a time.",
+	"Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors — keep it in_progress and create a new task for the blocker instead.",
+	"Task status is a 4-state machine: pending → in_progress → completed, plus deleted as a tombstone. Pass activeForm (present-continuous label, e.g. 'researching existing tool') when marking in_progress.",
+	"Use blockedBy to express dependencies (A is blocked by B). On create, pass blockedBy as the initial set. On update, use addBlockedBy / removeBlockedBy (additive merge — do not resend the full array). Cycles are rejected.",
+	"list hides tombstoned (deleted) tasks by default; pass includeDeleted:true to see them. Pass status to filter by a single status.",
+	"Subject must be short and imperative (e.g. 'Research existing tool'); description is for long-form detail. activeForm is a present-continuous label shown while in_progress.",
+];
+
+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 tracking multi-step progress. Actions: create (new task), update (change status/fields/dependencies), list (all tasks, optionally filtered by status), get (single task details), delete (tombstone), clear (reset all). Status: pending → in_progress → completed, plus deleted tombstone. Use this to plan and track multi-step work like research, design, and implementation.",
+		promptSnippet: guidance.promptSnippet ?? DEFAULT_PROMPT_SNIPPET,
+		promptGuidelines: guidance.promptGuidelines ?? DEFAULT_PROMPT_GUIDELINES,
+		parameters: TodoParamsSchema,
+
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const result = applyTaskMutation(getState(sid(ctx)), params.action, params as TaskMutationParams);
+			commitState(sid(ctx), result.state);
+			return buildToolResult(params.action, params as TaskMutationParams, result.state, result.op);
+		},
+
+		// renderCall reflects the FOREGROUND slot, not the calling session's. Pi's
+		// `ToolRenderContext` carries no session identity (no sessionManager/sessionId),
+		// so this ctx-less hook cannot re-key by caller. For the foreground session's
+		// own transcript that is exactly right. A detached/child call rendered in the
+		// lane-transcript viewer whose task lives only in the child's slot misses the
+		// foreground lookup and falls back to `#<id>` (see renderTodoCall). That is the
+		// safe outcome: per-session ids restart at 1, so searching sibling slots could
+		// surface the WRONG subject — the `#<id>` fallback is intentional, not a gap.
+		renderCall(args, theme, _context) {
+			return renderTodoCall(args as never, theme, getRenderState());
+		},
+
+		renderResult(result, _opts, theme, _context) {
+			return renderTodoResult(result, theme);
+		},
+	});
+}
+
+// ---------------------------------------------------------------------------
+// /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(sid(ctx));
+			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/node_modules/@juicesharp/rpiv-todo/tool/response-envelope.ts

@@ -0,0 +1,97 @@
+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 t = state.tasks.find((x) => x.id === op.taskId);
+			// Defensive — `op.taskId` always resolves on success path.
+			if (!t) return `Created #${op.taskId}`;
+			return `Created #${t.id}: ${t.subject} (pending)`;
+		}
+		case "update": {
+			if (!op.changed) {
+				return `No change: #${op.id} already matches the requested values (status: ${op.toStatus})`;
+			}
+			const transition = op.fromStatus !== op.toStatus ? ` (${op.fromStatus} → ${op.toStatus})` : "";
+			return `Updated #${op.id}${transition}`;
+		}
+		case "delete":
+			return `Deleted #${op.id}: ${op.subject}`;
+		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 formatGetLines(op.task, state);
+		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 };
+}

package/node_modules/@juicesharp/rpiv-todo/tool/types.ts

@@ -0,0 +1,128 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { type Static, Type } from "typebox";
+
+// ---------------------------------------------------------------------------
+// Tool / command identity — verbatim string boundaries.
+// Tool name "todo" is the persistence key for branch replay (filtering
+// `toolResult.toolName === "todo"`) AND the permissions entry at
+// `templates/pi-permissions.jsonc:26`. DO NOT rename.
+// ---------------------------------------------------------------------------
+
+export const TOOL_NAME = "todo";
+export const TOOL_LABEL = "Todo";
+export const COMMAND_NAME = "todos";
+
+// ---------------------------------------------------------------------------
+// User-facing strings (kept stable for /todos UX parity).
+// ---------------------------------------------------------------------------
+
+export const ERR_REQUIRES_INTERACTIVE = "/todos requires interactive mode";
+export const MSG_NO_TODOS = "No todos yet. Ask the agent to add some!";
+
+// ---------------------------------------------------------------------------
+// Public domain types
+// ---------------------------------------------------------------------------
+
+export type TaskStatus = "pending" | "in_progress" | "completed" | "deleted";
+
+export type TaskAction = "create" | "update" | "list" | "get" | "delete" | "clear";
+
+export interface Task {
+	id: number;
+	subject: string;
+	description?: string;
+	activeForm?: string;
+	status: TaskStatus;
+	blockedBy?: number[];
+	owner?: string;
+	metadata?: Record<string, unknown>;
+}
+
+/**
+ * Persistence + replay snapshot. Every successful `todo` tool call returns this
+ * shape under `details`; `state/replay.ts` reads the latest one from the branch
+ * to reconstruct module state. Field order and field names are pinned by
+ * cross-version replay compatibility.
+ */
+export interface TaskDetails {
+	action: TaskAction;
+	params: Record<string, unknown>;
+	tasks: Task[];
+	nextId: number;
+	error?: string;
+}
+
+/**
+ * Open-shape input bag the reducer accepts. Stays an interface so the index
+ * signature (`[key: string]: unknown`) lets the runtime pass through TypeBox
+ * `Static<typeof TodoParamsSchema>` without `as` casts.
+ */
+export interface TaskMutationParams {
+	[key: string]: unknown;
+	subject?: string;
+	description?: string;
+	activeForm?: string;
+	status?: TaskStatus;
+	blockedBy?: number[];
+	addBlockedBy?: number[];
+	removeBlockedBy?: number[];
+	owner?: string;
+	metadata?: Record<string, unknown>;
+	id?: number;
+	includeDeleted?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// TypeBox parameter schema — every `description` doubles as LLM-facing prompt
+// copy. Field order and wording are pinned by registration tests and the
+// pre-refactor schema at `packages/rpiv-todo/todo.ts:512-573`.
+// ---------------------------------------------------------------------------
+
+export const TodoParamsSchema = Type.Object({
+	action: StringEnum(["create", "update", "list", "get", "delete", "clear"] as const),
+	subject: Type.Optional(Type.String({ description: "Task subject line (required for create)" })),
+	description: Type.Optional(Type.String({ description: "Long-form task description" })),
+	activeForm: Type.Optional(
+		Type.String({
+			description: "Present-continuous spinner label shown while status is in_progress (e.g. 'writing tests')",
+		}),
+	),
+	status: Type.Optional(
+		StringEnum(["pending", "in_progress", "completed", "deleted"] as const, {
+			description: "Target status (update) or list filter (list)",
+		}),
+	),
+	blockedBy: Type.Optional(
+		Type.Array(Type.Number(), {
+			description: "Initial blockedBy ids (create only)",
+		}),
+	),
+	addBlockedBy: Type.Optional(
+		Type.Array(Type.Number(), {
+			description: "Task ids to add to blockedBy (update only, additive merge)",
+		}),
+	),
+	removeBlockedBy: Type.Optional(
+		Type.Array(Type.Number(), {
+			description: "Task ids to remove from blockedBy (update only, additive merge)",
+		}),
+	),
+	owner: Type.Optional(Type.String({ description: "Agent/owner assigned to this task" })),
+	metadata: Type.Optional(
+		Type.Record(Type.String(), Type.Unknown(), {
+			description: "Arbitrary metadata; pass null value for a key to delete that key on update",
+		}),
+	),
+	id: Type.Optional(
+		Type.Number({
+			description: "Task id (required for update, get, delete)",
+		}),
+	),
+	includeDeleted: Type.Optional(
+		Type.Boolean({
+			description: "If true, list action returns deleted (tombstoned) tasks as well. Default: false.",
+		}),
+	),
+});
+
+export type TodoParams = Static<typeof TodoParamsSchema>;