@trevonistrevon/pi-loop 0.5.8 → 0.6.0

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

@@ -1,10 +1,14 @@
 import { Type } from "typebox";
-import { emitNativeTaskEvent } from "../runtime/task-events.js";
-function textResult(msg) {
-    return { content: [{ type: "text", text: msg }], details: undefined };
+import { createTask, deleteTask, updateTask, } from "../runtime/task-mutations.js";
+import { textResult } from "./tool-result.js";
+function backlogSuffix(backlog) {
+    return backlog.created && backlog.entry
+        ? `\nBacklog worker loop #${backlog.entry.id} created`
+        : "";
 }
 export function registerNativeTaskTools(options) {
     const { pi, taskStore, evaluateTaskBacklog, updateWidget } = options;
+    const mutationCtx = { pi, taskStore, evaluateTaskBacklog, updateWidget };
     pi.registerTool({
         name: "TaskCreate",
         label: "TaskCreate",
@@ -30,14 +34,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)}`);
         },
     });
     pi.registerTool({
@@ -84,41 +85,16 @@ 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,
+                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)}`);
         },
     });
     pi.registerTool({
@@ -129,16 +105,10 @@ 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/dist/tools/tool-result.d.ts

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

package/dist/tools/tool-result.js

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

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/docs/architecture/state-machine-migration.md

@@ -9,7 +9,6 @@ It is the capstone document for the architecture work captured in:
 - `docs/architecture/state-machine-transition-map.md`
 - `docs/architecture/state-machine-test-matrix.md`
 - `docs/architecture/state-machine-reducer-event-model.md`
-- `docs/architecture/goal-state-schema.md`
 
 The goal of this document is to explain:
 
@@ -95,7 +94,6 @@ Instead, it uses separate reducer families for:
 - loops
 - notifications
 - monitors
-- later, goals
 
 ### 2.5 Name coordination rules explicitly
 
@@ -203,14 +201,6 @@ This defines:
 - event vocabulary
 - coordinator rules
 
-### 4.4 Goal schema
-
-`docs/architecture/goal-state-schema.md`
-
-This defines the future Goal layer as a reducer-owned, verification-oriented composition of existing reducer state.
-
----
-
 ## 5. Implemented extraction status
 
 At the time of this document, the following extractions are complete.
@@ -300,18 +290,6 @@ The coordinator currently exists as a reusable module with:
 
 It is not yet fully wired through the main runtime.
 
-### 5.6 Goal verifier prototype
-
-Implemented:
-
-- `src/goal-types.ts`
-- `src/goal-verifier.ts`
-- `test/goal-verifier.test.ts`
-
-This is intentionally read-only and verification-oriented.
-
----
-
 ## 6. Current architecture after extraction
 
 The codebase now sits in an intermediate but useful state.
@@ -321,7 +299,6 @@ The codebase now sits in an intermediate but useful state.
 - entity state transitions are increasingly centralized in pure reducers
 - transition semantics are backed by focused reducer tests
 - scenario coverage exists for the highest-risk lifecycle behavior
-- goal work no longer needs to start from an undefined state model
 
 ### 6.2 What remains transitional
 
@@ -380,7 +357,6 @@ Reducers own logical state transitions for:
 - loops
 - notifications
 - monitors
-- goals
 
 ### 7.3 Coordinator
 
@@ -424,10 +400,6 @@ Suggested order:
 
 As each slice moves over, imperative code should become effect execution rather than state mutation.
 
-### Step 4 — add a goal reducer
-
-Once the coordinator is meaningfully integrated, add a true `reduceGoalState(...)` layer rather than keeping goal work verifier-only.
-
 ### Step 5 — remove redundant imperative state paths
 
 Only after coordinator-owned dispatch is proven stable should old duplicated state paths be deleted.
@@ -476,20 +448,6 @@ Mitigation:
 - only reduce logical state
 - preserve stop/completion race tests
 
-### 9.4 Goals can grow too ambitious too early
-
-The goal prototype is intentionally read-only.
-
-Risk:
-
-- adding autonomous write-side goal behavior before coordinator adoption is mature
-
-Mitigation:
-
-- keep goal verification read-only until reducer/coordinator integration is stable
-
----
-
 ## 10. Validation strategy
 
 The migration should continue to rely on three validation layers.
@@ -525,7 +483,6 @@ We now have:
 - a test contract
 - reducer modules for the four existing entity families
 - a coordinator abstraction
-- a goal schema and verifier prototype
 
 This means future work can be judged against a coherent architecture instead of a collection of local fixes.
 
@@ -541,6 +498,5 @@ The system is not yet at the final architecture. However, it now has the essenti
 - reducer state boundaries
 - effect boundaries
 - coordinator machinery
-- verification-oriented goal design
 
 The recommended next step, if further work continues, is to adopt the coordinator in narrow runtime slices rather than attempt a single large integration rewrite.

package/docs/architecture/state-machine-reducer-event-model.md

@@ -81,7 +81,7 @@ interface ReducerEvent<TType extends string = string, TPayload = unknown> {
     | "session"
     | "coordinator"
     | "system";
-  entityType?: "task" | "loop" | "monitor" | "notification" | "goal";
+  entityType?: "task" | "loop" | "monitor" | "notification";
   entityId?: string;
   payload: TPayload;
 }
@@ -104,7 +104,7 @@ Reducers do not call Pi APIs directly. They emit effects.
 ```ts
 interface ReducerEffect<TEffect extends string = string, TPayload = unknown> {
   type: TEffect;
-  entityType?: "task" | "loop" | "monitor" | "notification" | "goal";
+  entityType?: "task" | "loop" | "monitor" | "notification";
   entityId?: string;
   payload: TPayload;
 }
@@ -801,7 +801,6 @@ If an event cannot be tied to a transition/invariant/scenario row, it is probabl
 This event model does **not** yet define:
 
 - Goal reducer fields
-- persistent serialization format for goals
 - UI rendering model
 - task provider abstraction replacement
 - a generalized event sourcing log

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trevonistrevon/pi-loop",
-  "version": "0.5.8",
+  "version": "0.6.0",
   "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
   "author": "trevonistrevon",
   "license": "MIT",
@@ -17,6 +17,11 @@
     "monitor",
     "scheduler"
   ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./api": "./src/api.ts",
+    "./package.json": "./package.json"
+  },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.75.5",
     "@earendil-works/pi-tui": "^0.75.5"

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/api.ts

@@ -0,0 +1,36 @@
+/**
+ * Public API surface for sibling extensions (imported as
+ * `@trevonistrevon/pi-loop/api`). Everything else under src/ is internal —
+ * the package `exports` map deliberately blocks deep imports.
+ */
+export {
+  type CleanReply,
+  type CreateTaskParams,
+  type CreateTaskReply,
+  type PendingReply,
+  type PingReply,
+  replyChannel,
+  type SpawnParams,
+  type SpawnReply,
+  SUBAGENTS_RPC,
+  TASK_EVENTS,
+  TASKS_RPC,
+  type TaskEntryWire,
+  type TaskStatusWire,
+  type UpdateTaskParams,
+  type UpdateTaskReply,
+} from "./rpc/channels.js";
+export {
+  type HandleRpcOptions,
+  handleRpc,
+  PROTOCOL_VERSION,
+  RpcError,
+  type RpcEventBus,
+  type RpcReply,
+  rpcCall,
+  rpcProbe,
+} from "./rpc/cross-extension-rpc.js";
+export { NATIVE_TASKS_PROVIDER } from "./runtime/native-task-rpc.js";
+export { resolveLoopStorePath, resolveTaskStorePath } from "./runtime/scope.js";
+export { TaskStore } from "./task-store.js";
+export type { TaskEntry, TaskStatus, TaskStoreData } from "./task-types.js";

package/src/commands/loop-command.ts

@@ -85,7 +85,7 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
     if (!selected || selected === "< Back") return;
 
     const match = selected.match(/#(\d+)/);
-    if (match) {
+    if (match?.[1]) {
       const entry = getStore().get(match[1]);
       if (entry) {
         const actions = ["x Delete"];
@@ -149,7 +149,7 @@ export function registerLoopCommand(options: LoopCommandOptions): void {
 
       const intervalMatch = trimmed.match(/^(\d+\s*[smhdS]\b)/i);
       if (intervalMatch) {
-        const interval = intervalMatch[1];
+        const interval = intervalMatch[1] ?? intervalMatch[0];
         const prompt = trimmed.slice(intervalMatch[0].length).trim();
 
         if (!prompt) {

package/src/commands/tasks-command.ts

@@ -67,10 +67,10 @@ export function registerTasksCommand(options: TasksCommandOptions): void {
       return viewNativeTasks(ui);
     }
 
-    const match = selected.match(/#(\d+)/);
-    if (!match) return viewNativeTasks(ui);
+    const taskId = selected.match(/#(\d+)/)?.[1];
+    if (!taskId) return viewNativeTasks(ui);
 
-    const task = taskStore.get(match[1]);
+    const task = taskStore.get(taskId);
     if (!task) return viewNativeTasks(ui);
 
     const actions = ["x Delete"];

package/src/coordinator.ts

@@ -8,7 +8,7 @@ export type ReducerSource =
   | "coordinator"
   | "system";
 
-export type ReducerEntityType = "task" | "loop" | "monitor" | "notification" | "goal";
+export type ReducerEntityType = "task" | "loop" | "monitor" | "notification";
 
 export interface ReducerEvent<TType extends string = string, TPayload = unknown> {
   type: TType;

package/src/index.ts

@@ -20,6 +20,7 @@ import { registerTasksCommand } from "./commands/tasks-command.js";
 import { atMaxFires } from "./loop-reducer.js";
 import { MonitorManager } from "./monitor-manager.js";
 import { createMonitorOnDoneRuntime } from "./runtime/monitor-ondone-runtime.js";
+import { registerNativeTaskRpc } from "./runtime/native-task-rpc.js";
 import {
   createNotificationRuntime,
   type LoopFireEvent,
@@ -43,6 +44,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;
@@ -59,7 +64,9 @@ export default function (pi: ExtensionAPI) {
   // call), so stale monitors don't linger in the count between turns.
   monitorManager.setOnChange(() => widget.update());
   widget.setTaskSummaryProvider(() => {
-    if (!nativeTaskStore) return { count: 0 };
+    // Once pi-tasks owns the channels, any native store created during the
+    // detection window is a shadow — never surface it in the status line.
+    if (tasksAvailable || !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");
@@ -76,9 +83,19 @@ export default function (pi: ExtensionAPI) {
 
   // ── pi-tasks integration ──
   let tasksAvailable = false;
+  let tasksDetectionSettled = false;
   let nativeTaskStore: TaskStore | undefined;
   let nativeTasksRegistered = false;
 
+  function getOrCreateNativeTaskStore(): TaskStore | undefined {
+    // pi-tasks owns the task channels; don't create a shadow store.
+    if (tasksAvailable) return undefined;
+    if (!nativeTaskStore) {
+      nativeTaskStore = new TaskStore(resolveTaskStorePath(getScopeOptions(), _sessionId));
+    }
+    return nativeTaskStore;
+  }
+
   const taskRuntime = createTaskRuntimeBridge({
     pi,
     isTasksAvailable: () => tasksAvailable,
@@ -93,6 +110,31 @@ export default function (pi: ExtensionAPI) {
       widget.update();
       await evaluateTaskBacklog(taskStore, taskStore.pendingCount());
     },
+    onDetectionStarted: () => {
+      tasksDetectionSettled = false;
+    },
+    onDetectionSettled: () => {
+      tasksDetectionSettled = true;
+    },
+    debug,
+  });
+
+  // The RPC server registers at init (not behind the 6s tool-fallback timer) so
+  // early cross-extension calls never race the timer; it stands down via
+  // isEnabled once an external pi-tasks is detected. checkTasksVersion ignores
+  // this server's own ping reply via its provider field. Mutating verbs stay
+  // silent until the detection probe settles, so a co-resident pi-tasks can
+  // never race the native server into creating divergent task state.
+  registerNativeTaskRpc({
+    pi,
+    getNativeTaskStore: getOrCreateNativeTaskStore,
+    isEnabled: () => !tasksAvailable,
+    isDetectionSettled: () => tasksDetectionSettled,
+    evaluateTaskBacklog: (taskStore, pendingCount) =>
+      evaluateTaskBacklog(taskStore, pendingCount),
+    updateWidget: () => {
+      widget.update();
+    },
     debug,
   });
 
@@ -169,6 +211,12 @@ export default function (pi: ExtensionAPI) {
     hasPendingTasks: () => hasPendingTasks(),
     bootstrapTaskLoop: (entry) => maybeBootstrapTaskLoop(entry),
     triggerHasEventSource,
+    emitLoopAutodeleted: (payload) => {
+      pi.events.emit("loops:autodeleted", payload);
+    },
+    emitTaskBacklogEmpty: (payload) => {
+      pi.events.emit("tasks:backlog_empty", payload);
+    },
     debug,
   });
 
@@ -297,30 +345,44 @@ export default function (pi: ExtensionAPI) {
 
   // ── Native task tools (only when pi-tasks is absent) ──
 
-  setTimeout(async () => {
+  // Only tool/command registration stays deferred: the tool names collide with
+  // pi-tasks and cannot be unregistered. The RPC server is already live (above).
+  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 = getOrCreateNativeTaskStore();
+    if (!taskStore) return;
+
+    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;
+    }
 
+    nativeTasksRegistered = true;
     debug("native task tools registered (pi-tasks not detected)");
   }, 6000);
+
+  pi.on("session_shutdown", () => {
+    clearTimeout(nativeTaskFallbackTimer);
+  });
 }

package/src/loop-parse.ts

@@ -23,8 +23,10 @@ const COMMON_INTERVALS: Record<number, string> = {
 };
 
 function roundToNearestCommon(seconds: number): { cron: string; description: string } {
+  // COMMON_INTERVALS is a non-empty const table, so keys[0] and
+  // COMMON_INTERVALS[best] below are true invariants, not runtime fallbacks.
   const keys = Object.keys(COMMON_INTERVALS).map(Number).sort((a, b) => a - b);
-  let best = keys[0];
+  let best = keys[0] as number;
   for (const k of keys) {
     if (Math.abs(k - seconds) < Math.abs(best - seconds)) best = k;
   }
@@ -43,7 +45,7 @@ function roundToNearestCommon(seconds: number): { cron: string; description: str
     }
   }
 
-  return { cron: COMMON_INTERVALS[best], description };
+  return { cron: COMMON_INTERVALS[best] as string, description };
 }
 
 function isFullCron(expr: string): boolean {
@@ -60,8 +62,8 @@ export function parseInterval(input: string): { cron: string; description: strin
 
   const match = trimmed.match(/^(\d+)\s*(s|m|h|d)$/i);
   if (match) {
-    const value = parseInt(match[1], 10);
-    const unit = match[2].toLowerCase();
+    const value = parseInt(match[1] ?? "", 10);
+    const unit = (match[2] ?? "").toLowerCase();
     const totalSec = value * (UNIT_TO_CRON[unit] ?? 60);
 
     if (totalSec < 60) {
@@ -81,6 +83,15 @@ export function cronToNextFire(cronExpr: string, fromDate: Date = new Date()): D
   if (parts.length !== 5) throw new Error(`Invalid cron expression: ${cronExpr}`);
 
   const [minF, hourF, dayF, monthF, dowF] = parts;
+  if (
+    minF === undefined ||
+    hourF === undefined ||
+    dayF === undefined ||
+    monthF === undefined ||
+    dowF === undefined
+  ) {
+    throw new Error(`Invalid cron expression: ${cronExpr}`);
+  }
   const now = new Date(fromDate);
   now.setSeconds(0, 0);
 
@@ -107,7 +118,7 @@ function cronFieldMatches(field: string, value: number): boolean {
     if (part === "*") return true;
 
     if (part.includes("/")) {
-      const [range, stepStr] = part.split("/");
+      const [range = "", stepStr = ""] = part.split("/");
       const step = parseInt(stepStr, 10);
       let rangeMin: number;
       let rangeMax: number;
@@ -116,7 +127,7 @@ function cronFieldMatches(field: string, value: number): boolean {
         rangeMin = 0;
         rangeMax = 59;
       } else if (range.includes("-")) {
-        const [minS, maxS] = range.split("-");
+        const [minS = "", maxS = ""] = range.split("-");
         rangeMin = parseInt(minS, 10);
         rangeMax = parseInt(maxS, 10);
       } else {
@@ -132,7 +143,7 @@ function cronFieldMatches(field: string, value: number): boolean {
     }
 
     if (part.includes("-")) {
-      const [minS, maxS] = part.split("-");
+      const [minS = "", maxS = ""] = part.split("-");
       const min = parseInt(minS, 10);
       const max = parseInt(maxS, 10);
       if (value >= min && value <= max) return true;

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
@@ -90,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 },