@osolmaz/pi-workflows 0.16.1 → 0.16.3

package/src/extension/index.ts

@@ -17,7 +17,6 @@ import { errorMessage } from "../workflows/errors.js";
 import { discoverWorkflows } from "../workflows/loader.js";
 import { createRunId } from "../workflows/store.js";
 import type { AgentStepContract, HumanDecisionResponse } from "../workflows/types.js";
-import { parseControllerArgs, type ParsedControllerArgs } from "./controller-command.js";
 import {
   HerdrWorkflowViewer,
   PIW_SHORTCUT,
@@ -27,12 +26,19 @@ import {
 } from "./herdr-viewer.js";
 import { SessionRecorder } from "./recorder.js";
 import { RemoteSessionRecordingStore } from "./remote-recorder-store.js";
+import {
+  parseResourceManagerArgs,
+  type ParsedResourceManagerArgs,
+} from "./resource-manager-command.js";
 import { SessionWorkflowView } from "./session-view.js";
 import { recoverAssistantStep, registerWorkflowAgentStepMessageRenderer } from "./step-message.js";
 import { responseEntryId, WorkflowMessageCoordinator } from "./workflow-message-coordinator.js";
 import { parseWorkflowToolInput, WorkflowToolParameters } from "./workflow-tool.js";
 
-export { parseControllerArgs, type ParsedControllerArgs } from "./controller-command.js";
+export {
+  parseResourceManagerArgs,
+  type ParsedResourceManagerArgs,
+} from "./resource-manager-command.js";
 
 export {
   audienceChannels,
@@ -176,14 +182,16 @@ export default function piWorkflows(pi: ExtensionAPI): void {
   let sessionGeneration = 0;
   let sessionUnsubscribe: (() => Promise<void>) | null = null;
   let sessionConnectTask: Promise<void> | null = null;
-  let hostUnavailableNotified = false;
+  let serverUnavailableNotified = false;
   let pollTimer: ReturnType<typeof setInterval> | null = null;
   let presentationTail = Promise.resolve();
   let toolTail = Promise.resolve();
   const workflowMessages = new WorkflowMessageCoordinator();
   const sessionView = new SessionWorkflowView();
   const sessionRecorders = new Map<string, SessionRecorder>();
+  let agentRunning = false;
   let activeRecorder: SessionRecorder | null = null;
+  let activeRecorderMessageId: string | null = null;
 
   const ensureRecorder = async (
     message: WorkflowMessage,
@@ -203,6 +211,33 @@ export default function piWorkflows(pi: ExtensionAPI): void {
     return recorder;
   };
 
+  const activateRecorder = async (ctx: ExtensionContext): Promise<void> => {
+    if (!agentRunning) return;
+    const message = workflowMessages.activeTurnMessage();
+    if (message === undefined || activeRecorderMessageId === message.workflowMessageId) return;
+    const contract = agentContractForWorkflowMessage(message);
+    if (contract === undefined && message.kind !== "terminal" && message.kind !== "followUp") {
+      return;
+    }
+    const recorder = await ensureRecorder(message, ctx);
+    if (
+      !agentRunning ||
+      workflowMessages.activeTurnMessage()?.workflowMessageId !== message.workflowMessageId
+    ) {
+      return;
+    }
+    if (contract === undefined) {
+      recorder.beginWorkflowMessage(
+        message.workflowMessageId,
+        message.kind as "terminal" | "followUp",
+      );
+    } else {
+      recorder.beginAttempt(contract);
+    }
+    activeRecorder = recorder;
+    activeRecorderMessageId = message.workflowMessageId;
+  };
+
   const presentInOrder = async (ctx: ExtensionContext): Promise<void> => {
     const prior = presentationTail;
     let release: (() => void) | undefined;
@@ -212,6 +247,7 @@ export default function piWorkflows(pi: ExtensionAPI): void {
     await prior;
     try {
       await workflowMessages.synchronize(pi, client, ctx);
+      await activateRecorder(ctx);
     } finally {
       sessionView.refresh(ctx);
       release?.();
@@ -430,8 +466,8 @@ export default function piWorkflows(pi: ExtensionAPI): void {
     },
   });
 
-  pi.registerCommand("controller", {
-    description: "Manage hosted controller resources: list, get, apply, reconcile, or delete",
+  pi.registerCommand("resource-manager", {
+    description: "Manage hosted managed resources: list, get, apply, reconcile, or delete",
     getArgumentCompletions: (prefix: string) => {
       const items = ["list", "get", "apply", "reconcile", "delete"]
         .filter((value) => value.startsWith(prefix))
@@ -440,7 +476,11 @@ export default function piWorkflows(pi: ExtensionAPI): void {
     },
     handler: async (args, ctx) => {
       try {
-        const result = await executeControllerCommand(client, ctx, parseControllerArgs(args));
+        const result = await executeResourceManagerCommand(
+          client,
+          ctx,
+          parseResourceManagerArgs(args),
+        );
         ctx.ui.notify(result.message, result.level ?? "info");
       } catch (error) {
         ctx.ui.notify(errorMessage(error), "error");
@@ -549,7 +589,7 @@ export default function piWorkflows(pi: ExtensionAPI): void {
 
   pi.on("session_start", (_event, ctx) => {
     sessionContext = ctx;
-    hostUnavailableNotified = false;
+    serverUnavailableNotified = false;
     const sessionId = ctx.sessionManager.getSessionId();
     const generation = ++sessionGeneration;
     let snapshotGeneration = 0;
@@ -615,7 +655,7 @@ export default function piWorkflows(pi: ExtensionAPI): void {
             return;
           }
           sessionUnsubscribe = unsubscribe;
-          hostUnavailableNotified = false;
+          serverUnavailableNotified = false;
           const capability = await herdrViewer.probe();
           if (generation !== sessionGeneration || sessionContext !== ctx) return;
           sessionView.setActionHint(capability.available ? PIW_SHORTCUT_HINT : undefined, ctx);
@@ -624,10 +664,10 @@ export default function piWorkflows(pi: ExtensionAPI): void {
           if (
             generation === sessionGeneration &&
             sessionContext === ctx &&
-            !hostUnavailableNotified
+            !serverUnavailableNotified
           ) {
-            hostUnavailableNotified = true;
-            ctx.ui.notify(`Workflow host is unavailable: ${errorMessage(error)}`, "warning");
+            serverUnavailableNotified = true;
+            ctx.ui.notify(`Workflow server is unavailable: ${errorMessage(error)}`, "warning");
           }
         }
       })();
@@ -651,27 +691,11 @@ export default function piWorkflows(pi: ExtensionAPI): void {
   });
 
   pi.on("agent_start", async (_event, ctx) => {
+    agentRunning = true;
+    activeRecorder = null;
+    activeRecorderMessageId = null;
     workflowMessages.startTurn();
     await presentInOrder(ctx).catch(() => undefined);
-    const message = workflowMessages.activeTurnMessage();
-    const contract = message === undefined ? undefined : agentContractForWorkflowMessage(message);
-    if (
-      message === undefined ||
-      (contract === undefined && message.kind !== "terminal" && message.kind !== "followUp")
-    ) {
-      activeRecorder = null;
-      return;
-    }
-    const recorder = await ensureRecorder(message, ctx);
-    if (contract === undefined) {
-      recorder.beginWorkflowMessage(
-        message.workflowMessageId,
-        message.kind as "terminal" | "followUp",
-      );
-    } else {
-      recorder.beginAttempt(contract);
-    }
-    activeRecorder = recorder;
   });
 
   pi.on("agent_end", async (event, ctx) => {
@@ -681,6 +705,8 @@ export default function piWorkflows(pi: ExtensionAPI): void {
       ctx.ui.notify(`Workflow response was rejected: ${errorMessage(error)}`, "error");
     }
     const finishedMessage = workflowMessages.activeTurnMessage();
+    agentRunning = false;
+    activeRecorderMessageId = null;
     workflowMessages.endTurn(
       workflowTurnStopReason(event.messages, ctx.signal?.aborted === true),
       responseEntryId(ctx.sessionManager.getBranch()),
@@ -747,7 +773,9 @@ export default function piWorkflows(pi: ExtensionAPI): void {
   pi.on("session_shutdown", async (_event, ctx) => {
     sessionGeneration += 1;
     sessionContext = null;
+    agentRunning = false;
     activeRecorder = null;
+    activeRecorderMessageId = null;
     await Promise.allSettled(
       [...sessionRecorders.values()].map(async (recorder) => recorder.stop()),
     );
@@ -760,7 +788,7 @@ export default function piWorkflows(pi: ExtensionAPI): void {
     if (sessionUnsubscribe !== null) await sessionUnsubscribe().catch(() => undefined);
     sessionUnsubscribe = null;
     sessionConnectTask = null;
-    hostUnavailableNotified = false;
+    serverUnavailableNotified = false;
     await client.close();
     client = new WorkflowClient({ clientId: `pi-extension-${randomUUID()}` });
   });
@@ -1065,57 +1093,57 @@ async function executeCommand(
   }
 }
 
-async function executeControllerCommand(
+async function executeResourceManagerCommand(
   client: WorkflowClient,
   ctx: ExtensionContext,
-  command: ParsedControllerArgs,
+  command: ParsedResourceManagerArgs,
 ): Promise<CommandResult> {
   const projectPath = path.resolve(ctx.cwd);
   if (command.kind === "list") {
     const response = await requestAccepted(client, {
-      operation: "controller.list",
+      operation: "resourceManager.list",
       payload: { projectPath },
     });
     return {
-      message: summarizeControllerResources(response.receipt),
+      message: summarizeManagedResources(response.receipt),
       details: { action: "list", resources: response.receipt ?? [] },
     };
   }
 
   const idempotencyKey = randomUUID();
   if (command.kind === "apply") {
-    const resolved = await client.resolveControllerInitialization({
+    const resolved = await client.resolveResourceManagerInitialization({
       cwd: projectPath,
-      controllerName: command.controller,
+      resourceManagerName: command.resourceManager,
       spec: command.spec,
     });
     const response = await requestAccepted(client, {
-      operation: "controller.apply",
-      requestId: `controller-apply-${idempotencyKey}`,
+      operation: "resourceManager.apply",
+      requestId: `resource-manager-apply-${idempotencyKey}`,
       idempotencyKey,
       payload: {
         projectPath,
-        controller: resolved.controllerName,
+        resourceManager: resolved.resourceManagerName,
         key: command.key,
         spec: command.spec,
         initialStatus: resolved.initialStatus,
-        controllerPath: resolved.controllerPath,
+        resourceManagerPath: resolved.resourceManagerPath,
         sourceHash: resolved.sourceHash,
       },
     });
     return {
-      message: `Applied controller resource ${command.controller}/${command.key}.`,
+      message: `Applied managed resource ${command.resourceManager}/${command.key}.`,
       details: { action: "apply", resource: response.receipt ?? null },
     };
   }
 
   const response = await requestAccepted(client, {
-    operation: `controller.${command.kind}`,
-    requestId: `controller-${command.kind}-${idempotencyKey}`,
+    operation: `resourceManager.${command.kind}`,
+    requestId: `resource-manager-${command.kind}-${idempotencyKey}`,
     idempotencyKey,
     payload: {
       projectPath,
-      controller: command.controller,
+      resourceManager: command.resourceManager,
       key: command.key,
     },
   });
@@ -1126,7 +1154,7 @@ async function executeControllerCommand(
     };
   }
   return {
-    message: `Controller resource ${command.controller}/${command.key} ${command.kind} request accepted.`,
+    message: `Managed resource ${command.resourceManager}/${command.key} ${command.kind} request accepted.`,
     details: { action: command.kind, resource: response.receipt ?? null },
   };
 }
@@ -1315,7 +1343,7 @@ async function requestAccepted(
       ? await client.request(options)
       : await client.requestDurable({ ...options, idempotencyKey: options.idempotencyKey });
   if (response.outcome !== "accepted" && response.outcome !== "adopted") {
-    throw new Error(response.error ?? `Workflow host rejected ${options.operation}`);
+    throw new Error(response.error ?? `Workflow server rejected ${options.operation}`);
   }
   return response;
 }
@@ -1400,18 +1428,18 @@ function summarizeRun(value: JsonValue | undefined): string {
     .join(" ");
 }
 
-function summarizeControllerResources(value: JsonValue | undefined): string {
-  if (!Array.isArray(value) || value.length === 0) return "No controller resources.";
+function summarizeManagedResources(value: JsonValue | undefined): string {
+  if (!Array.isArray(value) || value.length === 0) return "No managed resources.";
   const resources = value.map((item) => {
     if (!isRecord(item) || !isRecord(item.metadata)) return "unknown";
-    const controller =
-      typeof item.metadata.controller === "string" ? item.metadata.controller : "unknown";
+    const resourceManager =
+      typeof item.metadata.resourceManager === "string" ? item.metadata.resourceManager : "unknown";
     const key = typeof item.metadata.key === "string" ? item.metadata.key : "unknown";
     const generation =
       typeof item.metadata.generation === "number" ? item.metadata.generation : "unknown";
-    return `${controller}/${key} generation=${generation}`;
+    return `${resourceManager}/${key} generation=${generation}`;
   });
-  return `Controller resources: ${resources.join(", ")}.`;
+  return `Managed resources: ${resources.join(", ")}.`;
 }
 
 function jsonValue(value: unknown): JsonValue {

package/src/extension/recorder.ts

@@ -104,7 +104,7 @@ export type SessionRecordingStore = {
   ): Promise<{ eventCount: number; entryCount: number; lastEventSeq: number }>;
 };
 
-/** Records settled Pi entries and normalized temporal events through the workflow host. */
+/** Records settled Pi entries and normalized temporal events through the workflow server. */
 export class SessionRecorder {
   private readonly store: SessionRecordingStore;
   private readonly runId: string;

package/src/extension/remote-recorder-store.ts

@@ -13,7 +13,7 @@ type SessionCommandContext = {
   coordinatorEpoch: string;
 };
 
-/** Sends bounded session recording batches to the single workflow host writer. */
+/** Sends bounded session recording batches to the single workflow server writer. */
 export class RemoteSessionRecordingStore implements SessionRecordingStore {
   constructor(
     private readonly client: WorkflowClient,
@@ -103,7 +103,7 @@ export class RemoteSessionRecordingStore implements SessionRecordingStore {
       payload: { ...this.context(), action, ...extra },
     });
     if (response.outcome !== "accepted" && response.outcome !== "adopted") {
-      throw new Error(response.error ?? "Workflow host rejected the session recording batch");
+      throw new Error(response.error ?? "Workflow server rejected the session recording batch");
     }
     if (!isRecord(response.receipt)) throw new Error("Session recording receipt is invalid");
     return response.receipt;

package/src/extension/resource-manager-command.ts

@@ -0,0 +1,45 @@
+import type { JsonValue } from "../state/json.js";
+
+export type ParsedResourceManagerArgs =
+  | { kind: "list" }
+  | { kind: "get"; resourceManager: string; key: string }
+  | { kind: "apply"; resourceManager: string; key: string; spec: JsonValue }
+  | { kind: "reconcile"; resourceManager: string; key: string }
+  | { kind: "delete"; resourceManager: string; key: string };
+
+const RESOURCE_MANAGER_USAGE =
+  "Usage: /resource-manager [list|get <resource-manager> <key>|apply <resource-manager> <key> <json>|reconcile <resource-manager> <key>|delete <resource-manager> <key>]";
+
+export function parseResourceManagerArgs(args: string): ParsedResourceManagerArgs {
+  const trimmed = args.trim();
+  if (trimmed.length === 0 || trimmed === "list") return { kind: "list" };
+
+  const apply = trimmed.match(/^apply\s+(\S+)\s+(\S+)\s+([\s\S]+)$/u);
+  if (apply !== null) {
+    let spec: JsonValue;
+    try {
+      spec = JSON.parse(apply[3] as string) as JsonValue;
+    } catch (error) {
+      throw new Error(
+        `Invalid resource manager spec JSON: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+    return {
+      kind: "apply",
+      resourceManager: apply[1] as string,
+      key: apply[2] as string,
+      spec,
+    };
+  }
+
+  const operation = trimmed.match(/^(get|reconcile|delete)\s+(\S+)\s+(\S+)$/u);
+  if (operation !== null) {
+    return {
+      kind: operation[1] as "get" | "reconcile" | "delete",
+      resourceManager: operation[2] as string,
+      key: operation[3] as string,
+    };
+  }
+
+  throw new Error(RESOURCE_MANAGER_USAGE);
+}

package/src/extension/session-delivery.ts

@@ -20,7 +20,7 @@ type QueuedSessionDelivery = {
 const SESSION_ENTRY_CONFIRMATION_MS = 10_000;
 
 /**
- * Delivers at most one host-owned message into a Pi session at a time.
+ * Delivers at most one server-owned message into a Pi session at a time.
  *
  * Pi's public sendMessage API does not return the saved session entry ID. Keep
  * the claimed delivery in memory until that entry becomes observable. Polling
@@ -54,7 +54,7 @@ export class SessionDeliveryCoordinator {
           return;
         }
 
-        // Remember the host claim before the final idle check. If Pi starts a
+        // Remember the server claim before the final idle check. If Pi starts a
         // turn while the claim request is in flight, a later poll can use this
         // exact still-live claim instead of making a conflicting second claim.
         this.claimed = delivery;

package/src/extension/session-view.ts

@@ -10,7 +10,7 @@ import { buildWidgetView } from "./widget.js";
 const WIDGET_KEY = "pi-workflows";
 const WIDGET_SCROLL_STEP = 3;
 
-/** Client-backed projection of the host-owned run into the origin Pi session. */
+/** Client-backed projection of the server-owned run into the origin Pi session. */
 export class SessionWorkflowView {
   private session: WorkflowSessionView | null = null;
   private scroll: number | null = null;

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

@@ -1,9 +1,18 @@
 import { randomUUID } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { WorkflowClient } from "../client/client.js";
-import type { WorkflowSessionView, WorkflowTurnReport } from "../client/view.js";
+import {
+  WORKFLOW_TURN_REPORT_RECEIPT_SCHEMA,
+  type WorkflowSessionView,
+  type WorkflowTurnReport,
+  type WorkflowTurnReportReceipt,
+} from "../client/view.js";
 import type { JsonValue } from "../state/json.js";
-import type { WorkflowMessage, WorkflowTurnStopReason } from "../state/workflow-messages.js";
+import {
+  WORKFLOW_TURN_SCHEMA,
+  type WorkflowMessage,
+  type WorkflowTurnStopReason,
+} from "../state/workflow-messages.js";
 
 const WORKFLOW_MESSAGE_ID_FIELD = "workflowMessageId";
 
@@ -11,17 +20,19 @@ type PendingTurn = {
   workflowTurnId: string;
   workflowMessageId: string | null;
   runId: string | null;
+  message: WorkflowMessage | null;
   startedReported: boolean;
   end: { stopReason: WorkflowTurnStopReason; responseSessionEntryId: string | null } | null;
 };
 
-/** Adds every host-owned workflow message to one Pi session through one public API path. */
+/** 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 synchronizing = false;
   private lastBranchEpoch: string | null = null;
   private view: WorkflowSessionView | null = null;
+  private awaitingTurnMessage: WorkflowMessage | null = null;
   private turn: PendingTurn | null = null;
 
   updateView(view: WorkflowSessionView): void {
@@ -50,15 +61,17 @@ export class WorkflowMessageCoordinator {
   }
 
   startTurn(): void {
-    if (this.turn !== null && this.turn.end === null) return;
+    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 = this.turnCandidate();
+    const candidate = awaited ?? this.turnCandidate();
     if (candidate !== undefined) this.bindTurn(candidate);
   }
 
@@ -68,10 +81,8 @@ export class WorkflowMessageCoordinator {
   }
 
   activeTurnMessage(): WorkflowMessage | undefined {
-    if (this.view === null || this.turn?.workflowMessageId === null || this.turn === null) {
-      return undefined;
-    }
-    return messageById(this.view, this.turn.workflowMessageId);
+    if (this.turn === null || !this.turn.startedReported) return undefined;
+    return this.turn.message ?? undefined;
   }
 
   async synchronize(
@@ -89,7 +100,8 @@ export class WorkflowMessageCoordinator {
           workflowTurnId: view.openWorkflowTurn.workflowTurnId,
           workflowMessageId: view.openWorkflowTurn.workflowMessageId,
           runId: view.openWorkflowTurn.runId,
-          startedReported: false,
+          message: messageById(view, view.openWorkflowTurn.workflowMessageId) ?? null,
+          startedReported: true,
           end: null,
         };
       }
@@ -128,6 +140,9 @@ export class WorkflowMessageCoordinator {
         this.queued.delete(messageId);
         return;
       }
+      if (message.content.triggerTurn && messageStartsTurn(message)) {
+        this.awaitingTurnMessage = message;
+      }
       try {
         pi.sendMessage(
           {
@@ -140,6 +155,9 @@ export class WorkflowMessageCoordinator {
         );
       } catch (error) {
         this.queued.delete(messageId);
+        if (this.awaitingTurnMessage?.workflowMessageId === messageId) {
+          this.awaitingTurnMessage = null;
+        }
         throw error;
       }
       await this.reportBranch(client, ctx, view);
@@ -153,6 +171,7 @@ export class WorkflowMessageCoordinator {
     this.queued.clear();
     this.closedTurnMessages.clear();
     this.view = null;
+    this.awaitingTurnMessage = null;
     this.turn = null;
     this.lastBranchEpoch = null;
     this.synchronizing = false;
@@ -182,6 +201,7 @@ export class WorkflowMessageCoordinator {
     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> {
@@ -195,31 +215,47 @@ export class WorkflowMessageCoordinator {
     ) {
       return;
     }
-    const message = messageById(view, pending.workflowMessageId);
-    if (message?.status !== "sent") return;
+    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: "started",
+        state: "ended",
         workflowMessageId: pending.workflowMessageId,
         workflowTurnId: pending.workflowTurnId,
         runId: pending.runId,
         targetSessionId: view.sessionId,
         coordinatorEpoch: view.coordinatorEpoch,
+        stopReason: pending.end.stopReason,
+        responseSessionEntryId: pending.end.responseSessionEntryId,
       });
-      pending.startedReported = true;
+    } catch (error) {
+      this.turn = null;
+      throw error;
     }
-    if (pending.end === null) return;
-    await reportTurn(client, {
-      state: "ended",
-      workflowMessageId: pending.workflowMessageId,
-      workflowTurnId: pending.workflowTurnId,
-      runId: pending.runId,
-      targetSessionId: view.sessionId,
-      coordinatorEpoch: view.coordinatorEpoch,
-      stopReason: pending.end.stopReason,
-      responseSessionEntryId: pending.end.responseSessionEntryId,
-    });
-    if (message.kind === "terminal" || message.kind === "followUp") {
+    if (message?.kind === "terminal" || message?.kind === "followUp") {
       this.closedTurnMessages.add(pending.workflowMessageId);
     }
     for (const current of new Set([view, this.view])) {
@@ -228,7 +264,7 @@ export class WorkflowMessageCoordinator {
       }
       if (
         current?.openWorkflowMessageId === pending.workflowMessageId &&
-        (message.kind === "terminal" || message.kind === "followUp")
+        (message?.kind === "terminal" || message?.kind === "followUp")
       ) {
         current.openWorkflowMessageId = null;
       }
@@ -260,7 +296,7 @@ export class WorkflowMessageCoordinator {
       },
     });
     if (response.outcome !== "accepted" && response.outcome !== "adopted") {
-      throw new Error(response.error ?? "Workflow host rejected the Pi branch report");
+      throw new Error(response.error ?? "Workflow server rejected the Pi branch report");
     }
     for (const entry of entries) {
       const message = messageById(view, entry.workflowMessageId);
@@ -318,15 +354,43 @@ function messageStartsTurn(message: WorkflowMessage): boolean {
   return message.kind === "step" || message.kind === "terminal" || message.kind === "followUp";
 }
 
-async function reportTurn(client: WorkflowClient, report: WorkflowTurnReport): Promise<void> {
+async function reportTurn(
+  client: WorkflowClient,
+  report: WorkflowTurnReport,
+): Promise<WorkflowTurnReportReceipt> {
   const response = await client.request({
     operation: "workflowTurn.report",
     runId: report.runId,
     payload: report as unknown as JsonValue,
   });
   if (response.outcome !== "accepted" && response.outcome !== "adopted") {
-    throw new Error(response.error ?? "Workflow host rejected the model-turn report");
+    throw new Error(response.error ?? "Workflow server rejected the model-turn report");
+  }
+  const receipt = response.receipt;
+  if (
+    !isRecord(receipt) ||
+    receipt.schema !== WORKFLOW_TURN_REPORT_RECEIPT_SCHEMA ||
+    !["active", "settled", "absent"].includes(String(receipt.ownership))
+  ) {
+    throw new Error("Workflow server returned an invalid model-turn receipt");
+  }
+  const ownership = receipt.ownership as WorkflowTurnReportReceipt["ownership"];
+  if (ownership === "absent") {
+    if (receipt.turn !== null) {
+      throw new Error("Workflow server returned an invalid model-turn receipt");
+    }
+  } else if (
+    !isRecord(receipt.turn) ||
+    receipt.turn.schema !== WORKFLOW_TURN_SCHEMA ||
+    receipt.turn.workflowTurnId !== report.workflowTurnId ||
+    receipt.turn.workflowMessageId !== report.workflowMessageId ||
+    receipt.turn.runId !== report.runId ||
+    receipt.turn.targetSessionId !== report.targetSessionId ||
+    receipt.turn.state !== (ownership === "active" ? "started" : "ended")
+  ) {
+    throw new Error("Workflow server returned an invalid model-turn receipt");
   }
+  return receipt as unknown as WorkflowTurnReportReceipt;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {