@trevonistrevon/pi-loop 0.5.9 → 0.6.1

package/src/loop-reducer.ts

@@ -1,4 +1,4 @@
-import type { LoopEntry, Trigger } from "./types.js";
+import type { DynamicLoopState, LoopEntry, Trigger } from "./types.js";
 
 export const MAX_LOOP_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -34,6 +34,7 @@ export type LoopReducerEvent =
       taskBacklog?: boolean;
       readOnly?: boolean;
       maxFires?: number;
+      dynamic?: Partial<DynamicLoopState>;
     };
   }
   | {
@@ -60,6 +61,18 @@ export type LoopReducerEvent =
       id: string;
       reason: "expires_at" | "resume_event_stale" | "already_completed_monitor";
     };
+  }
+  | {
+    type: "LOOP_DYNAMIC_UPDATED";
+    at: number;
+    source: ReducerSource;
+    entityType?: "loop";
+    entityId?: string;
+    payload: {
+      id: string;
+      prompt?: string;
+      dynamic: Partial<DynamicLoopState>;
+    };
   };
 
 export type LoopReducerEffect =
@@ -106,6 +119,18 @@ export function reduceLoopState(state: LoopReducerState, event: LoopReducerEvent
       readOnly: event.payload.readOnly,
       maxFires: event.payload.maxFires,
       fireCount: 0,
+      dynamic: event.payload.trigger.type === "dynamic" || event.payload.dynamic
+        ? {
+            goal: event.payload.dynamic?.goal ?? event.payload.prompt,
+            state: event.payload.dynamic?.state,
+            metrics: event.payload.dynamic?.metrics,
+            doneCriteria: event.payload.dynamic?.doneCriteria,
+            iteration: event.payload.dynamic?.iteration ?? 0,
+            nextWakeAt: event.payload.dynamic?.nextWakeAt,
+            awaitingUpdate: event.payload.dynamic?.awaitingUpdate ?? false,
+            lastUpdatedAt: event.payload.dynamic?.lastUpdatedAt ?? event.at,
+          }
+        : undefined,
     };
     next.loopsById[id] = loop;
     return {
@@ -150,6 +175,21 @@ export function reduceLoopState(state: LoopReducerState, event: LoopReducerEvent
     loop.updatedAt = event.at;
   }
 
+  if (event.type === "LOOP_DYNAMIC_UPDATED") {
+    loop.prompt = event.payload.prompt ?? loop.prompt;
+    loop.dynamic = {
+      goal: event.payload.dynamic.goal ?? loop.dynamic?.goal ?? loop.prompt,
+      state: event.payload.dynamic.state ?? loop.dynamic?.state,
+      metrics: event.payload.dynamic.metrics ?? loop.dynamic?.metrics,
+      doneCriteria: event.payload.dynamic.doneCriteria ?? loop.dynamic?.doneCriteria,
+      iteration: event.payload.dynamic.iteration ?? loop.dynamic?.iteration ?? 0,
+      nextWakeAt: "nextWakeAt" in event.payload.dynamic ? event.payload.dynamic.nextWakeAt : loop.dynamic?.nextWakeAt,
+      awaitingUpdate: event.payload.dynamic.awaitingUpdate ?? loop.dynamic?.awaitingUpdate ?? false,
+      lastUpdatedAt: event.payload.dynamic.lastUpdatedAt ?? event.at,
+    };
+    loop.updatedAt = event.at;
+  }
+
   next.loopsById[id] = loop;
   return {
     state: next,

package/src/monitor-manager.ts

@@ -270,7 +270,7 @@ export class MonitorManager {
   onComplete(id: string, callback: () => void): boolean {
     const bp = this.processes.get(id);
     if (!bp) return false;
-    if (bp.entry.status === "completed") {
+    if (bp.entry.status === "completed" || bp.entry.status === "error") {
       callback();
       return true;
     }

package/src/notification-reducer.ts

@@ -1,3 +1,5 @@
+import type { DynamicLoopState } from "./types.js";
+
 type ReducerSource = "tool" | "command" | "scheduler" | "eventbus" | "monitor" | "session" | "coordinator" | "system";
 
 export interface ReducerNotification {
@@ -9,6 +11,7 @@ export interface ReducerNotification {
   recurring?: boolean;
   autoTask?: boolean;
   readOnly?: boolean;
+  dynamic?: DynamicLoopState;
 }
 
 export interface NotificationReducerState {

package/src/reducer-backed-store.ts

@@ -11,8 +11,8 @@ function acquireLock(lockPath: string): void {
     try {
       writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
       return;
-    } catch (e: any) {
-      if (e.code === "EEXIST") {
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code === "EEXIST") {
         try {
           const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
           if (!pid || !isProcessRunning(pid)) {
@@ -60,7 +60,7 @@ export interface ReducerBackedStoreConfig<TEntry, TState, TEvent, TData> {
 
 /**
  * Shared persistence + reducer-dispatch machinery for the file-backed entity
- * stores (loops, tasks, goals). Owns file locking, signature-gated load, atomic
+ * stores (loops, tasks). Owns file locking, signature-gated load, atomic
  * save, and reducer application; subclasses add only their entity-specific
  * command methods.
  *

package/src/rpc/channels.ts

@@ -0,0 +1,97 @@
+// 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: 1
+
+/** Cross-extension RPC channels served by a tasks provider (pi-tasks or pi-loop native). */
+export const TASKS_RPC = {
+  ping: "tasks:rpc:ping",
+  create: "tasks:rpc:create",
+  update: "tasks:rpc:update",
+  pending: "tasks:rpc:pending",
+  clean: "tasks:rpc:clean",
+} as const;
+
+/** Cross-extension RPC channels served by @tintinweb/pi-subagents. */
+export const SUBAGENTS_RPC = {
+  ping: "subagents:rpc:ping",
+  spawn: "subagents:rpc:spawn",
+  stop: "subagents:rpc:stop",
+} as const;
+
+/** Broadcast (fire-and-forget) task lifecycle events. */
+export const TASK_EVENTS = {
+  ready: "tasks:ready",
+  created: "tasks:created",
+  started: "tasks:started",
+  completed: "tasks:completed",
+  reopened: "tasks:reopened",
+  updated: "tasks:updated",
+  deleted: "tasks:deleted",
+} as const;
+
+export function replyChannel(channel: string, requestId: string): string {
+  return `${channel}:reply:${requestId}`;
+}
+
+// ── Wire-level DTOs ──
+// Structural: pi-loop's TaskEntry satisfies TaskEntryWire; consumers on the
+// other side of the bus depend only on these shapes, never on store internals.
+
+export type TaskStatusWire = "pending" | "in_progress" | "completed";
+
+export interface TaskEntryWire {
+  id: string;
+  subject: string;
+  description: string;
+  status: TaskStatusWire;
+  createdAt: number;
+  updatedAt: number;
+  completedAt?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CreateTaskParams {
+  subject: string;
+  description: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CreateTaskReply {
+  id: string;
+  task: TaskEntryWire;
+}
+
+export interface UpdateTaskParams {
+  id: string;
+  status?: TaskStatusWire;
+  subject?: string;
+  description?: string;
+}
+
+export interface UpdateTaskReply {
+  task: TaskEntryWire;
+}
+
+export interface PendingReply {
+  pending: number;
+}
+
+export interface CleanReply {
+  pruned: number;
+}
+
+export interface PingReply {
+  version: number;
+  /** Identifies which extension answered; lets a provider ignore its own reply. */
+  provider?: string;
+}
+
+export interface SpawnParams {
+  type: string;
+  prompt: string;
+  options?: Record<string, unknown>;
+}
+
+export interface SpawnReply {
+  id: string;
+}

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/monitor-ondone-runtime.ts

@@ -62,7 +62,7 @@ export function createMonitorOnDoneRuntime(options: MonitorOnDoneRuntimeOptions)
 
     const monitor = monitorManager.get(monitorId);
     if (monitor && monitor.status !== "running") {
-      if (monitor.status === "completed") {
+      if (monitor.status === "completed" || monitor.status === "error") {
         deliver();
         return;
       }

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/notification-runtime.ts

@@ -5,13 +5,14 @@ import {
   type ReducerEvent,
   type ReducerHandler,
 } from "../coordinator.js";
+import { formatTrigger } from "../loop-format.js";
 import {
   type NotificationReducerEvent,
   type NotificationReducerState,
   type ReducerNotification,
   reduceNotificationState,
 } from "../notification-reducer.js";
-import type { Trigger } from "../types.js";
+import type { DynamicLoopState, Trigger } from "../types.js";
 
 export interface LoopFireEvent {
   loopId: string;
@@ -21,6 +22,7 @@ export interface LoopFireEvent {
   readOnly?: boolean;
   recurring?: boolean;
   autoTask?: boolean;
+  dynamic?: DynamicLoopState;
 }
 
 export interface PendingNotification extends LoopFireEvent {
@@ -94,13 +96,7 @@ export function createNotificationRuntime(options: NotificationRuntimeOptions):
   }
 
   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 triggerInfo = formatTrigger(data.trigger, "notification");
 
     const loopId = data.loopId || "?";
     const prompt = data.prompt || "loop fired";
@@ -108,6 +104,22 @@ export function createNotificationRuntime(options: NotificationRuntimeOptions):
       ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, etc.). No file writes, shell execution, or destructive changes."
       : "";
 
+    if (data.dynamic || (typeof data.trigger !== "string" && data.trigger?.type === "dynamic")) {
+      const dynamic = data.dynamic;
+      const lines = [
+        `[pi-loop] Loop #${loopId} fired (dynamic).${constraint}`,
+        `Goal: ${dynamic?.goal ?? prompt}`,
+        `Iteration: ${dynamic?.iteration ?? 0}`,
+      ];
+      if (dynamic?.state) lines.push(`State: ${dynamic.state}`);
+      if (dynamic?.metrics) lines.push(`Metrics: ${dynamic.metrics}`);
+      if (dynamic?.doneCriteria) lines.push(`Done criteria: ${dynamic.doneCriteria}`);
+      lines.push(
+        "Continue toward the goal. When done call LoopUpdate with status=\"completed\". If more work remains, call LoopUpdate with status=\"continue\" plus state/metrics. Omit nextInterval for idle-driven rewake; include nextInterval for a timed wake. If blocked, use status=\"paused\".",
+      );
+      return lines.join("\n");
+    }
+
     return [
       `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
       prompt,
@@ -144,6 +156,7 @@ export function createNotificationRuntime(options: NotificationRuntimeOptions):
         recurring: notification.recurring,
         readOnly: notification.readOnly,
         autoTask: notification.autoTask,
+        dynamic: notification.dynamic,
         timestamp: notification.timestamp,
       },
     }, {