@trevonistrevon/pi-loop 0.3.1 → 0.4.0

package/DIFFERENTIAL_REVIEW_REPORT.md

@@ -0,0 +1,59 @@
+# Differential Review Report
+
+## Scope
+Reviewed recent uncommitted changes in:
+- `src/index.ts`
+- `src/ui/widget.ts`
+- `test/index.test.ts`
+- `test/widget.test.ts`
+- `README.md`
+
+## Risk Summary
+- **Overall risk:** Medium
+- **Primary areas affected:** runtime task fallback routing, UI/widget behavior, interactive command registration
+- **Security impact:** Low direct security impact; main risks are state-management regressions and missing coverage around command behavior
+
+## Findings
+
+### 🟡 Warning
+`src/index.ts` - Native task fallback is covered for registration and file persistence, but not for interactive `/tasks` flows or loop-driven task lifecycle integration.
+
+**Why it matters:**
+The new `/tasks` command and interactive actions (`Start`, `Complete`, `Reopen`, `Delete`) are stateful and user-facing. Regressions here would not be caught by current tests. Similarly, native fallback behavior for `autoTask`, `hasPendingTasks()`, and `cleanDoneTasks()` is only indirectly covered.
+
+**Recommended follow-up:**
+Add tests for:
+- `/tasks` command registration and quick-create path
+- native `autoTask` creation path
+- `hasPendingTasks()` using native fallback
+- completed-task sweep behavior for native tasks
+
+### 🟢 Suggestion
+`src/ui/widget.ts` - Compact widget behavior is appropriately simplified and focus-oriented.
+
+**Good pattern:**
+The single-line status approach reduces noise and matches the intended UX. Showing only active/next task focus text is a good constraint.
+
+## Test Coverage Review
+
+### Covered well
+- Native tool registration when `pi-tasks` is absent/present
+- Native task persistence path (`.pi/tasks/tasks.json`)
+- Compact widget states:
+  - `none`
+  - monitor-only count
+  - loop + monitor count
+  - active task focus text
+  - next task focus text
+  - retained widget rendering after content clears
+
+### Coverage gaps
+- No tests for `/tasks` command behavior beyond registration
+- No direct tests for native `TaskUpdate` → widget focus transitions
+- No direct tests for native `cleanDoneTasks()` sweep behavior
+- No end-to-end tests for `LoopCreate(autoTask: true)` using native fallback
+
+## Review Verdict
+- **No merge-blocking issues found**
+- Safe to release after version bump and validation
+- Recommended follow-up: add native task lifecycle command/integration tests in a later pass

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
 <h1 align="center">@trevonistrevon/pi-loop</h1>
-<h6 align="center">Cron and event loops for the pi coding agent. Background monitors, scheduled re-wakes, pi-tasks integration.</h6>
+<h6 align="center">Cron and event loops for the pi coding agent. Background monitors, scheduled re-wakes, pi-tasks integration, and native task fallback.</h6>
 </p>
 
 ## Install
@@ -11,29 +11,45 @@ pi install @trevonistrevon/pi-loop
 
 ## Quick start
 
-```
+```text
 LoopCreate trigger="5m" prompt="Check if the build passed"
 LoopCreate trigger="tool_execution_start" prompt="Log the tool being used" triggerType="event"
 LoopList
 LoopDelete id="1"
 ```
 
-```
+```text
 MonitorCreate command="tail -n0 -f build.log" description="Watch build"
 MonitorCreate command="python train.py" onDone="Analyze results and report best loss"
 MonitorList
 MonitorStop monitorId="1"
 ```
 
+When `pi-tasks` is not installed, `pi-loop` also exposes native task tools after startup detection:
+
+```text
+TaskCreate subject="Fix deploy polling" description="Switch deploy check to event-driven loop"
+TaskList
+TaskUpdate id="1" status="in_progress"
+TaskDelete id="1"
+```
+
 ## Commands
 
 `/loop [interval] [prompt]` — interactive loop creation.
 
