lastlight-workflow-engine 0.3.5 → 0.5.0

package/dist/core/phase-executor.d.ts

@@ -39,6 +39,15 @@ export interface PhaseRunContext {
     /** Bot identity (was `getBotName()`), used in the generic-loop gate prompt. */
     botName: string;
 }
+/**
+ * Reject shell commands containing mustache template markers to prevent
+ * accidental template injection into until_bash values.
+ *
+ * Exported so app-registered {@link PhaseTypeHandler}s that run their own gates
+ * (the `fanout` handler's per-branch `until_bash`) enforce the identical rule
+ * rather than a second copy of it that drifts.
+ */
+export declare function validateShellCommand(cmd: string): void;
 /**
  * Build the agent prompt for a phase, handling both `prompt:` (template file)
  * and `skill:`/`skills:` (skill references) phase definitions.
@@ -67,14 +76,22 @@ export declare function isSoftOutcome(r: Pick<ExecutionResult, "success" | "erro
  * The seams the dedup ledger needs: the runs+executions store, the agent
  * runtime, container liveness, and telemetry. Threaded from the
  * {@link PhaseExecutor}'s injected {@link EnginePorts}.
+ *
+ * `agent` is optional because {@link runLedgeredPhase} never calls it — the
+ * caller's `run` callback does the work. It is required by {@link runPhase} /
+ * {@link runCommandPhase}, which dispatch through it.
  */
