@trevonistrevon/pi-loop 0.5.8 → 0.6.0

package/src/runtime/task-rpc.ts

@@ -1,7 +1,17 @@
 import { randomUUID } from "node:crypto";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  type CleanReply,
+  type CreateTaskReply,
+  type PendingReply,
+  type PingReply,
+  replyChannel,
+  TASKS_RPC,
+} from "../rpc/channels.js";
+import { type RpcReply, rpcCall } from "../rpc/cross-extension-rpc.js";
 import type { TaskStore } from "../task-store.js";
 import type { LoopEntry } from "../types.js";
+import { NATIVE_TASKS_PROVIDER } from "./native-task-rpc.js";
 import { emitNativeTaskEvent } from "./task-events.js";
 
 export interface TaskRuntimeBridgeOptions {
@@ -11,6 +21,10 @@ export interface TaskRuntimeBridgeOptions {
   getNativeTaskStore: () => TaskStore | undefined;
   onNativeTaskCreated?: (taskStore: TaskStore) => void;
   onNativeTasksPruned?: (taskStore: TaskStore) => Promise<void> | void;
+  /** Called when a detection window opens. */
+  onDetectionStarted?: () => void;
+  /** Called when a detection window closes (provider found or probe timed out). */
+  onDetectionSettled?: () => void;
   debug?: (...args: unknown[]) => void;
 }
 
@@ -29,48 +43,51 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
     getNativeTaskStore,
     onNativeTaskCreated,
     onNativeTasksPruned,
+    onDetectionStarted,
+    onDetectionSettled,
     debug,
   } = options;
+  let detectionEpoch = 0;
 
   function checkTasksVersion() {
+    // Not rpcProbe: pi-loop's own native server also answers this ping, and a
+    // first-reply-wins probe would always settle on that self-reply. Keep the
+    // listener open for the whole window and skip self-replies so a slower
+    // external provider (pi-tasks) is still detected.
+    const epoch = ++detectionEpoch;
+    onDetectionStarted?.();
+    const settleCurrentDetection = () => {
+      if (epoch !== detectionEpoch) return;
+      onDetectionSettled?.();
+    };
     const requestId = randomUUID();
     const timer = setTimeout(() => {
       unsub();
+      settleCurrentDetection();
     }, 5000);
-    const unsub = pi.events.on(`tasks:rpc:ping:reply:${requestId}`, (raw: unknown) => {
+    const unsub = pi.events.on(replyChannel(TASKS_RPC.ping, requestId), (raw: unknown) => {
+      const reply = raw as RpcReply<PingReply> | undefined;
+      if (!reply?.success || !reply.data) return;
+      if (reply.data.provider === NATIVE_TASKS_PROVIDER) return;
+      if (reply.data.version === undefined) return;
       unsub();
       clearTimeout(timer);
-      const remoteVersion = (raw as { data?: { version?: number } })?.data?.version;
-      if (remoteVersion !== undefined) setTasksAvailable(true);
+      setTasksAvailable(true);
+      settleCurrentDetection();
     });
-    pi.events.emit("tasks:rpc:ping", { requestId });
+    pi.events.emit(TASKS_RPC.ping, { requestId });
   }
 
   async function autoCreateTask(entry: LoopEntry): Promise<string | undefined> {
     if (!entry.autoTask) return undefined;
     if (isTasksAvailable()) {
       try {
-        const requestId = randomUUID();
-        const taskId = await new Promise<string | undefined>((resolve) => {
-          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 } };
-            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;
+        const reply = await rpcCall<CreateTaskReply>(pi.events, TASKS_RPC.create, {
+          subject: entry.prompt.slice(0, 80),
+          description: `Auto-created from loop #${entry.id}`,
+          metadata: { loopId: entry.id, trigger: entry.trigger },
+        }, 5000);
+        return reply.id;
       } catch {
         return undefined;
       }
@@ -90,22 +107,11 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
 
   async function hasPendingTasks(): Promise<number> {
     if (isTasksAvailable()) {
+      // -1 is this bridge's "unknown" sentinel, consumed by notification-runtime;
+      // the RPC layer itself rejects on failure.
       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 } };
-            resolve(reply.success && reply.data ? reply.data.pending : -1);
-          });
-          pi.events.emit("tasks:rpc:pending", { requestId });
-        });
-        return count;
+        const reply = await rpcCall<PendingReply>(pi.events, TASKS_RPC.pending, {}, 3000);
+        return reply.pending;
       } catch {
         return -1;
       }