-```
+```text
 /loop                         # menu
 /loop 5m check the deploy     # 5-minute cron loop
 ```
 
+`/tasks` — interactive native task viewer/manager, only registered when `pi-tasks` is absent.
+
+```text
+/tasks                        # open native task viewer
+/tasks Write README updates   # quick-create native task
+```
+
 ## Tools
 
 | Tool | What it does |
@@ -44,16 +60,44 @@ MonitorStop monitorId="1"
 | `MonitorCreate` | Run a background command, stream output as `monitor:output` events. Use `onDone` for auto-notify on completion |
 | `MonitorList` | Show monitors with status, uptime, and output line count |
 | `MonitorStop` | Stop a monitor (SIGTERM → 5s → SIGKILL) |
+| `TaskCreate` | Create a native fallback task when `pi-tasks` is absent |
+| `TaskList` | List native fallback tasks |
+| `TaskUpdate` | Update native fallback task status/details |
+| `TaskDelete` | Delete a native fallback task |
 
 Trigger types: `cron` (`5m`, `1h`, `0 9 * * 1-5`), `event` (any pi event source), or `hybrid` (both, debounced).
 
-## pi-tasks
+## Tasks
+
+### With `pi-tasks`
 
 Works with [@tintinweb/pi-tasks](https://github.com/tintinweb/pi-tasks). Pass `autoTask: true` on `LoopCreate` and each loop fire auto-creates a tracked task. Detection happens over pi's event bus — no manual wiring.
 
+### Without `pi-tasks`
+
+If `pi-tasks` does not respond during startup detection, `pi-loop` registers a native fallback task system for the session:
+
+- persistent store at `.pi/tasks/tasks.json`
+- `TaskCreate`, `TaskList`, `TaskUpdate`, `TaskDelete`
+- `/tasks` interactive viewer
+- compact widget task tracking
+
+This fallback is session-sticky: `pi-loop` decides once at startup whether `pi-tasks` or native tasks own task management for that session.
+
 ## Widget
 
-Active loops and monitors show in a persistent TUI widget above the editor.
+`pi-loop` keeps a compact persistent TUI widget above the editor.
+
+It now shows a single focus-friendly status line such as:
+
+```text
+none
+1 loop · 1 monitor
+2 tasks | active: Fix deploy polling
+1 loop · 2 monitors · 3 tasks | next: Update README
+```
+
+Only task counts and the single active/next task are shown in the widget so attention stays on what is currently happening. Use `LoopList`, `MonitorList`, and `/tasks` for detail.
 
 ## Configuration
 

package/dist/index.js

@@ -20,6 +20,7 @@ import { parseInterval } from "./loop-parse.js";
 import { MonitorManager } from "./monitor-manager.js";
 import { CronScheduler } from "./scheduler.js";
 import { LoopStore } from "./store.js";
+import { TaskStore } from "./task-store.js";
 import { TriggerSystem } from "./trigger-system.js";
 import { LoopWidget } from "./ui/widget.js";
 const DEBUG = !!process.env.PI_LOOP_DEBUG;
@@ -52,17 +53,35 @@ export default function (pi) {
             return undefined;
         return join(process.cwd(), ".pi", "loops", "loops.json");
     }
+    function resolveTaskStorePath() {
+        if (loopScope === "memory")
+            return undefined;
+        return join(process.cwd(), ".pi", "tasks", "tasks.json");
+    }
     let store = new LoopStore(resolveStorePath());
     const monitorManager = new MonitorManager(pi);
     let scheduler;
     let triggerSystem;
-    const widget = new LoopWidget(store, undefined, monitorManager);
+    const widget = new LoopWidget(store, monitorManager);
+    widget.setTaskSummaryProvider(() => {
+        if (!nativeTaskStore)
+            return { count: 0 };
+        const tasks = nativeTaskStore.list().filter(t => t.status === "pending" || t.status === "in_progress");
+        const active = tasks.find(t => t.status === "in_progress");
+        const next = tasks.find(t => t.status === "pending");
+        const focus = active
+            ? `active: ${active.subject.slice(0, 50)}`
+            : next
+                ? `next: ${next.subject.slice(0, 50)}`
+                : undefined;
+        return { count: tasks.length, focusText: focus };
+    });
     scheduler = new CronScheduler(store, onLoopFire);
-    widget.setScheduler(scheduler);
-    triggerSystem = new TriggerSystem(pi, scheduler, store);
+    triggerSystem = new TriggerSystem(pi, scheduler, store, onLoopFire);
     // ── pi-tasks integration ──
     let tasksAvailable = false;
-    const _PROTOCOL_VERSION = 1;
+    let nativeTaskStore;
+    let nativeTasksRegistered = false;
     function checkTasksVersion() {
         const requestId = randomUUID();
         const timer = setTimeout(() => { unsub(); }, 5000);
@@ -78,53 +97,87 @@ export default function (pi) {
     checkTasksVersion();
     pi.events.on("tasks:ready", () => checkTasksVersion());
     async function autoCreateTask(entry) {
-        if (!tasksAvailable || !entry.autoTask)
+        if (!entry.autoTask)
             return undefined;
-        try {
-            const requestId = randomUUID();
-            const taskId = await new Promise((resolve, _reject) => {
-                const timer = setTimeout(() => { unsub(); resolve(undefined); }, 5000);
-                const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw) => {
-                    unsub();
-                    clearTimeout(timer);
-                    const reply = raw;
-                    if (reply.success && reply.data)
-                        resolve(reply.data.id);
-                    else
-                        resolve(undefined);
+        if (tasksAvailable) {
+            try {
+                const requestId = randomUUID();
+                const taskId = await new Promise((resolve, _reject) => {
+                    const timer = setTimeout(() => { unsub(); resolve(undefined); }, 5000);
+                    const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw) => {
+                        unsub();
+                        clearTimeout(timer);
+                        const reply = raw;
+                        if (reply.success && reply.data)
+                            resolve(reply.data.id);
+                        else
+                            resolve(undefined);
+                    });
+                    pi.events.emit("tasks:rpc:create", {
+                        requestId,
+                        subject: entry.prompt.slice(0, 80),
+                        description: `Auto-created from loop #${entry.id}`,
+                        metadata: { loopId: entry.id, trigger: entry.trigger },
+                    });
                 });
