@trevonistrevon/pi-loop 0.5.9 → 0.6.0

package/src/rpc/cross-extension-rpc.ts

@@ -0,0 +1,152 @@
+// VENDORED MODULE — canonical copy shared verbatim by pi-loop and pi-orca.
+// If you edit this file, copy it to the sibling repo and bump VENDOR_REV.
+// VENDOR_REV: 2
+
+import { randomUUID } from "node:crypto";
+import { type PingReply, replyChannel } from "./channels.js";
+
+/**
+ * Cross-extension request/reply over the in-process pi event bus.
+ *
+ * Wire contract (matches the pi-mono convention used by @tintinweb/pi-subagents):
+ *   request:  emit(channel, { requestId, ...params })
+ *   reply:    emit(`${channel}:reply:${requestId}`, RpcReply)
+ */
+export const PROTOCOL_VERSION = 2;
+
+export type RpcReply<T = void> =
+  | { success: true; data?: T }
+  | { success: false; error: string };
+
+export class RpcError extends Error {
+  constructor(
+    readonly channel: string,
+    message: string,
+    readonly timedOut = false,
+  ) {
+    super(message);
+    this.name = "RpcError";
+  }
+}
+
+/** Minimal event-bus surface — satisfied by pi.events. */
+export interface RpcEventBus {
+  on(event: string, handler: (data: unknown) => void): () => void;
+  emit(event: string, data: unknown): void;
+}
+
+/**
+ * Call a remote handler and await its reply.
+ *
+ * Rejects with RpcError on a failure envelope or on timeout (timedOut=true).
+ * Callers that treat failure as "fall back" wrap this in try/catch at the
+ * layer that knows the fallback — the RPC layer itself never returns sentinels.
+ */
+export function rpcCall<T = void>(
+  bus: RpcEventBus,
+  channel: string,
+  params: Record<string, unknown> = {},
+  timeoutMs = 5000,
+): Promise<T> {
+  const requestId = randomUUID();
+  return new Promise<T>((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      unsub();
+      reject(new RpcError(channel, `${channel} timed out after ${timeoutMs}ms`, true));
+    }, timeoutMs);
+    const unsub = bus.on(replyChannel(channel, requestId), (raw) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      unsub();
+      const reply = raw as RpcReply<T> | undefined;
+      if (reply?.success) {
+        resolve(reply.data as T);
+      } else {
+        const error = reply && "error" in reply ? reply.error : undefined;
+        reject(new RpcError(channel, error ?? `${channel} replied with a malformed envelope`));
+      }
+    });
+    try {
+      bus.emit(channel, { requestId, ...params });
+    } catch (error) {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        unsub();
+        reject(error);
+      }
+    }
+  });
+}
+
+/**
+ * Detection probe: resolves undefined when nobody answers the ping channel.
+ * Absence of a provider is expected, not an error.
+ *
+ * First reply wins. If the probing extension also serves this channel, its
+ * own reply will settle the probe — in that case listen on the reply channel
+ * directly for the full window and filter by PingReply.provider instead.
+ */
+export async function rpcProbe(
+  bus: RpcEventBus,
+  pingChannel: string,
+  timeoutMs = 5000,
+): Promise<PingReply | undefined> {
+  try {
+    return await rpcCall<PingReply>(bus, pingChannel, {}, timeoutMs);
+  } catch {
+    return undefined;
+  }
+}
+
+export interface HandleRpcOptions {
+  /**
+   * When false, the handler is a silent no-op: another extension owns the
+   * channel and will reply; emitting a failure here would race its reply.
+   */
+  enabled?: () => boolean;
+  debug?: (...args: unknown[]) => void;
+}
+
+/**
+ * Register a server handler for one RPC channel. Returns the unsubscribe fn.
+ *
+ * Malformed requests get a failure reply, never a silent drop — the only
+ * silent case is a missing requestId, which leaves no reply address.
+ * A thrown/rejected fn becomes a failure envelope.
+ */
+export function handleRpc<P extends object, R = unknown>(
+  bus: RpcEventBus,
+  channel: string,
+  fn: (params: P) => R | Promise<R>,
+  opts?: HandleRpcOptions,
+): () => void {
+  return bus.on(channel, async (raw) => {
+    if (opts?.enabled && !opts.enabled()) return;
+
+    const requestId =
+      raw && typeof raw === "object"
+        ? (raw as { requestId?: unknown }).requestId
+        : undefined;
+    if (typeof requestId !== "string" || requestId.length === 0) {
+      opts?.debug?.(`${channel} — dropped request without requestId`);
+      return;
+    }
+
+    let reply: RpcReply<R>;
+    try {
+      const result = await fn(raw as P);
+      reply = result === undefined ? { success: true } : { success: true, data: result };
+    } catch (error) {
+      reply = {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+    bus.emit(replyChannel(channel, requestId), reply);
+  });
+}

package/src/runtime/loop-events.ts

@@ -0,0 +1,60 @@
+import type { LoopEntry } from "../types.js";
+
+export type LoopAutoDeleteReason = "task_backlog_empty";
+
+export interface LoopAutodeletedPayload {
+  loopId: string;
+  prompt: string;
+  trigger: LoopEntry["trigger"];
+  recurring: boolean;
+  autoTask?: boolean;
+  taskBacklog?: boolean;
+  readOnly?: boolean;
+  maxFires?: number;
+  fireCount?: number;
+  createdAt: number;
+  updatedAt: number;
+  expiresAt: number;
+  source: "task_backlog_runtime";
+  reason: LoopAutoDeleteReason;
+  pendingCount: number;
+}
+
+export interface TaskBacklogEmptyPayload {
+  pendingCount: 0;
+  deletedLoopIds: string[];
+  source: "task_backlog_runtime";
+}
+
+export function buildLoopAutodeletedPayload(
+  entry: LoopEntry,
+  pendingCount: number,
+): LoopAutodeletedPayload {
+  return {
+    loopId: entry.id,
+    prompt: entry.prompt,
+    trigger: entry.trigger,
+    recurring: entry.recurring,
+    autoTask: entry.autoTask,
+    taskBacklog: entry.taskBacklog,
+    readOnly: entry.readOnly,
+    maxFires: entry.maxFires,
+    fireCount: entry.fireCount,
+    createdAt: entry.createdAt,
+    updatedAt: entry.updatedAt,
+    expiresAt: entry.expiresAt,
+    source: "task_backlog_runtime",
+    reason: "task_backlog_empty",
+    pendingCount,
+  };
+}
+
+export function buildTaskBacklogEmptyPayload(
+  deletedLoopIds: string[],
+): TaskBacklogEmptyPayload {
+  return {
+    pendingCount: 0,
+    deletedLoopIds,
+    source: "task_backlog_runtime",
+  };
+}

package/src/runtime/native-task-rpc.ts

@@ -0,0 +1,139 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  type CleanReply,
+  type CreateTaskReply,
+  type PendingReply,
+  type PingReply,
+  TASKS_RPC,
+  type UpdateTaskReply,
+} from "../rpc/channels.js";
+import { handleRpc, PROTOCOL_VERSION } from "../rpc/cross-extension-rpc.js";
+import type { TaskStore } from "../task-store.js";
+import type { TaskStatus } from "../task-types.js";
+import {
+  cleanTasks,
+  createTask,
+  type TaskBacklogResult,
+  type TaskMutationContext,
+  updateTask,
+} from "./task-mutations.js";
+
+/** Discriminates pi-loop's own ping replies from an external pi-tasks provider. */
+export const NATIVE_TASKS_PROVIDER = "pi-loop-native";
+
+interface CreateTaskRequest {
+  requestId: string;
+  subject?: string;
+  description?: string;
+  metadata?: Record<string, unknown>;
+}
+
+interface UpdateTaskRequest {
+  requestId: string;
+  id?: string;
+  status?: TaskStatus;
+  subject?: string;
+  description?: string;
+}
+
+export interface NativeTaskRpcOptions {
+  pi: ExtensionAPI;
+  getNativeTaskStore: () => TaskStore | undefined;
+  /** Stands the server down (silent no-op) when an external pi-tasks owns the channels. */
+  isEnabled?: () => boolean;
+  /**
+   * Gates the mutating/reading verbs (create/update/pending/clean) until the
+   * pi-tasks detection probe has settled. Ping stays answerable throughout so
+   * providers remain discoverable, but no state diverges while an external
+   * provider might still claim the channels. Defaults to settled.
+   */
+  isDetectionSettled?: () => boolean;
+  evaluateTaskBacklog: (
+    taskStore: TaskStore,
+    pendingCount: number,
+  ) => Promise<TaskBacklogResult>;
+  updateWidget: () => void;
+  debug?: (...args: unknown[]) => void;
+}
+
+export function registerNativeTaskRpc(options: NativeTaskRpcOptions): void {
+  const {
+    pi,
+    getNativeTaskStore,
+    isEnabled,
+    isDetectionSettled,
+    evaluateTaskBacklog,
+    updateWidget,
+    debug,
+  } = options;
+  const rpcOpts = { enabled: isEnabled, debug };
+  const settledRpcOpts = {
+    enabled: () => (isEnabled ? isEnabled() : true) && (isDetectionSettled ? isDetectionSettled() : true),
+    debug,
+  };
+
+  function requireMutationContext(): TaskMutationContext {
+    const taskStore = getNativeTaskStore();
+    if (!taskStore) throw new Error("native task store unavailable");
+    return { pi, taskStore, evaluateTaskBacklog, updateWidget };
+  }
+
+  handleRpc<{ requestId: string }, PingReply>(
+    pi.events,
+    TASKS_RPC.ping,
+    () => ({ version: PROTOCOL_VERSION, provider: NATIVE_TASKS_PROVIDER }),
+    rpcOpts,
+  );
+
+  handleRpc<{ requestId: string }, PendingReply>(
+    pi.events,
+    TASKS_RPC.pending,
+    () => ({ pending: requireMutationContext().taskStore.pendingCount() }),
+    settledRpcOpts,
+  );
+
+  handleRpc<CreateTaskRequest, CreateTaskReply>(
+    pi.events,
+    TASKS_RPC.create,
+    async (request) => {
+      if (!request.subject || !request.description) {
+        throw new Error("subject and description are required");
+      }
+      const { entry } = await createTask(requireMutationContext(), {
+        subject: request.subject,
+        description: request.description,
+        metadata: request.metadata,
+      });
+      return { id: entry.id, task: entry };
+    },
+    settledRpcOpts,
+  );
+
+  handleRpc<{ requestId: string }, CleanReply>(
+    pi.events,
+    TASKS_RPC.clean,
+    async () => {
+      const pruned = await cleanTasks(requireMutationContext());
+      debug?.(`${TASKS_RPC.clean} — pruned ${pruned} completed task(s)`);
+      return { pruned };
+    },
+    settledRpcOpts,
+  );
+
+  handleRpc<UpdateTaskRequest, UpdateTaskReply>(
+    pi.events,
+    TASKS_RPC.update,
+    async (request) => {
+      if (!request.id) throw new Error("id is required");
+      const result = await updateTask(requireMutationContext(), {
+        id: request.id,
+        status: request.status,
+        subject: request.subject,
+        description: request.description,
+      });
+      if (!result) throw new Error(`Task #${request.id} not found`);
+      return { task: result.entry };
+    },
+    settledRpcOpts,
+  );
+}

package/src/runtime/task-backlog-runtime.ts

@@ -9,6 +9,12 @@ import {
 } from "../task-backlog-coordinator.js";
 import type { TaskStore } from "../task-store.js";
 import type { LoopEntry, Trigger } from "../types.js";
+import {
+  buildLoopAutodeletedPayload,
+  buildTaskBacklogEmptyPayload,
+  type LoopAutodeletedPayload,
+  type TaskBacklogEmptyPayload,
+} from "./loop-events.js";
 
 export const AUTO_TASK_WORKER_THRESHOLD = 5;
 export const AUTO_TASK_WORKER_PROMPT = "Run TaskList, pick next pending task, mark it in_progress, implement it, run validation, complete it. If no pending tasks remain, call LoopDelete on your own loop ID.";
@@ -27,6 +33,8 @@ export interface TaskBacklogRuntimeOptions {
   hasPendingTasks: () => Promise<number>;
   bootstrapTaskLoop: (entry: LoopEntry) => Promise<boolean>;
   triggerHasEventSource: (trigger: Trigger | string, source: string) => boolean;
+  emitLoopAutodeleted?: (payload: LoopAutodeletedPayload) => void;
+  emitTaskBacklogEmpty?: (payload: TaskBacklogEmptyPayload) => void;
   debug?: (...args: unknown[]) => void;
 }
 
@@ -50,6 +58,8 @@ export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): Ta
     hasPendingTasks,
     bootstrapTaskLoop,
     triggerHasEventSource,
