pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/pitasks/task-tools.ts

@@ -0,0 +1,375 @@
+/**
+ * task-tools.ts — Task management tool registrations.
+ * Copied from @tintinweb/pi-tasks (MIT license).
+ * Removed: TaskExecute, TaskOutput, TaskStop (handled by async-agents.ts).
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { TaskStore } from "./task-store.js";
+import type { TaskWidget } from "./task-widget.js";
+
+function textResult(msg: string) {
+	return { content: [{ type: "text" as const, text: msg }], details: undefined };
+}
+
+export function registerTaskTools(
+	pi: ExtensionAPI,
+	getStore: () => TaskStore,
+	widget: TaskWidget,
+): void {
+	// ── TaskCreate ──
+	pi.registerTool({
+		name: "TaskCreate",
+		label: "TaskCreate",
+		description: `Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+
+Use this tool proactively in these scenarios:
+
+- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+- Plan mode - When using plan mode, create a task list to track the work
+- User explicitly requests todo list - When the user directly asks you to use the todo list
+- User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+- After receiving new instructions - Immediately capture user requirements as tasks
+- When you start working on a task - Mark it as in_progress BEFORE beginning work
+- After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+- There is only a single, straightforward task
+- The task is trivial and tracking it provides no organizational benefit
+- The task can be completed in less than 3 trivial steps
+- The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Task Fields
+
+- **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
+- **description**: Detailed description of what needs to be done, including context and acceptance criteria
+- **activeForm** (optional): Present continuous form shown in the spinner when the task is in_progress (e.g., "Fixing authentication bug"). If omitted, the spinner shows the subject instead.
+
+All tasks are created with status \`pending\`.
+
+## Tips
+
+- Create tasks with clear, specific subjects that describe the outcome
+- Include enough detail in the description for another agent to understand and complete the task
+- After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
+- Check TaskList first to avoid creating duplicate tasks
+- Include \`agentType\` (e.g., "general-purpose", "Explore") to mark tasks for subagent execution via TaskExecute`,
+		promptGuidelines: [
+			"When working on complex multi-step tasks, use TaskCreate to track progress and TaskUpdate to update status.",
+			"Mark tasks as in_progress before starting work and completed when done.",
+			"Use TaskList to check for available work after completing a task.",
+		],
+		parameters: Type.Object({
+			subject: Type.String({ description: "A brief title for the task" }),
+			description: Type.String({ description: "A detailed description of what needs to be done" }),
+			activeForm: Type.Optional(Type.String({ description: "Present continuous form shown in spinner when in_progress (e.g., 'Running tests')" })),
+			agentType: Type.Optional(Type.String({ description: "Agent type for subagent execution (e.g., 'general-purpose', 'Explore'). Tasks with agentType can be started via TaskExecute." })),
+			metadata: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "Arbitrary metadata to attach to the task" })),
+		}),
+		execute(_toolCallId: string, params: any) {
+			const store = getStore();
+			const meta = params.metadata ?? {};
+			if (params.agentType) meta.agentType = params.agentType;
+			const createdBy = { type: "local" as const, origin: "system", session: "", project: "" };
+			const task = store.create(params.subject, params.description, createdBy, params.activeForm, Object.keys(meta).length > 0 ? meta : undefined);
+			widget.update();
+			return Promise.resolve(textResult(`Task #${task.id} created successfully: ${task.subject}`));
+		},
+	});
+
+	// ── TaskList ──
+	pi.registerTool({
+		name: "TaskList",
+		label: "TaskList",
+		description: `Use this tool to list all tasks in the task list.
+
+## When to Use This Tool
+
+- To see what tasks are available to work on (status: 'pending', no owner, not blocked)
+- To check overall progress on the project
+- To find tasks that are blocked and need dependencies resolved
+- After completing a task, to check for newly unblocked work or claim the next available task
+- **Prefer working on tasks in ID order** (lowest ID first) when multiple tasks are available, as earlier tasks often set up context for later ones
+
+## Output
+
+Returns a summary of each task:
+- **id**: Task identifier (use with TaskGet, TaskUpdate)
+- **subject**: Brief description of the task
+- **status**: 'pending', 'in_progress', or 'completed'
+- **owner**: Agent ID if assigned, empty if available
+- **blockedBy**: List of open task IDs that must be resolved first (tasks with blockedBy cannot be claimed until dependencies resolve)
+
+Use TaskGet with a specific task ID to view full details including description and comments.`,
+		parameters: Type.Object({}),
+		execute() {
+			const store = getStore();
+			const tasks = store.list();
+			if (tasks.length === 0) return Promise.resolve(textResult("No tasks found"));
+			const statusOrder: Record<string, number> = { pending: 0, in_progress: 1, completed: 2 };
+			const sorted = [...tasks].sort((a, b) => {
+				const so = (statusOrder[a.status] ?? 0) - (statusOrder[b.status] ?? 0);
+				if (so !== 0) return so;
+				return Number(a.id) - Number(b.id);
+			});
+			const lines = sorted.map(task => {
+				let line = `#${task.id} [${task.status}] ${task.subject}`;
+				if (task.owner) line += ` (${task.owner})`;
+				if (task.blockedBy.length > 0) {
+					const openBlockers = task.blockedBy.filter(bid => {
+						const blocker = store.get(bid);
+						return blocker && blocker.status !== "completed";
+					});
+					if (openBlockers.length > 0) line += ` [blocked by ${openBlockers.map(id => "#" + id).join(", ")}]`;
+				}
+				return line;
+			});
+			return Promise.resolve(textResult(lines.join("\n")));
+		},
+	});
+
+	// ── TaskGet ──
+	pi.registerTool({
+		name: "TaskGet",
+		label: "TaskGet",
+		description: `Use this tool to retrieve a task by its ID from the task list.
+
+## When to Use This Tool
+
+- When you need the full description and context before starting work on a task
+- To understand task dependencies (what it blocks, what blocks it)
+- After being assigned a task, to get complete requirements
+
+## Output
+
+Returns full task details:
+- **subject**: Task title
+- **description**: Detailed requirements and context
+- **status**: 'pending', 'in_progress', or 'completed'
+- **blocks**: Tasks waiting on this one to complete
+- **blockedBy**: Tasks that must complete before this one can start
+
+## Tips
+
+- After fetching a task, verify its blockedBy list is empty before beginning work.
+- Use TaskList to see all tasks in summary form.`,
+		parameters: Type.Object({
+			taskId: Type.String({ description: "The ID of the task to retrieve" }),
+		}),
+		execute(_toolCallId: string, params: any) {
+			const store = getStore();
+			const task = store.get(params.taskId);
+			if (!task) return Promise.resolve(textResult("Task not found"));
+			const desc = task.description.replace(/\\n/g, "\n");
+			const lines = [`Task #${task.id}: ${task.subject}`, `Status: ${task.status}`];
+			if (task.owner) lines.push(`Owner: ${task.owner}`);
+			lines.push(`Description: ${desc}`);
+			if (task.blockedBy.length > 0) {
+				const openBlockers = task.blockedBy.filter(bid => { const b = store.get(bid); return b && b.status !== "completed"; });
+				if (openBlockers.length > 0) lines.push(`Blocked by: ${openBlockers.map(id => "#" + id).join(", ")}`);
+			}
+			if (task.blocks.length > 0) lines.push(`Blocks: ${task.blocks.map(id => "#" + id).join(", ")}`);
+			if (task.statusHistory) {
+				const sh = task.statusHistory;
+				const parts: string[] = [];
+				if (sh.pending_at) parts.push(`Created: ${sh.pending_at}`);
+				if (sh.in_progress_at) parts.push(`Started: ${sh.in_progress_at}`);
+				if (sh.completed_at) parts.push(`Completed: ${sh.completed_at}`);
+				if (parts.length > 0) lines.push(`Timeline: ${parts.join(" → ")}`);
+			}
+			if (task.createdBy) lines.push(`Created by: ${task.createdBy.origin} (${task.createdBy.type})`);
+			const metaKeys = Object.keys(task.metadata);
+			if (metaKeys.length > 0) lines.push(`Metadata: ${JSON.stringify(task.metadata)}`);
+			return Promise.resolve(textResult(lines.join("\n")));
+		},
+	});
+
+	// ── TaskUpdate ──
+	pi.registerTool({
+		name: "TaskUpdate",
+		label: "TaskUpdate",
+		description: `Use this tool to update a task in the task list.
+
+## When to Use This Tool
+
+**Before starting work on a task:**
+- Mark it in_progress BEFORE beginning — do not start work without updating status first
+- After resolving, call TaskList to find your next task
+
+**Mark tasks as resolved:**
+- When you have completed the work described in a task
+- When a task is no longer needed or has been superseded
+- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
+- After resolving, call TaskList to find your next task
+
+- ONLY mark a task as completed when you have FULLY accomplished it
+- If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+- When blocked, create a new task describing what needs to be resolved
+- Never mark a task as completed if:
+  - Tests are failing
+  - Implementation is partial
+  - You encountered unresolved errors
+  - You couldn't find necessary files or dependencies
+
+**Delete tasks:**
+- When a task is no longer relevant or was created in error
+- Setting status to \`deleted\` permanently removes the task
+
+**Update task details:**
+- When requirements change or become clearer
+- When establishing dependencies between tasks
+
+## Fields You Can Update
+
+- **status**: The task status (see Status Workflow below)
+- **subject**: Change the task title (imperative form, e.g., "Run tests")
+- **description**: Change the task description
+- **activeForm**: Present continuous form shown in spinner when in_progress (e.g., "Running tests")
+- **owner**: Change the task owner (agent name)
+- **metadata**: Merge metadata keys into the task (set a key to null to delete it)
+- **addBlocks**: Mark tasks that cannot start until this one completes
+- **addBlockedBy**: Mark tasks that must complete before this one can start
+
+## Status Workflow
+
+Status progresses: \`pending\` → \`in_progress\` → \`completed\`
+
+Use \`deleted\` to permanently remove a task.
+
+## Staleness
+
+Make sure to read a task's latest state using \`TaskGet\` before updating it.
+
+## Examples
+
+Mark task as in progress when starting work:
+\`\`\`json
+{"taskId": "1", "status": "in_progress"}
+\`\`\`
+
+Mark task as completed after finishing work:
+\`\`\`json
+{"taskId": "1", "status": "completed"}
+\`\`\`
+
+Delete a task:
+\`\`\`json
+{"taskId": "1", "status": "deleted"}
+\`\`\`
+
+Claim a task by setting owner:
+\`\`\`json
+{"taskId": "1", "owner": "my-name"}
+\`\`\`
+
+Set up task dependencies:
+\`\`\`json
+{"taskId": "2", "addBlockedBy": ["1"]}
+\`\`\``,
+		parameters: Type.Object({
+			taskId: Type.String({ description: "The ID of the task to update" }),
+			status: Type.Optional(Type.Unsafe({ type: "string", enum: ["pending", "in_progress", "completed", "deleted"], description: "New status for the task" })),
+			subject: Type.Optional(Type.String({ description: "New subject for the task" })),
+			description: Type.Optional(Type.String({ description: "New description for the task" })),
+			activeForm: Type.Optional(Type.String({ description: "Present continuous form shown in spinner when in_progress" })),
+			owner: Type.Optional(Type.String({ description: "New owner for the task" })),
+			metadata: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "Metadata keys to merge into the task. Set a key to null to delete it." })),
+			addBlocks: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that this task blocks" })),
+			addBlockedBy: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that block this task" })),
+		}),
+		execute(_toolCallId: string, params: any) {
+			const store = getStore();
+			const { taskId, ...fields } = params;
+			const { task, changedFields, warnings } = store.update(taskId, fields);
+			if (changedFields.length === 0 && !task) return Promise.resolve(textResult(`Task #${taskId} not found`));
+			if (fields.status === "in_progress") { widget.setActiveTask(taskId); }
+			else if (fields.status === "completed" || fields.status === "deleted") {
+				widget.setActiveTask(taskId, false);
+			}
+			widget.update();
+			let msg = `Updated task #${taskId} ${changedFields.join(", ")}`;
+			if (warnings.length > 0) msg += ` (warning: ${warnings.join("; ")})`;
+			return Promise.resolve(textResult(msg));
+		},
+	});
+
+	// ── TaskBulkCreate ──
+	pi.registerTool({
+		name: "TaskBulkCreate",
+		label: "TaskBulkCreate",
+		description: "Create multiple tasks at once. More efficient than calling TaskCreate multiple times.",
+		parameters: Type.Object({
+			tasks: Type.Array(Type.Object({
+				subject: Type.String({ description: "Brief task title" }),
+				description: Type.String({ description: "Detailed task description" }),
+				blockedBy: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that block this task" })),
+			}), { description: "Array of tasks to create" }),
+		}),
+		async execute(_callId, params) {
+			const store = getStore();
+			const createdBy = { type: "local" as const, origin: "system", session: "", project: "" };
+			const created = store.createTasks(params.tasks.map(t => ({ ...t, createdBy })));
+			widget.update();
+			const lines = created.map(t => `#${t.id}: ${t.subject}`);
+			return textResult(`Created ${created.length} tasks:\n${lines.join("\n")}`);
+		},
+	});
+
+	// ── TaskBulkDelete ──
+	pi.registerTool({
+		name: "TaskBulkDelete",
+		label: "TaskBulkDelete",
+		description: "Delete multiple tasks at once by ID.",
+		parameters: Type.Object({
+			taskIds: Type.Array(Type.String(), { description: "Task IDs to delete" }),
+		}),
+		async execute(_callId, params) {
+			const store = getStore();
+			const count = store.deleteTasks(params.taskIds);
+			widget.update();
+			return textResult(`Deleted ${count} task(s)`);
+		},
+	});
+
+	// ── TaskBulkUpdate ──
+	pi.registerTool({
+		name: "TaskBulkUpdate",
+		label: "TaskBulkUpdate",
+		description: "Update multiple tasks at once. More efficient than calling TaskUpdate multiple times.",
+		parameters: Type.Object({
+			updates: Type.Array(Type.Object({
+				taskId: Type.String({ description: "Task ID to update" }),
+				status: Type.Optional(Type.Unsafe({ type: "string", enum: ["pending", "in_progress", "completed", "deleted"], description: "New status" })),
+				subject: Type.Optional(Type.String({ description: "New subject" })),
+				description: Type.Optional(Type.String({ description: "New description" })),
+				addBlockedBy: Type.Optional(Type.Array(Type.String(), { description: "Task IDs that block this task" })),
+				addBlocks: Type.Optional(Type.Array(Type.String(), { description: "Task IDs this task blocks" })),
+			}), { description: "Array of task updates" }),
+		}),
+		async execute(_callId, params) {
+			const store = getStore();
+			const updates = params.updates.map(u => ({
+				id: u.taskId,
+				fields: {
+					...(u.status !== undefined ? { status: u.status } : {}),
+					...(u.subject !== undefined ? { subject: u.subject } : {}),
+					...(u.description !== undefined ? { description: u.description } : {}),
+					...(u.addBlockedBy !== undefined ? { addBlockedBy: u.addBlockedBy } : {}),
+					...(u.addBlocks !== undefined ? { addBlocks: u.addBlocks } : {}),
+				},
+			}));
+			const results = store.updateTasks(updates);
+			widget.update();
+			const lines = results.map(r => r.success ? `#${r.id}: ${r.changedFields?.join(", ") || "no changes"}` : `#${r.id}: not found`);
+			return textResult(`Updated ${results.filter(r => r.success).length} task(s):\n${lines.join("\n")}`);
+		},
+	});
+}

package/extensions/pitasks/task-widget.ts

@@ -0,0 +1,181 @@
+/**
+ * task-widget.ts — Persistent widget showing task list with status icons and progress.
+ * Copied from @tintinweb/pi-tasks (MIT license).
+ */
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { TaskStore } from "./task-store.js";
+
+const SPINNER = ["✳", "✴", "✵", "✶", "✷", "✸", "✹", "✺", "✻", "✼", "✽"];
+const DEFAULT_MAX_VISIBLE_TASKS = 10;
+
+function truncateFromTop(tasks: any[], limit: number): any[] { return tasks.slice(-limit); }
+function truncateFromBottom(tasks: any[], limit: number): any[] { return tasks.slice(0, limit); }
+const TRUNCATE_FNS: Record<string, (t: any[], l: number) => any[]> = { top: truncateFromTop, bottom: truncateFromBottom };
+
+function formatDuration(ms: number): string {
+	const totalSec = Math.floor(ms / 1000);
+	if (totalSec < 60) return `${totalSec}s`;
+	const min = Math.floor(totalSec / 60);
+	const sec = totalSec % 60;
+	if (min < 60) return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+	const hr = Math.floor(min / 60);
+	const remMin = min % 60;
+	return remMin > 0 ? `${hr}h ${remMin}m` : `${hr}h`;
+}
+
+function formatTokens(n: number): string {
+	if (n < 1000) return String(n);
+	return (n / 1000).toFixed(1).replace(/\.0$/, "") + "k";
+}
+
+export class TaskWidget {
+	private uiCtx: any;
+	private widgetFrame = 0;
+	private widgetInterval: ReturnType<typeof setInterval> | undefined;
+	private activeTaskIds = new Set<string>();
+	private metrics = new Map<string, { startedAt: number; inputTokens: number; outputTokens: number }>();
+	private tui: any;
+	private widgetRegistered = false;
+
+	constructor(private store: TaskStore, private config: Record<string, any> = {}) {}
+
+	setStore(store: TaskStore): void { this.store = store; }
+	setUICtx(ctx: any): void { this.uiCtx = ctx; }
+
+	setActiveTask(taskId: string, active = true): void {
+		if (taskId && active) {
+			this.activeTaskIds.add(taskId);
+			if (!this.metrics.has(taskId)) {
+				this.metrics.set(taskId, { startedAt: Date.now(), inputTokens: 0, outputTokens: 0 });
+			}
+			this.ensureTimer();
+		} else if (taskId) {
+			this.activeTaskIds.delete(taskId);
+		}
+		this.update();
+	}
+
+	addTokenUsage(inputTokens: number, outputTokens: number): void {
+		for (const id of this.activeTaskIds) {
+			const m = this.metrics.get(id);
+			if (m) { m.inputTokens += inputTokens; m.outputTokens += outputTokens; }
+		}
+	}
+
+	private ensureTimer(): void {
+		if (!this.widgetInterval) {
+			this.widgetInterval = setInterval(() => this.update(), 150);
+		}
+	}
+
+	private renderWidget(tui: any, theme: any): string[] {
+		try { return this.buildWidgetLines(tui, theme); } catch { return []; }
+	}
+
+	private buildWidgetLines(tui: any, theme: any): string[] {
+		const sortOrder = this.config.sortOrder ?? "id";
+		const tasks = this.store.list(sortOrder);
+		const w = tui.terminal.columns;
+		const truncate = (line: string) => truncateToWidth(line, w);
+		if (tasks.length === 0) return [];
+
+		const completed = tasks.filter(t => t.status === "completed");
+		const inProgress = tasks.filter(t => t.status === "in_progress");
+		const pending = tasks.filter(t => t.status === "pending");
+		const parts: string[] = [];
+		if (completed.length > 0) parts.push(`${completed.length} done`);
+		if (inProgress.length > 0) parts.push(`${inProgress.length} in progress`);
+		if (pending.length > 0) parts.push(`${pending.length} open`);
+		const statusText = `${tasks.length} tasks (${parts.join(", ")})`;
+		const spinnerChar = SPINNER[this.widgetFrame % SPINNER.length];
+		const lines: string[] = [truncate(theme.fg("accent", "●") + " " + theme.fg("accent", statusText))];
+
+		const showAll = this.config.showAll ?? false;
+		const limit = this.config.maxVisible ?? DEFAULT_MAX_VISIBLE_TASKS;
+		const hiddenAt = this.config.hiddenAt ?? "bottom";
+		const visible = showAll ? tasks : TRUNCATE_FNS[hiddenAt](tasks, limit);
+		const hiddenCount = tasks.length - visible.length;
+		const overflowLine = hiddenCount > 0 ? truncate(theme.fg("dim", `    … and ${hiddenCount} more`)) : undefined;
+
+		if (overflowLine && hiddenAt === "top") lines.push(overflowLine);
+
+		for (const task of visible) {
+			let icon: string;
+			if (task.status === "in_progress") icon = theme.fg("accent", spinnerChar);
+			else if (task.status === "completed") icon = theme.fg("success", "✔");
+			else icon = "◻";
+
+			let suffix = "";
+			if (task.status === "pending" && task.blockedBy.length > 0) {
+				const openBlockers = task.blockedBy.filter((bid: string) => {
+					const blocker = this.store.get(bid);
+					return blocker && blocker.status !== "completed";
+				});
+				if (openBlockers.length > 0) suffix = theme.fg("dim", ` › blocked by ${openBlockers.map((id: string) => "#" + id).join(", ")}`);
+			}
+
+			let text: string;
+			if (task.status === "in_progress") {
+				const form = task.activeForm || task.subject;
+				const agentId = task.metadata?.agentId;
+				const agentLabel = agentId ? ` (agent ${agentId.slice(0, 5)})` : "";
+				const m = this.metrics.get(task.id);
+				let stats = "";
+				if (m) {
+					const elapsed = formatDuration(Date.now() - m.startedAt);
+					const tokenParts: string[] = [];
+					if (m.inputTokens > 0) tokenParts.push(`↑ ${formatTokens(m.inputTokens)}`);
+					if (m.outputTokens > 0) tokenParts.push(`↓ ${formatTokens(m.outputTokens)}`);
+					stats = tokenParts.length > 0
+						? ` ${theme.fg("dim", `(${elapsed} · ${tokenParts.join(" ")})`)}`
+						: ` ${theme.fg("dim", `(${elapsed})`)}`;
+				}
+				text = `  ${icon} ${theme.fg("dim", "#" + task.id)} ${theme.fg("accent", form + agentLabel + "…")}${stats}`;
+			} else if (task.status === "completed") {
+				text = `  ${icon} ${theme.fg("dim", theme.strikethrough("#" + task.id + " " + task.subject))}`;
+			} else {
+				const agentSuffix = task.status === "in_progress" && task.metadata?.agentId
+					? theme.fg("dim", ` (agent ${task.metadata.agentId.slice(0, 5)})`) : "";
+				text = `  ${icon} ${theme.fg("dim", "#" + task.id)} ${task.subject}${agentSuffix}`;
+			}
+			lines.push(truncate(text + suffix));
+		}
+
+		if (overflowLine && hiddenAt !== "top") lines.push(overflowLine);
+		return lines;
+	}
+
+	update(): void {
+		if (!this.uiCtx) return;
+		const tasks = this.store.list();
+		if (tasks.length === 0) {
+			if (this.widgetRegistered) { this.uiCtx.setWidget("tasks", undefined); this.widgetRegistered = false; }
+			if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
+			return;
+		}
+		for (const id of this.activeTaskIds) {
+			const t = this.store.get(id);
+			if (!t || t.status !== "in_progress") { this.activeTaskIds.delete(id); this.metrics.delete(id); }
+		}
+		const hasActiveSpinner = tasks.some(t => t.status === "in_progress");
+		if (hasActiveSpinner) this.ensureTimer();
+		else if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
+		this.widgetFrame++;
+		if (!this.widgetRegistered) {
+			this.uiCtx.setWidget("tasks", (tui: any, theme: any) => {
+				this.tui = tui;
+				return { render: () => this.renderWidget(tui, theme), invalidate: () => {} };
+			}, { placement: "aboveEditor" });
+			this.widgetRegistered = true;
+		} else if (this.tui) {
+			this.tui.requestRender();
+		}
+	}
+
+	dispose(): void {
+		if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
+		if (this.uiCtx) this.uiCtx.setWidget("tasks", undefined);
+		this.widgetRegistered = false;
+		this.tui = undefined;
+	}
+}