-                pi.events.emit("tasks:rpc:create", {
-                    requestId,
-                    subject: entry.prompt.slice(0, 80),
-                    description: `Auto-created from loop #${entry.id}`,
-                    metadata: { loopId: entry.id, trigger: entry.trigger },
-                });
-            });
-            return taskId;
+                return taskId;
+            }
+            catch {
+                return undefined;
+            }
         }
-        catch {
+        if (!nativeTaskStore)
             return undefined;
-        }
+        const task = nativeTaskStore.create(entry.prompt.slice(0, 80), `Auto-created from loop #${entry.id}`, {
+            loopId: entry.id,
+            trigger: entry.trigger,
+        });
+        widget.update();
+        return task.id;
     }
     async function hasPendingTasks() {
-        if (!tasksAvailable)
-            return -1;
-        try {
-            const requestId = randomUUID();
-            const count = await new Promise((resolve) => {
-                const timer = setTimeout(() => { unsub(); resolve(-1); }, 3000);
-                const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw) => {
-                    unsub();
-                    clearTimeout(timer);
-                    const reply = raw;
-                    resolve(reply.success && reply.data ? reply.data.pending : -1);
+        if (tasksAvailable) {
+            try {
+                const requestId = randomUUID();
+                const count = await new Promise((resolve) => {
+                    const timer = setTimeout(() => { unsub(); resolve(-1); }, 3000);
+                    const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw) => {
+                        unsub();
+                        clearTimeout(timer);
+                        const reply = raw;
+                        resolve(reply.success && reply.data ? reply.data.pending : -1);
+                    });
+                    pi.events.emit("tasks:rpc:pending", { requestId });
                 });
-                pi.events.emit("tasks:rpc:pending", { requestId });
-            });
-            return count;
+                return count;
+            }
+            catch {
+                return -1;
+            }
+        }
+        return nativeTaskStore ? nativeTaskStore.pendingCount() : -1;
+    }
+    async function cleanDoneTasks() {
+        if (tasksAvailable) {
+            try {
+                const requestId = randomUUID();
+                await new Promise((resolve) => {
+                    const timer = setTimeout(() => { unsub(); resolve(); }, 3000);
+                    const unsub = pi.events.on(`tasks:rpc:clean:reply:${requestId}`, () => {
+                        unsub();
+                        clearTimeout(timer);
+                        debug("tasks:rpc:clean — done tasks swept");
+                        resolve();
+                    });
+                    pi.events.emit("tasks:rpc:clean", { requestId });
+                });
+            }
+            catch { /* timeout or error, ignore */ }
+            return;
         }
-        catch {
-            return -1;
+        if (nativeTaskStore) {
+            nativeTaskStore.sweepCompleted();
+            widget.update();
         }
     }
     // ── Loop fire handler ──
@@ -165,8 +218,7 @@ export default function (pi) {
             store = new LoopStore(path);
             widget.setStore(store);
             scheduler = new CronScheduler(store, onLoopFire);
-            widget.setScheduler(scheduler);
-            triggerSystem = new TriggerSystem(pi, scheduler, store);
+            triggerSystem = new TriggerSystem(pi, scheduler, store, onLoopFire);
         }
         storeUpgraded = true;
     }