@@ -117,20 +123,8 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
   async function cleanDoneTasks(): Promise<void> {
     if (isTasksAvailable()) {
       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 });
-        });
+        await rpcCall<CleanReply>(pi.events, TASKS_RPC.clean, {}, 3000);
+        debug?.(`${TASKS_RPC.clean} — done tasks swept`);
       } catch {
         // timeout or error, ignore
       }

package/src/scheduler.ts

@@ -50,7 +50,7 @@ export class CronScheduler {
     const _scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : (entry.trigger as { schedule: string }).schedule;
 
     const nextFire = computeNextFire(entry);
-    const minuteField = _scheduleExpr.trim().split(/\s+/)[0];
+    const minuteField = _scheduleExpr.trim().split(/\s+/)[0] ?? "";
     const minuteStep = minuteField.startsWith("*/") ? parseInt(minuteField.slice(2), 10) || 30 : 30;
     const jitter = computeJitter(entry.id, entry.recurring, minuteStep);
     const fireTime = nextFire.getTime() + jitter;

package/src/tools/loop-tools.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { parseInterval } from "../loop-parse.js";
 import type { LoopEntry, Trigger } from "../types.js";
+import { textResult } from "./tool-result.js";
 
 interface LoopStoreLike {
   list(): LoopEntry[];
@@ -46,10 +47,6 @@ export interface LoopToolsOptions {
   isTaskSystemReady: () => boolean;
 }
 
-function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
-}
-
 function validateTrigger(trigger: Trigger): string | null {
   if (trigger.type === "cron") {
     const parts = trigger.schedule.trim().split(/\s+/);

package/src/tools/monitor-tools.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import type { LoopEntry, MonitorEntry, Trigger } from "../types.js";
+import { textResult } from "./tool-result.js";
 
 interface MonitorManagerLike {
   list(): MonitorEntry[];
@@ -26,10 +27,6 @@ export interface MonitorToolsOptions {
   handleMonitorDoneLoop: (doneLoop: LoopEntry, monitorId: string) => void;
 }
 
-function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
-}
-
 function formatRemaining(ms: number): string {
   if (ms < 60000) return `${Math.round(ms / 1000)}s`;
   if (ms < 3600000) return `${Math.round(ms / 60000)}m`;

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

@@ -1,12 +1,17 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { emitNativeTaskEvent } from "../runtime/task-events.js";
+import {
+  createTask,
+  deleteTask,
+  type TaskBacklogResult,
+  type TaskMutationContext,
+  updateTask,
+} from "../runtime/task-mutations.js";
 import { TaskStore } from "../task-store.js";
+import type { TaskStatus } from "../task-types.js";
+import { textResult } from "./tool-result.js";
 
-export interface TaskBacklogResult {
-  created: boolean;
-  entry?: { id: string };
-}
+export type { TaskBacklogResult };
 
 export interface NativeTaskToolsOptions {
   pi: ExtensionAPI;
@@ -15,12 +20,15 @@ export interface NativeTaskToolsOptions {
   updateWidget: () => void;
 }
 
-function textResult(msg: string) {
-  return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
+function backlogSuffix(backlog: TaskBacklogResult): string {
+  return backlog.created && backlog.entry
+    ? `\nBacklog worker loop #${backlog.entry.id} created`
+    : "";
 }
 
 export function registerNativeTaskTools(options: NativeTaskToolsOptions): void {
   const { pi, taskStore, evaluateTaskBacklog, updateWidget } = options;
+  const mutationCtx: TaskMutationContext = { pi, taskStore, evaluateTaskBacklog, updateWidget };
 
   pi.registerTool({
     name: "TaskCreate",
@@ -47,15 +55,11 @@ Fields:
       description: Type.String({ description: "Detailed description of what needs to be done" }),
     }),
     async execute(_toolCallId, params) {
-      const entry = taskStore.create(params.subject, params.description);
-      emitNativeTaskEvent(pi, "tasks:created", entry);
-      const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
-      updateWidget();
-
-      const autoLoopMsg = backlog.created && backlog.entry
-        ? `\nBacklog worker loop #${backlog.entry.id} created`
-        : "";
-      return Promise.resolve(textResult(`Task #${entry.id} created: ${entry.subject}${autoLoopMsg}`));
+      const { entry, backlog } = await createTask(mutationCtx, {
+        subject: params.subject,
+        description: params.description,
+      });
+      return textResult(`Task #${entry.id} created: ${entry.subject}${backlogSuffix(backlog)}`);
     },
   });
 
@@ -104,34 +108,15 @@ Parameters: id (required), status, subject, description`,
     }),
     async execute(_toolCallId, params) {
       const { id, status, subject, description } = params;
-      let entry = taskStore.get(id);
-      if (!entry) return Promise.resolve(textResult(`Task #${id} not found`));
-
-      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();
-      const backlog = await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
+      const result = await updateTask(mutationCtx, {
+        id,
+        status: status as TaskStatus | undefined,
+        subject,
+        description,
+      });
+      if (!result) return textResult(`Task #${id} not found`);
       const statusMsg = status ? ` → ${status}` : "";
-      const autoLoopMsg = backlog.created && backlog.entry
-        ? `\nBacklog worker loop #${backlog.entry.id} created`
-        : "";
-      return Promise.resolve(textResult(`Task #${id} updated${statusMsg}${autoLoopMsg}`));
+      return textResult(`Task #${id} updated${statusMsg}${backlogSuffix(result.backlog)}`);
     },
   });
 
@@ -143,15 +128,9 @@ 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`));
-      }
-      return Promise.resolve(textResult(`Task #${params.id} not found`));
+      const result = await deleteTask(mutationCtx, params.id);
+      if (!result) return textResult(`Task #${params.id} not found`);
+      return textResult(`Task #${params.id} deleted`);
     },
   });
 }

