@osolmaz/pi-workflows 0.12.0 → 0.13.0

package/dist/extension/index.js

@@ -1,17 +1,15 @@
 import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { builtinWorkflowCatalog } from "../builtins/catalog.js";
-import { projectControllerStorePath, SqliteControllerStore, } from "../controllers/index.js";
+import { SqliteControllerStore } from "../controllers/index.js";
 import { compositionMetadata } from "../workflows/composition.js";
 import { humanDecisionChannelRequest } from "../workflows/decision-presentation.js";
 import { WorkflowEngine } from "../workflows/engine.js";
-import { ClaimLostError, errorMessage, isClaimLostError, TimeoutError, } from "../workflows/errors.js";
+import { BuiltinWorkflowRevisionChangedError, ClaimLostError, errorMessage, isClaimLostError, TimeoutError, } from "../workflows/errors.js";
 import { HumanDecisionStore, createHumanDecisionAttemptId, validateHumanDecisionResponse, } from "../workflows/human-decision.js";
 import { discoverWorkflows, resolveWorkflowRef } from "../workflows/loader.js";
-import { migrateLegacyWorkflowSources } from "../workflows/migrate-sources.js";
 import { appendProgressHistory, progressRecordsFromTrace } from "../workflows/progress.js";
-import { createRunId, listRunBundles, readLastTraceEvent, readRunBundle, WorkflowRunStore, createDefinitionSnapshot, } from "../workflows/store.js";
+import { createRunId, listWorkflowRuns, readWorkflowRun, WorkflowRunStore, createDefinitionSnapshot, } from "../workflows/store.js";
 import { PiControllerHost, parseControllerArgs, } from "./controller-host.js";
 import { PiDecisionChannel, TelegramDecisionChannel, audienceChannels, createTelegramChannels, loadDecisionChannelConfig, verifyTelegramTokenFile, writeDecisionChannelProfile, } from "./decision-channels.js";
 import { DeferredTurnCoordinator, } from "./deferred-turn-coordinator.js";