package/extensions/pitasks/types.ts

@@ -0,0 +1,38 @@
+/**
+ * types.ts — Type definitions for the task management system.
+ * Copied from @tintinweb/pi-tasks (MIT license).
+ */
+
+export type TaskStatus = "pending" | "in_progress" | "completed";
+
+export interface Task {
+	id: string;
+	subject: string;
+	description: string;
+	status: TaskStatus;
+	activeForm?: string;
+	owner?: string;
+	metadata: Record<string, any>;
+	blocks: string[];
+	blockedBy: string[];
+	createdBy: {
+		type: "local" | "coms";
+		origin: string;
+		session: string;
+		project: string;
+	};
+	createdAt: number;
+	updatedAt: number;
+	statusHistory: {
+		pending_at: string;
+		in_progress_at: string | null;
+		completed_at: string | null;
+		deleted_at: string | null;
+	};
+}
+
+/** Serialized store format on disk. */
+export interface TaskStoreData {
+	nextId: number;
+	tasks: Task[];
+}

package/extensions/providers/acpx-driver.ts

@@ -35,6 +35,7 @@ import { loadAcpxRuntime, type AcpxRuntimeModule } from "../acpx-provider/load-r
 import { modelIdToDisplayName } from "../acpx-provider/runtime-models.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import { fileLog } from "../shared/file-logger.js";