@@ -187,12 +239,14 @@ export default function (pi) {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         upgradeStoreIfNeeded(ctx);
+        widget.update();
     });
     pi.on("before_agent_start", async (_event, ctx) => {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         upgradeStoreIfNeeded(ctx);
         showPersistedLoops();
+        widget.update();
     });
     pi.on("session_switch", async (event, ctx) => {
         _latestCtx = ctx;
@@ -206,6 +260,7 @@ export default function (pi) {
         }
         upgradeStoreIfNeeded(ctx);
         showPersistedLoops(isResume);
+        widget.update();
     });
     // ── Loop fire handler — sends a user message to re-wake the agent ──
     pi.events.on("loop:fire", async (event) => {
@@ -217,7 +272,8 @@ export default function (pi) {
         if (data.autoTask) {
             const pending = await hasPendingTasks();
             if (pending === 0) {
-                debug(`loop:fire #${data.loopId} — no pending tasks, skipping`);
+                debug(`loop:fire #${data.loopId} — no pending tasks, skipping, requesting cleanup`);
+                cleanDoneTasks();
                 return;
             }
         }
@@ -430,7 +486,7 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
                 const nextFire = entry.trigger.type !== "event"
                     ? scheduler.nextFire(entry.id)
                     : undefined;
-                const statusIcon = entry.status === "active" ? "⟳" : entry.status === "paused" ? "⏸" : "✗";
+                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) {
@@ -550,7 +606,7 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
                 return Promise.resolve(textResult("No monitors running."));
             const lines = [];
             for (const m of monitors) {
-                const icon = m.status === "running" ? "◉" : m.status === "completed" ? "✓" : "✗";
+                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})`;
@@ -680,42 +736,42 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     async function viewLoops(ui) {
         const loops = store.list();
         if (loops.length === 0) {
-            await ui.select("No active loops", ["← Back"]);
+            await ui.select("No active loops", ["< Back"]);
             return;
         }
         const choices = loops.map((l) => {
-            const icon = l.status === "active" ? "⟳" : l.status === "paused" ? "⏸" : "✗";
+            const icon = l.status === "active" ? "*" : l.status === "paused" ? "-" : "x";
             const triggerDesc = l.trigger.type === "cron" ? `cron: ${l.trigger.schedule}` : l.trigger.type === "event" ? `event: ${l.trigger.source}` : `hybrid: ${l.trigger.cron}`;
             return `${icon} #${l.id} [${l.status}] ${l.prompt.slice(0, 50)} (${triggerDesc})`;
         });
