@trevonistrevon/pi-loop 0.5.0 → 0.5.1

package/dist/tools/loop-tools.js

@@ -0,0 +1,241 @@
+import { Type } from "typebox";
+import { parseInterval } from "../loop-parse.js";
+function textResult(msg) {
+    return { content: [{ type: "text", text: msg }], details: undefined };
+}
+function validateTrigger(trigger) {
+    if (trigger.type === "cron") {
+        const parts = trigger.schedule.trim().split(/\s+/);
+        if (parts.length !== 5) {
+            return `Invalid cron trigger. Expected 5 fields, got ${parts.length}: "${trigger.schedule}". Use formats like "5m", "1h", "0 9 * * 1-5", or set triggerType to "event" for event sources.`;
+        }
+    }
+    else if (trigger.type === "event") {
+        if (!trigger.source || trigger.source.trim().length === 0) {
+            return "Invalid event trigger. Event source must be non-empty (e.g., \"tool_execution_start\").";
+        }
+    }
+    else if (trigger.type === "hybrid") {
+        const cronParts = trigger.cron.trim().split(/\s+/);
+        if (cronParts.length !== 5) {
+            return `Invalid hybrid trigger. Cron part must have 5 fields, got ${cronParts.length}: "${trigger.cron}".`;
+        }
+        if (!trigger.event.source || trigger.event.source.trim().length === 0) {
+            return "Invalid hybrid trigger. Event source must be non-empty (e.g., \"tool_execution_start\").";
+        }
+    }
+    return null;
+}
+function inferTriggerType(input) {
+    if (input.includes("hybrid") || (input.includes("cron") && input.includes("event")))
+        return "hybrid";
+    if (/^\d+\s*[smhd]$/i.test(input.trim()))
+        return "cron";
+    if (/^(\*|\d+)/.test(input.trim()) && input.trim().split(/\s+/).length === 5)
+        return "cron";
+    return "event";
+}
+function formatRemaining(ms) {
+    if (ms < 60000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3600000)
+        return `${Math.round(ms / 60000)}m`;
+    return `${Math.round(ms / 3600000)}h`;
+}
+export function registerLoopTools(options) {
+    const { pi, getStore, getTriggerSystem, getScheduler, getMonitorManager, updateWidget, maybeBootstrapTaskLoop, isTaskSystemReady, } = options;
+    pi.registerTool({
+        name: "LoopCreate",
+        label: "LoopCreate",
+        description: `Create a scheduled repeating task (loop) that runs a prompt on a timer or when an event fires.
+
+Use this tool whenever the user asks to:
+- "create a loop" to check something periodically
+- "run every X seconds/minutes/hours"
+- "remind me to check..."
+- "watch for..." or "when X happens, do Y"
+- "schedule a recurring check"
+- set up a periodic monitor or poller
+- has a task list with open items — create a loop to work through tasks automatically
+
+DO NOT use raw Bash loops (for/sleep/while). Use LoopCreate instead — it integrates with the session lifecycle, survives across turns, and the scheduler handles timing.
+
+## When NOT to Use
+
+Skip this tool when the task is a one-off check (just do it directly) or when the user wants a purely reactive hook.
+
+## Trigger Types
+
+- **cron**: time-based. "30s" (rounded to 1m), "5m", "2h", "1d", or full cron like "0 9 * * 1-5"
+- **event**: fires on pi events like "tool_execution_start", "before_agent_start"
+- **hybrid**: both cron + event with debounce
+
+## Parameters
+
+- **trigger**: interval like "30s", "5m", "2h", event source, or hybrid spec
+- **prompt**: what to do when the loop fires (e.g., "check if the build passed")
+- **recurring**: repeat or fire once (default: true)
+- **autoTask**: when pi-tasks is loaded or native task fallback is active, auto-create a task on each fire
+- **taskBacklog**: mark this as a task-backlog worker loop so it auto-deletes when pending tasks reach zero
+- **readOnly**: restrict the agent to read-only tools when this loop fires (default: false)
+- **maxFires**: auto-stop after N fires — prevents infinite token burn on polling loops`,
+        promptGuidelines: [
+            "Use LoopCreate when the user asks for a repeating task, periodic check, scheduled reminder, or 'every X' — never use raw Bash for/sleep/while.",
+            "## Choosing trigger type",
+            "Prefer event triggers over cron when possible — they fire exactly when needed instead of polling.",
+            "Use event triggers for: tool completion ('tool_execution_end'), task creation ('tasks:created'), monitor completion ('monitor:done').",
+            "Use cron triggers only when: the user explicitly asks for a time interval, or there's no relevant pi event to subscribe to.",
+            "Hybrid triggers (cron + event) give you both: event-driven responsiveness with a cron safety-net fallback.",
+            "## Choosing an interval",
+            "Default to 5m unless the user specifies differently. Use shorter intervals only when time-sensitive.",
+            "## maxFires — prevent infinite token burn",
+            "Always set maxFires on polling loops so they don't run forever. For task-continuation loops, use maxFires: 20-50.",
+            "When a loop fires and finds nothing to do, call LoopDelete on its own ID to stop it — don't keep polling.",
+            "## readOnly mode",
+            "Set readOnly: true for loops that only observe and report (checks, status polls). This prevents unintended changes.",
+            "## Task-driven workflows",
+            "Do not rely on a past 'tasks:created' event to replay. If tasks already exist, bootstrap the first pass in the current turn or use a hybrid/event loop that can catch future task creation and a cron safety-net.",
+            "Use autoTask only when you want the loop itself to create a task on each fire. For processing an existing task backlog, leave autoTask off and have the loop run TaskList to pick the next pending task.",
+            "Set taskBacklog: true for task-worker loops that process the existing pending queue. Task-backlog loops bootstrap against existing pending tasks and auto-delete when the queue reaches zero.",
+            "When no tasks are pending, the loop should stop itself or skip the wake entirely — no tokens burned on empty polls.",
+            "After creating a loop, tell the user the loop ID so they can cancel it with LoopDelete.",
+        ],
+        parameters: Type.Object({
+            trigger: Type.String({ description: "Cron expression (e.g., '5m', '1h', '0 9 * * 1-5'), event source (e.g., 'tool_execution_start'), or JSON hybrid spec" }),
+            prompt: Type.String({ description: "Prompt to run when the loop fires" }),
+            recurring: Type.Optional(Type.Boolean({ description: "Whether loop repeats (default: true)", default: true })),
+            autoTask: Type.Optional(Type.Boolean({ description: "Auto-create pi-tasks task on fire", default: false })),
+            taskBacklog: Type.Optional(Type.Boolean({ description: "Mark as a task-backlog worker loop that auto-deletes when pending tasks reach zero", default: false })),
+            triggerType: Type.Optional(Type.String({ description: "cron, event, or hybrid (inferred from trigger string if omitted)", enum: ["cron", "event", "hybrid"] })),
+            debounceMs: Type.Optional(Type.Number({ description: "Debounce for hybrid triggers (default: 30000)", default: 30000 })),
+            readOnly: Type.Optional(Type.Boolean({ description: "Restrict the agent to read-only tools when this loop fires (default: false)", default: false })),
+            maxFires: Type.Optional(Type.Number({ description: "Auto-stop after N fires. Prevents infinite token burn on polling loops." })),
+        }),
+        async execute(_toolCallId, params) {
+            const { trigger: triggerInput, prompt, recurring, autoTask, taskBacklog, triggerType, debounceMs, readOnly, maxFires } = params;
+            let trigger;
+            const inferred = triggerType ?? inferTriggerType(triggerInput);
+            if (inferred === "cron") {
+                const parsed = parseInterval(triggerInput);
+                trigger = { type: "cron", schedule: parsed.cron };
+            }
+            else if (inferred === "event") {
+                trigger = { type: "event", source: triggerInput };
+            }
+            else {
+                const cronPart = triggerInput.match(/cron:?\s*(\S+)/)?.[1] || triggerInput;
+                const eventPart = triggerInput.match(/event:?\s*(\S+)/)?.[1];
+                const parsed = parseInterval(cronPart);
+                trigger = {
+                    type: "hybrid",
+                    cron: parsed.cron,
+                    event: { source: eventPart || "tool_execution_start" },
+                    debounceMs: debounceMs ?? 30000,
+                };
+            }
+            const validationError = validateTrigger(trigger);
+            if (validationError)
+                return Promise.resolve(textResult(validationError));
+            const entry = getStore().create(trigger, prompt, {
+                recurring: recurring ?? (inferred !== "event"),
+                autoTask,
+                taskBacklog,
+                readOnly,
+                maxFires,
+            });
+            getTriggerSystem().add(entry);
+            if (trigger.type === "event" && trigger.source === "monitor:done" && trigger.filter) {
+                try {
+                    const filterObj = JSON.parse(trigger.filter);
+                    const monitorId = filterObj.monitorId;
+                    if (monitorId) {
+                        const monitor = getMonitorManager().get(monitorId);
+                        if (monitor && monitor.status !== "running") {
+                            getTriggerSystem().remove(entry.id);
+                            getStore().delete(entry.id);
+                        }
+                    }
+                }
+                catch {
+                    // ignore malformed monitor filter; loop remains registered
+                }
+            }
+            const bootstrapped = await maybeBootstrapTaskLoop(entry);
+            updateWidget();
+            const triggerDesc = trigger.type === "cron"
+                ? `schedule: ${trigger.schedule}`
+                : trigger.type === "event"
+                    ? `event: ${trigger.source}`
+                    : `hybrid: cron ${trigger.cron} + event ${trigger.event.source}`;
+            return Promise.resolve(textResult(`Loop #${entry.id} created: ${entry.prompt.slice(0, 60)}\n` +
+                `Trigger: ${triggerDesc}\n` +
+                `Recurring: ${entry.recurring}\n` +
+                (entry.autoTask ? "Auto-task: enabled\n" : "") +
+                (entry.taskBacklog ? "Task-backlog: enabled\n" : "") +
+                (bootstrapped ? "Bootstrap: queued initial wake for existing pending tasks\n" : "") +
+                (isTaskSystemReady() ? "" : "(task system not ready yet — autoTask may not fire until native fallback or pi-tasks becomes available)\n") +
+                `ID: ${entry.id} (use LoopDelete to cancel)`));
+        },
+    });
+    pi.registerTool({
+        name: "LoopList",
+        label: "LoopList",
+        description: `List all active scheduled loops with their IDs, triggers, and next-fire times.
+
+Use this before creating new loops to avoid duplicates, or to find IDs for LoopDelete.`,
+        parameters: Type.Object({}),
+        execute() {
+            const loops = getStore().list();
+            if (loops.length === 0)
+                return Promise.resolve(textResult("No loops configured. Use LoopCreate to set up a schedule."));
+            const lines = [];
+            for (const entry of loops) {
+                const triggerDesc = entry.trigger.type === "cron"
+                    ? `cron: ${entry.trigger.schedule}`
+                    : entry.trigger.type === "event"
+                        ? `event: ${entry.trigger.source}`
+                        : `hybrid: ${entry.trigger.cron} + ${entry.trigger.event.source}`;
+                const nextFire = entry.trigger.type !== "event" ? getScheduler().nextFire(entry.id) : undefined;
+                const statusIcon = entry.status === "active" ? "*" : entry.status === "paused" ? "-" : "x";
+                let line = `${statusIcon} #${entry.id} [${entry.status}] ${entry.prompt.slice(0, 60)}`;
+                line += ` (${triggerDesc})`;
+                if (nextFire) {
+                    const remaining = Math.max(0, nextFire - Date.now());
+                    line += ` next: ${formatRemaining(remaining)}`;
+                }
+                if (entry.autoTask)
+                    line += " [auto-task]";
+                lines.push(line);
+            }
+            return Promise.resolve(textResult(lines.join("\n")));
+        },
+    });
+    pi.registerTool({
+        name: "LoopDelete",
+        label: "LoopDelete",
+        description: `Delete or pause a loop by its ID.
+
+Use "pause" to temporarily stop a loop without removing it. Use "delete" to permanently remove it.`,
+        parameters: Type.Object({
+            id: Type.String({ description: "Loop ID to delete or pause" }),
+            action: Type.Optional(Type.String({ description: "delete or pause (default: delete)", enum: ["delete", "pause"], default: "delete" })),
+        }),
+        execute(_toolCallId, params) {
+            const { id, action } = params;
+            if (action === "pause") {
+                const entry = getStore().pause(id);
+                if (!entry)
+                    return Promise.resolve(textResult(`Loop #${id} not found`));
+                getTriggerSystem().remove(id);
+                updateWidget();
+                return Promise.resolve(textResult(`Loop #${id} paused`));
+            }
+            getTriggerSystem().remove(id);
+            const deleted = getStore().delete(id);
+            updateWidget();
+            if (deleted)
+                return Promise.resolve(textResult(`Loop #${id} deleted`));
+            return Promise.resolve(textResult(`Loop #${id} not found`));
+        },
+    });
+}

