@trevonistrevon/pi-loop 0.4.11 → 0.5.1

package/dist/task-store.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
+import { reduceTaskState } from "./task-reducer.js";
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
 const LOCK_RETRY_MS = 50;
 const LOCK_MAX_RETRIES = 100;
@@ -103,23 +104,31 @@ export class TaskStore {
             releaseLock(this.lockPath);
         }
     }
+    toReducerState() {
+        return {
+            nextId: this.nextId,
+            tasksById: Object.fromEntries(this.tasks.entries()),
+        };
+    }
+    applyReducerEvent(event) {
+        const result = reduceTaskState(this.toReducerState(), event);
+        this.nextId = result.state.nextId;
+        this.tasks = new Map(Object.entries(result.state.tasksById));
+    }
     create(subject, description, metadata) {
         return this.withLock(() => {
             if (this.tasks.size >= MAX_TASKS) {
                 throw new Error(`Maximum of ${MAX_TASKS} tasks reached. Delete some before creating new ones.`);
             }
             const now = Date.now();
-            const entry = {
-                id: String(this.nextId++),
-                subject,
-                description,
-                status: "pending",
-                createdAt: now,
-                updatedAt: now,
-                metadata,
-            };
-            this.tasks.set(entry.id, entry);
-            return entry;
+            this.applyReducerEvent({
+                type: "TASK_CREATED",
+                at: now,
+                source: "tool",
+                entityType: "task",
+                payload: { subject, description, metadata },
+            });
+            return this.tasks.get(String(this.nextId - 1));
         });
     }
     get(id) {
@@ -132,29 +141,88 @@ export class TaskStore {
             this.load();
         return Array.from(this.tasks.values()).sort((a, b) => Number(a.id) - Number(b.id));
     }
-    update(id, fields) {
+    start(id) {
         return this.withLock(() => {
             const entry = this.tasks.get(id);
             if (!entry)
                 return undefined;
-            if (fields.status !== undefined) {
-                entry.status = fields.status;
-                if (fields.status === "completed")
-                    entry.completedAt = Date.now();
-            }
-            if (fields.subject !== undefined)
-                entry.subject = fields.subject;
-            if (fields.description !== undefined)
-                entry.description = fields.description;
-            entry.updatedAt = Date.now();
-            return entry;
+            this.applyReducerEvent({
+                type: "TASK_STARTED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
+            return this.tasks.get(id);
+        });
+    }
+    complete(id) {
+        return this.withLock(() => {
+            const entry = this.tasks.get(id);
+            if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "TASK_COMPLETED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
+            return this.tasks.get(id);
+        });
+    }
+    reopen(id) {
+        return this.withLock(() => {
+            const entry = this.tasks.get(id);
+            if (!entry)
+                return undefined;
+            this.applyReducerEvent({
+                type: "TASK_REOPENED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
+            return this.tasks.get(id);
+        });
+    }
+    updateDetails(id, fields) {
+        return this.withLock(() => {
+            const entry = this.tasks.get(id);
+            if (!entry)
+                return undefined;
+            if (fields.subject === undefined && fields.description === undefined)
+                return entry;
+            this.applyReducerEvent({
+                type: "TASK_UPDATED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: {
+                    id,
+                    subject: fields.subject,
+                    description: fields.description,
+                },
+            });
+            return this.tasks.get(id);
         });
     }
     delete(id) {
         return this.withLock(() => {
             if (!this.tasks.has(id))
                 return false;
-            this.tasks.delete(id);
+            this.applyReducerEvent({
+                type: "TASK_DELETED",
+                at: Date.now(),
+                source: "tool",
+                entityType: "task",
+                entityId: id,
+                payload: { id },
+            });
             return true;
         });
     }
@@ -166,16 +234,17 @@ export class TaskStore {
         }
         return count;
     }
-    sweepCompleted() {
+    pruneCompleted() {
         return this.withLock(() => {
-            let count = 0;
-            for (const [id, entry] of this.tasks) {
-                if (entry.status === "completed") {
-                    this.tasks.delete(id);
-                    count++;
-                }
-            }
-            return count;
+            const before = this.tasks.size;
+            this.applyReducerEvent({
+                type: "TASKS_PRUNED",
+                at: Date.now(),
+                source: "system",
+                entityType: "task",
+                payload: { reason: "manual" },
+            });
+            return before - this.tasks.size;
         });
     }
 }

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

@@ -0,0 +1,41 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { LoopEntry, Trigger } from "../types.js";
+interface LoopStoreLike {
+    list(): LoopEntry[];
+    get(id: string): LoopEntry | undefined;
+    create(trigger: Trigger, prompt: string, opts: {
+        recurring: boolean;
+        autoTask?: boolean;
+        taskBacklog?: boolean;
+        readOnly?: boolean;
+        maxFires?: number;
+    }): LoopEntry;
+    pause(id: string): LoopEntry | undefined;
+    delete(id: string): boolean;
+}
+interface TriggerSystemLike {
+    add(entry: LoopEntry): void;
+    remove(id: string): void;
+}
+interface SchedulerLike {
+    nextFire(id: string): number | undefined;
+}
+interface MonitorLike {
+    id: string;
+    status: string;
+}
+interface MonitorManagerLike {
+    get(id: string): MonitorLike | undefined;
+}
+export interface LoopToolsOptions {
+    pi: ExtensionAPI;
+    getStore: () => LoopStoreLike;
+    getTriggerSystem: () => TriggerSystemLike;
+    getScheduler: () => SchedulerLike;
+    getMonitorManager: () => MonitorManagerLike;
+    updateWidget: () => void;
+    maybeBootstrapTaskLoop: (entry: LoopEntry) => Promise<boolean>;
+    isTaskSystemReady: () => boolean;
+}
+export declare function registerLoopTools(options: LoopToolsOptions): void;
+export {};

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;