@trevonistrevon/pi-loop 0.3.1 → 0.4.1

package/src/index.ts

@@ -22,6 +22,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 type { LoopEntry, Trigger } from "./types.js";
 import { LoopWidget } from "./ui/widget.js";
@@ -49,6 +50,10 @@ interface SessionSwitchEvent {
   reason?: string;
 }
 
+interface PendingNotification extends LoopFireEvent {
+  key: string;
+  message: string;
+}
 
 export default function (pi: ExtensionAPI) {
   const piLoopEnv = process.env.PI_LOOP;
@@ -68,19 +73,36 @@ export default function (pi: ExtensionAPI) {
     return join(process.cwd(), ".pi", "loops", "loops.json");
   }
 
+  function resolveTaskStorePath(): string | undefined {
+    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: CronScheduler;
   let triggerSystem: 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: TaskStore | undefined;
+  let nativeTasksRegistered = false;
 
   function checkTasksVersion() {
     const requestId = randomUUID();
@@ -97,47 +119,171 @@ export default function (pi: ExtensionAPI) {
   pi.events.on("tasks:ready", () => checkTasksVersion());
 
   async function autoCreateTask(entry: LoopEntry): Promise<string | undefined> {
-    if (!tasksAvailable || !entry.autoTask) return undefined;
-    try {
-      const requestId = randomUUID();
-      const taskId = await new Promise<string | undefined>((resolve, _reject) => {
-        const timer = setTimeout(() => { unsub(); resolve(undefined); }, 5000);
-        const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw: unknown) => {
-          unsub(); clearTimeout(timer);
-          const reply = raw as { success: boolean; data?: { id: string }; error?: string };
-          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 (!entry.autoTask) return undefined;
+    if (tasksAvailable) {
+      try {
+        const requestId = randomUUID();
+        const taskId = await new Promise<string | undefined>((resolve, _reject) => {
+          const timer = setTimeout(() => { unsub(); resolve(undefined); }, 5000);
+          const unsub = pi.events.on(`tasks:rpc:create:reply:${requestId}`, (raw: unknown) => {
+            unsub(); clearTimeout(timer);
+            const reply = raw as { success: boolean; data?: { id: string }; error?: string };
+            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;
-    } catch {
-      return undefined;
+        return taskId;
+      } catch {
+        return undefined;
+      }
     }
+    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(): Promise<number> {
-    if (!tasksAvailable) return -1;
-    try {
-      const requestId = randomUUID();
-      const count = await new Promise<number>((resolve) => {
-        const timer = setTimeout(() => { unsub(); resolve(-1); }, 3000);
-        const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw: unknown) => {
-          unsub(); clearTimeout(timer);
-          const reply = raw as { success: boolean; data?: { pending: number }; error?: string };
-          resolve(reply.success && reply.data ? reply.data.pending : -1);
+    if (tasksAvailable) {
+      try {
+        const requestId = randomUUID();
+        const count = await new Promise<number>((resolve) => {
+          const timer = setTimeout(() => { unsub(); resolve(-1); }, 3000);
+          const unsub = pi.events.on(`tasks:rpc:pending:reply:${requestId}`, (raw: unknown) => {
+            unsub(); clearTimeout(timer);
+            const reply = raw as { success: boolean; data?: { pending: number }; error?: string };
+            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;
-    } catch {
-      return -1;
+        return count;
+      } catch {
+        return -1;
+      }
+    }
+    return nativeTaskStore ? nativeTaskStore.pendingCount() : -1;
+  }
+
+  async function cleanDoneTasks(): Promise<void> {
+    if (tasksAvailable) {
+      try {
+        const requestId = randomUUID();
+        await new Promise<void>((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();
+    }
+  }
+
+  let agentRunning = false;
+  const pendingNotifications = new Map<string, PendingNotification>();
+  let flushPromise: Promise<void> | undefined;
+
+  function buildLoopFireMessage(data: LoopFireEvent): string {
+    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: LoopFireEvent): PendingNotification {
+    const key = data.recurring ? `loop:${data.loopId}` : `loop:${data.loopId}:${data.timestamp}`;
+    return {
+      ...data,
+      key,
+      message: buildLoopFireMessage(data),
+    };
+  }
+
+  async function deliverNotification(notification: PendingNotification): Promise<boolean> {
+    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(): Promise<void> {
+    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: LoopFireEvent): Promise<void> {
+    const notification = buildPendingNotification(data);
+    pendingNotifications.set(notification.key, notification);
+    await flushPendingNotifications();
   }
 
   // ── Loop fire handler ──
@@ -183,8 +329,7 @@ export default function (pi: ExtensionAPI) {
       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;
   }
@@ -206,6 +351,7 @@ export default function (pi: ExtensionAPI) {
     _latestCtx = ctx;
     widget.setUICtx(ctx.ui);
     upgradeStoreIfNeeded(ctx);
+    widget.update();
   });
 
   pi.on("before_agent_start", async (_event, ctx) => {
@@ -213,12 +359,33 @@ export default function (pi: ExtensionAPI) {
     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" as any, async (event: SessionSwitchEvent, ctx: ExtensionContext) => {
     _latestCtx = ctx;
     widget.setUICtx(ctx.ui);
     triggerSystem.stop();
+    agentRunning = false;
+    pendingNotifications.clear();
 
     const isResume = event?.reason === "resume";
     storeUpgraded = false;
@@ -230,43 +397,24 @@ export default function (pi: ExtensionAPI) {
 
     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: unknown) => {
     const data = event as LoopFireEvent;
 
-    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);
   });
 
   // ──────────────────────────────────────────────────
@@ -304,7 +452,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: [
@@ -323,7 +471,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({
@@ -401,7 +549,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)`
       ));
     },
@@ -474,7 +622,7 @@ Use this before creating new loops to avoid duplicates, or to find IDs for LoopD
           ? 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) {
@@ -540,7 +688,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.
 
@@ -554,7 +702,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.",
@@ -564,7 +712,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) {
@@ -607,7 +755,7 @@ Pass onDone with a prompt and the monitor auto-creates a one-shot loop that fire
 
       const lines: string[] = [];
       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})`;
@@ -744,45 +892,45 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
   async function viewLoops(ui: ExtensionUIContext) {
     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: LoopEntry) => {
-      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") return;
+    if (!selected || selected === "< Back") return;
 
     const match = selected.match(/#(\d+)/);
     if (match) {
       const entry = store.get(match[1]);
       if (entry) {
-        const actions = ["✗ Delete"];
-        if (entry.status === "active") actions.unshift("⏸ Pause");
-        else if (entry.status === "paused") actions.unshift("▶ Resume");
-        actions.push("← Back");
+        const actions = ["x Delete"];
+        if (entry.status === "active") actions.unshift("- Pause");
+        else if (entry.status === "paused") 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();
@@ -799,4 +947,193 @@ 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: ExtensionUIContext) {
+    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: ExtensionUIContext): Promise<void> {
+    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: string, ctx: ExtensionCommandContext) => {
+        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: string[] = [];
+        const statuses: Record<"pending" | "in_progress" | "completed", number> = {
+          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 as "pending" | "in_progress" | "completed" | undefined,
+          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);
 }