package/dist/tools/monitor-tools.d.ts

@@ -0,0 +1,25 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { LoopEntry, MonitorEntry, Trigger } from "../types.js";
+interface MonitorManagerLike {
+    list(): MonitorEntry[];
+    create(command: string, description?: string, timeout?: number): MonitorEntry;
+    stop(id: string): Promise<boolean>;
+}
+interface LoopStoreLike {
+    create(trigger: Trigger, prompt: string, opts: {
+        recurring: boolean;
+        autoTask?: boolean;
+        taskBacklog?: boolean;
+        readOnly?: boolean;
+        maxFires?: number;
+    }): LoopEntry;
+}
+export interface MonitorToolsOptions {
+    pi: ExtensionAPI;
+    getStore: () => LoopStoreLike;
+    getMonitorManager: () => MonitorManagerLike;
+    updateWidget: () => void;
+    handleMonitorDoneLoop: (doneLoop: LoopEntry, monitorId: string) => void;
+}
+export declare function registerMonitorTools(options: MonitorToolsOptions): void;
+export {};

package/dist/tools/monitor-tools.js

@@ -0,0 +1,110 @@
+import { Type } from "typebox";
+function textResult(msg) {
+    return { content: [{ type: "text", text: msg }], details: undefined };
+}
+function formatRemaining(ms) {
+    if (ms < 60000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3600000)
+        return `${Math.round(ms / 60000)}m`;
+    return `${Math.round(ms / 3600000)}h`;
+}
+export function registerMonitorTools(options) {
+    const { pi, getStore, getMonitorManager, updateWidget, handleMonitorDoneLoop } = options;
+    pi.registerTool({
+        name: "MonitorCreate",
+        label: "MonitorCreate",
+        description: `Run a shell command in the background and get notified when it finishes. The core tool for async/parallel work.
+
+Fire off a build check, CI monitor, experiment, script, or any slow command — then keep working. Output streams back as "monitor:output" events. When the process exits, "monitor:done" fires (or "monitor:error" on failure).
+
+If you pass onDone with a prompt, the monitor auto-creates a one-shot completion loop — you get a completion wake with the exit code and output line count. No need to poll or create a separate loop.
+
+DO NOT use raw Bash while/sleep/for loops to watch something. DO NOT run slow commands inline that could be offloaded. Use MonitorCreate to run work in parallel while you continue.
+
+## When to Use
+
+Default to MonitorCreate for any long-running or background work:\n- Watch a CI/CD build (hut, gh, curl polling) while you work on something else\n- Run experiments, benchmarks, or training scripts in parallel\n- Tail a log or poll an API endpoint\n- Fire off a slow curl/fetch and check the result later\n- Run any script or command you don't need to wait on inline
+
+## Events emitted
+
+- "monitor:output" — { monitorId, line, timestamp } for each output line\n- "monitor:done" — { monitorId, exitCode, outputLines } on clean exit\n- "monitor:error" — { monitorId, error } on failure
+
+## onDone — auto-notify on completion
+
+Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fires when the process exits. The completion wake includes the exit code and output line count.\n\nExample: MonitorCreate command="python train.py" onDone="Check training results and report best loss"\nExample: MonitorCreate command="hut builds show 1769753" onDone="Analyze the build result and report status"`,
+        promptGuidelines: [
+            "Default to MonitorCreate for any long-running or background command — releases the agent to keep working on other tasks in parallel.",
+            "When the user asks to monitor CI builds, watch a build, check a remote job, or run an experiment, use MonitorCreate instead of inline bash/curl/wait.",
+            "Use onDone to auto-notify when a background command finishes — the agent will pick up the results automatically.",
+        ],
+        parameters: Type.Object({
+            command: Type.String({ description: "Shell command to run in background" }),
+            description: Type.Optional(Type.String({ description: "Human-readable description" })),
+            timeout: Type.Optional(Type.Number({ description: "Auto-stop after N ms (default: 300000, 0 = no timeout)", default: 300000 })),
+            onDone: Type.Optional(Type.String({ description: "Prompt to run when the monitor completes. Auto-creates a one-shot completion wake — no need for a separate LoopCreate." })),
+        }),
+        execute(_toolCallId, params) {
+            if (getMonitorManager().list().filter((m) => m.status === "running").length >= 25) {
+                return Promise.resolve(textResult("Maximum of 25 running monitors reached. Stop some before creating new ones."));
+            }
+            const entry = getMonitorManager().create(params.command, params.description, params.timeout);
+            updateWidget();
+            let onDoneMsg = "";
+            if (params.onDone) {
+                const doneTrigger = { type: "event", source: "monitor:done", filter: JSON.stringify({ monitorId: entry.id }) };
+                const doneLoop = getStore().create(doneTrigger, params.onDone, { recurring: false });
+                handleMonitorDoneLoop(doneLoop, entry.id);
+                onDoneMsg = `\nonDone loop #${doneLoop.id}: fires when monitor completes — no polling needed`;
+            }
+            return Promise.resolve(textResult(`Monitor #${entry.id} started: ${entry.command.slice(0, 60)}\n` +
+                `Output stream: monitor:output (monitorId: ${entry.id})\n` +
+                `Timeout: ${params.timeout ? `${params.timeout / 1000}s` : "none"}${onDoneMsg}`));
+        },
+    });
+    pi.registerTool({
+        name: "MonitorList",
+        label: "MonitorList",
+        description: "List all monitors with their status, command, exit code, output line count, and last 5 lines of buffered output.",
+        parameters: Type.Object({}),
+        execute() {
+            const monitors = getMonitorManager().list();
+            if (monitors.length === 0)
+                return Promise.resolve(textResult("No monitors running."));
+            const lines = [];
+            for (const m of monitors) {
+                const icon = m.status === "running" ? ">" : m.status === "completed" ? "ok" : "!!";
+                const age = Date.now() - m.startedAt;
+                const ageStr = formatRemaining(age);
+                let line = `${icon} #${m.id} [${m.status}] ${m.command.slice(0, 60)} — ${m.outputLines} lines (${ageStr})`;
+                if (m.exitCode !== undefined)
+                    line += ` exit=${m.exitCode}`;
+                lines.push(line);
+                if (m.status !== "running" && m.outputBuffer.length > 0) {
+                    const tail = m.outputBuffer.slice(-5);
+                    for (const out of tail) {
+                        lines.push(`  | ${out.slice(0, 100)}`);
+                    }
+                }
+            }
+            return Promise.resolve(textResult(lines.join("\n")));
+        },
+    });
+    pi.registerTool({
+        name: "MonitorStop",
+        label: "MonitorStop",
+        description: `Stop a running monitor. Sends SIGTERM, waits 5s, then SIGKILL.
+
+Use MonitorList to find the monitor ID, then stop it with this tool.`,
+        parameters: Type.Object({
+            monitorId: Type.String({ description: "Monitor ID to stop" }),
+        }),
+        async execute(_toolCallId, params) {
+            const stopped = await getMonitorManager().stop(params.monitorId);
+            updateWidget();
+            if (stopped)
+                return textResult(`Monitor #${params.monitorId} stopped`);
+            return textResult(`Monitor #${params.monitorId} not found or not running`);
+        },
+    });
+}

