@trevonistrevon/pi-loop 0.3.1 → 0.4.1

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,54 +97,169 @@ 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);
-                });
-                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 },
+        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 },
+                    });
                 });
-            });
-            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;
+        }
+        if (nativeTaskStore) {
+            nativeTaskStore.sweepCompleted();
+            widget.update();
         }
-        catch {
-            return -1;
+    }
+    let agentRunning = false;
+    const pendingNotifications = new Map();
+    let flushPromise;
+    function buildLoopFireMessage(data) {
+        const triggerInfo = typeof data.trigger === "string"
+            ? data.trigger
+            : data.trigger?.type === "cron"
+                ? `schedule: ${data.trigger.schedule}`
+                : data.trigger?.type === "event"
+                    ? `event: ${data.trigger.source}`
+                    : "hybrid";
+        const loopId = data.loopId || "?";
+        const prompt = data.prompt || "loop fired";
+        const constraint = data.readOnly
+            ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, etc.). No file writes, shell execution, or destructive changes."
+            : "";
+        return [
+            `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
+            prompt,
+        ].join("\n");
+    }
+    function buildPendingNotification(data) {
+        const key = data.recurring ? `loop:${data.loopId}` : `loop:${data.loopId}:${data.timestamp}`;
+        return {
+            ...data,
+            key,
+            message: buildLoopFireMessage(data),
+        };
+    }
+    async function deliverNotification(notification) {
+        if (notification.autoTask) {
+            const pending = await hasPendingTasks();
+            if (pending === 0) {
+                debug(`loop:fire #${notification.loopId} — no pending tasks at delivery time, dropping wake`);
+                await cleanDoneTasks();
+                return false;
+            }
         }
+        agentRunning = true;
+        pi.sendMessage({
+            customType: "pi-loop",
+            content: notification.message,
+            display: false,
+            details: {
+                loopId: notification.loopId,
+                trigger: notification.trigger,
+                recurring: notification.recurring,
+                readOnly: notification.readOnly,
+                autoTask: notification.autoTask,
+                timestamp: notification.timestamp,
+            },
+        }, {
+            deliverAs: "steer",
+            triggerTurn: true,
+        });
+        return true;
+    }
+    async function flushPendingNotifications() {
+        if (flushPromise)
+            return flushPromise;
+        flushPromise = (async () => {
+            if (agentRunning || _latestCtx?.hasPendingMessages())
+                return;
+            const entries = [...pendingNotifications.entries()]
+                .sort(([, left], [, right]) => left.timestamp - right.timestamp);
+            for (const [key, notification] of entries) {
+                pendingNotifications.delete(key);
+                const delivered = await deliverNotification(notification);
+                if (delivered)
+                    return;
+            }
+        })().finally(() => {
+            flushPromise = undefined;
+        });
+        return flushPromise;
+    }
+    async function queueOrDeliverNotification(data) {
+        const notification = buildPendingNotification(data);
+        pendingNotifications.set(notification.key, notification);
+        await flushPendingNotifications();
     }
     // ── Loop fire handler ──
     function onLoopFire(entry) {
@@ -165,8 +299,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,17 +320,36 @@ 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("agent_start", async (_event, ctx) => {
+        agentRunning = true;
+        _latestCtx = ctx;
+        widget.setUICtx(ctx.ui);
+    });
+    pi.on("agent_end", async (_event, ctx) => {
+        agentRunning = false;
+        _latestCtx = ctx;
+        widget.setUICtx(ctx.ui);
+        await flushPendingNotifications();
+    });
+    pi.on("session_shutdown", async () => {
+        agentRunning = false;
+        pendingNotifications.clear();
     });
     pi.on("session_switch", async (event, ctx) => {
         _latestCtx = ctx;
         widget.setUICtx(ctx.ui);
         triggerSystem.stop();
+        agentRunning = false;
+        pendingNotifications.clear();
         const isResume = event?.reason === "resume";
         storeUpgraded = false;
         persistedShown = false;
@@ -206,36 +358,20 @@ export default function (pi) {
         }
         upgradeStoreIfNeeded(ctx);
         showPersistedLoops(isResume);
+        widget.update();
     });
-    // ── Loop fire handler — sends a user message to re-wake the agent ──
+    // ── Loop fire handler — queues an in-memory notification, then injects a custom message when delivery is safe ──
     pi.events.on("loop:fire", async (event) => {
         const data = event;
-        if (data.recurring && _latestCtx?.hasPendingMessages()) {
-            debug(`loop:fire #${data.loopId} — agent has pending messages, skipping recurring fire`);
-            return;
-        }
         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`);
+                await cleanDoneTasks();
                 return;
             }
         }
-        const triggerInfo = typeof data.trigger === "string"
-            ? data.trigger
-            : data.trigger?.type === "cron"
-                ? `schedule: ${data.trigger.schedule}`
-                : data.trigger?.type === "event"
-                    ? `event: ${data.trigger.source}`
-                    : `hybrid`;
-        const loopId = data.loopId || "?";
-        const prompt = data.prompt || "loop fired";
-        const constraint = data.readOnly ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, LoopCreate, etc.). No file writes, shell execution, or destructive changes." : "";
-        const message = [
-            `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
-            prompt,
-        ].join("\n");
-        pi.sendUserMessage(message, { deliverAs: "followUp" });
+        await queueOrDeliverNotification(data);
     });
     // ──────────────────────────────────────────────────
     // Tool 1: LoopCreate
@@ -271,7 +407,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
 - **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**: if pi-tasks is loaded, auto-create a task on each fire
+- **autoTask**: when pi-tasks is loaded or native task fallback is active, auto-create a task on each fire
 - **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: [
@@ -290,7 +426,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             "Set readOnly: true for loops that only observe and report (checks, status polls). This prevents unintended changes.",
             "## Task-driven workflows",
             "After creating tasks with TaskCreate, use an event loop with autoTask: true so the system checks for pending tasks before firing: LoopCreate trigger='tasks:created' triggerType='event' autoTask: true maxFires: 30 prompt='Run TaskList, pick the next available pending task, work on it.'",
-            "When no tasks are pending, the loop skips the follow-up — no tokens burned on empty polls.",
+            "When no tasks are pending, the loop skips 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({
@@ -361,7 +497,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
                 `Trigger: ${triggerDesc}\n` +
                 `Recurring: ${entry.recurring}\n` +
                 (entry.autoTask ? `Auto-task: enabled\n` : "") +
-                (tasksAvailable ? "" : "(pi-tasks not detected — autoTask will have no effect)\n") +
+                ((tasksAvailable || nativeTasksRegistered) ? "" : "(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)`));
         },
     });
@@ -430,7 +566,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) {
@@ -492,7 +628,7 @@ Use "pause" to temporarily stop a loop without removing it. Use "delete" to perm
 
 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 system reminder with the exit code and output line count. No need to poll or create a separate loop.
+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.
 
@@ -506,7 +642,7 @@ Default to MonitorCreate for any long-running or background work:\n- Watch a CI/
 
 ## 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 system reminder 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"`,
+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.",
@@ -516,7 +652,7 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
             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 loop — no need for a separate LoopCreate." })),
+            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, _signal, _onUpdate, _ctx) {
             if (monitorManager.list().filter(m => m.status === "running").length >= 25) {
@@ -550,7 +686,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 +816,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 +866,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);
 }