@trevonistrevon/pi-loop 0.5.7 → 0.5.9

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

@@ -1,4 +1,5 @@
 import { Type } from "typebox";
+import { emitNativeTaskEvent } from "../runtime/task-events.js";
 function textResult(msg) {
     return { content: [{ type: "text", text: msg }], details: undefined };
 }
@@ -30,12 +31,7 @@ Fields:
         }),
         async execute(_toolCallId, params) {
             const entry = taskStore.create(params.subject, params.description);
-            pi.events.emit("tasks:created", {
-                taskId: entry.id,
-                subject: entry.subject,
-                description: entry.description,
-                status: entry.status,
-            });
+            emitNativeTaskEvent(pi, "tasks:created", entry);
             const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
             updateWidget();
             const autoLoopMsg = backlog.created && backlog.entry
@@ -91,16 +87,28 @@ Parameters: id (required), status, subject, description`,
             let entry = taskStore.get(id);
             if (!entry)
                 return Promise.resolve(textResult(`Task #${id} not found`));
-            if (status === "in_progress")
+            const previousStatus = entry.status;
+            if (status === "in_progress") {
                 entry = taskStore.start(id);
-            else if (status === "completed")
+                if (entry)
+                    emitNativeTaskEvent(pi, "tasks:started", entry, previousStatus);
+            }
+            else if (status === "completed") {
                 entry = taskStore.complete(id);
-            else if (status === "pending")
+                if (entry)
+                    emitNativeTaskEvent(pi, "tasks:completed", entry, previousStatus);
+            }
+            else if (status === "pending") {
                 entry = taskStore.reopen(id);
+                if (entry)
+                    emitNativeTaskEvent(pi, "tasks:reopened", entry, previousStatus);
+            }
             if (!entry)
                 return Promise.resolve(textResult(`Task #${id} not found`));
             if (subject !== undefined || description !== undefined) {
                 entry = taskStore.updateDetails(id, { subject, description });
+                if (entry)
+                    emitNativeTaskEvent(pi, "tasks:updated", entry, previousStatus);
             }
             if (!entry)
                 return Promise.resolve(textResult(`Task #${id} not found`));
@@ -121,9 +129,12 @@ Parameters: id (required), status, subject, description`,
             id: Type.String({ description: "Task ID to delete" }),
         }),
         async execute(_toolCallId, params) {
+            const existing = taskStore.get(params.id);
             const deleted = taskStore.delete(params.id);
             updateWidget();
             if (deleted) {
+                if (existing)
+                    emitNativeTaskEvent(pi, "tasks:deleted", existing, existing.status);
                 await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
                 return Promise.resolve(textResult(`Task #${params.id} deleted`));
             }

package/docker-compose.yml

@@ -0,0 +1,12 @@
+services:
+  ci-node20:
+    build:
+      context: .
+      target: node20
+    command: sh -c "npm run typecheck && npm run lint && npm run test:coverage && npm run build"
+
+  ci-node22:
+    build:
+      context: .
+      target: node22
+    command: sh -c "npm run typecheck && npm run lint && npm run test:coverage && npm run build"

package/package.json

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

package/release-please-config.json

@@ -0,0 +1,9 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "node",
+      "bump-minor-pre-major": true,
+      "bump-patch-for-minor-pre-major": true
+    }
+  }
+}

package/src/commands/tasks-command.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { emitNativeTaskEvent } from "../runtime/task-events.js";
 import { TaskStore } from "../task-store.js";
 import type { TaskEntry } from "../task-types.js";
 