package/dist/tools/native-task-tools.d.ts

@@ -0,0 +1,15 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { TaskStore } from "../task-store.js";
+export interface TaskBacklogResult {
+    created: boolean;
+    entry?: {
+        id: string;
+    };
+}
+export interface NativeTaskToolsOptions {
+    pi: ExtensionAPI;
+    taskStore: TaskStore;
+    evaluateTaskBacklog: (taskStore: TaskStore, pendingCount: number) => Promise<TaskBacklogResult>;
+    updateWidget: () => void;
+}
+export declare function registerNativeTaskTools(options: NativeTaskToolsOptions): void;

package/dist/tools/native-task-tools.js

@@ -0,0 +1,127 @@
+import { Type } from "typebox";
+function textResult(msg) {
+    return { content: [{ type: "text", text: msg }], details: undefined };
+}
+export function registerNativeTaskTools(options) {
+    const { pi, taskStore, evaluateTaskBacklog, updateWidget } = options;
+    pi.registerTool({
+        name: "TaskCreate",
+        label: "TaskCreate",
+        description: `Create a task for tracking work across turns. Use when you need to track progress on complex multi-step tasks.
+
+Fields:
+- subject: brief actionable title
+- description: detailed requirements
+- metadata: optional tags/metadata`,
+        promptGuidelines: [
+            "Use TaskCreate to track complex multi-step work across turns.",
+            "Break work into small, independently completable tasks. A task should be finishable in one focused session — if a task would take multiple turns, split it further.",
+            "TaskCreate accepts `subject` and `description` parameters only — do not invent extra fields unless the schema explicitly adds them.",
+        ],
+        parameters: Type.Object({
+            subject: Type.String({ description: "Brief actionable title for the task" }),
+            description: Type.String({ description: "Detailed description of what needs to be done" }),
+        }),
+        async execute(_toolCallId, params) {
+            const entry = taskStore.create(params.subject, params.description);
+            pi.events.emit("tasks:created", {
+                taskId: entry.id,
+                subject: entry.subject,
+                description: entry.description,
+                status: entry.status,
+            });
+            const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+            updateWidget();
+            const autoLoopMsg = backlog.created && backlog.entry
+                ? `\nWorker loop #${backlog.entry.id} auto-created`
+                : "";
+            return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
+        },
+    });
+    pi.registerTool({
+        name: "TaskList",
+        label: "TaskList",
+        description: "List all tasks with status. Use to check progress and find available work.",
+        parameters: Type.Object({}),
+        execute() {
+            const tasks = taskStore.list();
+            if (tasks.length === 0)
+                return Promise.resolve(textResult("No tasks."));
+            const lines = [];
+            const statuses = {
+                pending: 0,
+                in_progress: 0,
+                completed: 0,
+            };
+            for (const t of tasks) {
+                statuses[t.status]++;
+                const icon = t.status === "completed" ? "ok" : t.status === "in_progress" ? ">" : "*";
+                lines.push(`${icon} #${t.id} [${t.status}] ${t.subject.slice(0, 80)}`);
+            }
+            lines.unshift(`${tasks.length} tasks (${statuses.pending} pending, ${statuses.in_progress} in progress, ${statuses.completed} done)`);
+            return Promise.resolve(textResult(lines.join("\n")));
+        },
+    });
+    pi.registerTool({
+        name: "TaskUpdate",
+        label: "TaskUpdate",
+        description: `Update task status or details. Set status to "in_progress" before starting work, "completed" when done.
+
+Statuses: pending → in_progress → completed
+Parameters: id (required), status, subject, description`,
+        promptGuidelines: [
+            "TaskUpdate uses parameter `id`, not `taskId`.",
+            "Accepted parameters: `id` (required), `status`, `subject`, `description`.",
+            "When validation fails with 'must have required properties id', you passed `taskId` instead of `id`. Correct silently and retry.",
+        ],
+        parameters: Type.Object({
+            id: Type.String({ description: "Task ID to update" }),
+            status: Type.Optional(Type.String({ description: "New status", enum: ["pending", "in_progress", "completed"] })),
+            subject: Type.Optional(Type.String({ description: "New title" })),
+            description: Type.Optional(Type.String({ description: "New description" })),
+        }),
+        async execute(_toolCallId, params) {
+            const { id, status, subject, description } = params;
+            let entry = taskStore.get(id);
+            if (!entry)
+                return Promise.resolve(textResult(`Task #${id} not found`));
+            if (status === "in_progress")
+                entry = taskStore.start(id);
+            else if (status === "completed")
+                entry = taskStore.complete(id);
+            else if (status === "pending")
+                entry = taskStore.reopen(id);
+            if (!entry)
+                return Promise.resolve(textResult(`Task #${id} not found`));
+            if (subject !== undefined || description !== undefined) {
+                entry = taskStore.updateDetails(id, { subject, description });
+            }
+            if (!entry)
+                return Promise.resolve(textResult(`Task #${id} not found`));
+            updateWidget();
+            const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+            const statusMsg = status ? ` → ${status}` : "";
+            const autoLoopMsg = backlog.created && backlog.entry
+                ? `\nWorker loop #${backlog.entry.id} auto-created`
+                : "";
+            return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
+        },
+    });
+    pi.registerTool({
+        name: "TaskDelete",
+        label: "TaskDelete",
+        description: "Delete a task by ID. Use for cleaning up completed or irrelevant tasks.",
+        parameters: Type.Object({
+            id: Type.String({ description: "Task ID to delete" }),
+        }),
+        async execute(_toolCallId, params) {
+            const deleted = taskStore.delete(params.id);
+            updateWidget();
+            if (deleted) {
+                await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+                return Promise.resolve(textResult(`Task #${params.id} deleted`));
+            }
+            return Promise.resolve(textResult(`Task #${params.id} not found`));
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trevonistrevon/pi-loop",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
   "author": "trevonistrevon",
   "license": "MIT",