+import { resolveBinary } from "../shared/resolve-binary.js";
 
 const LOG_DOMAIN = "acpx-driver";
 const DRIVER_KIND = "acpx";
@@ -378,12 +379,21 @@ export const AcpxDriver: ProviderDriver<AcpxConfig> = {
   driverKind: DRIVER_KIND,
   metadata: {
     displayName: "ACPX",
-    supportsMultipleInstances: false,
+    supportsMultipleInstances: true,
   },
   configSchema: acpxConfigSchema,
   defaultConfig: () => ({ agent: "cursor", enabled: true }),
 
-  probe: async (_config: AcpxConfig): Promise<ProviderProbeResult> => {
+  probe: async (config: AcpxConfig): Promise<ProviderProbeResult> => {
+    // Check that the underlying CLI binary is installed (e.g. cursor, claude, gemini)
+    const binaryName = config.agent === "cursor" ? "agent" : config.agent;
+    const binary = resolveBinary(binaryName);
+    if (!binary) {
+      return {
+        available: false,
+        reason: `CLI binary '${binaryName}' for acpx agent '${config.agent}' not found on PATH`,
+      };
+    }
     try {
       await loadAcpxRuntime();
       return { available: true };

package/extensions/providers/built-in-drivers.ts

@@ -39,14 +39,14 @@ export const BUILT_IN_DRIVERS: readonly AnyProviderDriver[] = [
  * Drivers use kinds like "cursor-cli", "acpx", "claude-cli".
  * This map resolves the mapping.
  */
-export const CLI_AGENT_TO_DRIVER: Record<string, string> = {
+export const CLI_AGENT_TO_DRIVER: Record<string, string> = Object.assign(Object.create(null), {
   claude: "claude-cli",
   gemini: "gemini-cli",
   cursor: "cursor-cli",
-};
+});
 
-export const ACPX_AGENT_TO_DRIVER: Record<string, string> = {
+export const ACPX_AGENT_TO_DRIVER: Record<string, string> = Object.assign(Object.create(null), {
   cursor: "acpx",
-  // Add more as they're implemented:
-  // copilot: "acpx",
-};
+  claude: "acpx",
+  gemini: "acpx",
+});

package/extensions/providers/claude-driver.ts

@@ -32,7 +32,7 @@ import type {
 } from "../shared/provider-driver.js";
 import { ProviderDriverError } from "../shared/provider-errors.js";
 import { makeManagedSnapshot, buildInitialSnapshot } from "../shared/managed-refresh.js";
-import { resolveBinary } from "../cli-provider/shared/discover-cache.js";
+import { resolveBinary } from "../shared/resolve-binary.js";
 import { discoverCliModelsDetailed } from "../cli-provider/discover.js";
 import { runCliAgent } from "../cli-provider/runner.js";
 import {

package/extensions/providers/cursor-cli-driver.ts

@@ -29,7 +29,7 @@ import type {
   TurnResult,
 } from "../shared/provider-driver.js";
 import { makeManagedSnapshot, buildInitialSnapshot } from "../shared/managed-refresh.js";
-import { resolveBinary } from "../cli-provider/shared/discover-cache.js";
+import { resolveBinary } from "../shared/resolve-binary.js";
 import { discoverCliModelsDetailed } from "../cli-provider/discover.js";
 import { runCliAgent } from "../cli-provider/runner.js";
 import {

package/extensions/providers/gemini-driver.ts

@@ -28,7 +28,7 @@ import type {
   TurnResult,
 } from "../shared/provider-driver.js";
 import { makeManagedSnapshot, buildInitialSnapshot } from "../shared/managed-refresh.js";
-import { resolveBinary } from "../cli-provider/shared/discover-cache.js";
+import { resolveBinary } from "../shared/resolve-binary.js";
 import { discoverCliModelsDetailed } from "../cli-provider/discover.js";
 import { runCliAgent } from "../cli-provider/runner.js";
 import {