@@ -18,12 +19,7 @@ export function registerTasksCommand(options: TasksCommandOptions): void {
   const { pi, getNativeTaskStore, evaluateTaskBacklog, updateWidget } = options;
 
   async function emitCreated(entry: TaskEntry) {
-    pi.events.emit("tasks:created", {
-      taskId: entry.id,
-      subject: entry.subject,
-      description: entry.description,
-      status: entry.status,
-    });
+    emitNativeTaskEvent(pi, "tasks:created", entry);
     const taskStore = getNativeTaskStore();
     if (!taskStore) return { created: false } satisfies TaskBacklogResult;
     const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
@@ -94,15 +90,19 @@ export function registerTasksCommand(options: TasksCommandOptions): void {
 
     if (action === "x Delete") {
       taskStore.delete(task.id);
+      emitNativeTaskEvent(pi, "tasks:deleted", task, task.status);
       ui.notify(`Task #${task.id} deleted`, "info");
     } else if (action === "> Start") {
-      taskStore.start(task.id);
+      const next = taskStore.start(task.id);
+      if (next) emitNativeTaskEvent(pi, "tasks:started", next, task.status);
       ui.notify(`Task #${task.id} started`, "info");
     } else if (action === "ok Complete") {
-      taskStore.complete(task.id);
+      const next = taskStore.complete(task.id);
+      if (next) emitNativeTaskEvent(pi, "tasks:completed", next, task.status);
       ui.notify(`Task #${task.id} completed`, "info");
     } else if (action === "* Return to pending" || action === "* Reopen") {
-      taskStore.reopen(task.id);
+      const next = taskStore.reopen(task.id);
+      if (next) emitNativeTaskEvent(pi, "tasks:reopened", next, task.status);
       ui.notify(`Task #${task.id} reopened`, "info");
     }
 

package/src/index.ts

@@ -43,6 +43,10 @@ function debug(...args: unknown[]) {
   if (DEBUG) console.error("[pi-loop]", ...args);
 }
 
+function isStaleExtensionContextError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes("extension ctx is stale");
+}
+
 export default function (pi: ExtensionAPI) {
   const piLoopEnv = process.env.PI_LOOP;
   const piLoopScope = process.env.PI_LOOP_SCOPE as "memory" | "session" | "project" | undefined;
@@ -297,30 +301,42 @@ export default function (pi: ExtensionAPI) {
 
   // ── Native task tools (only when pi-tasks is absent) ──
 
-  setTimeout(async () => {
+  const nativeTaskFallbackTimer = setTimeout(() => {
     if (tasksAvailable || nativeTasksRegistered) return;
-    nativeTaskStore = new TaskStore(resolveTaskStorePath(getScopeOptions(), _sessionId));
-    nativeTasksRegistered = true;
-    const taskStore = nativeTaskStore;
-
-    registerTasksCommand({
-      pi,
-      getNativeTaskStore: () => nativeTaskStore,
-      evaluateTaskBacklog,
-      updateWidget: () => {
-        widget.update();
-      },
-    });
+    const taskStore = new TaskStore(resolveTaskStorePath(getScopeOptions(), _sessionId));
+
+    try {
+      registerTasksCommand({
+        pi,
+        getNativeTaskStore: () => nativeTaskStore,
+        evaluateTaskBacklog,
+        updateWidget: () => {
+          widget.update();
+        },
+      });
 
-    registerNativeTaskTools({
-      pi,
-      taskStore,
-      evaluateTaskBacklog,
-      updateWidget: () => {
-        widget.update();
-      },
-    });
+      registerNativeTaskTools({
+        pi,
+        taskStore,
+        evaluateTaskBacklog,
+        updateWidget: () => {
+          widget.update();
+        },
+      });
+    } catch (error) {
+      if (isStaleExtensionContextError(error)) {
+        debug("native task fallback skipped: extension context went stale");
+        return;
+      }
+      throw error;
+    }
 
+    nativeTaskStore = taskStore;
+    nativeTasksRegistered = true;
     debug("native task tools registered (pi-tasks not detected)");
   }, 6000);
+
+  pi.on("session_shutdown", () => {
+    clearTimeout(nativeTaskFallbackTimer);
+  });
 }

package/src/monitor-manager.ts

@@ -1,5 +1,5 @@
 
-import { spawn } from "node:child_process";
+import { type ChildProcess, spawn as nodeSpawn, type SpawnOptions } from "node:child_process";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   type MonitorReducerEvent,
@@ -8,12 +8,20 @@ import {
 } from "./monitor-reducer.js";
 import type { MonitorEntry, MonitorProcess } from "./types.js";
 
+export type SpawnFn = (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+
 export class MonitorManager {
   private processes = new Map<string, MonitorProcess>();
   private nextId = 1;
   private onChange: (() => void) | undefined;
+  private spawnFn: SpawnFn;
 
-  constructor(private pi: ExtensionAPI) {}
+  constructor(
+    private pi: ExtensionAPI,
+    spawnFn?: SpawnFn,
+  ) {
+    this.spawnFn = spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, opts));
+  }
 
   /**
    * Register a callback fired when a monitor's status changes or it is pruned
@@ -58,7 +66,8 @@ export class MonitorManager {
   // finish() and stop() so every terminal status is pruned consistently — a
   // stopped monitor that is never pruned lingers in list() and the widget count.
   private schedulePrune(id: string): void {
-    setTimeout(() => {
+    // unref so a pending prune never keeps a one-shot (`pi -p`) process alive.
+    const timer = setTimeout(() => {
       this.applyReducerEvent({
         type: "MONITOR_PRUNED",
         at: Date.now(),
@@ -68,6 +77,7 @@ export class MonitorManager {
         payload: { id },
       });
     }, 30000);
+    timer.unref?.();
   }
 
   create(command: string, description?: string, timeout = 300000): MonitorEntry {
@@ -88,7 +98,7 @@ export class MonitorManager {
     const entry = result.state.monitorsById[id]!;
 
     const abortController = new AbortController();
-    const child = spawn("sh", ["-c", command], {
+    const child = this.spawnFn("sh", ["-c", command], {
       stdio: ["ignore", "pipe", "pipe"],
       signal: abortController.signal,
       env: { ...process.env },

package/src/runtime/session-runtime.ts

@@ -61,7 +61,9 @@ export function registerSessionRuntimeHooks(options: SessionRuntimeOptions): voi
   function ensureHeartbeat(): void {
     if (heartbeatTimer) return;
     heartbeatTimer = setInterval(() => {
-      void pumpLoops();
+      // Swallow pump failures so a transient error never surfaces as an
+      // unhandled rejection; the next tick retries.
+      void pumpLoops().catch(() => {});
     }, HEARTBEAT_MS);
     heartbeatTimer.unref?.();
   }

package/src/runtime/task-events.ts

@@ -0,0 +1,41 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskEntry, TaskStatus } from "../task-types.js";
+
+export type NativeTaskEventName =
+  | "tasks:created"
+  | "tasks:started"
+  | "tasks:completed"
+  | "tasks:reopened"
+  | "tasks:updated"
+  | "tasks:deleted";
+
+export interface NativeTaskEventPayload {
+  taskId: string;
+  subject: string;
+  description: string;
+  status: TaskStatus;
+  previousStatus?: TaskStatus;
+  createdAt: number;
+  updatedAt: number;
+  completedAt?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export function emitNativeTaskEvent(
+  pi: ExtensionAPI,
+  name: NativeTaskEventName,
+  entry: TaskEntry,
+  previousStatus?: TaskStatus,
+): void {
+  pi.events.emit(name, {
+    taskId: entry.id,
+    subject: entry.subject,
+    description: entry.description,
+    status: entry.status,
+    previousStatus,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
+    completedAt: entry.completedAt,
+    metadata: entry.metadata,
+  } satisfies NativeTaskEventPayload);
+}

package/src/runtime/task-rpc.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { TaskStore } from "../task-store.js";
 import type { LoopEntry } from "../types.js";
+import { emitNativeTaskEvent } from "./task-events.js";
 
 export interface TaskRuntimeBridgeOptions {
   pi: ExtensionAPI;
@@ -82,6 +83,7 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
       `Auto-created from loop #${entry.id}`,
       { loopId: entry.id, trigger: entry.trigger },
     );
+    emitNativeTaskEvent(pi, "tasks:created", task);
     onNativeTaskCreated?.(nativeTaskStore);
     return task.id;
   }

package/src/tools/native-task-tools.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { emitNativeTaskEvent } from "../runtime/task-events.js";
 import { TaskStore } from "../task-store.js";
 
 export interface TaskBacklogResult {
@@ -47,12 +48,7 @@ Fields:
     }),
     async execute(_toolCallId, params) {
       const entry = taskStore.create(params.subject, params.description);
-      pi.events.emit("tasks:created", {
-        taskId: entry.id,
-        subject: entry.subject,
-        description: entry.description,
-        status: entry.status,
-      });
+      emitNativeTaskEvent(pi, "tasks:created", entry);
       const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
       updateWidget();
 
@@ -111,13 +107,22 @@ Parameters: id (required), status, subject, description`,
       let entry = taskStore.get(id);
       if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
 
-      if (status === "in_progress") entry = taskStore.start(id);
-      else if (status === "completed") entry = taskStore.complete(id);
-      else if (status === "pending") entry = taskStore.reopen(id);
+      const previousStatus = entry.status;
+      if (status === "in_progress") {
+        entry = taskStore.start(id);
+        if (entry) emitNativeTaskEvent(pi, "tasks:started", entry, previousStatus);
+      } else if (status === "completed") {
+        entry = taskStore.complete(id);
+        if (entry) emitNativeTaskEvent(pi, "tasks:completed", entry, previousStatus);
+      } else if (status === "pending") {
+        entry = taskStore.reopen(id);
+        if (entry) emitNativeTaskEvent(pi, "tasks:reopened", entry, previousStatus);
+      }
 
       if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
       if (subject !== undefined || description !== undefined) {
         entry = taskStore.updateDetails(id, { subject, description });
+        if (entry) emitNativeTaskEvent(pi, "tasks:updated", entry, previousStatus);
       }
       if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
       updateWidget();
@@ -138,9 +143,11 @@ Parameters: id (required), status, subject, description`,
       id: Type.String({ description: "Task ID to delete" }),
     }),
     async execute(_toolCallId, params) {
+      const existing = taskStore.get(params.id);
       const deleted = taskStore.delete(params.id);
       updateWidget();
       if (deleted) {
+        if (existing) emitNativeTaskEvent(pi, "tasks:deleted", existing, existing.status);
         await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
         return Promise.resolve(textResult(`Task #${params.id} deleted`));
       }

package/vitest.config.ts

@@ -5,20 +5,24 @@ export default defineConfig({
     environment: "node",
     include: ["test/**/*.test.ts"],
     exclude: ["node_modules", "dist"],
+    // CI runners are slower than local; 15s gives real-child-process
+    // tests (monitor stop, lifecycle) enough headroom.
+    testTimeout: 15000,
+    hookTimeout: 15000,
     coverage: {
       provider: "v8",
       reporter: ["text-summary", "html", "json"],
       include: ["src/**/*.ts"],
       // Type-only modules and test helpers carry no executable logic worth gating.
       exclude: ["src/**/*-types.ts", "src/types.ts"],
-      // Floors set just below current actuals (stmts 80%, branches 69.5%,
-      // funcs 92.5%, lines 82.9%) to catch regressions. Ratchet up as the
-      // runtime/ and tools/ suites land in Phase 4.
+      // Floors set just below current actuals (stmts 84%, branches 75%,
+      // funcs 95%, lines 86%) to catch regressions. Raised in Phase 4 after the
+      // runtime/ + tools/ suites landed.
       thresholds: {
-        statements: 78,
-        branches: 67,
-        functions: 90,
-        lines: 80,
+        statements: 82,
+        branches: 73,
+        functions: 94,
+        lines: 84,
       },
     },
   },