@osolmaz/pi-workflows 0.16.5 → 0.16.7

package/src/extension/workflow-message-coordinator.ts

@@ -16,24 +16,28 @@ import {
 
 const WORKFLOW_MESSAGE_ID_FIELD = "workflowMessageId";
 
-type PendingTurn = {
+type SettledTurn = { stopReason: WorkflowTurnStopReason; responseSessionEntryId: string | null };
+type BeforeTurnEnd = (message: WorkflowMessage, end: SettledTurn) => Promise<void>;
+type DeliveryCallbacks = {
+  beforeTurnEnd?: BeforeTurnEnd;
+  terminalDelivered?: (message: WorkflowMessage) => Promise<void>;
+};
+
+type OwnedTurn = {
   workflowTurnId: string;
-  workflowMessageId: string | null;
-  runId: string | null;
-  message: WorkflowMessage | null;
+  message: WorkflowMessage;
   startedReported: boolean;
-  end: { stopReason: WorkflowTurnStopReason; responseSessionEntryId: string | null } | null;
-};
+} & ({ phase: "delivering" | "running" } | { phase: "settled"; end: SettledTurn });
 
 /** Adds every server-owned workflow message to one Pi session through one public API path. */
 export class WorkflowMessageCoordinator {
   private readonly queued = new Set<string>();
   private readonly closedTurnMessages = new Set<string>();
+  private readonly finalizedTerminals = new Set<string>();
   private synchronizing = false;
   private lastBranchEpoch: string | null = null;
   private view: WorkflowSessionView | null = null;
-  private awaitingTurnMessage: WorkflowMessage | null = null;
-  private turn: PendingTurn | null = null;
+  private turn: OwnedTurn | null = null;
 
   updateView(view: WorkflowSessionView): void {
     this.view = view;
@@ -41,19 +45,14 @@ export class WorkflowMessageCoordinator {
     for (const messageId of this.closedTurnMessages) {
       if (!visibleIds.has(messageId)) this.closedTurnMessages.delete(messageId);
     }
+    for (const messageId of this.finalizedTerminals) {
+      if (!visibleIds.has(messageId)) this.finalizedTerminals.delete(messageId);
+    }
     for (const message of view.workflowMessages) {
       if (message.status === "sent" || message.status === "cancelled") {
         this.queued.delete(message.workflowMessageId);
       }
     }
-    if (
-      this.turn !== null &&
-      this.turn.workflowMessageId === null &&
-      view.openWorkflowMessageId !== null
-    ) {
-      const message = messageById(view, view.openWorkflowMessageId);
-      if (message !== undefined && messageStartsTurn(message)) this.bindTurn(message);
-    }
   }
 
   branchChanged(): void {
@@ -61,23 +60,15 @@ export class WorkflowMessageCoordinator {
   }
 
   startTurn(): void {
-    const awaited = this.awaitingTurnMessage;
-    this.awaitingTurnMessage = null;
-    this.turn = {
-      workflowTurnId: `workflow-turn-${randomUUID()}`,
-      workflowMessageId: null,
-      runId: null,
-      message: null,
-      startedReported: false,
-      end: null,
-    };
-    const candidate = awaited ?? this.turnCandidate();
-    if (candidate !== undefined) this.bindTurn(candidate);
+    // Ordinary chat owns no workflow turn. Automatic Pi retries retain the
+    // existing turn, including a settled result whose acknowledgment is pending.
+    if (this.turn?.phase === "delivering") this.turn = { ...this.turn, phase: "running" };
   }
 
   endTurn(stopReason: WorkflowTurnStopReason, responseSessionEntryId: string | null): void {
-    if (this.turn === null) this.startTurn();
-    if (this.turn !== null) this.turn.end = { stopReason, responseSessionEntryId };
+    if (this.turn?.phase === "running") {
+      this.turn = { ...this.turn, phase: "settled", end: { stopReason, responseSessionEntryId } };
+    }
   }
 
   activeTurnMessage(): WorkflowMessage | undefined {
@@ -89,21 +80,32 @@ export class WorkflowMessageCoordinator {
     pi: ExtensionAPI,
     client: WorkflowClient,
     ctx: Pick<ExtensionContext, "hasPendingMessages" | "isIdle" | "sessionManager">,
+    callbacks: DeliveryCallbacks = {},
   ): Promise<void> {
     if (this.synchronizing || this.view === null) return;
     this.synchronizing = true;
     try {
       const view = this.view;
       if (!view.coordinatorActive || view.coordinatorEpoch === null) return;
-      if (this.turn === null && !ctx.isIdle() && view.openWorkflowTurn !== null) {
-        this.turn = {
-          workflowTurnId: view.openWorkflowTurn.workflowTurnId,
-          workflowMessageId: view.openWorkflowTurn.workflowMessageId,
-          runId: view.openWorkflowTurn.runId,
-          message: messageById(view, view.openWorkflowTurn.workflowMessageId) ?? null,
-          startedReported: true,
-          end: null,
-        };
+      const branchEntries = branchWorkflowEntries(ctx.sessionManager.getBranch());
+      if (this.turn === null && !ctx.isIdle()) {
+        const candidate = this.turnCandidate();
+        const open = view.openWorkflowTurn;
+        if (
+          candidate !== undefined &&
+          open?.state === "started" &&
+          open.workflowMessageId === candidate.workflowMessageId &&
+          open.runId === candidate.runId &&
+          open.targetSessionId === view.sessionId &&
+          latestTurnInputIsWorkflow(ctx.sessionManager.getBranch(), candidate.workflowMessageId)
+        ) {
+          this.turn = {
+            workflowTurnId: open.workflowTurnId,
+            message: candidate,
+            startedReported: true,
+            phase: "running",
+          };
+        }
       }
       if (
         view.branchReportRequired ||
@@ -112,7 +114,19 @@ export class WorkflowMessageCoordinator {
       ) {
         await this.reportBranch(client, ctx, view);
       }
-      await this.flushTurn(client, view);
+      await this.flushTurn(client, view, callbacks.beforeTurnEnd);
+      if (this.turn !== null || !ctx.isIdle() || ctx.hasPendingMessages()) return;
+      for (const message of view.workflowMessages) {
+        if (
+          message.kind === "terminal" &&
+          message.status === "sent" &&
+          branchEntries.has(message.workflowMessageId) &&
+          !this.finalizedTerminals.has(message.workflowMessageId)
+        ) {
+          await callbacks.terminalDelivered?.(message);
+          this.finalizedTerminals.add(message.workflowMessageId);
+        }
+      }
       const messageId = view.nextWorkflowMessageId;
       if (messageId === null || this.queued.has(messageId)) return;
       const message = messageById(view, messageId);
@@ -140,8 +154,13 @@ export class WorkflowMessageCoordinator {
         this.queued.delete(messageId);
         return;
       }
-      if (message.content.triggerTurn && messageStartsTurn(message)) {
-        this.awaitingTurnMessage = message;
+      if (messageStartsTurn(message)) {
+        this.turn = {
+          workflowTurnId: `workflow-turn-${randomUUID()}`,
+          message,
+          startedReported: false,
+          phase: "delivering",
+        };
       }
       try {
         pi.sendMessage(
@@ -155,13 +174,16 @@ export class WorkflowMessageCoordinator {
         );
       } catch (error) {
         this.queued.delete(messageId);
-        if (this.awaitingTurnMessage?.workflowMessageId === messageId) {
-          this.awaitingTurnMessage = null;
+        if (
+          this.turn?.phase === "delivering" &&
+          this.turn.message.workflowMessageId === messageId
+        ) {
+          this.turn = null;
         }
         throw error;
       }
       await this.reportBranch(client, ctx, view);
-      await this.flushTurn(client, view);
+      await this.flushTurn(client, view, callbacks.beforeTurnEnd);
     } finally {
       this.synchronizing = false;
     }
@@ -170,8 +192,8 @@ export class WorkflowMessageCoordinator {
   clear(): void {
     this.queued.clear();
     this.closedTurnMessages.clear();
+    this.finalizedTerminals.clear();
     this.view = null;
-    this.awaitingTurnMessage = null;
     this.turn = null;
     this.lastBranchEpoch = null;
     this.synchronizing = false;
@@ -197,19 +219,15 @@ export class WorkflowMessageCoordinator {
     return undefined;
   }
 
-  private bindTurn(message: WorkflowMessage): void {
-    if (this.turn === null) return;
-    this.turn.workflowMessageId = message.workflowMessageId;
-    this.turn.runId = message.runId;
-    this.turn.message = message;
-  }
-
-  private async flushTurn(client: WorkflowClient, view: WorkflowSessionView): Promise<void> {
-    const pending = this.turn;
+  private async flushTurn(
+    client: WorkflowClient,
+    view: WorkflowSessionView,
+    beforeTurnEnd?: BeforeTurnEnd,
+  ): Promise<void> {
+    let pending = this.turn;
     if (
       pending === null ||
-      pending.workflowMessageId === null ||
-      pending.runId === null ||
+      pending.phase === "delivering" ||
       view.coordinatorEpoch === null ||
       this.lastBranchEpoch !== view.coordinatorEpoch
     ) {
@@ -217,54 +235,53 @@ export class WorkflowMessageCoordinator {
     }
     let message = pending.message;
     if (!pending.startedReported) {
-      message = messageById(view, pending.workflowMessageId) ?? null;
-      if (message?.status !== "sent") return;
-      try {
-        const receipt = await reportTurn(client, {
-          state: "started",
-          workflowMessageId: pending.workflowMessageId,
-          workflowTurnId: pending.workflowTurnId,
-          runId: pending.runId,
-          targetSessionId: view.sessionId,
-          coordinatorEpoch: view.coordinatorEpoch,
-        });
-        if (receipt.ownership !== "active") {
-          this.turn = null;
-          return;
-        }
-        pending.message = message;
-        pending.startedReported = true;
-      } catch (error) {
-        this.turn = null;
-        throw error;
-      }
-    }
-    if (pending.end === null) return;
-    try {
-      await reportTurn(client, {
-        state: "ended",
-        workflowMessageId: pending.workflowMessageId,
+      const confirmed = messageById(view, message.workflowMessageId);
+      if (confirmed?.status !== "sent") return;
+      message = confirmed;
+      const receipt = await reportTurn(client, {
+        state: "started",
+        workflowMessageId: message.workflowMessageId,
         workflowTurnId: pending.workflowTurnId,
-        runId: pending.runId,
+        runId: message.runId,
         targetSessionId: view.sessionId,
         coordinatorEpoch: view.coordinatorEpoch,
-        stopReason: pending.end.stopReason,
-        responseSessionEntryId: pending.end.responseSessionEntryId,
       });
-    } catch (error) {
-      this.turn = null;
-      throw error;
+      // Pi can settle while the start report is in flight. Keep that exact
+      // response and do not restore a turn cleared by session shutdown.
+      if (this.turn?.workflowTurnId !== pending.workflowTurnId) return;
+      pending = this.turn;
+      if (
+        receipt.ownership !== "active" &&
+        !(receipt.ownership === "settled" && pending.phase === "settled")
+      ) {
+        this.turn = null;
+        return;
+      }
+      pending.message = message;
+      pending.startedReported = true;
     }
-    if (message?.kind === "terminal" || message?.kind === "followUp") {
-      this.closedTurnMessages.add(pending.workflowMessageId);
+    if (pending.phase !== "settled") return;
+    await beforeTurnEnd?.(message, pending.end);
+    await reportTurn(client, {
+      state: "ended",
+      workflowMessageId: message.workflowMessageId,
+      workflowTurnId: pending.workflowTurnId,
+      runId: message.runId,
+      targetSessionId: view.sessionId,
+      coordinatorEpoch: view.coordinatorEpoch,
+      stopReason: pending.end.stopReason,
+      responseSessionEntryId: pending.end.responseSessionEntryId,
+    });
+    if (message.kind === "followUp") {
+      this.closedTurnMessages.add(message.workflowMessageId);
     }
     for (const current of new Set([view, this.view])) {
       if (current?.openWorkflowTurn?.workflowTurnId === pending.workflowTurnId) {
         current.openWorkflowTurn = null;
       }
       if (
-        current?.openWorkflowMessageId === pending.workflowMessageId &&
-        (message?.kind === "terminal" || message?.kind === "followUp")
+        current?.openWorkflowMessageId === message.workflowMessageId &&
+        message.kind === "followUp"
       ) {
         current.openWorkflowMessageId = null;
       }
@@ -332,6 +349,27 @@ export function branchWorkflowEntries(entries: readonly unknown[]): Map<string,
   return found;
 }
 
+function latestTurnInputIsWorkflow(
+  entries: readonly unknown[],
+  workflowMessageId: string,
+): boolean {
+  for (const value of [...entries].reverse()) {
+    if (!isRecord(value)) continue;
+    if (
+      value.role === "user" ||
+      (value.type === "message" && isRecord(value.message) && value.message.role === "user")
+    ) {
+      return false;
+    }
+    if (value.type === "custom_message" || value.role === "custom") {
+      return (
+        isRecord(value.details) && value.details[WORKFLOW_MESSAGE_ID_FIELD] === workflowMessageId
+      );
+    }
+  }
+  return false;
+}
+
 export function responseEntryId(entries: readonly unknown[]): string | null {
   for (const value of [...entries].reverse()) {
     if (!isRecord(value) || typeof value.id !== "string") continue;
@@ -351,7 +389,7 @@ function messageById(
 }
 
 function messageStartsTurn(message: WorkflowMessage): boolean {
-  return message.kind === "step" || message.kind === "terminal" || message.kind === "followUp";
+  return message.content.triggerTurn;
 }
 
 async function reportTurn(

package/src/render/graph-render.ts

@@ -48,7 +48,7 @@ const STATUS_GLYPHS: Record<NodeStatus, string> = {
   timed_out: "×",
   active: "◐",
   replay_focus: "◆",
-  waiting: "⏸",
+  waiting: "○",
   cancelled: "~",
   queued: "·",
 };

package/src/resource-managers/index.ts

@@ -18,16 +18,8 @@ export {
 } from "./errors.js";
 export { ResourceManagerEffectService } from "./effects.js";
 export { canonicalJson, jsonFingerprint } from "./json.js";
-export { ResourceManagerRuntime, type ResourceManagerRuntimeOptions } from "./runtime.js";
 export { createResultHelpers, requeue, requeueAfter, settled } from "./results.js";
-export {
-  SqliteResourceManagerStore,
-  type RunEventRecord,
-  type WorkflowRunClaimOptions,
-  type WorkflowRunPreparationResult,
-  type WorkflowRunQueueRecord,
-  type WorkflowRunReservationOptions,
-} from "./sqlite.js";
+export { SqliteResourceManagerStore } from "./sqlite.js";
 export {
   type ResourceManagerStore,
   type EffectReservation,