@@ -19,7 +17,7 @@ import { buildDeferredTurnContent, createDeferredTurnDescriptor, DEFERRED_TURN_M
 import { ConversationStepExecutor } from "./executor.js";
 import { HerdrWorkflowViewer, parseViewerPlacement, PIW_SHORTCUT, PIW_SHORTCUT_HINT, VIEWER_PLACEMENTS, } from "./herdr-viewer.js";
 import { SessionRecorder } from "./recorder.js";
-import { registerWorkflowAgentStepMessageRenderer, WORKFLOW_AGENT_STEP_MESSAGE_SCHEMA, WORKFLOW_AGENT_STEP_MESSAGE_TYPE, } from "./step-message.js";
+import { recoverAssistantStep, registerWorkflowAgentStepMessageRenderer, WORKFLOW_AGENT_STEP_MESSAGE_SCHEMA, WORKFLOW_AGENT_STEP_MESSAGE_TYPE, } from "./step-message.js";
 import { buildWidgetView } from "./widget.js";
 import { parseWorkflowToolInput, WorkflowToolParameters } from "./workflow-tool.js";
 export { PiDecisionChannel, TelegramDecisionChannel, audienceChannels, createTelegramChannels, decisionConfigDir, loadDecisionChannelConfig, verifyTelegramTokenFile, writeDecisionChannelProfile, } from "./decision-channels.js";
@@ -55,10 +53,8 @@ function humanDecisionRequest(value) {
     const schema = value !== null && typeof value === "object"
         ? value.schema
         : undefined;
-    if (schema !== "pi-workflows.human-decision-request.v1" &&
-        schema !== "pi-workflows.human-decision-request.v2") {
+    if (schema !== "pi-workflows.human-decision-request.v1")
         return null;
-    }
     return value;
 }
 function definitionDigest(snapshot) {
@@ -70,6 +66,20 @@ function launchSourceIdentity(workflow, root) {
         mounted: compositionMetadata(workflow)?.sources ?? [],
     };
 }
+function continuationSourceChangedError(runId, previous, current) {
+    if (previous.kind === "builtin" &&
+        current.kind === "builtin" &&
+        previous.id === current.id &&
+        previous.revision !== current.revision) {
+        return new BuiltinWorkflowRevisionChangedError({
+            runId,
+            workflowId: current.id,
+            previousRevision: previous.revision,
+            currentRevision: current.revision,
+        });
+    }
+    return new Error(`Workflow source changed since run ${runId} started; revert the edit to answer its checkpoint`);
+}
 function preparedLaunchOptions(options) {
     return {
         ...(options.presentation !== undefined ? { presentation: options.presentation } : {}),
@@ -89,7 +99,7 @@ function safeLaunchError(error) {
         .replace(/(token|api[_-]?key|secret|password)(\s*[:=]\s*)\S+/giu, "$1$2[redacted]")
         .replaceAll("\n", " ")
         .trim();
-    const code = /not found|cannot find|unknown workflow/iu.test(raw)
+    const code = /not found|cannot find|unknown workflow|no such file or directory/iu.test(raw)
         ? "workflow_not_found"
         : /source changed|source mismatch/iu.test(raw)
             ? "source_changed"
@@ -212,11 +222,21 @@ export default function piWorkflows(pi) {
             ...[...telegramDecisionChannels.values()].map(async (channel) => channel.settle(decision)),
         ]);
     };
-    const migrationBlockedRuns = new Set();
     const ensureRunQueueStore = (cwd) => {
-        runQueueStore ??= new SqliteControllerStore(projectControllerStorePath(cwd));
+        runQueueStore ??= new SqliteControllerStore(undefined, { projectPath: cwd });
         return runQueueStore;
     };
+    const workflowStore = (cwd, options = {}) => {
+        const queue = ensureRunQueueStore(cwd);
+        return new WorkflowRunStore(queue.filePath, { ...options, state: queue.state });
+    };
+    const humanDecisionStore = (cwd, authorityProvider) => {
+        const queue = ensureRunQueueStore(cwd);
+        return new HumanDecisionStore(queue.filePath, {
+            state: queue.state,
+            ...(authorityProvider === undefined ? {} : { authorityProvider }),
+        });
+    };
     // Session-addressed delivery: each session polls only its durable outbox.
     // Run events remain an audit feed and never enter a conversation.
     let syncArmed = false;
@@ -557,7 +577,6 @@ export default function piWorkflows(pi) {
         workflowViewTarget = {
             runId: state.runId,
             workflowName: state.workflowName,
-            runDir: path.resolve(new WorkflowRunStore().runDirFor(state.runId)),
         };
         renderWidget(ctx);
     };
@@ -734,14 +753,16 @@ export default function piWorkflows(pi) {
         }
         try {
             if (outcome === "park") {
-                runQueueStore.parkWorkflowRun({ runId: run.runId, claimToken: run.claimToken });
+                if (runQueueStore.parkWorkflowRun({ runId: run.runId, claimToken: run.claimToken })) {
+                    runQueueStore.settleRunEffect(run.runId, "run.park_queue");
+                }
             }
-            else {
-                runQueueStore.completeWorkflowRun({ runId: run.runId, claimToken: run.claimToken });
+            else if (runQueueStore.completeWorkflowRun({ runId: run.runId, claimToken: run.claimToken })) {
+                runQueueStore.settleRunEffect(run.runId, "run.settle_queue");
             }
         }
         catch {
-            // Queue bookkeeping is best-effort next to the durable bundle.
+            // Queue bookkeeping is best-effort next to the durable run fact.
         }
         finally {
             run.claimToken = undefined;
@@ -752,7 +773,7 @@ export default function piWorkflows(pi) {
             activeRun = null;
         }
         if (result.state.status === "running") {
-            // The run was parked for another runner; its bundle stays resumable
+            // The run was parked for another runner; its SQLite state stays resumable
             // and its queue row becomes claimable. The recorder drains first: its
             // finalization writes share the fenced store, so the claim must stay
             // valid until capture is complete. Nothing else to present.
@@ -776,7 +797,7 @@ export default function piWorkflows(pi) {
             notify(ctx, `Workflow ${run.workflowName} continues under another runner (run ${run.runId}).`);
             return;
         }
-        releaseClaim(run, "done");
+        releaseClaim(run, result.state.status === "waiting" ? "park" : "done");
         recordRunEvent({
             runId: run.runId,
             workflowRef: run.workflowName,
@@ -882,13 +903,13 @@ export default function piWorkflows(pi) {
         // refused continuation (edited source, missing parent) must not consume
         // the parent's one-continuation slot.
         if (options.parentRunId !== undefined) {
-            const parent = await readRunBundle(new WorkflowRunStore().runDirFor(options.parentRunId));
+            const parent = readWorkflowRun(options.parentRunId);
             if (parent === null || parent.state.status !== "waiting") {
                 throw new Error(`Workflow run ${options.parentRunId} is not waiting at a checkpoint`);
             }
             if (parent.state.workflowSource !== undefined &&
                 !isDeepStrictEqual(parent.state.workflowSource, workflowSource)) {
-                throw new Error(`Workflow source changed since run ${options.parentRunId} started; revert the edit to answer its checkpoint`);
+                throw continuationSourceChangedError(options.parentRunId, parent.state.workflowSource, workflowSource);
             }
         }
         // Interactive runs are queued and claimed atomically, so this session
@@ -909,6 +930,7 @@ export default function piWorkflows(pi) {
                         : workflowSource.path,
                     workflowSource: launchSourceIdentity(workflow, workflowSource),
                     definitionDigest: definitionDigest(snapshot),
+                    definitionSnapshot: snapshot,
                     input,
                     launchOptions: preparedLaunchOptions(options),
                     runnerId,
@@ -982,14 +1004,17 @@ export default function piWorkflows(pi) {
             },
             conversation: {
                 beginAttempt: (contract) => run.recorder?.beginAttempt(contract),
+                recoverAssistant: (contract) => recoverAssistantStep(ctx.sessionManager.getBranch(), contract),
                 mark: () => run.recorder?.mark() ?? 0,
                 rangeSince: (mark) => run.recorder?.rangeSince(mark),
             },
         });
-        // The store is shared between the engine and the session recorder so the
-        // trace sequence stays single-writer (see docs/run-bundles.md). Queued
-        // runs are fenced: every write proves the claim is still ours first.
-        const store = new WorkflowRunStore(undefined, fence === undefined ? {} : { fenceProvider: () => fence });
+        // The engine and session recorder share one transactional SQLite store.
+        const store = workflowStore(ctx.cwd, queueStore === null || claimToken === undefined
+            ? {}
+            : {
+                authorityProvider: () => queueStore.workflowRunAuthority(runId, claimToken),
+            });
         const engine = new WorkflowEngine({
             executor,
             store,
@@ -1014,8 +1039,8 @@ export default function piWorkflows(pi) {
             },
             // Awaited by the engine after run_started is persisted, so the session
             // binding and its trace event always precede node and terminal events.
-            onRunStarted: async (runDir, state) => {
-                const recorder = new SessionRecorder(store, runDir, state.runId);
+            onRunStarted: async (runId) => {
+                const recorder = new SessionRecorder(store, runId);
                 try {
                     await recorder.bind(ctx);
                     run.recorder = recorder;
@@ -1107,31 +1132,30 @@ export default function piWorkflows(pi) {
             // once the cause is fixed, and say so in the feed.
             let resumeFailed = run.resume === true && !isClaimLostError(error);
             let terminalStatus;
-            // Re-parking only makes sense while the bundle is still resumable.
-            // A terminal or waiting bundle closes the queue row instead, or
-            // every session start would retry it forever — and the feed reports
-            // the bundle's real state, not a bogus failure.
+            // Re-parking only makes sense while the run is still resumable.
+            // A terminal or waiting run closes the queue row instead, and the feed
+            // reports the authoritative run state.
             if (resumeFailed) {
                 try {
-                    const bundle = await readRunBundle(new WorkflowRunStore().runDirFor(runId));
+                    const bundle = readWorkflowRun(runId);
                     if (bundle === null || bundle.state.status !== "running") {
                         resumeFailed = false;
                         terminalStatus = bundle?.state.status;
                     }
                 }
                 catch {
-                    // Unreadable bundles close the row too.
+                    // Unreadable run state closes the row too.
                     resumeFailed = false;
                 }
             }
-            // A continuation that failed before its bundle exists frees the
+            // A continuation that failed before its run row exists frees the
             // parent's continuation slot instead of consuming it forever.
             let continuationSlotFreed = false;
             if (run.parentRunId !== undefined &&
                 run.claimToken !== undefined &&
                 !isClaimLostError(error)) {
                 try {
-                    const bundle = await readRunBundle(new WorkflowRunStore().runDirFor(runId));
+                    const bundle = readWorkflowRun(runId);
                     if (bundle === null) {
                         continuationSlotFreed =
                             runQueueStore?.deleteWorkflowRun({ runId, claimToken: run.claimToken }) === true;
@@ -1201,7 +1225,7 @@ export default function piWorkflows(pi) {
             runnerId,
             claimToken,
             leaseMs: RUN_CLAIM_LEASE_MS,
-            excludeRunIds: [...migrationBlockedRuns],
+            excludeRunIds: [],
             sessionId: ctx.sessionManager.getSessionId(),
         });
         if (claimed === undefined) {
@@ -1209,7 +1233,11 @@ export default function piWorkflows(pi) {
         }
         let started;
         try {
-            const bundle = await readRunBundle(new WorkflowRunStore().runDirFor(claimed.runId));
+            const bundle = readWorkflowRun(claimed.runId);
+            if (bundle?.state.status === "waiting") {
+                queueStore.parkWorkflowRun({ runId: claimed.runId, claimToken });
+                return;
+            }
             const sourceRef = bundle?.state.workflowSource === undefined
                 ? claimed.workflowSourceRef
                 : bundle.state.workflowSource.kind === "builtin"
@@ -1218,7 +1246,7 @@ export default function piWorkflows(pi) {
             const launchOptions = parsePreparedLaunchOptions(claimed.launchOptions);
             started = await startRun(ctx, sourceRef, claimed.input, {
                 ...launchOptions,
-                resume: bundle !== null,
+                resume: claimed.initialized,
                 runId: claimed.runId,
                 claimToken,
             });
@@ -1247,12 +1275,12 @@ export default function piWorkflows(pi) {
                 ? { state: "running", runId: activeRun.runId }
                 : workflowSchedulerResult(activeRun.lastState);
         }
-        const store = new WorkflowRunStore();
-        const bundle = await readRunBundle(store.runDirFor(request.runId));
+        const store = workflowStore(controllerContext?.cwd ?? process.cwd());
+        const bundle = store.readRun(request.runId);
         if (bundle !== null) {
             const recovered = bundle.state.status === "running" ? await store.markRunInterrupted(request.runId) : bundle;
             if (recovered !== null) {
-                const lastTraceEvent = await readLastTraceEvent(recovered.runDir, recovered.manifest.paths.trace);
+                const lastTraceEvent = recovered.traceEvents?.at(-1) ?? null;
                 return workflowSchedulerResult(recovered.state, lastTraceEvent?.type === "run_interrupted");
             }
             return { state: "pending" };
@@ -1260,7 +1288,6 @@ export default function piWorkflows(pi) {
         if (controllerContext === null) {
             return { state: "pending" };
         }
-        await store.quarantineIncompleteRun(request.runId);
         const runId = await startRun(controllerContext, request.workflow, request.input, {
             runId: request.runId,
             childKey,
@@ -1344,12 +1371,14 @@ export default function piWorkflows(pi) {
         const result = await listWorkflowControl(ctx);
         notify(ctx, result.message, result.level);
     };
-    const cancelHumanDecision = async (request) => {
-        const store = new HumanDecisionStore(new WorkflowRunStore().outputRoot);
+    const cancelHumanDecision = async (ctx, request) => {
+        const store = humanDecisionStore(ctx.cwd);
         await store.cancel(request, "cancelled");
         const cancellation = await store.readCancellation(request.decisionId);
-        if (cancellation !== null)
+        if (cancellation !== null) {
             await settleHumanDecisionChannels(cancellation);
+            store.markEffectApplied(request.decisionId, "decision.settle_presentations");
+        }
         lastWaitingRunId = null;
     };
     const findOwnedWaitingHumanDecision = async (ctx) => {
@@ -1359,7 +1388,7 @@ export default function piWorkflows(pi) {
             .filter((row) => row.originSessionId === null || row.originSessionId === sessionId)
             .map((row) => row.runId));
         const continued = new Set(rows.map((row) => row.parentRunId).filter((parent) => parent !== null));
-        const bundles = await listRunBundles(new WorkflowRunStore().outputRoot);
+        const bundles = listWorkflowRuns();
         for (const bundle of bundles) {
             if (bundle.state.status !== "waiting" ||
                 !owned.has(bundle.state.runId) ||
@@ -1414,7 +1443,7 @@ export default function piWorkflows(pi) {
             const { state } = widgetSource;
             const request = humanDecisionRequest(state.finalOutput);
             if (state.status === "waiting" && request !== null) {
-                await cancelHumanDecision(request);
+                await cancelHumanDecision(ctx, request);
                 clearWidgetTimer();
                 clearWidget(ctx);
                 return {
@@ -1434,7 +1463,7 @@ export default function piWorkflows(pi) {
         }
         const recovered = await findOwnedWaitingHumanDecision(ctx);
         if (recovered !== null) {
-            await cancelHumanDecision(recovered.request);
+            await cancelHumanDecision(ctx, recovered.request);
             return {
                 message: `Cancelled the pending human decision for workflow ${recovered.state.workflowName}.`,
                 details: {
@@ -1532,9 +1561,13 @@ export default function piWorkflows(pi) {
     });
     const statusWorkflowControl = async (ctx, runId) => {
         if (runId !== undefined) {
-            const bundle = await readRunBundle(new WorkflowRunStore().runDirFor(runId));
+            const launch = ensureRunQueueStore(ctx.cwd).getWorkflowRun(runId);
+            if (launch !== undefined &&
+                ["queued", "starting", "failed", "cancelled"].includes(launch.status)) {
+                return workflowLaunchStatus(launch);
+            }
+            const bundle = readWorkflowRun(runId);
             if (bundle === null) {
-                const launch = ensureRunQueueStore(ctx.cwd).getWorkflowRun(runId);
                 if (launch === undefined)
                     throw new Error(`Workflow run not found: ${runId}`);
                 return workflowLaunchStatus(launch);
@@ -1572,7 +1605,7 @@ export default function piWorkflows(pi) {
                 .filter((row) => row.originSessionId === null || row.originSessionId === sessionId)
                 .map((row) => row.runId));
             const continued = new Set(rows.map((row) => row.parentRunId).filter((parent) => parent !== null));
-            const bundles = await listRunBundles(new WorkflowRunStore().outputRoot);
+            const bundles = listWorkflowRuns();
             parentRunId =
                 bundles.find((bundle) => bundle.state.status === "waiting" &&
                     known.has(bundle.state.runId) &&
@@ -1588,7 +1621,7 @@ export default function piWorkflows(pi) {
             queueRecord.originSessionId !== ctx.sessionManager.getSessionId()) {
             throw new Error(`Workflow run ${parentRunId} belongs to another Pi session.`);
         }
-        const parent = await readRunBundle(new WorkflowRunStore().runDirFor(parentRunId));
+        const parent = readWorkflowRun(parentRunId);
         if (parent === null ||
             parent.state.status !== "waiting" ||
             parent.state.workflowSource === undefined) {
@@ -1606,7 +1639,7 @@ export default function piWorkflows(pi) {
     };
     const answerWorkflowControl = async (ctx, input, requestedRunId, verified) => {
         const waiting = await resolveWaitingWorkflow(ctx, requestedRunId, verified !== undefined);
-        const parent = await readRunBundle(new WorkflowRunStore().runDirFor(waiting.parentRunId));
+        const parent = readWorkflowRun(waiting.parentRunId);
         if (parent === null)
             throw new Error(`Workflow run ${waiting.parentRunId} is unreadable.`);
         const request = humanDecisionRequest(parent.state.finalOutput);
@@ -1631,9 +1664,9 @@ export default function piWorkflows(pi) {
                 },
                 idempotencyKey: verified?.idempotencyKey ?? createHumanDecisionAttemptId(),
             };
-            const store = new HumanDecisionStore(new WorkflowRunStore().outputRoot);
+            const store = humanDecisionStore(ctx.cwd);
             const acceptance = await store.accept(request, submission);
-            if (acceptance.status === "conflict") {
+            if (acceptance.status === "conflict" || acceptance.decision.provenance !== "human") {
                 throw new Error("That human decision was already answered differently.");
             }
             accepted = acceptance.decision;
@@ -1657,19 +1690,9 @@ export default function piWorkflows(pi) {
                 };
             }
         }
-        const decisionStore = new HumanDecisionStore(new WorkflowRunStore().outputRoot);
-        if (request !== null && continuationRunId !== undefined && accepted !== undefined) {
-            await decisionStore.recordContinuation(request.decisionId, {
-                schema: "pi-workflows.human-decision-continuation.v1",
-                decisionId: request.decisionId,
-                requestDigest: request.requestDigest,
-                parentRunId: waiting.parentRunId,
-                runId: continuationRunId,
-                createdAt: accepted.acceptedAt,
-            });
-        }
+        const decisionStore = humanDecisionStore(ctx.cwd);
         if (continuationRunId !== undefined) {
-            const existingContinuation = await readRunBundle(new WorkflowRunStore().runDirFor(continuationRunId));
+            const existingContinuation = readWorkflowRun(continuationRunId);
             if (existingContinuation !== null) {
                 if (accepted !== undefined)
                     await settleHumanDecisionChannels(accepted);
@@ -1694,7 +1717,18 @@ export default function piWorkflows(pi) {
             throw new Error("Could not start the checkpoint continuation.");
         }
         if (request !== null && accepted !== undefined) {
+            await decisionStore.recordContinuation(request.decisionId, {
+                schema: "pi-workflows.human-decision-continuation.v1",
+                decisionId: request.decisionId,
+                requestDigest: request.requestDigest,
+                provenance: accepted.provenance,
+                parentRunId: waiting.parentRunId,
+                runId: continued,
+                createdAt: accepted.acceptedAt,
+            });
+            decisionStore.markEffectApplied(request.decisionId, "decision.continue");
             await settleHumanDecisionChannels(accepted);
+            decisionStore.markEffectApplied(request.decisionId, "decision.settle_presentations");
         }
         lastWaitingRunId = null;
         return {
@@ -1712,7 +1746,7 @@ export default function piWorkflows(pi) {
         const channel = new PiDecisionChannel({
             actorId: ctx.sessionManager.getSessionId(),
             ui: ctx.ui,
-            store: new HumanDecisionStore(new WorkflowRunStore().outputRoot),
+            store: humanDecisionStore(ctx.cwd),
             onAnswer: async (answer) => {
                 const result = await answerWorkflowControl(ctx, answer.response, request.runId, answer);
                 notify(ctx, result.message, result.level);
@@ -1750,7 +1784,7 @@ export default function piWorkflows(pi) {
             config: loaded.channels,
             credentials: loaded.credentials,
             configDir: loaded.configDir,
-            store: new HumanDecisionStore(new WorkflowRunStore().outputRoot),
+            store: humanDecisionStore(ctx.cwd),
             onAnswer: async (answer) => {
                 await answerWorkflowControl(ctx, answer.response, answer.request.runId, answer);
             },
@@ -1758,11 +1792,11 @@ export default function piWorkflows(pi) {
         await Promise.all([...telegramDecisionChannels.values()].map(async (channel) => channel.start()));
     };
     const recoverHumanDecisions = async (ctx, deliverPending = true) => {
-        const runStore = new WorkflowRunStore();
-        const store = new HumanDecisionStore(runStore.outputRoot);
+        const runStore = workflowStore(ctx.cwd);
+        const store = humanDecisionStore(ctx.cwd);
         const requests = (await store.listRequests()).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
         for (const request of requests) {
-            const parent = await readRunBundle(runStore.runDirFor(request.runId));
+            const parent = runStore.readRun(request.runId);
             if (parent === null || parent.state.status !== "waiting")
                 continue;
             const currentRequest = humanDecisionRequest(parent.state.finalOutput);
@@ -1775,60 +1809,110 @@ export default function piWorkflows(pi) {
             const ownedBySession = queueRecord !== undefined &&
                 (queueRecord.originSessionId === null ||
                     queueRecord.originSessionId === ctx.sessionManager.getSessionId());
-            const accepted = await store.readAccepted(request.decisionId);
-            if (accepted === null) {
+            if (!ownedBySession)
+                continue;
+            const recoveryToken = randomUUID();
+            const recoveryQueue = ensureRunQueueStore(ctx.cwd);
+            const claimed = recoveryQueue.claimWorkflowRun({
+                runId: request.runId,
+                runnerId: ctx.sessionManager.getSessionId(),
+                claimToken: recoveryToken,
+                leaseMs: RUN_CLAIM_LEASE_MS,
+            });
+            if (claimed === undefined)
+                continue;
+            const ownerStore = humanDecisionStore(ctx.cwd, () => recoveryQueue.workflowRunAuthority(request.runId, recoveryToken));
+            let resolved = await store.readResolved(request.decisionId);
+            if (resolved === null) {
                 let cancellation = await store.readCancellation(request.decisionId);
-                if (cancellation === null &&
-                    request.expiresAt !== undefined &&
-                    Date.parse(request.expiresAt) <= Date.now()) {
-                    await store.cancel(request, "expired");
-                    cancellation = await store.readCancellation(request.decisionId);
+                const expired = request.expiresAt !== undefined && Date.parse(request.expiresAt) <= Date.now();
+                if (cancellation === null && expired) {
+                    if (request.defaultResponse === undefined) {
+                        await ownerStore.cancel(request, "expired");
+                        cancellation = await ownerStore.readCancellation(request.decisionId);
+                    }
+                    else {
+                        try {
+                            resolved = (await ownerStore.resolveTimeout(request)).decision;
+                        }
+                        catch {
+                            cancellation = await store.readCancellation(request.decisionId);
+                            resolved = await store.readResolved(request.decisionId);
+                        }
+                    }
                 }
                 if (cancellation !== null) {
+                    recoveryQueue.completeWorkflowRun({ runId: request.runId, claimToken: recoveryToken });
+                    ownerStore.markEffectApplied(request.decisionId, "decision.cancel_parent");
                     await settleHumanDecisionChannels(cancellation);
+                    ownerStore.markEffectApplied(request.decisionId, "decision.settle_presentations");
+                    ownerStore.close();
                     continue;
                 }
-                if (!deliverPending || !ownedBySession)
+                if (resolved === null) {
+                    if (!deliverPending) {
+                        recoveryQueue.parkWorkflowRun({ runId: request.runId, claimToken: recoveryToken });
+                        ownerStore.close();
+                        continue;
+                    }
+                    const channels = audienceChannels(decisionChannelConfig, request.audience);
+                    for (const channelId of channels) {
+                        const channel = telegramDecisionChannels.get(channelId);
+                        if (channel !== undefined)
+                            await channel.deliver(humanDecisionChannelRequest(request));
+                    }
+                    if (ctx.mode === "tui" && channels.includes("pi") && lastWaitingRunId === null) {
+                        lastWaitingRunId = request.runId;
+                        queueMicrotask(() => void promptHumanDecision(ctx, request));
+                    }
+                    recoveryQueue.parkWorkflowRun({ runId: request.runId, claimToken: recoveryToken });
+                    ownerStore.close();
                     continue;
-                const channels = audienceChannels(decisionChannelConfig, request.audience);
-                for (const channelId of channels) {
-                    const channel = telegramDecisionChannels.get(channelId);
-                    if (channel !== undefined)
-                        await channel.deliver(humanDecisionChannelRequest(request));
                 }
-                if (ctx.mode === "tui" && channels.includes("pi") && lastWaitingRunId === null) {
-                    lastWaitingRunId = request.runId;
-                    queueMicrotask(() => void promptHumanDecision(ctx, request));
-                }
-                continue;
             }
-            if (!ownedBySession)
+            const currentParent = runStore.readRun(request.runId);
+            if (currentParent === null || currentParent.state.status !== "waiting") {
+                recoveryQueue.parkWorkflowRun({ runId: request.runId, claimToken: recoveryToken });
+                ownerStore.close();
                 continue;
+            }
             const runId = `continuation-${request.decisionId.slice("decision-".length)}`;
             const continuation = (await store.readContinuation(request.decisionId)) ?? {
                 schema: "pi-workflows.human-decision-continuation.v1",
                 decisionId: request.decisionId,
                 requestDigest: request.requestDigest,
+                provenance: resolved.provenance,
                 parentRunId: request.runId,
                 runId,
-                createdAt: accepted.acceptedAt,
+                createdAt: resolved.acceptedAt,
             };
-            await store.recordContinuation(request.decisionId, continuation);
-            const existing = await readRunBundle(runStore.runDirFor(continuation.runId));
+            recoveryQueue.parkWorkflowRun({
+                runId: request.runId,
+                claimToken: recoveryToken,
+            });
+            const existing = runStore.readRun(continuation.runId);
             if (existing === null && activeRun === null) {
-                if (parent.state.workflowSource === undefined)
+                if (currentParent.state.workflowSource === undefined) {
+                    ownerStore.close();
                     continue;
-                const workflowRef = parent.state.workflowSource.kind === "builtin"
-                    ? `builtin:${parent.state.workflowSource.id}`
-                    : parent.state.workflowSource.path;
-                await startRun(ctx, workflowRef, parent.state.input, {
+                }
+                const workflowRef = currentParent.state.workflowSource.kind === "builtin"
+                    ? `builtin:${currentParent.state.workflowSource.id}`
+                    : currentParent.state.workflowSource.path;
+                await startRun(ctx, workflowRef, currentParent.state.input, {
                     parentRunId: request.runId,
-                    humanDecision: accepted,
+                    humanDecision: resolved,
                     runId: continuation.runId,
                     quiet: true,
                 });
             }
-            await settleHumanDecisionChannels(accepted);
+            if (runStore.readRun(continuation.runId) !== null) {
+                await ownerStore.recordContinuation(request.decisionId, continuation);
+                ownerStore.markEffectApplied(request.decisionId, "decision.continue");
+            }
+            await settleHumanDecisionChannels(resolved);
+            ownerStore.markEffectApplied(request.decisionId, "decision.settle_presentations");
+            ownerStore.close();
             if (activeRun !== null)
                 break;
         }
@@ -1874,7 +1958,7 @@ export default function piWorkflows(pi) {
         }
         const queue = ensureRunQueueStore(ctx.cwd);
         const existing = queue.findSessionReservation(ctx.sessionManager.getSessionId());
-        if (existing !== undefined) {
+        if (existing !== undefined && existing.runId !== options.parentRunId) {
             throw new Error(`Workflow ${existing.workflowName} is already ${existing.status} (run ${existing.runId}).`);
         }
         if (presentationPending !== null) {
@@ -1884,13 +1968,13 @@ export default function piWorkflows(pi) {
         const workflow = resolved.definition;
         const workflowSource = resolved.source;
         if (options.parentRunId !== undefined) {
-            const parent = await readRunBundle(new WorkflowRunStore().runDirFor(options.parentRunId));
+            const parent = readWorkflowRun(options.parentRunId);
             if (parent === null || parent.state.status !== "waiting") {
                 throw new Error(`Workflow run ${options.parentRunId} is not waiting at a checkpoint`);
             }
             if (parent.state.workflowSource !== undefined &&
                 !isDeepStrictEqual(parent.state.workflowSource, workflowSource)) {
-                throw new Error(`Workflow source changed since run ${options.parentRunId} started; revert the edit to answer its checkpoint`);
+                throw continuationSourceChangedError(options.parentRunId, parent.state.workflowSource, workflowSource);
             }
         }
         const snapshot = createDefinitionSnapshot(workflow);
@@ -1902,6 +1986,7 @@ export default function piWorkflows(pi) {
                 workflowSourceRef: workflowSource.kind === "builtin" ? `builtin:${workflowSource.id}` : workflowSource.path,
                 workflowSource: launchSourceIdentity(workflow, workflowSource),
                 definitionDigest: definitionDigest(snapshot),
+                definitionSnapshot: snapshot,
                 input,
                 launchOptions: preparedLaunchOptions(options),
                 runnerId,
@@ -2090,7 +2175,7 @@ export default function piWorkflows(pi) {
                 }
                 catch (error) {
                     const message = errorMessage(error);
-                    notify(ctx, /workflow_run_queue_parent/.test(message)
+                    notify(ctx, /continuations\.parent_run_id/.test(message)
                         ? "That checkpoint was already answered; see its continuation run."
                         : `Could not continue workflow: ${message}`, "error");
                 }
@@ -2237,9 +2322,10 @@ export default function piWorkflows(pi) {
         label: "Workflow",
         description: [
             "List, start, inspect, pause, resume, cancel, answer, update, or complete pi-workflows runs.",
-            "When the user asks to monitor, watch, poll, or check something repeatedly, start the built-in monitor workflow with input keys task, everyMinutes, stopWhen, and optional maxChecks.",
+            "When the user asks to monitor, watch, poll, or check something repeatedly, start the built-in monitor workflow with input keys task, stopWhen, everyMinutes, and optional maxChecks.",
+            "Put the exact goal, authority, limits, and recovery rules in task; Monitor observes first, performs only safe authorized actions, verifies them immediately, and waits only while target work is moving or an external event is pending.",
             "Use update or submit only when a workflow step contract asks for it, and pass the exact step and attempt ids.",
-            "Do not start repeated work without the user's request, and keep monitoring observation-only unless the user authorizes mutations.",
+            "Do not start repeated work without the user's request.",
         ].join(" "),
         parameters: WorkflowToolParameters,
         async execute(toolCallId, rawParams, _signal, _onUpdate, ctx) {
@@ -2266,7 +2352,7 @@ export default function piWorkflows(pi) {
                     break;
                 case "answer": {
                     const waiting = await resolveWaitingWorkflow(ctx, params.runId);
-                    const parent = await readRunBundle(new WorkflowRunStore().runDirFor(waiting.parentRunId));
+                    const parent = readWorkflowRun(waiting.parentRunId);
                     if (parent !== null && humanDecisionRequest(parent.state.finalOutput) !== null) {
                         throw new Error("This checkpoint requires a verified human answer from Pi UI or a configured decision channel.");
                     }
@@ -2294,7 +2380,7 @@ export default function piWorkflows(pi) {
                         }
                         throw new Error("No workflow step is waiting for output.");
                     }
-                    // Flush the conversation into the bundle before accepting, so the
+                    // Flush the conversation into SQLite before accepting, so the
                     // attempt range includes the assistant message carrying this call.
                     await activeRun.recorder?.record(ctx).catch(() => undefined);
                     await activeRun.recorder?.synchronize(ctx).catch(() => undefined);
@@ -2334,22 +2420,7 @@ export default function piWorkflows(pi) {
         controllerContext = ctx;
         if (herdrEnabled)
             void refreshHerdrCapability(ctx);
-        try {
-            const queue = ensureRunQueueStore(ctx.cwd);
-            const migration = await migrateLegacyWorkflowSources({
-                catalog: builtinWorkflowCatalog,
-                queue,
-            });
-            migrationBlockedRuns.clear();
-            for (const blocked of migration.blocked)
-                migrationBlockedRuns.add(blocked.runId);
-            if (migration.blocked.length > 0) {
-                notify(ctx, `Could not migrate ${migration.blocked.length} legacy workflow source(s).`, "warning");
-            }
-        }
-        catch (error) {
-            notify(ctx, `Could not migrate legacy workflow sources: ${errorMessage(error)}`, "warning");
-        }
+        ensureRunQueueStore(ctx.cwd);
         try {
             await reloadDecisionChannels(ctx);
         }
@@ -2431,6 +2502,9 @@ export default function piWorkflows(pi) {
     });
     pi.on("turn_end", async (event, ctx) => {
         await activeRun?.recorder?.handleTurnEnd(event, ctx).catch(() => undefined);
+        // turn_end observes the message after message_end replacement handlers,
+        // so this is the exact assistant message that remains visible.
+        activeRun?.executor.handleMessageEnd(event.message);
     });
     pi.on("message_start", async (event, ctx) => {
         await activeRun?.recorder?.handleMessageStart(event, ctx).catch(() => undefined);
@@ -2473,9 +2547,9 @@ export default function piWorkflows(pi) {
                 return;
             }
         }
-        const flushedNatural = turnCoordinator.flushNatural(ctx.isIdle() && !sessionClosed && !runHeld());
         const run = activeRun;
         if (!run) {
+            turnCoordinator.flushNatural(ctx.isIdle() && !sessionClosed && !runHeld());
             presentationPending = null;
             runSyncPass(ctx);
             return;
@@ -2483,8 +2557,16 @@ export default function piWorkflows(pi) {
         await run.recorder?.synchronize(ctx).catch(() => undefined);
         run.recorder?.settleAttempt();
         run.executor.setStreaming(false);
-        if (flushedNatural === 0)
+        if (run.executor.pendingCompletion === "assistant") {
+            // The visible response is the step output. Resolve it before any
+            // unrelated deferred turn can start and replace the captured message.
             run.executor.handleAgentSettled();
+        }
+        else {
+            const flushedNatural = turnCoordinator.flushNatural(ctx.isIdle() && !sessionClosed && !runHeld());
+            if (flushedNatural === 0)
+                run.executor.handleAgentSettled();
+        }
         runSyncPass(ctx);
     });
     pi.on("session_shutdown", async () => {