-interface LedgerDeps {
+export interface LedgerDeps {
     store?: WorkflowStateStore;
-    agent: AgentPort;
+    agent?: AgentPort;
     liveness: LivenessPort;
     observability: ObservabilityPort;
     logger?: LoggerPort;
 }
+/** {@link LedgerDeps} for the two entry points that DO dispatch through the port. */
+interface AgentLedgerDeps extends LedgerDeps {
+    agent: AgentPort;
+}
 /**
  * The `owner/repo` a TELEMETRY consumer expects to filter traces by.
  *
@@ -86,7 +103,7 @@ interface LedgerDeps {
  * rule is small enough to restate, and the pair is right here on the row.
  */
 export declare function telemetryRepo(access: GitSandboxAccess | undefined): string | undefined;
-type RunPhaseResult = {
+export type RunPhaseResult = {
     result: ExecutionResult;
     executionId: string;
     skipped: false;
@@ -97,18 +114,48 @@ type RunPhaseResult = {
     skipped: true;
     reason: "running" | "done";
 };
+/**
+ * Run a single agent phase with DB-tracked deduplication. Moved verbatim from
+ * runner.ts — the dedup ledger (`shouldRunPhase`) is the single source of
+ * truth for resume, so re-running from the top skips completed phases here.
+ */
+/**
+ * The DB-tracked dedup ledger shared by agent phases ({@link runPhase}) and
+ * deterministic command phases ({@link runCommandPhase}). The `run` callback
+ * does the actual work and receives a session-id sink so the executions row can
+ * be linked to its session jsonl mid-run. `shouldRunPhase` is the single source
+ * of truth for resume — re-running from the top skips completed phases here.
+ *
+ * **Exported** so an app-registered {@link PhaseTypeHandler} can put its own
+ * units of work on the same ledger. That is what a `type: fanout` phase needs:
+ * it bypasses {@link AgentPort} (it drives one already-provisioned sandbox
+ * directly) but each of its branches must still get an `executions` row, or the
+ * fan-out silently loses resume, dedup and per-branch cost attribution — the
+ * exact price WP5 warned an in-agent fan-out would pay
+ * (`docs/plans/deterministic-pr-levers.md` §"Parked: parallel phases (WP5)").
+ */
+export declare function runLedgeredPhase(attrs: Record<string, unknown>, meta: {
+    dedupKey: string;
+    phaseName: string;
+    taskId: string;
+    triggerId: string;
+    /** BARE repo name + its account — the pair, never a qualified string. */
+    repo?: string;
+    owner?: string;
+    workflowRunId?: string;
+}, deps: LedgerDeps, run: (onSessionId: (sessionId: string) => void) => Promise<ExecutionResult>): Promise<RunPhaseResult>;
 /**
  * Run a single agent phase with DB-tracked deduplication. The dedup ledger
  * (`shouldRunPhase`) is the single source of truth for resume, so re-running
  * from the top skips completed phases here.
  */
-export declare function runPhase(workflowName: string, phaseName: string, taskId: string, triggerId: string, prompt: string, config: ExecutorConfig, deps: LedgerDeps, modelOverride?: string, workflowRunId?: string, githubAccess?: GitSandboxAccess, variantOverride?: string): Promise<RunPhaseResult>;
+export declare function runPhase(workflowName: string, phaseName: string, taskId: string, triggerId: string, prompt: string, config: ExecutorConfig, deps: AgentLedgerDeps, modelOverride?: string, workflowRunId?: string, githubAccess?: GitSandboxAccess, variantOverride?: string): Promise<RunPhaseResult>;
 /**
  * Run a single deterministic `bash`/`script` phase, sharing the agent phase's
  * dedup ledger + executions row so it appears (and dedups on resume) exactly
  * like an agent phase — just with `turns: 0` and no model cost.
  */
-export declare function runCommandPhase(workflowName: string, phaseName: string, taskId: string, triggerId: string, spec: CommandSpec, config: ExecutorConfig, deps: LedgerDeps, workflowRunId?: string, githubAccess?: GitSandboxAccess, timeoutSeconds?: number, sandboxEnv?: Record<string, string>): Promise<RunPhaseResult>;
+export declare function runCommandPhase(workflowName: string, phaseName: string, taskId: string, triggerId: string, spec: CommandSpec, config: ExecutorConfig, deps: AgentLedgerDeps, workflowRunId?: string, githubAccess?: GitSandboxAccess, timeoutSeconds?: number, sandboxEnv?: Record<string, string>): Promise<RunPhaseResult>;
 export declare class PhaseExecutor {
     private readonly run;
     private readonly reporter;
@@ -163,7 +210,7 @@ export declare class PhaseExecutor {
      * and the same renderers already know how to draw it.
      *
      * Two deliberate choices in the row:
-     *  - It bypasses `runPhaseLedger` (and so `shouldRunPhase`). A condition must
+     *  - It bypasses `runLedgeredPhase` (and so `shouldRunPhase`). A condition must
      *    be re-evaluated every time it is asked; a dedup hit that replayed a
      *    stale verdict against a workspace that has since changed is precisely
      *    the bug this row exists to expose.

package/dist/core/phase-executor.js

@@ -11,8 +11,12 @@ import { noopLogger } from "../ports/ports.js";
 /**
  * Reject shell commands containing mustache template markers to prevent
  * accidental template injection into until_bash values.
+ *
+ * Exported so app-registered {@link PhaseTypeHandler}s that run their own gates
+ * (the `fanout` handler's per-branch `until_bash`) enforce the identical rule
+ * rather than a second copy of it that drifts.
  */
-function validateShellCommand(cmd) {
+export function validateShellCommand(cmd) {
     if (cmd.includes("{{")) {
         throw new Error(`until_bash command rejected: contains template marker '{{'. Render templates before passing to shell.`);
     }
@@ -167,14 +171,22 @@ export function telemetryRepo(access) {
  * does the actual work and receives a session-id sink so the executions row can
  * be linked to its session jsonl mid-run. `shouldRunPhase` is the single source
  * of truth for resume — re-running from the top skips completed phases here.
+ *
+ * **Exported** so an app-registered {@link PhaseTypeHandler} can put its own
+ * units of work on the same ledger. That is what a `type: fanout` phase needs:
+ * it bypasses {@link AgentPort} (it drives one already-provisioned sandbox
+ * directly) but each of its branches must still get an `executions` row, or the
+ * fan-out silently loses resume, dedup and per-branch cost attribution — the
+ * exact price WP5 warned an in-agent fan-out would pay
+ * (`docs/plans/deterministic-pr-levers.md` §"Parked: parallel phases (WP5)").
  */
-async function runPhaseLedger(attrs, meta, deps, run) {
+export async function runLedgeredPhase(attrs, meta, deps, run) {
     const { dedupKey, phaseName, taskId, triggerId, repo, owner, workflowRunId } = meta;
     const { store: db, liveness, observability } = deps;
     const log = deps.logger ?? noopLogger;
     return observability.withSpan("lastlight.workflow.phase", attrs, async (span) => {
         if (db) {
-            const status = db.executions.shouldRunPhase(dedupKey, triggerId, workflowRunId);
+            const status = await db.executions.shouldRunPhase(dedupKey, triggerId, workflowRunId);
             if (status === "running") {
                 const alive = await isContainerAlive(liveness, taskId);
                 if (alive) {
@@ -183,7 +195,7 @@ async function runPhaseLedger(attrs, meta, deps, run) {
                     return { skipped: true, reason: "running" };
                 }
                 log.warn("phase container is dead", { phase: phaseName });
-                db.executions.markStaleAsFailed(dedupKey, triggerId, workflowRunId);
+                await db.executions.markStaleAsFailed(dedupKey, triggerId, workflowRunId);
             }
             else if (status === "done") {
                 log.debug("phase already completed", { phase: phaseName });
@@ -191,7 +203,7 @@ async function runPhaseLedger(attrs, meta, deps, run) {
                 return { skipped: true, reason: "done" };
             }
             const executionId = randomUUID();
-            db.executions.recordStart({
+            await db.executions.recordStart({
                 id: executionId,
                 triggerType: "webhook",
                 triggerId,
@@ -204,14 +216,17 @@ async function runPhaseLedger(attrs, meta, deps, run) {
             });
             try {
                 const result = await run((sessionId) => {
-                    try {
-                        db.executions.recordSessionId(executionId, sessionId);
-                    }
-                    catch (err) {
+                    // Deliberate fire-and-forget: this callback is invoked mid-stream
+                    // from a synchronous context that threads through the whole executor
+                    // stack, so it cannot be awaited. Best-effort by design — the id is
+                    // re-recorded when the phase finishes. Note the handler had to move
+                    // from `catch` to `.catch`: the write is a promise now, so a
+                    // surrounding try/catch would no longer see its rejection.
+                    void db.executions.recordSessionId(executionId, sessionId).catch((err) => {
                         log.warn("failed to persist session id mid-run", { phase: phaseName, err });
-                    }
+                    });
                 });
-                db.executions.recordFinish(executionId, {
+                await db.executions.recordFinish(executionId, {
                     success: result.success,
                     error: result.error,
                     turns: result.turns,
@@ -224,8 +239,8 @@ async function runPhaseLedger(attrs, meta, deps, run) {
                     outputTokens: result.outputTokens,
                     apiDurationMs: result.apiDurationMs,
                     stopReason: result.stopReason,
-                    extensionStatus: result.extensions ? JSON.stringify(result.extensions) : undefined,
-                    skillsStatus: result.skills ? JSON.stringify(result.skills) : undefined,
+                    extensionStatus: result.extensions,
+                    skillsStatus: result.skills,
                 });
                 span?.setAttributes({ success: result.success, stop_reason: result.stopReason ?? "unknown" });
                 observability.recordExecutionMetrics("phase", { ...attrs, success: result.success, stop_reason: result.stopReason, durationMs: result.durationMs, costUsd: result.costUsd, inputTokens: result.inputTokens, outputTokens: result.outputTokens });
@@ -239,7 +254,7 @@ async function runPhaseLedger(attrs, meta, deps, run) {
                 // CLI/dashboard instead of `✗`). The success path already finished the
                 // row and returned, so this only fires on a genuine throw — no
                 // double-finish.
-                db.executions.recordFinish(executionId, {
+                await db.executions.recordFinish(executionId, {
                     success: false,
                     error: err instanceof Error ? err.message : String(err),
                     stopReason: "error_fatal",
@@ -277,7 +292,7 @@ export async function runPhase(workflowName, phaseName, taskId, triggerId, promp
         ...phaseConfigBase,
         telemetry: { workflowName, phaseName, triggerId, workflowRunId },
     };
-    return runPhaseLedger(attrs, { dedupKey, phaseName, taskId, triggerId, repo: githubAccess?.repo, owner: githubAccess?.owner, workflowRunId }, deps, (onSessionId) => deps.agent.runAgent(prompt, phaseConfig, { taskId, githubAccess, onSessionId }));
+    return runLedgeredPhase(attrs, { dedupKey, phaseName, taskId, triggerId, repo: githubAccess?.repo, owner: githubAccess?.owner, workflowRunId }, deps, (onSessionId) => deps.agent.runAgent(prompt, phaseConfig, { taskId, githubAccess, onSessionId }));
 }
 /**
  * Run a single deterministic `bash`/`script` phase, sharing the agent phase's
@@ -299,7 +314,7 @@ export async function runCommandPhase(workflowName, phaseName, taskId, triggerId
         [OPENINFERENCE_SPAN_KIND]: OPENINFERENCE_CHAIN,
     };
     const phaseConfig = { ...config, telemetry: { workflowName, phaseName, triggerId, workflowRunId } };
-    return runPhaseLedger(attrs, { dedupKey, phaseName, taskId, triggerId, repo: githubAccess?.repo, owner: githubAccess?.owner, workflowRunId }, deps, (onSessionId) => deps.agent.runCommand(spec, phaseConfig, { taskId, githubAccess, onSessionId, timeoutSeconds, sandboxEnv }));
+    return runLedgeredPhase(attrs, { dedupKey, phaseName, taskId, triggerId, repo: githubAccess?.repo, owner: githubAccess?.owner, workflowRunId }, deps, (onSessionId) => deps.agent.runCommand(spec, phaseConfig, { taskId, githubAccess, onSessionId, timeoutSeconds, sandboxEnv }));
 }
 // ── PhaseExecutor ────────────────────────────────────────────────────────────
 const MAX_PREV_OUTPUT_BYTES = 10 * 1024; // cap accumulated generic-loop output at 10KB
@@ -362,7 +377,7 @@ export class PhaseExecutor {
         await this.reporter.onStart(phase.name);
         const result = { phase: phase.name, success: true, output: "Context assembled" };
         // Persist a phase_history entry so the dashboard marks context phases done.
-        this.reporter.persistPhase(phase.name, "Context assembled");
+        await this.reporter.persistPhase(phase.name, "Context assembled");
         await this.reporter.onEnd(phase.name, result);
         return { results: [result], status: "succeeded" };
     }
@@ -394,7 +409,7 @@ export class PhaseExecutor {
                 return { results: [], status: "failed", aborted: true };
             }
             const result = { phase: phaseName, success: true, output: "Already completed" };
-            this.reporter.persistPhase(phaseName, "Already completed (deduplicated)");
+            await this.reporter.persistPhase(phaseName, "Already completed (deduplicated)");
             await this.reporter.onEnd(phaseName, result);
             await this.reporter.step(phaseName, "done", phase.messages?.on_skipped_done);
             return { results: [result], status: "succeeded" };
@@ -409,7 +424,7 @@ export class PhaseExecutor {
             if (!isTerminated(pr.result.error)) {
                 await this.reporter.step(phaseName, "failed", phase.messages?.on_failure);
             }
-            this.reporter.failWorkflow(pr.result.error);
+            await this.reporter.failWorkflow(pr.result.error);
             return { results: [result], status: "failed", outputVars };
         }
         // on_output rules (BLOCKED).
@@ -432,7 +447,7 @@ export class PhaseExecutor {
             if (marker && !(pr.result.output ?? "").includes(marker)) {
                 const error = `phase produced no outcome — missing completion marker "${marker}"`;
                 await this.reporter.step(phaseName, "failed", phase.messages?.on_failure);
-                this.reporter.failWorkflow(error);
+                await this.reporter.failWorkflow(error);
                 const failResult = {
                     phase: phaseName,
                     success: false,
@@ -447,7 +462,7 @@ export class PhaseExecutor {
             await this.pauseForApproval(phaseName, phase.approval_gate, `${phaseName} complete — awaiting ${phase.approval_gate} approval.`, "approve", phase.approval_gate_message, { gateKey: phase.approval_gate }, undefined, phase.approval_artifact);
             return { results: [result], status: "succeeded", paused: true, outputVars };
         }
-        this.reporter.persistPhase(phaseName);
+        await this.reporter.persistPhase(phaseName);
         // Make THIS phase's own output available to its on_success message. The
         // scheduler only merges `outputVars` into the shared outputs map after
         // execute() returns, so without this a phase referencing its own output
@@ -478,7 +493,7 @@ export class PhaseExecutor {
                 return { results: [], status: "failed", aborted: true };
             }
             const result = { phase: phaseName, success: true, output: "Already completed" };
-            this.reporter.persistPhase(phaseName, "Already completed (deduplicated)");
+            await this.reporter.persistPhase(phaseName, "Already completed (deduplicated)");
             await this.reporter.onEnd(phaseName, result);
             await this.reporter.step(phaseName, "done", phase.messages?.on_skipped_done);
             return { results: [result], status: "succeeded" };
@@ -493,14 +508,14 @@ export class PhaseExecutor {
             if (!isTerminated(pr.result.error)) {
                 await this.reporter.step(phaseName, "failed", phase.messages?.on_failure);
             }
-            this.reporter.failWorkflow(pr.result.error);
+            await this.reporter.failWorkflow(pr.result.error);
             return { results: [result], status: "failed", outputVars };
         }
         if (phase.approval_gate && this.resolver.gateEnabled(phase.approval_gate) && this.run.store && this.run.workflowId) {
             await this.pauseForApproval(phaseName, phase.approval_gate, `${phaseName} complete — awaiting ${phase.approval_gate} approval.`, "approve", phase.approval_gate_message, { gateKey: phase.approval_gate }, undefined, phase.approval_artifact);
             return { results: [result], status: "succeeded", paused: true, outputVars };
         }
-        this.reporter.persistPhase(phaseName);
+        await this.reporter.persistPhase(phaseName);
         await this.reporter.step(phaseName, "done", phase.messages?.on_success, {
             phaseOutputs: { ...outputs, ...outputVars },
         });
@@ -548,7 +563,7 @@ export class PhaseExecutor {
      * and the same renderers already know how to draw it.
      *
      * Two deliberate choices in the row:
-     *  - It bypasses `runPhaseLedger` (and so `shouldRunPhase`). A condition must
+     *  - It bypasses `runLedgeredPhase` (and so `shouldRunPhase`). A condition must
      *    be re-evaluated every time it is asked; a dedup hit that replayed a
      *    stale verdict against a workspace that has since changed is precisely
      *    the bug this row exists to expose.
@@ -565,7 +580,7 @@ export class PhaseExecutor {
         const executionId = db ? randomUUID() : undefined;
         if (db && executionId) {
             try {
-                db.executions.recordStart({
+                await db.executions.recordStart({
                     id: executionId,
                     triggerType: "webhook",
                     triggerId,
@@ -600,7 +615,7 @@ export class PhaseExecutor {
         }
         if (db && executionId) {
             try {
-                db.executions.recordFinish(executionId, {
+                await db.executions.recordFinish(executionId, {
                     success: error === undefined,
                     error,
                     turns: 0,
@@ -613,7 +628,7 @@ export class PhaseExecutor {
                 // Nothing renders `output_text` today (it backs the scratch
                 // `lastOutputExecutionId` indirection); it is queryable on the row, and
                 // it is the column any future surface would read.
-                db.executions.recordOutputText(executionId, `$ ${command}\n\n${output.length > MAX_UNTIL_OUTPUT_BYTES ? output.slice(-MAX_UNTIL_OUTPUT_BYTES) : output}`);
+                await db.executions.recordOutputText(executionId, `$ ${command}\n\n${output.length > MAX_UNTIL_OUTPUT_BYTES ? output.slice(-MAX_UNTIL_OUTPUT_BYTES) : output}`);
             }
             catch (err) {
                 log.warn("Failed to finish until_bash check row", { label, err });
@@ -652,8 +667,8 @@ export class PhaseExecutor {
             return "continue";
         }
         if (rule.action === "fail") {
-            this.run.store?.executions.markLatestAsFailed(`${this.run.definition.name}:${phase.name}`, this.run.triggerId, rule.message || "BLOCKED", this.run.workflowId);
-            this.reporter.failWorkflow(rule.message || "BLOCKED");
+            await this.run.store?.executions.markLatestAsFailed(`${this.run.definition.name}:${phase.name}`, this.run.triggerId, rule.message || "BLOCKED", this.run.workflowId);
+            await this.reporter.failWorkflow(rule.message || "BLOCKED");
             const blockedTemplate = rule.message || phase.messages?.on_blocked;
             if (blockedTemplate)
                 await this.reporter.step(phase.name, "blocked", blockedTemplate);
@@ -673,7 +688,7 @@ export class PhaseExecutor {
         if (!db || !workflowId)
             return;
         const approvalId = randomUUID();
-        db.runs.pauseForApproval(workflowId, {
+        await db.runs.pauseForApproval(workflowId, {
             id: approvalId,
             workflowRunId: workflowId,
             gate,
@@ -739,7 +754,7 @@ export class PhaseExecutor {
                     await this.reporter.message(phase.messages?.on_skipped_done);
                     return { results, status: "failed", aborted: true };
                 }
-                const prevOutput = db?.executions.getPhaseOutput(`${wf}:${reviewLabel}`, triggerId, workflowId) ?? "";
+                const prevOutput = (await db?.executions.getPhaseOutput(`${wf}:${reviewLabel}`, triggerId, workflowId)) ?? "";
                 verdict = parseReviewerVerdict(prevOutput).verdict;
                 results.push({ phase: reviewLabel, success: true, output: "Already completed" });
             }
@@ -789,26 +804,26 @@ export class PhaseExecutor {
                     : `VERDICT: ${verdict}\n${reviewerOutput}`;
                 const execId = "executionId" in rr ? rr.executionId : undefined;
                 if (execId && db)
-                    db.executions.recordOutputText(execId, persistText);
+                    await db.executions.recordOutputText(execId, persistText);
             }
             const isApproved = verdict === "APPROVED";
             if (isApproved) {
                 approved = true;
                 if (reviewRan)
-                    this.reporter.persistPhase(reviewLabel, "APPROVED");
+                    await this.reporter.persistPhase(reviewLabel, "APPROVED");
                 await this.reporter.step(reviewLabel, "done", loop.messages?.on_approved, { cycle: fixCycles + 1 });
             }
             else if (fixCycles < MAX_CYCLES) {
                 fixCycles++;
                 if (reviewRan)
-                    this.reporter.persistPhase(reviewLabel, "REQUEST_CHANGES");
+                    await this.reporter.persistPhase(reviewLabel, "REQUEST_CHANGES");
                 // Approval gate before the fix loop. Pause only on a *fresh* gate hit:
                 // not when the fix for this cycle has already run (gate was approved in
                 // a prior entry), and not when we're resuming right after approving
                 // exactly this cycle's gate.
                 if (this.resolver.gateEnabled(loop.approval_gate) && db && workflowId) {
                     const fixLabel = PhaseRef.fix(phaseName, fixCycles).format();
-                    const fixAlreadyDone = db.executions.shouldRunPhase(`${wf}:${fixLabel}`, triggerId, workflowId) === "done";
+                    const fixAlreadyDone = (await db.executions.shouldRunPhase(`${wf}:${fixLabel}`, triggerId, workflowId)) === "done";
                     const resumingThisGate = pausedAtCycle === fixCycles;
                     if (!fixAlreadyDone && !resumingThisGate) {
                         scratch[loopKey] = { ...slot, pausedAtCycle: fixCycles };
@@ -849,12 +864,12 @@ export class PhaseExecutor {
                         }
                         break;
                     }
-                    this.reporter.persistPhase(fixLabel);
+                    await this.reporter.persistPhase(fixLabel);
                     await this.reporter.step(fixLabel, "done");
                 }
             }
             else {
-                this.reporter.persistPhase(reviewLabel, "REQUEST_CHANGES — max cycles reached");
+                await this.reporter.persistPhase(reviewLabel, "REQUEST_CHANGES — max cycles reached");
                 await this.reporter.step(reviewLabel, "blocked", loop.messages?.on_max_cycles, {
                     cycle: fixCycles,
                     maxCycles: MAX_CYCLES,
@@ -889,9 +904,9 @@ export class PhaseExecutor {
             : 0;
         let iteration = resumeFromIter;
         let complete = false;
-        let previousOutput = (scratchSlot.lastOutputExecutionId && db
-            ? db.executions.getExecutionOutput(scratchSlot.lastOutputExecutionId) ?? ""
-            : scratchSlot.lastOutput ?? "");
+        let previousOutput = scratchSlot.lastOutputExecutionId && db
+            ? ((await db.executions.getExecutionOutput(scratchSlot.lastOutputExecutionId)) ?? "")
+            : (scratchSlot.lastOutput ?? "");
         // The LAST iteration's raw output — what the phase signs off with, and so
         // what the `on_output.requires_marker` postcondition is checked against
         // below. `previousOutput` can't stand in: it's the accumulated, truncated
@@ -964,10 +979,10 @@ export class PhaseExecutor {
                     if (iterExecutionId)
                         slot.lastOutputExecutionId = iterExecutionId;
                     delete slot.lastOutput;
-                    db.runs.mergeScratch(workflowId, { [scratchKey]: slot });
+                    await db.runs.mergeScratch(workflowId, { [scratchKey]: slot });
                     scratch[scratchKey] = slot;
                 }
-                this.reporter.persistPhase(iterLabel, `iteration ${iteration} — soft outcome, advancing`);
+                await this.reporter.persistPhase(iterLabel, `iteration ${iteration} — soft outcome, advancing`);
                 await this.reporter.step(phaseName, "done");
                 break;
             }
@@ -977,7 +992,7 @@ export class PhaseExecutor {
                 if (!isTerminated(ir.result.error)) {
                     await this.reporter.step(phaseName, "failed", phase.messages?.on_failure, { iteration });
                 }
-                this.reporter.failWorkflow(ir.result.error);
+                await this.reporter.failWorkflow(ir.result.error);
                 const outputVars = phase.output_var
                     ? { [phase.output_var]: { completed: false, iterations: iteration } }
                     : undefined;
@@ -1013,8 +1028,8 @@ export class PhaseExecutor {
             // summary it shows and the summary the pipeline shows agree.
             const iterExecutionId = "executionId" in ir ? ir.executionId : undefined;
             if (iterExecutionId && db)
-                db.executions.recordOutputText(iterExecutionId, iterOutput);
-            this.reporter.persistPhase(iterLabel, `iteration ${iteration} — work complete`);
+                await db.executions.recordOutputText(iterExecutionId, iterOutput);
+            await this.reporter.persistPhase(iterLabel, `iteration ${iteration} — work complete`);
             let conditionMet = false;
             if (loop.until) {
                 conditionMet = evalUntilExpression(loop.until, {
@@ -1035,10 +1050,10 @@ export class PhaseExecutor {
                     if (iterExecutionId)
                         slot.lastOutputExecutionId = iterExecutionId;
                     delete slot.lastOutput;
-                    db.runs.mergeScratch(workflowId, { [scratchKey]: slot });
+                    await db.runs.mergeScratch(workflowId, { [scratchKey]: slot });
                     scratch[scratchKey] = slot;
                 }
-                this.reporter.persistPhase(iterLabel, `iteration ${iteration} — condition met`);
+                await this.reporter.persistPhase(iterLabel, `iteration ${iteration} — condition met`);
                 await this.reporter.step(phaseName, "done", phase.messages?.on_success, {
                     iteration,
                     maxIterations: MAX_ITER,
@@ -1066,7 +1081,7 @@ export class PhaseExecutor {
                 const approvalId = randomUUID();
                 // One transaction: persist the iteration scratch, create the pending
                 // gate, append the waiting_approval marker, and pause the run.
-                db.runs.pauseForApproval(workflowId, {
+                await db.runs.pauseForApproval(workflowId, {
                     id: approvalId,
                     workflowRunId: workflowId,
                     gate: iterLabel,
@@ -1124,7 +1139,7 @@ export class PhaseExecutor {
                 iteration,
                 maxIterations: MAX_ITER,
             });
-            this.reporter.failWorkflow(error);
+            await this.reporter.failWorkflow(error);
             results.push({ phase: phaseName, success: false, output: lastIterOutput, error });
             return { results, status: "failed", outputVars };
         }