@trevonistrevon/pi-loop 0.6.3 → 0.6.4

package/src/runtime/task-rpc.ts

@@ -7,9 +7,11 @@ import {
   type PingReply,
   replyChannel,
   TASKS_RPC,
+  type UpdateTaskReply,
 } from "../rpc/channels.js";
 import { type RpcReply, rpcCall } from "../rpc/cross-extension-rpc.js";
 import type { TaskStore } from "../task-store.js";
+import type { TaskWorkflowLink } from "../task-types.js";
 import type { LoopEntry } from "../types.js";
 import { NATIVE_TASKS_PROVIDER } from "./native-task-rpc.js";
 import { emitNativeTaskEvent } from "./task-events.js";
@@ -20,7 +22,9 @@ export interface TaskRuntimeBridgeOptions {
   setTasksAvailable: (available: boolean) => void;
   getNativeTaskStore: () => TaskStore | undefined;
   onNativeTaskCreated?: (taskStore: TaskStore) => void;
+  onNativeTaskCompleted?: (taskStore: TaskStore) => Promise<void> | void;
   onNativeTasksPruned?: (taskStore: TaskStore) => Promise<void> | void;
+  isDetectionSettled?: () => boolean;
   /** Called when a detection window opens. */
   onDetectionStarted?: () => void;
   /** Called when a detection window closes (provider found or probe timed out). */
@@ -31,6 +35,8 @@ export interface TaskRuntimeBridgeOptions {
 export interface TaskRuntimeBridge {
   checkTasksVersion(): void;
   autoCreateTask(entry: LoopEntry): Promise<string | undefined>;
+  createWorkflowTask(entry: LoopEntry): Promise<string | undefined>;
+  completeWorkflowTask(taskId: string): Promise<boolean>;
   hasPendingTasks(): Promise<number>;
   cleanDoneTasks(): Promise<void>;
 }
@@ -42,7 +48,9 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
     setTasksAvailable,
     getNativeTaskStore,
     onNativeTaskCreated,
+    onNativeTaskCompleted,
     onNativeTasksPruned,
+    isDetectionSettled,
     onDetectionStarted,
     onDetectionSettled,
     debug,
@@ -105,6 +113,62 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
     return task.id;
   }
 
+  async function createWorkflowTask(entry: LoopEntry): Promise<string | undefined> {
+    const workflow = entry.workflow;
+    if (!workflow) return undefined;
+    const state = workflow.definition.states[workflow.currentState];
+    if (!state?.task || state.terminal) return undefined;
+
+    const link: TaskWorkflowLink = {
+      loopId: entry.id,
+      stateId: workflow.currentState,
+      transitionSeq: workflow.transitionSeq,
+    };
+    const metadata = { workflow: link };
+    if (isTasksAvailable()) {
+      try {
+        const reply = await rpcCall<CreateTaskReply>(pi.events, TASKS_RPC.create, {
+          subject: state.task.subject,
+          description: state.task.description,
+          metadata,
+        }, 5000);
+        return reply.id;
+      } catch {
+        return undefined;
+      }
+    }
+
+    if (isDetectionSettled && !isDetectionSettled()) return undefined;
+    const nativeTaskStore = getNativeTaskStore();
+    if (!nativeTaskStore) return undefined;
+    const task = nativeTaskStore.create(state.task.subject, state.task.description, metadata, link);
+    emitNativeTaskEvent(pi, "tasks:created", task);
+    onNativeTaskCreated?.(nativeTaskStore);
+    return task.id;
+  }
+
+  async function completeWorkflowTask(taskId: string): Promise<boolean> {
+    if (isTasksAvailable()) {
+      try {
+        await rpcCall<UpdateTaskReply>(pi.events, TASKS_RPC.update, { id: taskId, status: "completed" }, 5000);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+
+    const nativeTaskStore = getNativeTaskStore();
+    const existing = nativeTaskStore?.get(taskId);
+    if (!nativeTaskStore || !existing) return false;
+    if (existing.status === "completed") return true;
+
+    const completed = nativeTaskStore.complete(taskId);
+    if (!completed) return false;
+    emitNativeTaskEvent(pi, "tasks:completed", completed, existing.status);
+    await onNativeTaskCompleted?.(nativeTaskStore);
+    return true;
+  }
+
   async function hasPendingTasks(): Promise<number> {
     if (isTasksAvailable()) {
       // -1 is this bridge's "unknown" sentinel, consumed by notification-runtime;
@@ -140,6 +204,8 @@ export function createTaskRuntimeBridge(options: TaskRuntimeBridgeOptions): Task
   return {
     checkTasksVersion,
     autoCreateTask,
+    createWorkflowTask,
+    completeWorkflowTask,
     hasPendingTasks,
     cleanDoneTasks,
   };

package/src/store.ts

@@ -2,7 +2,8 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { type LoopReducerEvent, type LoopReducerState, reduceLoopState } from "./loop-reducer.js";
 import { ReducerBackedStore } from "./reducer-backed-store.js";
-import type { DynamicLoopState, LoopDeletionTombstone, LoopDeletionTombstoneInput, LoopEntry, LoopStoreData, Trigger } from "./types.js";
+import type { DynamicLoopState, LoopDeletionTombstone, LoopDeletionTombstoneInput, LoopEntry, LoopStoreData, Trigger, WorkflowDefinition, WorkflowTerminalStatus } from "./types.js";
+import { transitionWorkflowRun, validateWorkflowDefinition, type WorkflowTransitionInput } from "./workflow-reducer.js";
 
 const LOOPS_DIR = join(homedir(), ".pi", "loops");
 const MAX_LOOPS = 25;
@@ -25,11 +26,16 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
     );
   }
 
-  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number; dynamic?: Partial<DynamicLoopState> }): LoopEntry {
+  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; taskBacklog?: boolean; readOnly?: boolean; maxFires?: number; dynamic?: Partial<DynamicLoopState>; workflow?: WorkflowDefinition }): LoopEntry {
     return this.withLock(() => {
       if (this.entries.size >= MAX_LOOPS) {
         throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
       }
+      if (opts.workflow) {
+        if (trigger.type !== "dynamic") throw new Error("Workflow loops require a dynamic trigger.");
+        const validationError = validateWorkflowDefinition(opts.workflow);
+        if (validationError) throw new Error(`Invalid workflow: ${validationError}`);
+      }
       const now = Date.now();
       this.applyReducerEvent({
         type: "LOOP_CREATED",
@@ -45,6 +51,7 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
           readOnly: opts.readOnly,
           maxFires: opts.maxFires,
           dynamic: opts.dynamic,
+          workflow: opts.workflow,
         },
       });
       return this.entries.get(String(this.nextId - 1))!;
@@ -154,6 +161,48 @@ export class LoopStore extends ReducerBackedStore<LoopEntry, LoopReducerState, L
     });
   }
 