-        choices.push("← Back");
+        choices.push("< Back");
         const selected = await ui.select("Active Loops", choices);
-        if (!selected || selected === "← Back")
+        if (!selected || selected === "< Back")
             return;
         const match = selected.match(/#(\d+)/);
         if (match) {
             const entry = store.get(match[1]);
             if (entry) {
-                const actions = ["✗ Delete"];
+                const actions = ["x Delete"];
                 if (entry.status === "active")
-                    actions.unshift("⏸ Pause");
+                    actions.unshift("- Pause");
                 else if (entry.status === "paused")
-                    actions.unshift("▶ Resume");
-                actions.push("← Back");
+                    actions.unshift("* Resume");
+                actions.push("< Back");
                 const action = await ui.select(`#${entry.id}: ${entry.prompt}\nTrigger: ${JSON.stringify(entry.trigger)}`, actions);
-                if (action === "✗ Delete") {
+                if (action === "x Delete") {
                     triggerSystem.remove(entry.id);
                     store.delete(entry.id);
                     widget.update();
                     ui.notify(`Loop #${entry.id} deleted`, "info");
                 }
-                else if (action === "⏸ Pause") {
+                else if (action === "- Pause") {
                     store.update(entry.id, { status: "paused" });
                     triggerSystem.remove(entry.id);
                     widget.update();
                     ui.notify(`Loop #${entry.id} paused`, "info");
                 }
-                else if (action === "▶ Resume") {
+                else if (action === "* Resume") {
                     store.update(entry.id, { status: "active" });
                     triggerSystem.add(entry);
                     widget.update();
@@ -730,4 +786,187 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
         const active = loops.filter(l => l.status === "active").length;
         ui.notify(`${active}/${loops.length} active loops (max 25)`, "info");
     }
+    async function createNativeTaskInteractively(ui) {
+        if (!nativeTaskStore) {
+            ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+            return;
+        }
+        const subject = await ui.input("Task subject");
+        if (!subject)
+            return;
+        const description = await ui.input("Task description") || subject;
+        const entry = nativeTaskStore.create(subject, description);
+        widget.update();
+        ui.notify(`Task #${entry.id} created`, "info");
+    }
+    async function viewNativeTasks(ui) {
+        if (!nativeTaskStore) {
+            ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+            return;
+        }
+        const tasks = nativeTaskStore.list();
+        const choices = tasks.map((task) => {
+            const icon = task.status === "in_progress" ? ">" : task.status === "completed" ? "ok" : "*";
+            return `${icon} #${task.id} [${task.status}] ${task.subject.slice(0, 60)}`;
+        });
+        choices.unshift("+ Create task");
+        choices.push("< Back");
+        const selected = await ui.select("Native Tasks", choices);
+        if (!selected || selected === "< Back")
+            return;
+        if (selected === "+ Create task") {
+            await createNativeTaskInteractively(ui);
+            return viewNativeTasks(ui);
+        }
+        const match = selected.match(/#(\d+)/);
+        if (!match)
+            return viewNativeTasks(ui);
+        const task = nativeTaskStore.get(match[1]);
+        if (!task)
+            return viewNativeTasks(ui);
+        const actions = ["x Delete"];
+        if (task.status === "pending") {
+            actions.unshift("ok Complete");
+            actions.unshift("> Start");
+        }
+        else if (task.status === "in_progress") {
+            actions.unshift("ok Complete");
+            actions.unshift("* Return to pending");
+        }
+        else {
+            actions.unshift("* Reopen");
+        }
+        actions.push("< Back");
+        const action = await ui.select(`#${task.id}: ${task.subject}\n\n${task.description}`, actions);
+        if (!action || action === "< Back")
+            return viewNativeTasks(ui);
+        if (action === "x Delete") {
+            nativeTaskStore.delete(task.id);
+            ui.notify(`Task #${task.id} deleted`, "info");
+        }
+        else if (action === "> Start") {
+            nativeTaskStore.update(task.id, { status: "in_progress" });
+            ui.notify(`Task #${task.id} started`, "info");
+        }
+        else if (action === "ok Complete") {
+            nativeTaskStore.update(task.id, { status: "completed" });
+            ui.notify(`Task #${task.id} completed`, "info");
+        }
+        else if (action === "* Return to pending" || action === "* Reopen") {
+            nativeTaskStore.update(task.id, { status: "pending" });
+            ui.notify(`Task #${task.id} reopened`, "info");
+        }
+        widget.update();
+        return viewNativeTasks(ui);
+    }
+    // ── Native task tools (only when pi-tasks is absent) ──
+    setTimeout(async () => {
+        if (tasksAvailable || nativeTasksRegistered)
+            return;
+        nativeTaskStore = new TaskStore(resolveTaskStorePath());
+        nativeTasksRegistered = true;
+        const taskStore = nativeTaskStore;
+        pi.registerCommand("tasks", {
+            description: "View or manage native pi-loop tasks when pi-tasks is not installed",
+            handler: async (args, ctx) => {
+                const trimmed = args.trim();
+                if (!nativeTaskStore) {
+                    ctx.ui.notify("Native tasks are unavailable while pi-tasks is active", "warning");
+                    return;
+                }
+                if (trimmed) {
+                    const entry = nativeTaskStore.create(trimmed.slice(0, 80), trimmed);
+                    widget.update();
+                    ctx.ui.notify(`Task #${entry.id} created`, "info");
+                    return;
+                }
+                await viewNativeTasks(ctx.ui);
+            },
+        });
+        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`,
+            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" }),
+            }),
+            execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+                const entry = taskStore.create(params.subject, params.description);
+                widget.update();
+                return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}`));
+            },
+        });
+        pi.registerTool({
+            name: "TaskList",
+            label: "TaskList",
+            description: `List all tasks with status. Use to check progress and find available work.`,
+            parameters: Type.Object({}),
+            execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+                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: 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" })),
+            }),
+            execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+                const { id, status, subject, description } = params;
+                const entry = taskStore.update(id, {
+                    status: status,
+                    subject,
+                    description,
+                });
+                if (!entry)
+                    return Promise.resolve(textResult(`Task #${id} not found`));
+                widget.update();
+                const statusMsg = status ? ` → ${status}` : "";
+                return Promise.resolve(textResult(`Task #${id} updated${statusMsg}`));
+            },
+        });
+        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" }),
+            }),
+            execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+                const deleted = taskStore.delete(params.id);
+                widget.update();
+                if (deleted)
+                    return Promise.resolve(textResult(`Task #${params.id} deleted`));
+                return Promise.resolve(textResult(`Task #${params.id} not found`));
+            },
+        });
+        debug("native task tools registered (pi-tasks not detected)");
+    }, 6000);
 }

package/dist/task-store.d.ts

@@ -0,0 +1,22 @@
+import type { TaskEntry, TaskStatus } from "./task-types.js";
+export declare class TaskStore {
+    private filePath;
+    private lockPath;
+    private nextId;
+    private tasks;
+    constructor(listIdOrPath?: string);
+    private load;
+    private save;
+    private withLock;
+    create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry;
+    get(id: string): TaskEntry | undefined;
+    list(): TaskEntry[];
+    update(id: string, fields: {
+        status?: TaskStatus;
+        subject?: string;
+        description?: string;
+    }): TaskEntry | undefined;
+    delete(id: string): boolean;
+    pendingCount(): number;
+    sweepCompleted(): number;
+}