package/src/tools/tool-result.ts

@@ -0,0 +1,4 @@
+/** Plain-text tool result in the shape pi's registerTool expects. */
+export function textResult(msg: string) {
+  return { content: [{ type: "text" as const, text: msg }], details: undefined };
+}

package/src/trigger-system.ts

@@ -58,7 +58,7 @@ export class TriggerSystem {
     }
     const subs = this.eventSubscriptions.get(source)!;
 
-    const unsub = this.pi.events.on(source as any, (data: any) => {
+    const unsub = this.pi.events.on(source, (data: unknown) => {
       if (entry.trigger.type === "hybrid") {
         this.handleHybridFire(entry, data);
       } else {
@@ -71,7 +71,7 @@ export class TriggerSystem {
     subs.set(entry.id, unsub);
   }
 
-  private handleHybridFire(entry: LoopEntry, _data: any): void {
+  private handleHybridFire(entry: LoopEntry, _data: unknown): void {
     const now = Date.now();
     const last = this.lastFireTime.get(entry.id) ?? 0;
     const debounceMs = entry.trigger.type === "hybrid" ? entry.trigger.debounceMs : 0;
@@ -123,7 +123,7 @@ export class TriggerSystem {
     }
   }
 
-  private matchesFilter(data: any, filter?: string): boolean {
+  private matchesFilter(data: unknown, filter?: string): boolean {
     if (!filter) return true;
 
     if (filter.startsWith("regex:")) {
@@ -138,7 +138,7 @@ export class TriggerSystem {
     try {
       const parsed = JSON.parse(filter);
       for (const [key, value] of Object.entries(parsed)) {
-        const dataValue = data?.[key];
+        const dataValue = (data as Record<string, unknown> | undefined)?.[key];
         if (dataValue === undefined) return false;
         if (typeof value === "object" && typeof dataValue === "object") {
           if (JSON.stringify(value) !== JSON.stringify(dataValue)) return false;

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 84%, branches 75%,
-      // funcs 95%, lines 86%) to catch regressions. Raised in Phase 4 after the
-      // runtime/ + tools/ suites landed.
+      // Floors set just below current actuals (stmts 91%, branches 83%,
+      // funcs 98%, lines 94%) to catch regressions. Re-anchored after the
+      // goal-subsystem removal and the rpc/native-task-rpc/command suites landed.
       thresholds: {
-        statements: 82,
-        branches: 73,
-        functions: 94,
-        lines: 84,
+        statements: 89,
+        branches: 80,
+        functions: 96,
+        lines: 91,
       },
     },
   },