@trevonistrevon/pi-loop 0.5.8 → 0.6.0

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