@osolmaz/pi-workflows 0.16.6 → 0.16.7

package/docs/2026-09-07-workflow-handoff-plan.md

@@ -0,0 +1,84 @@
+---
+title: Workflow handoff and fixed run definitions
+author: Onur Solmaz <2453968+osolmaz@users.noreply.github.com>
+date: 2026-09-07
+status: complete
+---
+
+# Workflow handoff and fixed run definitions
+
+Keep the architecture small. Make ownership, delivery, and recovery rules explicit.
+This corrects regressions found after the [durable execution work](2026-09-06-durable-execution-plan.md).
+Normal chat currently leaves a turn record that blocks the first workflow message.
+Forced resume accepts changed source, then fails against the old saved graph.
+
+## Scope
+
+Change only pi-workflows. Implement, test, commit, push, review, and rebase-merge this
+change into main. Do not release, install packages into user profiles, alter live
+runs, reset databases, or modify Pi itself. No new workflow primitive, database,
+transport, persisted schema, compatibility path, or hidden model retry is needed.
+
+## Design
+
+- The extension tracks only workflow-owned turns. Its local states are absent,
+  delivering, running, and settled awaiting server acknowledgment. Normal chat
+  creates no owned turn. Pi automatic retries retain the same owned turn.
+- Save delivery identity before the public `sendMessage` call. Confirm delivery
+  from the public session branch. Retry reports with the same identity; never
+  resend a message merely because its acknowledgment was lost. Preserve an exact
+  settled response until submission and turn-end acknowledgment succeed.
+- Resume requires the original source and graph. Remove the `force` option.
+  Reject changes before any durable mutation. A changed definition requires an
+  explicit new run; accepted outputs and approvals are not silently transferred.
+- Derive delivery, active model work, required results, and pause labels from
+  existing message, turn, request, and run records. An unconfirmed message is not
+  proof that the agent received it. A start receipt proves only that a run exists.
+- Use Pi's public `agent_start`, `agent_end`, `agent_settled`, `sendMessage`, and
+  session branch APIs. Pi's normal message delivery appends the existing custom
+  message entry. There are no new Pi session fields or changes to Pi internals.
+
+## Acceptance and validation
+
+Tests must cover ordinary chat before and during start, full step delivery and
+submission, automatic retries, delayed branch and turn acknowledgments, reconnect,
+cancellation, pause/resume, and changed source or graph. Assert delivery counts,
+exact receipts, and durable state. Rejected resume must leave the run unchanged.
+Use real Pi with a mock provider for automated full-lifecycle tests, then a
+separate authenticated low-cost model for a tool-started live lifecycle.
+
+Run `npm run check`, `npm run test:e2e`,
+`npx slophammer-ts@latest dry .`, and
+`npx slophammer-ts@latest check . --only ts.dependency-boundaries-required`.
+Run SimpleDoc and relevant Rust viewer checks. Existing unrelated documentation
+issues must be identified, not silently repaired. Push before running
+`pi-reviewer --base main`; address P0/P1 findings before checking CI and merging.
+
+## Completion evidence
+
+Implemented in PR #85. Local validation passed with 1,215 unit tests, 13 real-Pi
+mock-provider E2E tests, and 76 Rust tests. Slophammer, Clippy, and format checks
+passed. SimpleDoc reports the existing nine naming/frontmatter issues and 24
+reference updates.
+
+The final code commit passed the authenticated live test with
+`openrouter/deepseek/deepseek-v4-flash`, Pi 0.85.0, and a 4,096-token output
+allowance. It verified ordinary chat, a model tool start, exact submission,
+next-step completion, and saved conversation capture. The isolated Autoimplement
+test also verified actual temporary worktree creation before cancellation.
+
+The first reviewer attempt stopped on an unsupported local provider configuration.
+After that configuration was repaired, the configured reviewer found a P1 recovery
+case: a delivered step without an active workflow turn could claim an ordinary
+chat response. Recovery now requires the recorded active turn and its exact
+message as the latest user or custom input. Regression tests cover missing turn
+records and later ordinary input. The configured reviewer then completed with no
+findings. All four CI jobs passed; the check job needed an unchanged retry after
+a lease-renewal test timed out. That test also passed locally in the full suite
+and a focused run.
+
+[PR #85](https://github.com/osolmaz/pi-workflows/pull/85) was rebase-merged on
+2026-09-07. The branch was removed. The final live-model run was
+`20260907T033236999Z-live-model-e2e-8c53326e`, with reported cost $0.0004163409.
+No Pi Workflows installation or live run was changed. Recovery of an installed
+live session is separate work and requires approval to update that installation.

package/docs/WORKFLOW_STEP_MESSAGES.md

@@ -120,6 +120,16 @@ Notifications keep the custom type `pi-workflows-notification` and use `triggerT
 
 The extension has one `WorkflowMessageCoordinator` for all message kinds. The server keeps one active coordinator connection and process-local epoch for each origin session. A replacement connection fences the old one, so two Pi processes cannot send for the same session.
 
+The coordinator retains only workflow-owned turns. Its local state is absent,
+delivering, running, or settled awaiting acknowledgment. An ordinary chat turn
+never creates an owned turn or blocks later workflow delivery. Recovery requires
+an already recorded active workflow turn and its exact message as the latest
+user or custom input in the active Pi branch. A delivered step with no active
+workflow turn cannot claim a later ordinary chat response.
+A delayed acknowledgment retains the same message, turn ID, and exact response;
+it never creates another model attempt. Unconfirmed delivery stays visible as
+unconfirmed instead of being reported as a received step.
+
 The coordinator follows this sequence:
 
 1. After every server connection, wait for the complete origin-session view and report the active branch before any send or turn report.
@@ -142,9 +152,10 @@ After Pi, the extension, or the server restarts, branch reporting runs before an
 ## Model-turn status
 
 `agent_start` has no message payload. A locally delivered prompt binds its start
-through the coordinator's saved message identity. Late binding and reconnect
-also require the exact message in the active branch. A session view alone does
-not prove that a message caused the current turn.
+through the coordinator's saved message identity. Reconnect requires the same
+recorded active turn, run, session, and message, with no later user or custom
+input in the active branch. Neither a session view nor an old branch entry alone
+proves that a message caused the current turn.
 
 Only pending, unpaused agent requests and explicit follow-ups can open model
 turns. Decisions, notifications, and terminal notices cannot. A stale start can

package/docs/workflows.md

@@ -5,6 +5,23 @@ covers the file format, every node type, edge routing, the step contract the
 model sees, and how runs behave at runtime. For durable state, see
 [SQLITE_STATE.md](SQLITE_STATE.md).
 
+## Starting and resuming runs
+
+A successful start call confirms that a run was created. Wait for the delivered
+step contract before submitting an agent result. Report worktree creation or
+implementation progress only after the corresponding recorded steps succeed.
+The status view distinguishes unconfirmed step delivery, active agent work,
+required results, and a durable pause. Waiting uses a different glyph from pause.
+
+Resume uses the run's original source and graph, including ordinary workflows
+without included workflows. Source and graph checks run before any durable
+mutation. `WorkflowEngine.resumeRun` has no `force` option. Restore the original
+source to resume its accepted work, or explicitly start a new run for changed
+code. A new run does not inherit outputs, approvals, or effect receipts.
+File and built-in source identities verify code; callers of the direct engine
+API must supply source identity to detect callback-body changes that leave the
+structural graph unchanged.
+
 ## Workflow files
 
 A workflow is a TypeScript module whose default export is `defineWorkflow(...)`.

package/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "osolmaz.pi-workflows"
 name = "pi-workflows"
-version = "0.16.6"
+version = "0.16.7"
 min_herdr_version = "0.7.0"
 description = "Open the active pi-workflows run in piw from a managed Herdr pane."
 platforms = ["linux", "macos"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osolmaz/pi-workflows",
-  "version": "0.16.6",
+  "version": "0.16.7",
   "description": "Workflow and resource manager runtime with a live terminal viewer for the pi coding agent",
   "keywords": [
     "pi-package"

package/src/extension/index.ts

@@ -850,7 +850,7 @@ async function executeCommand(
         },
       });
       return {
-        message: `Started hosted workflow ${resolved.workflowName} as ${runId}.`,
+        message: `Created hosted workflow ${resolved.workflowName} as ${runId}. This confirms the run, not worktree creation or implementation. Complete the next delivered step using its exact contract.`,
         details: { action: "start", runId, response: response.receipt ?? null },
       };
     }

package/src/extension/widget.ts

@@ -54,7 +54,7 @@ export function nodeGlyph(
     return "◐";
   }
   if (state.waitingOn === nodeId) {
-    return "⏸";
+    return displayStatus === "paused" || state.paused === true ? "⏸" : "○";
   }
   const result = state.results[nodeId];
   if (!result) {

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

@@ -23,14 +23,11 @@ type DeliveryCallbacks = {
   terminalDelivered?: (message: WorkflowMessage) => Promise<void>;
 };
 
-type PendingTurn = {
+type OwnedTurn = {
   workflowTurnId: string;
-  workflowMessageId: string | null;
-  runId: string | null;
-  message: WorkflowMessage | null;
+  message: WorkflowMessage;
   startedReported: boolean;
-  end: SettledTurn | 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 {
@@ -40,8 +37,7 @@ export class WorkflowMessageCoordinator {
   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;
@@ -64,24 +60,15 @@ export class WorkflowMessageCoordinator {
   }
 
   startTurn(): void {
-    // Automatic Pi retries belong to the same unsettled workflow turn.
-    if (this.turn !== 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,
-    };
-    if (awaited !== null) this.bindTurn(awaited);
+    // 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.turn.end === null)
-      this.turn.end = { stopReason, responseSessionEntryId };
+    if (this.turn?.phase === "running") {
+      this.turn = { ...this.turn, phase: "settled", end: { stopReason, responseSessionEntryId } };
+    }
   }
 
   activeTurnMessage(): WorkflowMessage | undefined {
@@ -101,27 +88,25 @@ export class WorkflowMessageCoordinator {
       const view = this.view;
       if (!view.coordinatorActive || view.coordinatorEpoch === null) return;
       const branchEntries = branchWorkflowEntries(ctx.sessionManager.getBranch());
-      if (this.turn?.workflowMessageId === null) {
+      if (this.turn === null && !ctx.isIdle()) {
         const candidate = this.turnCandidate();
-        if (candidate !== undefined && branchEntries.has(candidate.workflowMessageId)) {
-          this.bindTurn(candidate);
+        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 (
-        this.turn === null &&
-        !ctx.isIdle() &&
-        view.openWorkflowTurn !== null &&
-        branchEntries.has(view.openWorkflowTurn.workflowMessageId)
-      ) {
-        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,
-        };
-      }
       if (
         view.branchReportRequired ||
         this.lastBranchEpoch !== view.coordinatorEpoch ||
@@ -170,7 +155,12 @@ export class WorkflowMessageCoordinator {
         return;
       }
       if (messageStartsTurn(message)) {
-        this.awaitingTurnMessage = message;
+        this.turn = {
+          workflowTurnId: `workflow-turn-${randomUUID()}`,
+          message,
+          startedReported: false,
+          phase: "delivering",
+        };
       }
       try {
         pi.sendMessage(
@@ -184,8 +174,11 @@ 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;
       }
@@ -201,7 +194,6 @@ export class WorkflowMessageCoordinator {
     this.closedTurnMessages.clear();
     this.finalizedTerminals.clear();
     this.view = null;
-    this.awaitingTurnMessage = null;
     this.turn = null;
     this.lastBranchEpoch = null;
     this.synchronizing = false;
@@ -227,23 +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,
     beforeTurnEnd?: BeforeTurnEnd,
   ): Promise<void> {
-    const pending = this.turn;
+    let pending = this.turn;
     if (
       pending === null ||
-      pending.workflowMessageId === null ||
-      pending.runId === null ||
+      pending.phase === "delivering" ||
       view.coordinatorEpoch === null ||
       this.lastBranchEpoch !== view.coordinatorEpoch
     ) {
@@ -251,19 +235,24 @@ export class WorkflowMessageCoordinator {
     }
     let message = pending.message;
     if (!pending.startedReported) {
-      message = messageById(view, pending.workflowMessageId) ?? null;
-      if (message?.status !== "sent") return;
+      const confirmed = messageById(view, message.workflowMessageId);
+      if (confirmed?.status !== "sent") return;
+      message = confirmed;
       const receipt = await reportTurn(client, {
         state: "started",
-        workflowMessageId: pending.workflowMessageId,
+        workflowMessageId: message.workflowMessageId,
         workflowTurnId: pending.workflowTurnId,
-        runId: pending.runId,
+        runId: message.runId,
         targetSessionId: view.sessionId,
         coordinatorEpoch: view.coordinatorEpoch,
       });
+      // 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.end !== null)
+        !(receipt.ownership === "settled" && pending.phase === "settled")
       ) {
         this.turn = null;
         return;
@@ -271,28 +260,28 @@ export class WorkflowMessageCoordinator {
       pending.message = message;
       pending.startedReported = true;
     }
-    if (pending.end === null) return;
-    if (message !== null) await beforeTurnEnd?.(message, pending.end);
+    if (pending.phase !== "settled") return;
+    await beforeTurnEnd?.(message, pending.end);
     await reportTurn(client, {
       state: "ended",
-      workflowMessageId: pending.workflowMessageId,
+      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,
     });
-    if (message?.kind === "followUp") {
-      this.closedTurnMessages.add(pending.workflowMessageId);
+    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 === "followUp"
+        current?.openWorkflowMessageId === message.workflowMessageId &&
+        message.kind === "followUp"
       ) {
         current.openWorkflowMessageId = null;
       }
@@ -360,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;

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/server/view.ts

@@ -774,6 +774,7 @@ export class ServerViewStore {
       runnerActive: this.hasLiveRunner(queue.runId),
       originTurnActive: this.hasActivity(queue.runId),
       pendingRequestKind: this.pendingRequestKind(queue.runId),
+      requestDeliveryConfirmed: this.requestDeliveryConfirmed(queue.runId),
       errorMessage: state?.error ?? queue.errorMessage,
     });
   }
@@ -803,6 +804,18 @@ export class ServerViewStore {
     return row?.kind ?? null;
   }
 
+  private requestDeliveryConfirmed(runId: string): boolean {
+    const row = this.state.connection
+      .prepare(
+        `SELECT m.status FROM interactive_requests i
+       JOIN workflow_messages m ON m.source_id = i.request_id AND m.kind = 'step'
+       WHERE i.run_id = ? AND i.status = 'pending'
+       ORDER BY m.order_number DESC LIMIT 1`,
+      )
+      .get(runId) as { status: string } | undefined;
+    return row?.status === "sent";
+  }
+
   private hasAmbiguousEffect(runId: string): boolean {
     const row = this.state.connection
       .prepare(
@@ -836,6 +849,7 @@ export class ServerViewStore {
       this.hasLiveRunner(runId),
       this.hasActivity(runId),
       this.pendingRequestKind(runId),
+      this.requestDeliveryConfirmed(runId),
       this.hasAmbiguousEffect(runId),
     ].join(":");
   }
@@ -869,6 +883,7 @@ export type WorkflowDisplayFacts = {
   runnerActive: boolean;
   originTurnActive: boolean;
   pendingRequestKind: "agent" | "assistant" | "checkpoint" | "decision" | null;
+  requestDeliveryConfirmed: boolean;
   errorMessage: string | null;
 };
 
@@ -909,6 +924,10 @@ export function reduceWorkflowDisplay(facts: WorkflowDisplayFacts): WorkflowDisp
             : facts.pendingRequestKind === "assistant"
               ? "The workflow needs its assigned visible response."
               : "The workflow is waiting.";
+    if (facts.pendingRequestKind === "agent" || facts.pendingRequestKind === "assistant") {
+      if (facts.originTurnActive) reason = "The agent is working on the workflow step.";
+      else if (!facts.requestDeliveryConfirmed) reason = "Workflow step delivery is not confirmed.";
+    }
   } else if (activity !== null) {
     status = "running";
   } else if (facts.queueStatus === "parked" || facts.queueStatus === "queued") {

package/src/workflows/engine.ts

@@ -329,7 +329,6 @@ export class WorkflowEngine {
     runId: string,
     options: {
       workflowSource?: WorkflowSource;
-      force?: boolean;
       resumeInteractionAttemptId?: string;
     } = {},
   ): Promise<WorkflowRunResult> {
@@ -343,7 +342,7 @@ export class WorkflowEngine {
     const stored = await this.store.readRunState(runId);
     if (stored === null) throw new Error(`Cannot resume unreadable workflow run: ${runId}`);
     const sourceMismatch = workflowIdentityMismatch(stored, workflow, options.workflowSource);
-    if (sourceMismatch && options.force !== true) {
+    if (sourceMismatch) {
       throw new WorkflowSourceChangedError(runId);
     }
     const state = await this.store.prepareRunResume(runId);
@@ -395,7 +394,6 @@ export class WorkflowEngine {
         ...(point.nodeId !== null ? { resumeAt: point.nodeId } : {}),
         ...(resumedAttempt !== undefined ? { resumedAttemptId: resumedAttempt.attemptId } : {}),
         replayedSteps: state.steps.length,
-        ...(sourceMismatch ? { workflowSourceMismatch: true, forced: true } : {}),
       },
     });
     await this.onRunStarted?.(runId, state);
@@ -533,9 +531,7 @@ export class WorkflowEngine {
       ...(await this.resolveTitleBounded(workflow, input)),
       ...(workflowSource !== undefined ? { workflowSource } : {}),
       ...(composition?.sources.length ? { workflowSources: composition.sources } : {}),
-      ...(composition?.snapshot.mounts.length
-        ? { definitionDigest: definitionDigest(workflow) }
-        : {}),
+      definitionDigest: definitionDigest(workflow),
       startedAt: now,
       updatedAt: now,
       status: "running",
@@ -1778,8 +1774,7 @@ export function workflowIdentityMismatch(
   const metadata = compositionMetadata(workflow);
   const currentSources = metadata?.sources ?? [];
   if (!isDeepStrictEqual(state.workflowSources ?? [], currentSources)) return true;
-  const currentDigest = metadata?.snapshot.mounts.length ? definitionDigest(workflow) : undefined;
-  return state.definitionDigest !== currentDigest;
+  return state.definitionDigest !== definitionDigest(workflow);
 }
 
 function definitionDigest(workflow: WorkflowDefinition): string {

package/src/workflows/errors.ts

@@ -54,12 +54,14 @@ export function isRunParkedError(error: unknown): error is RunParkedError {
   return error instanceof RunParkedError;
 }
 
-/** The workflow source changed after the run started; resume needs force. */
+/** A run can resume only with its original workflow source and definition. */
 export class WorkflowSourceChangedError extends Error {
   readonly runId: string;
 
   constructor(runId: string) {
-    super(`Workflow source changed since run ${runId} started; pass force to resume anyway`);
+    super(
+      `Workflow source or definition changed since run ${runId} started; restore the original definition to resume, or explicitly start a new run`,
+    );
     this.name = "WorkflowSourceChangedError";
     this.runId = runId;
   }

package/src/workflows/store.ts

@@ -19,7 +19,7 @@ import {
   type ViewerDeltaDraft,
 } from "../state/viewer.js";
 import { WorkflowMessageStore, workflowMessageIdFor } from "../state/workflow-messages.js";
-import { compositionMetadata } from "./composition.js";
+import { compileWorkflowDefinition, compositionMetadata } from "./composition.js";
 import { ClaimLostError } from "./errors.js";
 import { HumanDecisionStore } from "./human-decision.js";
 import { applyJsonPatch, validateJsonPatch } from "./json-patch.js";
@@ -844,7 +844,7 @@ export class WorkflowRunStore {
     options: InitializeWorkflowRunOptions = {},
   ): Promise<string> {
     return await this.initializeRunFromSnapshot(
-      createDefinitionSnapshot(workflow),
+      createDefinitionSnapshot(compileWorkflowDefinition(workflow)),
       workflow.name,
       state,
       options,
@@ -3608,9 +3608,7 @@ export class WorkflowRunStore {
       ...(row.title === null ? {} : { runTitle: row.title }),
       ...(sources.root === undefined ? {} : { workflowSource: sources.root }),
       ...(sources.mounted.length === 0 ? {} : { workflowSources: sources.mounted }),
-      ...(sources.mounted.length !== 0 || snapshot.composition?.mounts.length
-        ? { definitionDigest: `sha256:${row.definitionDigest.toString("hex")}` }
-        : {}),
+      definitionDigest: `sha256:${row.definitionDigest.toString("hex")}`,
       startedAt: new Date(row.createdAt).toISOString(),
       ...(row.finishedAt === null ? {} : { finishedAt: new Date(row.finishedAt).toISOString() }),
       updatedAt: new Date(row.updatedAt).toISOString(),