@osolmaz/pi-workflows 0.12.0 → 0.13.0

package/src/extension/recorder.ts

@@ -76,19 +76,12 @@ function failureMessage(error: unknown): string {
 }
 
 /**
- * Records both settled Pi entries and normalized temporal events into one run
- * bundle. The hot event path only stamps and queues records; filesystem work
- * runs on a separate ordered append chain.
+ * Records settled Pi entries and normalized temporal events in SQLite.
  */
 export class SessionRecorder {
   private readonly store: WorkflowRunStore;
-  private readonly runDir: string;
   private readonly runId: string;
-  /**
-   * Capture segment for this recorder. Undefined writes the legacy flat
-   * stream; a second recorder attaching to the same bundle (resume or
-   * handoff) writes a segment instead so the first capture stays intact.
-   */
+  /** Capture segment for this recorder after an ownership handoff. */
   private segmentId: string | undefined;
   private cursor: string | null = null;
   private readonly recorded: string[] = [];
@@ -122,9 +115,8 @@ export class SessionRecorder {
   private flushPromise: Promise<void> | null = null;
   private captureFailure: WorkflowSessionCaptureFailure | null = null;
 
-  constructor(store: WorkflowRunStore, runDir: string, runId: string) {
+  constructor(store: WorkflowRunStore, runId: string) {
     this.store = store;
-    this.runDir = runDir;
     this.runId = runId;
   }
 
@@ -135,13 +127,12 @@ export class SessionRecorder {
     this.bound = true;
     this.cursor = ctx.sessionManager.getLeafId();
     const sessionFile = ctx.sessionManager.getSessionFile();
-    // A bundle that already has a binding belongs to an earlier capture
-    // attempt; this recorder writes its own segment under session/segments.
-    if (await this.store.hasSessionBinding(this.runDir)) {
+    // An existing binding belongs to an earlier capture segment.
+    if (await this.store.hasSessionBinding(this.runId)) {
       this.segmentId = randomUUID();
     }
     await this.store.writeSessionBinding(
-      this.runDir,
+      this.runId,
       {
         schema: SESSION_BINDING_SCHEMA,
         runId: this.runId,
@@ -153,7 +144,7 @@ export class SessionRecorder {
       this.segmentId,
     );
     await this.store.writeSessionCapture(
-      this.runDir,
+      this.runId,
       {
         schema: SESSION_CAPTURE_SCHEMA,
         eventSchema: SESSION_EVENT_SCHEMA,
@@ -344,7 +335,7 @@ export class SessionRecorder {
       }
       const appended: RecordedEntry[] = [];
       for (const entry of branch.slice(startIndex)) {
-        await this.store.appendSessionEntry(this.runDir, entry, this.segmentId);
+        await this.store.appendSessionEntry(this.runId, entry, this.segmentId);
         const recorded = { id: entry.id, entry, claimed: false };
         appended.push(recorded);
         this.unclaimedEntries.push(recorded);
@@ -426,9 +417,9 @@ export class SessionRecorder {
       try {
         await this.flushAllEvents();
         await this.entryChain;
-        const counts = await this.store.sessionCounts(this.runDir, this.segmentId);
+        const counts = await this.store.sessionCounts(this.runId, this.segmentId);
         await this.store.writeSessionCapture(
-          this.runDir,
+          this.runId,
           {
             schema: SESSION_CAPTURE_SCHEMA,
             eventSchema: SESSION_EVENT_SCHEMA,
@@ -443,9 +434,9 @@ export class SessionRecorder {
         // the workflow's terminal persistence hook.
         this.failCapture("capture_finalize_failed", failureMessage(error));
         try {
-          const counts = await this.store.sessionCounts(this.runDir, this.segmentId);
+          const counts = await this.store.sessionCounts(this.runId, this.segmentId);
           await this.store.writeSessionCapture(
-            this.runDir,
+            this.runId,
             {
               schema: SESSION_CAPTURE_SCHEMA,
               eventSchema: SESSION_EVENT_SCHEMA,
@@ -602,7 +593,7 @@ export class SessionRecorder {
     }
     this.flushPromise = this.store
       .appendSessionEventBatch(
-        this.runDir,
+        this.runId,
         batch.map((queued) => queued.record),
         this.segmentId,
       )

package/src/extension/session-events.ts

@@ -9,7 +9,7 @@ export type PublicAssistantMessageEvent =
   | { type: "toolcall_start"; contentIndex: number; partial: unknown }
   | { type: "toolcall_delta"; contentIndex: number; delta: string; partial: unknown }
   | { type: "toolcall_end"; contentIndex: number; toolCall: unknown; partial: unknown }
-  | { type: "done"; reason: "stop" | "length" | "toolUse"; message: unknown }
+  | { type: "done"; reason: "stop" | "length" | "toolUse" | "deferred"; message: unknown }
   | { type: "error"; reason: "aborted" | "error"; error: unknown };
 
 export type TurnStartEventLike = { turnIndex: number };
@@ -44,7 +44,7 @@ export type NormalizedAssistantEvent =
   | { type: "toolcall_start"; contentIndex: number }
   | { type: "toolcall_delta"; contentIndex: number; delta: string }
   | { type: "toolcall_end"; contentIndex: number; toolCall: unknown }
-  | { type: "done"; reason: "stop" | "length" | "toolUse" }
+  | { type: "done"; reason: "stop" | "length" | "toolUse" | "deferred" }
   | { type: "error"; reason: "aborted" | "error" };
 
 /** Remove cumulative snapshots while preserving every semantic stream event. */

package/src/extension/step-message.ts

@@ -1,8 +1,13 @@
+import { createHash } from "node:crypto";
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
 import { Box, Text, TruncatedText } from "@earendil-works/pi-tui";
 import { sanitizeText } from "../workflows/text.js";
-import type { AgentStepContract, AgentStepPresentation } from "../workflows/types.js";
-import type { PromptDeliveryKind } from "./executor.js";
+import type {
+  AgentStepContract,
+  AgentStepPresentation,
+  AgentStepSubmission,
+} from "../workflows/types.js";
+import { visibleAssistantText, type PromptDeliveryKind } from "./executor.js";
 
 export const WORKFLOW_AGENT_STEP_MESSAGE_TYPE = "pi-workflows-agent-step";
 export const WORKFLOW_AGENT_STEP_MESSAGE_SCHEMA = "pi-workflows.agent-step-message.v1";
@@ -69,6 +74,10 @@ export function buildWorkflowAgentStepView(
     };
   }
 
+  const assistant = contract?.completion === "assistant";
+  const expectedOutput = assistant
+    ? `normal assistant response${contract?.maxOutputChars === undefined ? "" : ` (maximum ${contract.maxOutputChars} characters)`}`
+    : (contract?.expectedOutput ?? "a JSON object with your result");
   const metadata = [
     `Workflow: ${workflowName}`,
     ...(runTitle !== undefined ? [`Run title: ${runTitle}`] : []),
@@ -76,7 +85,8 @@ export function buildWorkflowAgentStepView(
     `Node id: ${nodeId}`,
     `Attempt id: ${cleanSingleLine(contract?.attemptId ?? "unknown")}`,
     `Delivery: ${kind}`,
-    `Expected output: ${cleanSingleLine(contract?.expectedOutput ?? "a JSON object with your result")}`,
+    `Completion: ${assistant ? "assistant response" : "workflow submission"}`,
+    `Expected output: ${cleanSingleLine(expectedOutput)}`,
   ];
   const prompt = contentText(message.content);
   return {
@@ -86,6 +96,93 @@ export function buildWorkflowAgentStepView(
   };
 }
 
+/**
+ * Adopt an already visible response for the same assistant-output attempt.
+ * This is used only when an interrupted run resumes in its origin session.
+ */
+export function recoverAssistantStep(
+  entries: readonly unknown[],
+  contract: AgentStepContract,
+): AgentStepSubmission | undefined {
+  if (contract.completion !== "assistant") return undefined;
+  for (let promptIndex = entries.length - 1; promptIndex >= 0; promptIndex -= 1) {
+    const prompt = sessionEntry(entries[promptIndex]);
+    if (
+      prompt?.type !== "custom_message" ||
+      prompt.customType !== WORKFLOW_AGENT_STEP_MESSAGE_TYPE
+    ) {
+      continue;
+    }
+    const details = parseDetails(prompt.details);
+    if (details === undefined || !sameAttempt(details.contract, contract)) continue;
+
+    let response: Record<string, unknown> | undefined;
+    for (let responseIndex = promptIndex + 1; responseIndex < entries.length; responseIndex += 1) {
+      const candidate = sessionEntry(entries[responseIndex]);
+      if (candidate === undefined) continue;
+      if (
+        candidate.type === "custom_message" &&
+        candidate.customType === WORKFLOW_AGENT_STEP_MESSAGE_TYPE
+      ) {
+        break;
+      }
+      if (candidate.type !== "message") continue;
+      const message = sessionEntry(candidate.message);
+      if (message?.role === "user") break;
+      if (isAssistantWithVisibleText(message)) response = candidate;
+    }
+    if (response === undefined) return undefined;
+    const output = visibleAssistantText(response.message, contract.maxOutputChars);
+    const entryId = typeof response.id === "string" ? response.id : undefined;
+    const promptId = typeof prompt.id === "string" ? prompt.id : undefined;
+    return {
+      output,
+      assistantMessage: {
+        sha256: createHash("sha256").update(output).digest("hex"),
+        ...(entryId !== undefined ? { entryId } : {}),
+        ...(contract.maxOutputChars !== undefined ? { maxChars: contract.maxOutputChars } : {}),
+        recovered: true,
+      },
+      ...(promptId !== undefined && entryId !== undefined
+        ? { conversation: { firstEntryId: promptId, lastEntryId: entryId } }
+        : {}),
+    };
+  }
+  return undefined;
+}
+
+function sameAttempt(left: AgentStepContract, right: AgentStepContract): boolean {
+  return (
+    left.runId === right.runId &&
+    left.workflowName === right.workflowName &&
+    left.nodeId === right.nodeId &&
+    left.attemptId === right.attemptId &&
+    left.completion === "assistant" &&
+    left.maxOutputChars === right.maxOutputChars
+  );
+}
+
+function sessionEntry(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function isAssistantWithVisibleText(message: unknown): boolean {
+  if (message === null || typeof message !== "object") return false;
+  const candidate = message as { role?: unknown; content?: unknown; stopReason?: unknown };
+  if (candidate.role !== "assistant" || !Array.isArray(candidate.content)) return false;
+  if (candidate.stopReason !== "stop" && candidate.stopReason !== "length") return false;
+  return candidate.content.some(
+    (part) =>
+      part !== null &&
+      typeof part === "object" &&
+      (part as { type?: unknown }).type === "text" &&
+      typeof (part as { text?: unknown }).text === "string" &&
+      (part as { text: string }).text.trim().length > 0,
+  );
+}
+
 function parseDetails(value: unknown): WorkflowAgentStepMessageDetails | undefined {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
   const candidate = value as Partial<WorkflowAgentStepMessageDetails>;
@@ -100,7 +197,12 @@ function parseDetails(value: unknown): WorkflowAgentStepMessageDetails | undefin
     typeof contract.runId !== "string" ||
     typeof contract.workflowName !== "string" ||
     typeof contract.nodeId !== "string" ||
-    typeof contract.attemptId !== "string"
+    typeof contract.attemptId !== "string" ||
+    (contract.completion !== "submit" && contract.completion !== "assistant") ||
+    (contract.maxOutputChars !== undefined &&
+      (typeof contract.maxOutputChars !== "number" ||
+        !Number.isInteger(contract.maxOutputChars) ||
+        contract.maxOutputChars <= 0))
   ) {
     return undefined;
   }

package/src/extension/widget.ts

@@ -162,9 +162,11 @@ function progressLines(
       : progressTracksFromRecords(updateHistory, now).map((track) => track.estimate);
   const projected = mergeProgressEstimates(latestProgressEstimates(state, now), measured ?? []);
   const estimates = mergeProgressEstimates(projected, monitorEstimates(state) ?? []);
-  const lines = prioritizeProgressEstimates(estimates).map((estimate) =>
-    formatProgressLine(estimate, now),
-  );
+  const lines = prioritizeWidgetProgress(prioritizeProgressEstimates(estimates)).map((estimate) => {
+    const indentation =
+      estimate.key.startsWith("agents/") && estimate.key.split("/").length > 2 ? "  " : "";
+    return `${indentation}${formatProgressLine(estimate, now)}`;
+  });
   const schedule = (state.updates ?? []).find(
     (record) => record.type === "monitor.schedule" && record.key === "next-check",
   );
@@ -180,6 +182,24 @@ function progressLines(
   return lines;
 }
 
+function prioritizeWidgetProgress(estimates: ProgressEstimate[]): ProgressEstimate[] {
+  const weight = (estimate: ProgressEstimate) => {
+    if (!estimate.key.startsWith("agents/")) return 0;
+    const child = estimate.key.split("/").length > 2;
+    if (!child) return -4;
+    if (estimate.data.status === "failed" || estimate.data.status === "blocked") return -3;
+    if (
+      estimate.data.status === "running" ||
+      estimate.data.status === "pending" ||
+      estimate.data.status === "waiting"
+    ) {
+      return -2;
+    }
+    return 2;
+  };
+  return [...estimates].sort((left, right) => weight(left) - weight(right));
+}
+
 function monitorEstimates(state: WorkflowRunState): ProgressEstimate[] | undefined {
   const output = state.outputs.estimate;
   if (output === null || typeof output !== "object" || Array.isArray(output)) return undefined;
@@ -278,6 +298,14 @@ function nodeRuntimeSegments(
   now: Date,
 ): string[] {
   const segments: string[] = [];
+  const node = snapshot.nodes[nodeId];
+  if (
+    node?.nodeType === "agent" &&
+    typeof node.expectedOutput === "object" &&
+    node.expectedOutput.kind === "assistant-message"
+  ) {
+    segments.push("assistant response");
+  }
   const completedAttempts = state.steps.filter((step) => step.nodeId === nodeId).length;
   const attempts = completedAttempts + (state.currentNode === nodeId ? 1 : 0);
   if (attempts > 1) {
@@ -309,8 +337,7 @@ function nodeRuntimeSegments(
             })
           : undefined;
       const requestAudience =
-        (request?.schema === "pi-workflows.human-decision-request.v1" ||
-          request?.schema === "pi-workflows.human-decision-request.v2") &&
+        request?.schema === "pi-workflows.human-decision-request.v1" &&
         typeof request.audience === "string"
           ? request.audience
           : human.audience;

package/src/host/rpc-executor.ts

@@ -43,6 +43,8 @@ export type RpcStepExecutorOptions = {
   env?: Record<string, string>;
   /** Extra pi arguments, for example a model override. */
   piArgs?: string[];
+  /** Park assistant-message nodes for a visible origin session. */
+  assistantMessageMode?: "park";
 };
 
 /**
@@ -53,6 +55,7 @@ export type RpcStepExecutorOptions = {
  * the model sees the same tool contract as an in-session run.
  */
 export class RpcStepExecutor implements AgentStepExecutor {
+  readonly assistantMessageMode: "park" | "unsupported";
   private readonly options: RpcStepExecutorOptions;
   private child: ChildProcess | null = null;
   private childExited: { code: number | null; signal: string | null } | null = null;
@@ -63,6 +66,7 @@ export class RpcStepExecutor implements AgentStepExecutor {
 
   constructor(options: RpcStepExecutorOptions) {
     this.options = options;
+    this.assistantMessageMode = options.assistantMessageMode ?? "unsupported";
   }
 
   async runAgentStep(request: AgentStepRequest, signal: AbortSignal): Promise<AgentStepSubmission> {

package/src/host/runner.ts

@@ -1,16 +1,16 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { builtinWorkflowCatalog } from "../builtins/catalog.js";
 import {
   ControllerManager,
   loadDiscoveredControllers,
-  projectControllerStorePath,
   SqliteControllerStore,
   WorkflowEngineScheduler,
   type WorkflowRunQueueRecord,
 } from "../controllers/index.js";
 import type { JsonObject } from "../controllers/types.js";
+import { workflowStatePath } from "../state/database.js";
 import { WorkflowEngine } from "../workflows/engine.js";
 import {
   ClaimLostError,
@@ -19,9 +19,8 @@ import {
   WorkflowSourceChangedError,
 } from "../workflows/errors.js";
 import { resolveWorkflowRef, resolveWorkflowSource } from "../workflows/loader.js";
-import { migrateLegacyWorkflowSources } from "../workflows/migrate-sources.js";
-import { WorkflowRunStore, readRunBundle } from "../workflows/store.js";
-import type { WorkflowDefinition } from "../workflows/types.js";
+import { WorkflowRunStore } from "../workflows/store.js";
+import type { ResolvedHumanDecision, WorkflowDefinition } from "../workflows/types.js";
 import { HostProcessRegistry } from "./processes.js";
 import { RpcStepExecutor } from "./rpc-executor.js";
 
@@ -32,10 +31,8 @@ const RUN_CLAIM_RENEW_MS = 10_000;
 export type WorkflowHostOptions = {
   cwd: string;
   runnerId?: string;
-  /** Explicit store path; defaults to the project-scoped controller store. */
-  storeFile?: string;
-  /** Explicit run-bundle root; defaults to the shared runs directory. */
-  runsDir?: string;
+  /** Explicit database path; defaults to the canonical workflow state database. */
+  databasePath?: string;
   registry?: HostProcessRegistry;
   piArgs?: string[];
   /** Extra environment for headless children (for example a test provider). */
@@ -49,7 +46,7 @@ export type WorkflowHostOptions = {
  * The always-on runner: claims parked workflow runs and reconciles durable
  * controllers without a Pi session. Conversation nodes execute in headless
  * `pi --mode rpc` children. Everything the host does is recoverable: claims
- * expire, bundles fence stale writers, and child processes are reaped by
+ * expire, SQLite leases fence stale writers, and child processes are reaped by
  * the next host.
  */
 export class WorkflowHost {
@@ -61,7 +58,6 @@ export class WorkflowHost {
   private manager: ControllerManager | null = null;
   private pollTimer: ReturnType<typeof setInterval> | null = null;
   private readonly activeRuns = new Map<string, Promise<void>>();
-  private readonly migrationBlockedRuns = new Set<string>();
   private readonly schedulerExecutors = new Map<WorkflowEngine, RpcStepExecutor>();
   /** Runs whose resume refused (edited source); skipped until a host restart. */
   private readonly skippedRuns = new Set<string>();
@@ -72,14 +68,15 @@ export class WorkflowHost {
   constructor(options: WorkflowHostOptions) {
     this.options = options;
     this.runnerId = options.runnerId ?? `host-${randomUUID().slice(0, 8)}`;
-    this.store = new SqliteControllerStore(
-      options.storeFile ?? projectControllerStorePath(options.cwd),
+    const databasePath = options.databasePath ?? workflowStatePath();
+    this.store = new SqliteControllerStore(databasePath, { projectPath: options.cwd });
+    this.stateDir = path.join(
+      path.dirname(this.store.filePath),
+      "hosts",
+      hostProjectScope(options.cwd),
     );
-    this.stateDir = path.dirname(this.store.filePath);
     this.registry = options.registry ?? new HostProcessRegistry(this.stateDir);
-    this.childRunStore = new WorkflowRunStore(
-      options.runsDir ?? process.env.PI_WORKFLOWS_RUNS_DIR ?? undefined,
-    );
+    this.childRunStore = new WorkflowRunStore(databasePath);
   }
 
   private log(message: string): void {
@@ -97,16 +94,6 @@ export class WorkflowHost {
       this.log(`reaped ${reaped.length} orphaned headless session(s): ${reaped.join(", ")}`);
     }
 
-    const migration = await migrateLegacyWorkflowSources({
-      catalog: builtinWorkflowCatalog,
-      store: this.childRunStore,
-      queue: this.store,
-    });
-    for (const blocked of migration.blocked) {
-      this.migrationBlockedRuns.add(blocked.runId);
-      this.log(`run ${blocked.runId} parked: ${blocked.reason}`);
-    }
-
     const definitions = await loadDiscoveredControllers({ cwd: this.options.cwd });
     if (definitions.length > 0) {
       const scheduler = new WorkflowEngineScheduler({
@@ -192,7 +179,7 @@ export class WorkflowHost {
         runnerId: this.runnerId,
         claimToken: randomUUID(),
         leaseMs: RUN_CLAIM_LEASE_MS,
-        excludeRunIds: [...this.skippedRuns, ...this.migrationBlockedRuns],
+        excludeRunIds: [...this.skippedRuns],
       });
     } catch (error) {
       // Store contention or corruption must not kill the host's loop.
@@ -215,7 +202,15 @@ export class WorkflowHost {
     let workflow: WorkflowDefinition;
     let workflowSource: import("../workflows/types.js").WorkflowSource;
     try {
-      const bundle = await readRunBundle(this.childRunStore.runDirFor(runId));
+      const bundle = this.childRunStore.readRun(runId);
+      if (bundle?.state.status === "waiting") {
+        if (this.store.parkWorkflowRun({ runId, claimToken })) {
+          this.store.settleRunEffect(runId, "run.park_queue");
+          this.skippedRuns.add(runId);
+          this.log(`left ${record.workflowName} run ${runId} waiting for its decision owner`);
+        }
+        return;
+      }
       if (bundle?.state.workflowSource === undefined) {
         throw new Error(`Workflow run ${runId} has no canonical workflow source`);
       }
@@ -260,12 +255,13 @@ export class WorkflowHost {
         throw new ClaimLostError(runId);
       }
     };
-    const fencedStore = new WorkflowRunStore(this.childRunStore.outputRoot, {
-      fenceProvider: () => fence,
+    const fencedStore = new WorkflowRunStore(this.childRunStore.databasePath, {
+      authorityProvider: () => store.workflowRunAuthority(runId, claimToken),
     });
     const executor = new RpcStepExecutor({
       cwd: this.options.cwd,
       registry: this.registry,
+      ...(record.originSessionId !== null ? { assistantMessageMode: "park" as const } : {}),
       ...(this.options.piArgs !== undefined ? { piArgs: this.options.piArgs } : {}),
       ...(this.options.env !== undefined ? { env: this.options.env } : {}),
     });
@@ -308,16 +304,39 @@ export class WorkflowHost {
 
     this.recordEvent(runId, record.workflowName, "resumed", { runnerId: this.runnerId });
     try {
-      const result = await engine.resumeRun(workflow, runId, { workflowSource });
+      const humanDecision =
+        record.parentRunId === null ? undefined : hostHumanDecision(record.launchOptions);
+      const result = record.initialized
+        ? await engine.resumeRun(workflow, runId, { workflowSource })
+        : record.parentRunId === null
+          ? await engine.run(workflow, record.input, { workflowSource, runId })
+          : await engine.continueRun(workflow, record.parentRunId, record.input, {
+              workflowSource,
+              runId,
+              ...(humanDecision === undefined ? {} : { humanDecision }),
+            });
       clearInterval(renewTimer);
-      if (result.state.status === "running") {
-        // Parked again mid-drain: leave it claimable for the next runner.
+      if (result.state.status === "running" || result.state.status === "waiting") {
+        // A drained run, visible-assistant handoff, or new checkpoint stays
+        // available to its next owner. Skip waits in this host process so it
+        // cannot reclaim the same run in a tight loop.
         this.store.parkWorkflowRun({ runId, claimToken });
-        this.recordEvent(runId, record.workflowName, "parked", {});
-        this.log(`parked ${record.workflowName} run ${runId}`);
+        this.store.settleRunEffect(runId, "run.park_queue");
+        const waitingForOrigin =
+          result.state.status === "running" &&
+          result.state.statusDetail === "waiting for origin Pi session";
+        if (result.state.status === "waiting" || waitingForOrigin) this.skippedRuns.add(runId);
+        this.recordEvent(runId, record.workflowName, "parked", {
+          status: result.state.status,
+          ...(waitingForOrigin ? { reason: "waiting for origin Pi session" } : {}),
+        });
+        this.log(
+          `parked ${record.workflowName} run ${runId}${waitingForOrigin ? ": waiting for origin Pi session" : ""}`,
+        );
         return;
       }
       this.store.completeWorkflowRun({ runId, claimToken });
+      this.store.settleRunEffect(runId, "run.settle_queue");
       this.recordEvent(runId, record.workflowName, result.state.status, {
         ...(result.state.error !== undefined ? { error: result.state.error } : {}),
         ...(result.state.waitingOn !== undefined ? { waitingOn: result.state.waitingOn } : {}),
@@ -352,6 +371,7 @@ export class WorkflowHost {
       if (index !== -1) {
         this.parkedEngines.splice(index, 1);
       }
+      fencedStore.close();
       await executor.close().catch(() => undefined);
     }
   }
@@ -365,17 +385,22 @@ export class WorkflowHost {
     let heldClaim = false;
     try {
       // The interruption write obeys the same fencing rule as every other
-      // bundle write: without a live claim, the current owner decides.
+      // state write: without a live claim, the current owner decides.
       heldClaim = this.store.verifyWorkflowRunClaim({ runId: record.runId, claimToken });
       if (heldClaim) {
-        const bundle = await this.childRunStore.markRunInterrupted(record.runId, message);
+        const claimedStore = new WorkflowRunStore(this.store.filePath, {
+          state: this.store.state,
+          authorityProvider: () => this.store.workflowRunAuthority(record.runId, claimToken),
+        });
+        const bundle = await claimedStore.markRunInterrupted(record.runId, message);
         actualStatus = bundle?.state.status;
       }
     } catch {
-      // The bundle may be unreadable; the queue row still needs closure.
+      // The run state may be unreadable; the queue row still needs closure.
     }
     try {
       this.store.completeWorkflowRun({ runId: record.runId, claimToken });
+      this.store.settleRunEffect(record.runId, "run.settle_queue");
     } catch {
       // Best-effort.
     }
@@ -384,8 +409,8 @@ export class WorkflowHost {
       this.log(`run ${record.runId} continues under another runner`);
       return;
     }
-    // Report the bundle's real terminal state when the interruption was a
-    // no-op (the bundle was already waiting or completed), so the feed
+    // Report the run's real terminal state when the interruption was a
+    // no-op (the run was already waiting or completed), so the feed
     // stays truthful for sessions syncing from it.
     if (actualStatus !== undefined && actualStatus !== "failed") {
       this.recordEvent(record.runId, record.workflowName, actualStatus, {});
@@ -404,6 +429,33 @@ export class WorkflowHost {
   }
 }
 
+function hostHumanDecision(value: unknown): ResolvedHumanDecision | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Stored workflow launch options are invalid");
+  }
+  const decision = Reflect.get(value, "humanDecision");
+  if (decision === undefined) return undefined;
+  if (
+    typeof decision !== "object" ||
+    decision === null ||
+    Array.isArray(decision) ||
+    Reflect.get(decision, "schema") !== "pi-workflows.human-decision-accepted.v1"
+  ) {
+    throw new Error("Stored human decision launch option is invalid");
+  }
+  return decision as ResolvedHumanDecision;
+}
+
+function hostProjectScope(cwd: string): string {
+  let canonical: string;
+  try {
+    canonical = fs.realpathSync.native(cwd);
+  } catch {
+    canonical = path.resolve(cwd);
+  }
+  return createHash("sha256").update(canonical).digest("hex").slice(0, 24);
+}
+
 function hostLockPath(stateDir: string): string {
   return path.join(stateDir, "host.lock");
 }

package/src/render/graph-render.ts

@@ -313,8 +313,7 @@ function renderCellText(
       ? (state.finalOutput as { schema?: unknown }).schema
       : undefined;
   const waitingRequest =
-    waitingSchema === "pi-workflows.human-decision-request.v1" ||
-    waitingSchema === "pi-workflows.human-decision-request.v2"
+    waitingSchema === "pi-workflows.human-decision-request.v1"
       ? (state.finalOutput as {
           audience?: unknown;
           presentationDigest?: unknown;
@@ -341,15 +340,22 @@ function renderCellText(
         : selected !== undefined
           ? `human: ${sanitizeText(selected.label)}`
           : undefined;
-  const detail =
-    humanDetail ??
-    (atLatestStep && state.currentNode === nodeId && state.statusDetail
+  const configuredDetail =
+    atLatestStep && state.currentNode === nodeId && state.statusDetail
       ? sanitizeText(state.statusDetail)
       : node?.statusDetail
         ? sanitizeText(node.statusDetail)
         : node?.summary
           ? sanitizeText(node.summary)
-          : "");
+          : "";
+  const assistantDetail =
+    node?.nodeType === "agent" &&
+    typeof node.expectedOutput === "object" &&
+    node.expectedOutput.kind === "assistant-message"
+      ? "assistant response"
+      : "";
+  const nodeDetail = [assistantDetail, configuredDetail].filter(Boolean).join(" · ");
+  const detail = humanDetail ?? nodeDetail;
   const branchLines = Array.from({ length: metrics.branchRows }, (_, index) =>
     labels[index] ? `◇ ${labels[index]}` : "",
   );