+  transitionWorkflow(id: string, input: WorkflowTransitionInput): { entry?: LoopEntry; applied: boolean; error?: string; terminal?: WorkflowTerminalStatus } {
+    return this.withLock(() => {
+      const entry = this.entries.get(id);
+      if (!entry) return { applied: false, error: `Loop #${id} not found` };
+      if (!entry.workflow) return { applied: false, error: `Loop #${id} is not a workflow loop` };
+
+      const result = transitionWorkflowRun(entry.workflow, input, Date.now());
+      if (!result.applied) return { applied: false, error: result.error };
+
+      this.applyReducerEvent({
+        type: "LOOP_WORKFLOW_TRANSITION",
+        at: result.run.stateEnteredAt,
+        source: "tool",
+        entityType: "loop",
+        entityId: id,
+        payload: {
+          id,
+          outcome: input.outcome,
+          evidence: input.evidence,
+          activeTaskId: input.activeTaskId,
+        },
+      });
+      return { entry: this.entries.get(id), applied: true, terminal: result.terminal };
+    });
+  }
+
+  setWorkflowActiveTask(id: string, taskId?: string): LoopEntry | undefined {
+    return this.withLock(() => {
+      const entry = this.entries.get(id);
+      if (!entry?.workflow) return undefined;
+      this.applyReducerEvent({
+        type: "LOOP_WORKFLOW_TASK_SET",
+        at: Date.now(),
+        source: "tool",
+        entityType: "loop",
+        entityId: id,
+        payload: { id, taskId },
+      });
+      return this.entries.get(id);
+    });
+  }
+
   getDeletionTombstone(id: string): LoopDeletionTombstone | undefined {
     const tombstone = this.tombstones.get(id);
     if (!tombstone) return undefined;

package/src/task-reducer.ts

@@ -1,4 +1,4 @@
-import type { TaskEntry } from "./task-types.js";
+import type { TaskEntry, TaskWorkflowLink } from "./task-types.js";
 
 export interface TaskReducerState {
   nextId: number;
@@ -16,6 +16,7 @@ export type TaskReducerEvent =
       subject: string;
       description: string;
       metadata?: Record<string, unknown>;
+      workflow?: TaskWorkflowLink;
     };
   }
   | {
@@ -87,6 +88,7 @@ export function reduceTaskState(state: TaskReducerState, event: TaskReducerEvent
       createdAt: event.at,
       updatedAt: event.at,
       metadata: event.payload.metadata,
+      workflow: event.payload.workflow,
     };
     next.tasksById[id] = task;
     return {

package/src/task-store.ts

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { ReducerBackedStore } from "./reducer-backed-store.js";
 import { reduceTaskState, type TaskReducerEvent, type TaskReducerState } from "./task-reducer.js";
-import type { TaskEntry, TaskStoreData } from "./task-types.js";
+import type { TaskEntry, TaskStoreData, TaskWorkflowLink } from "./task-types.js";
 
 const TASKS_DIR = join(homedir(), ".pi", "tasks");
 const MAX_TASKS = 200;
@@ -22,7 +22,7 @@ export class TaskStore extends ReducerBackedStore<TaskEntry, TaskReducerState, T
     );
   }
 
-  create(subject: string, description: string, metadata?: Record<string, unknown>): TaskEntry {
+  create(subject: string, description: string, metadata?: Record<string, unknown>, workflow?: TaskWorkflowLink): TaskEntry {
     return this.withLock(() => {
       if (this.entries.size >= MAX_TASKS) {
         throw new Error(`Maximum of ${MAX_TASKS} tasks reached. Delete some before creating new ones.`);
@@ -33,7 +33,7 @@ export class TaskStore extends ReducerBackedStore<TaskEntry, TaskReducerState, T
         at: now,
         source: "tool",
         entityType: "task",
-        payload: { subject, description, metadata },
+        payload: { subject, description, metadata, workflow },
       });
       return this.entries.get(String(this.nextId - 1))!;
     });

package/src/task-types.ts

@@ -1,5 +1,11 @@
 export type TaskStatus = "pending" | "in_progress" | "completed";
 
+export interface TaskWorkflowLink {
+  loopId: string;
+  stateId: string;
+  transitionSeq: number;
+}
+
 export interface TaskEntry {
   id: string;
   subject: string;
@@ -9,6 +15,7 @@ export interface TaskEntry {
   updatedAt: number;
   completedAt?: number;
   metadata?: Record<string, unknown>;
+  workflow?: TaskWorkflowLink;
 }
 
 export interface TaskStoreData {