+    emitLoopAutodeleted,
+    emitTaskBacklogEmpty,
     debug,
   } = options;
 
@@ -76,10 +86,14 @@ export function createTaskBacklogRuntime(options: TaskBacklogRuntimeOptions): Ta
     const pending = await hasPendingTasks();
     if (pending < 0 || pending > 0) return 0;
 
+    emitTaskBacklogEmpty?.(
+      buildTaskBacklogEmptyPayload(backlogLoops.map((entry) => entry.id)),
+    );
     for (const entry of backlogLoops) {
       debug?.(`task backlog loop #${entry.id} — no pending tasks remain, deleting`);
       removeTrigger(entry.id);
       deleteLoop(entry.id);
+      emitLoopAutodeleted?.(buildLoopAutodeletedPayload(entry, pending));
     }
     updateWidget();
     return backlogLoops.length;

package/src/runtime/task-mutations.ts

@@ -0,0 +1,103 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TaskStore } from "../task-store.js";
+import type { TaskEntry, TaskStatus } from "../task-types.js";
+import { emitNativeTaskEvent } from "./task-events.js";
+
+export interface TaskBacklogResult {
+  created: boolean;
+  entry?: { id: string };
+  cleaned?: number;
+}
+
+export interface TaskMutationContext {
+  pi: ExtensionAPI;
+  taskStore: TaskStore;
+  evaluateTaskBacklog: (
+    taskStore: TaskStore,
+    pendingCount: number,
+  ) => Promise<TaskBacklogResult>;
+  updateWidget: () => void;
+}
+
+export interface UpdateTaskFields {
+  id: string;
+  status?: TaskStatus;
+  subject?: string;
+  description?: string;
+}
+
+/**
+ * Single source of truth for native task mutations, shared by the TaskCreate/
+ * TaskUpdate/TaskDelete tools and the tasks:rpc:* server so both surfaces emit
+ * identical events in one canonical order: mutate → emit → widget → backlog.
+ */
+
+async function settle(ctx: TaskMutationContext): Promise<TaskBacklogResult> {
+  ctx.updateWidget();
+  return await ctx.evaluateTaskBacklog(ctx.taskStore, ctx.taskStore.pendingCount());
+}
+
+export async function createTask(
+  ctx: TaskMutationContext,
+  params: { subject: string; description: string; metadata?: Record<string, unknown> },
+): Promise<{ entry: TaskEntry; backlog: TaskBacklogResult }> {
+  const entry = ctx.taskStore.create(params.subject, params.description, params.metadata);
+  emitNativeTaskEvent(ctx.pi, "tasks:created", entry);
+  const backlog = await settle(ctx);
+  return { entry, backlog };
+}
+
+export async function updateTask(
+  ctx: TaskMutationContext,
+  params: UpdateTaskFields,
+): Promise<{ entry: TaskEntry; backlog: TaskBacklogResult } | undefined> {
+  const { id, status, subject, description } = params;
+  let entry = ctx.taskStore.get(id);
+  if (!entry) return undefined;
+
+  const previousStatus = entry.status;
+  if (status === "in_progress") {
+    entry = ctx.taskStore.start(id);
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:started", entry, previousStatus);
+  } else if (status === "completed") {
+    entry = ctx.taskStore.complete(id);
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:completed", entry, previousStatus);
+  } else if (status === "pending") {
+    entry = ctx.taskStore.reopen(id);
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:reopened", entry, previousStatus);
+  }
+  if (!entry) return undefined;
+
+  if (subject !== undefined || description !== undefined) {
+    // A details edit is not a transition: its previousStatus is the status
+    // current at edit time (i.e. after any transition above), so consumers
+    // never see a fabricated second transition.
+    const statusAtEdit = entry.status;
+    entry = ctx.taskStore.updateDetails(id, { subject, description });
+    if (entry) emitNativeTaskEvent(ctx.pi, "tasks:updated", entry, statusAtEdit);
+  }
+  if (!entry) return undefined;
+
+  const backlog = await settle(ctx);
+  return { entry, backlog };
+}
+
+export async function deleteTask(
+  ctx: TaskMutationContext,
+  id: string,
+): Promise<{ entry: TaskEntry; backlog: TaskBacklogResult } | undefined> {
+  const existing = ctx.taskStore.get(id);
+  if (!existing || !ctx.taskStore.delete(id)) {
+    ctx.updateWidget();
+    return undefined;
+  }
+  emitNativeTaskEvent(ctx.pi, "tasks:deleted", existing, existing.status);
+  const backlog = await settle(ctx);
+  return { entry: existing, backlog };
+}
+
+export async function cleanTasks(ctx: TaskMutationContext): Promise<number> {
+  const pruned = ctx.taskStore.pruneCompleted();
+  await settle(ctx);
+  return pruned;
+}

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+/);