@trevonistrevon/pi-loop 0.5.9 → 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/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.9",
+  "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/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,
@@ -63,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");
@@ -80,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,
@@ -97,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,
   });
 
@@ -173,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,
   });
 
@@ -301,9 +345,12 @@ export default function (pi: ExtensionAPI) {
 
   // ── Native task tools (only when pi-tasks is absent) ──
 
+  // 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;
-    const taskStore = new TaskStore(resolveTaskStorePath(getScopeOptions(), _sessionId));
+    const taskStore = getOrCreateNativeTaskStore();
+    if (!taskStore) return;
 
     try {
       registerTasksCommand({
@@ -331,7 +378,6 @@ export default function (pi: ExtensionAPI) {
       throw error;
     }
 
-    nativeTaskStore = taskStore;
     nativeTasksRegistered = true;
     debug("native task tools registered (pi-tasks not detected)");
   }, 6000);

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