@bastani/atomic 0.9.28-alpha.1 → 0.9.28-alpha.2

package/dist/builtin/workflows/builtin/{chunk-wz8v67bn.js → chunk-aqv8ny38.js}

@@ -35,10 +35,9 @@ import {
   contradictedStopReviewLoopGap,
   consolidateFindingsBatch,
   parseFailureDiagnostics,
-  reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-tecnpe8j.js";
+} from "./chunk-p3xmajmj.js";
 import {
   VERIFICATION_SCALE
 } from "./chunk-n1910xc4.js";
@@ -52,6 +51,12 @@ import { Type as Type2 } from "typebox";
 // dist/builtin/workflows/builtin/goal-runner.ts
 import { join as join3 } from "node:path";
 
+// dist/builtin/workflows/src/runs/foreground/stage-runner-structured-output.ts
+import { createStructuredOutputTool } from "@bastani/atomic";
+function isWorkflowStructuredOutputContractError(error) {
+  return error instanceof Error && "code" in error && error.code === "ATOMIC_WORKFLOW_STRUCTURED_OUTPUT_CONTRACT";
+}
+
 // dist/builtin/workflows/builtin/goal-schemas.ts
 import { Type } from "typebox";
 var reviewFindingSchema = Type.Object({
@@ -163,100 +168,7 @@ async function writeReviewRoundArtifact(artifactDir, reviews, consolidatedFindin
 import { randomUUID } from "node:crypto";
 import { readFile, rename, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
-var LEDGER_STATE_FILENAME = "goal-ledger-state.json";
-function withoutTurn2(value) {
-  const copy = { ...value };
-  delete copy.turn;
-  return copy;
-}
-function modelVisibleLedger(ledger) {
-  return {
-    goal_id: ledger.goal_id,
-    objective: ledger.objective,
-    acceptance_criteria: ledger.acceptance_criteria,
-    status: ledger.status,
-    created_at: ledger.created_at,
-    updated_at: ledger.updated_at,
-    receipts: ledger.receipts.map(withoutTurn2),
-    reviews: ledger.reviews.map(withoutTurn2),
-    blockers: ledger.blockers.map(withoutTurn2),
-    decisions: ledger.decisions.map(withoutTurn2),
-    lifecycle: ledger.lifecycle.map(withoutTurn2),
-    reverification: ledger.reverification ?? [],
-    convergence: ledger.convergence ?? []
-  };
-}
-function goalLedgerStatePath(ledgerPath) {
-  return join2(dirname(ledgerPath), LEDGER_STATE_FILENAME);
-}
-function appendLifecycleEvent(ledger, event, summary, turn = ledger.turns) {
-  ledger.lifecycle.push({
-    turn,
-    event,
-    status: ledger.status,
-    at: new Date().toISOString(),
-    summary
-  });
-}
-async function readExistingGoalLedger(ledgerPath) {
-  let contents;
-  try {
-    contents = await readFile(goalLedgerStatePath(ledgerPath), "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return;
-    throw error;
-  }
-  try {
-    return JSON.parse(contents);
-  } catch {
-    return;
-  }
-}
-async function createGoalLedger(objective, acceptanceCriteria, artifactDir) {
-  const ledgerPath = join2(artifactDir, LEDGER_FILENAME);
-  const existing = await readExistingGoalLedger(ledgerPath);
-  if (existing !== undefined)
-    return { ledger: existing, ledgerPath, artifactDir };
-  const goalId = randomUUID();
-  const now = new Date().toISOString();
-  const ledger = {
-    goal_id: goalId,
-    objective,
-    acceptance_criteria: acceptanceCriteria,
-    status: "active",
-    turns: 0,
-    created_at: now,
-    updated_at: now,
-    receipts: [],
-    reviews: [],
-    blockers: [],
-    decisions: [],
-    lifecycle: [],
-    reverification: [],
-    convergence: []
-  };
-  appendLifecycleEvent(ledger, "created", "Goal created.", 0);
-  await writeGoalLedger(ledgerPath, ledger);
-  return { ledger, ledgerPath, artifactDir };
-}
-async function writeGoalLedger(ledgerPath, ledger) {
-  ledger.updated_at = new Date().toISOString();
-  const visibleContents = `${JSON.stringify(modelVisibleLedger(ledger), null, 2)}
-`;
-  const stateContents = `${JSON.stringify(ledger, null, 2)}
-`;
-  const statePath = goalLedgerStatePath(ledgerPath);
-  const pendingStatePath = `${statePath}.${randomUUID()}.tmp`;
-  await writeFile2(pendingStatePath, stateContents, { encoding: "utf8" });
-  try {
-    await rename(pendingStatePath, statePath);
-  } catch (error) {
-    await rm(pendingStatePath, { force: true });
-    throw error;
-  }
-  await writeFile2(ledgerPath, visibleContents, { encoding: "utf8" });
-}
+import { isDeepStrictEqual } from "node:util";
 
 // dist/builtin/workflows/builtin/goal-reducer.ts
 function reducerSummary(reviews, approved, nextAction) {
@@ -379,70 +291,6 @@ function reduceGoalDecision(ledger, turnReviews, options) {
   };
 }
 
-// dist/builtin/workflows/builtin/goal-reports.ts
-function formatReviewReport(reviews) {
-  if (reviews.length === 0)
-    return "No reviewer decisions were recorded.";
-  return reviews.map((review) => [
-    `### ${review.reviewer}`,
-    "",
-    `Decision: ${review.decision}`,
-    `Artifact: ${review.artifact_path}`,
-    `Verification remaining: ${review.verification_remaining}`,
-    "Finding alignment warning: beyond_objective and contradicts_objective findings are non-blocking and must not be folded into follow-up objectives without checking them against the acceptance criteria.",
-    review.findings.length === 0 ? "Findings: none" : [
-      "Findings:",
-      ...review.findings.map((finding) => `- ${finding.objective_alignment}: ${finding.title}`)
-    ].join(`
-`),
-    review.requirements_traceability.length === 0 ? "Requirements traceability: none" : [
-      "Requirements traceability:",
-      ...review.requirements_traceability.map((entry) => `- ${entry.status}: ${entry.requirement} — ${entry.evidence}`)
-    ].join(`
-`)
-  ].join(`
-`)).join(`
-
----
-
-`);
-}
-function renderFinalReport(ledger, ledgerPath, remainingWork) {
-  const receiptLines = ledger.receipts.length > 0 ? ledger.receipts.map((receipt) => `- ${receipt.summary} (artifact: ${receipt.artifact_path})`) : ["- No receipts captured."];
-  const lastDecision = ledger.decisions.at(-1);
-  return [
-    "# Goal Run Final Report",
-    "",
-    "## Goal ID",
-    ledger.goal_id,
-    "",
-    "## Objective",
-    ledger.objective,
-    "",
-    "## Acceptance criteria",
-    ledger.acceptance_criteria,
-    "",
-    "## Final status",
-    ledger.status,
-    "",
-    "## Ledger artifact",
-    ledgerPath,
-    "",
-    "## Evidence and receipts",
-    ...receiptLines,
-    "",
-    "## Final decision",
-    lastDecision?.reason ?? "No reducer decision was recorded.",
-    "",
-    "## Objective-alignment warning",
-    "Review findings classified beyond_objective or contradicts_objective are non-blocking and must not be promoted into follow-up objectives without checking them against the acceptance criteria.",
-    "",
-    "## Remaining work if incomplete",
-    ledger.status === "complete" ? "none" : remainingWork
-  ].join(`
-`);
-}
-
 // dist/builtin/workflows/builtin/goal-review.ts
 function reviewDecisionFromResult(result) {
   return result.structured;
@@ -532,6 +380,225 @@ function reviewDecisionToRecord(args) {
   };
 }
 
+// dist/builtin/workflows/builtin/goal-ledger.ts
+var LEDGER_STATE_FILENAME = "goal-ledger-state.json";
+function withoutTurn2(value) {
+  const copy = { ...value };
+  delete copy.turn;
+  return copy;
+}
+function modelVisibleLedger(ledger) {
+  return {
+    goal_id: ledger.goal_id,
+    objective: ledger.objective,
+    acceptance_criteria: ledger.acceptance_criteria,
+    status: ledger.status,
+    created_at: ledger.created_at,
+    updated_at: ledger.updated_at,
+    receipts: ledger.receipts.map(withoutTurn2),
+    reviews: ledger.reviews.map(withoutTurn2),
+    blockers: ledger.blockers.map(withoutTurn2),
+    decisions: ledger.decisions.map(withoutTurn2),
+    lifecycle: ledger.lifecycle.map(withoutTurn2),
+    reverification: ledger.reverification ?? [],
+    convergence: ledger.convergence ?? []
+  };
+}
+function goalLedgerStatePath(ledgerPath) {
+  return join2(dirname(ledgerPath), LEDGER_STATE_FILENAME);
+}
+function appendLifecycleEvent(ledger, event, summary, turn = ledger.turns) {
+  ledger.lifecycle.push({
+    turn,
+    event,
+    status: ledger.status,
+    at: new Date().toISOString(),
+    summary
+  });
+}
+async function readExistingGoalLedger(ledgerPath) {
+  let contents;
+  try {
+    contents = await readFile(goalLedgerStatePath(ledgerPath), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  try {
+    return JSON.parse(contents);
+  } catch {
+    return;
+  }
+}
+function isLegacyDatabaseInterruption(diagnostic) {
+  const failure = diagnostic.replace(/^(?:Orchestrator failed before producing a receipt|Reviewer execution failed before producing a decision|Reviewer execution failed while resolving its reads contract): /u, "");
+  return [
+    "Workflow database unavailable",
+    "Workflow database checkpoint timed out",
+    "Workflow database ownership generation changed",
+    "Managed PostgreSQL did not answer a health check in time",
+    "Managed PostgreSQL failed its live health check",
+    "managed PostgreSQL health-check failed",
+    "durable checkpoint timeout",
+    "lost DB connection"
+  ].some((prefix) => failure === prefix || failure.startsWith(`${prefix}.`) || failure.startsWith(`${prefix}:`) || failure.startsWith(`${prefix} `));
+}
+function recoverLegacyExecutionInterruption(ledger) {
+  const decision = ledger.decisions.at(-1);
+  const event = ledger.lifecycle.at(-1);
+  if (ledger.status !== "needs_human" || decision === undefined || event === undefined || decision.turn !== ledger.turns || !Number.isInteger(decision.turn) || decision.turn < 1 || decision.decision !== "needs_human" || decision.parsed !== false || decision.approved !== false || decision.stopReviewLoop !== false || decision.nextAction !== "needs_human" || decision.finalActionRemaining !== false || decision.complete_votes !== 0 || decision.review_quorum !== DEFAULT_REVIEW_QUORUM || decision.blocker !== undefined || event.event !== "status_decided" || event.status !== "needs_human" || event.turn !== decision.turn || event.summary !== decision.reason || ledger.decisions.slice(0, -1).some((record) => record.turn >= decision.turn || record.decision !== "continue") || ledger.lifecycle.slice(0, -1).some((record) => record.turn > decision.turn || record.turn === decision.turn && record.event === "status_decided") || ledger.blockers.some((record) => record.turn >= decision.turn)) {
+    return false;
+  }
+  const diagnostic = decision.diagnostics[0];
+  if (decision.diagnostics.length !== 1 || diagnostic === undefined)
+    return false;
+  if (!isLegacyDatabaseInterruption(diagnostic))
+    return false;
+  const turnReviews = ledger.reviews.filter((record) => record.turn >= decision.turn);
+  const turnReceipts = ledger.receipts.filter((record) => record.turn >= decision.turn);
+  const previousEvent = ledger.lifecycle.at(-2);
+  const orchestratorInterrupted = diagnostic.startsWith("Orchestrator failed before producing a receipt: ") && decision.reason === [diagnostic, ...convergence_escalation_evidence(ledger.convergence ?? [])].join(`
+`) && turnReceipts.length === 0 && turnReviews.length === 0 && previousEvent?.event === "work_turn_started" && previousEvent.turn === decision.turn && previousEvent.status === "active" && previousEvent.summary === "Orchestrator started.";
+  const review = turnReviews[0];
+  const reviewerInterrupted = (diagnostic.startsWith("Reviewer execution failed before producing a decision: ") || diagnostic.startsWith("Reviewer execution failed while resolving its reads contract: ")) && turnReviews.length === 1 && review !== undefined && turnReceipts.length === 1 && turnReceipts[0]?.turn === decision.turn && previousEvent?.event === "reviews_recorded" && previousEvent.turn === decision.turn && previousEvent.status === "active" && previousEvent.summary === "Recorded 1 reviewer decisions." && isDeepStrictEqual(review, reviewDecisionToRecord({
+    turn: decision.turn,
+    reviewer: "reviewer-error",
+    artifactPath: review.artifact_path,
+    decision: reviewerErrorDecision(diagnostic),
+    parsed: false,
+    diagnostics: [diagnostic],
+    allowFinalActionRemaining: false
+  })) && decision.reason === [
+    `Reviewer execution failed before quorum could be established. Remaining work: ${collectRemainingWork([review])}`,
+    ...convergence_escalation_evidence(ledger.convergence ?? [])
+  ].join(`
+`);
+  if (!orchestratorInterrupted && !reviewerInterrupted)
+    return false;
+  ledger.decisions.pop();
+  ledger.lifecycle.pop();
+  if (reviewerInterrupted) {
+    ledger.reviews = ledger.reviews.filter((record) => record !== review);
+    ledger.lifecycle.pop();
+  } else {
+    ledger.turns = Math.max(0, ...ledger.decisions.map((record) => record.turn));
+  }
+  ledger.status = "active";
+  return true;
+}
+async function createGoalLedger(objective, acceptanceCriteria, artifactDir) {
+  const ledgerPath = join2(artifactDir, LEDGER_FILENAME);
+  const existing = await readExistingGoalLedger(ledgerPath);
+  if (existing !== undefined) {
+    if (recoverLegacyExecutionInterruption(existing))
+      await writeGoalLedger(ledgerPath, existing);
+    return { ledger: existing, ledgerPath, artifactDir };
+  }
+  const goalId = randomUUID();
+  const now = new Date().toISOString();
+  const ledger = {
+    goal_id: goalId,
+    objective,
+    acceptance_criteria: acceptanceCriteria,
+    status: "active",
+    turns: 0,
+    created_at: now,
+    updated_at: now,
+    receipts: [],
+    reviews: [],
+    blockers: [],
+    decisions: [],
+    lifecycle: [],
+    reverification: [],
+    convergence: []
+  };
+  appendLifecycleEvent(ledger, "created", "Goal created.", 0);
+  await writeGoalLedger(ledgerPath, ledger);
+  return { ledger, ledgerPath, artifactDir };
+}
+async function writeGoalLedger(ledgerPath, ledger) {
+  ledger.updated_at = new Date().toISOString();
+  const visibleContents = `${JSON.stringify(modelVisibleLedger(ledger), null, 2)}
+`;
+  const stateContents = `${JSON.stringify(ledger, null, 2)}
+`;
+  const statePath = goalLedgerStatePath(ledgerPath);
+  const pendingStatePath = `${statePath}.${randomUUID()}.tmp`;
+  await writeFile2(pendingStatePath, stateContents, { encoding: "utf8" });
+  try {
+    await rename(pendingStatePath, statePath);
+  } catch (error) {
+    await rm(pendingStatePath, { force: true });
+    throw error;
+  }
+  await writeFile2(ledgerPath, visibleContents, { encoding: "utf8" });
+}
+
+// dist/builtin/workflows/builtin/goal-reports.ts
+function formatReviewReport(reviews) {
+  if (reviews.length === 0)
+    return "No reviewer decisions were recorded.";
+  return reviews.map((review) => [
+    `### ${review.reviewer}`,
+    "",
+    `Decision: ${review.decision}`,
+    `Artifact: ${review.artifact_path}`,
+    `Verification remaining: ${review.verification_remaining}`,
+    "Finding alignment warning: beyond_objective and contradicts_objective findings are non-blocking and must not be folded into follow-up objectives without checking them against the acceptance criteria.",
+    review.findings.length === 0 ? "Findings: none" : [
+      "Findings:",
+      ...review.findings.map((finding) => `- ${finding.objective_alignment}: ${finding.title}`)
+    ].join(`
+`),
+    review.requirements_traceability.length === 0 ? "Requirements traceability: none" : [
+      "Requirements traceability:",
+      ...review.requirements_traceability.map((entry) => `- ${entry.status}: ${entry.requirement} — ${entry.evidence}`)
+    ].join(`
+`)
+  ].join(`
+`)).join(`
+
+---
+
+`);
+}
+function renderFinalReport(ledger, ledgerPath, remainingWork) {
+  const receiptLines = ledger.receipts.length > 0 ? ledger.receipts.map((receipt) => `- ${receipt.summary} (artifact: ${receipt.artifact_path})`) : ["- No receipts captured."];
+  const lastDecision = ledger.decisions.at(-1);
+  return [
+    "# Goal Run Final Report",
+    "",
+    "## Goal ID",
+    ledger.goal_id,
+    "",
+    "## Objective",
+    ledger.objective,
+    "",
+    "## Acceptance criteria",
+    ledger.acceptance_criteria,
+    "",
+    "## Final status",
+    ledger.status,
+    "",
+    "## Ledger artifact",
+    ledgerPath,
+    "",
+    "## Evidence and receipts",
+    ...receiptLines,
+    "",
+    "## Final decision",
+    lastDecision?.reason ?? "No reducer decision was recorded.",
+    "",
+    "## Objective-alignment warning",
+    "Review findings classified beyond_objective or contradicts_objective are non-blocking and must not be promoted into follow-up objectives without checking them against the acceptance criteria.",
+    "",
+    "## Remaining work if incomplete",
+    ledger.status === "complete" ? "none" : remainingWork
+  ].join(`
+`);
+}
+
 // dist/builtin/workflows/builtin/goal-prompts.ts
 var GOAL_CONTINUATION_REFERENCE = [
   "Continuation and completion:",
@@ -776,23 +843,6 @@ async function createGoalArtifactDirectory(ctx) {
   const artifactDir = await ctx.tool("artifact-root", { workflow: "goal" }, async () => workflowArtifactDirectoryPath(ctx.runId));
   return ensureWorkflowArtifactDirectory(artifactDir);
 }
-function reviewerExecutionFailedDecision(input) {
-  const evidence = convergence_escalation_evidence(input.convergence ?? []);
-  return {
-    turn: input.turn,
-    decision: "needs_human",
-    reason: [input.reason, ...evidence].join(`
-`),
-    complete_votes: input.reviews.filter((review) => review.decision === "complete").length,
-    review_quorum: input.reviewQuorum,
-    parsed: input.reviews.every((review) => review.parsed),
-    approved: false,
-    stopReviewLoop: false,
-    nextAction: "needs_human",
-    finalActionRemaining: false,
-    diagnostics: input.reviews.flatMap((review) => review.parse_diagnostics)
-  };
-}
 async function runGoalWorkflow(ctx, options) {
   const inputs = ctx.inputs;
   const createPr = options.createPr;
@@ -812,12 +862,13 @@ async function runGoalWorkflow(ctx, options) {
   let latestReviews = [];
   let latestReviewArtifactPaths = [];
   let latestReviewReportPath;
-  let terminalRemainingWork;
   let previousOrchestratorSessionFile;
-  const recordedTurns = ledger.turns;
-  for (let turn = 1;turn <= maxTurns && (ledger.status === "active" || turn <= recordedTurns); turn += 1) {
-    const replayingRecordedTurn = turn <= recordedTurns;
-    if (!replayingRecordedTurn) {
+  const recordedTurns = new Set(ledger.decisions.map((decision) => decision.turn));
+  const lastRecordedTurn = Math.max(0, ...recordedTurns);
+  for (let turn = 1;turn <= maxTurns && (ledger.status === "active" || turn <= lastRecordedTurn); turn += 1) {
+    const replayingRecordedTurn = recordedTurns.has(turn);
+    const turnAlreadyStarted = ledger.lifecycle.some((event) => event.turn === turn && event.event === "work_turn_started");
+    if (!replayingRecordedTurn && !turnAlreadyStarted) {
       appendLifecycleEvent(ledger, "work_turn_started", "Orchestrator started.", turn);
       await writeGoalLedger(ledgerPath, ledger);
     }
@@ -830,44 +881,14 @@ async function runGoalWorkflow(ctx, options) {
       latestReviewArtifactPaths,
       workflowStartCwd
     }) : renderForkedGoalOrchestratorPrompt(ledger, ledgerPath, latestReviewArtifactPaths);
-    let orchestrator;
-    try {
-      orchestrator = await ctx.task(`orchestrator-${turn}`, {
-        prompt: orchestratorPrompt,
-        reads: [ledgerPath, ...latestReviewArtifactPaths],
-        output: orchestratorReceiptPath,
-        outputMode: "file-only",
-        ...orchestratorModelConfig,
-        ...orchestratorForkOptions
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const baseReason = `Orchestrator failed before producing a receipt: ${message}`;
-      terminalRemainingWork = baseReason;
-      const reason = [baseReason, ...convergence_escalation_evidence(ledger.convergence ?? [])].join(`
-`);
-      latestReviews = [];
-      latestReviewArtifactPaths = [];
-      latestReviewReportPath = undefined;
-      ledger.turns = Math.max(ledger.turns, turn);
-      ledger.status = "needs_human";
-      ledger.decisions.push({
-        turn,
-        decision: "needs_human",
-        reason,
-        complete_votes: 0,
-        review_quorum: reviewQuorum,
-        parsed: false,
-        approved: false,
-        stopReviewLoop: false,
-        nextAction: "needs_human",
-        finalActionRemaining: false,
-        diagnostics: [baseReason]
-      });
-      appendLifecycleEvent(ledger, "status_decided", reason, turn);
-      await writeGoalLedger(ledgerPath, ledger);
-      break;
-    }
+    const orchestrator = await ctx.task(`orchestrator-${turn}`, {
+      prompt: orchestratorPrompt,
+      reads: [ledgerPath, ...latestReviewArtifactPaths],
+      output: orchestratorReceiptPath,
+      outputMode: "file-only",
+      ...orchestratorModelConfig,
+      ...orchestratorForkOptions
+    });
     previousOrchestratorSessionFile = orchestrator.sessionFile;
     if (!replayingRecordedTurn) {
       ledger.turns = turn;
@@ -905,34 +926,23 @@ async function runGoalWorkflow(ctx, options) {
       reviewerStep(`risk-reviewer-${turn}`, "Risk Reviewer: owns adversarial boundary checks across transition matrices, configuration precedence, feature-flag coupling, permissive inputs, and over-implementation.", "Probe state transitions, configuration paths and precedence, low-level API behavior across feature flags, and contract-permitted edge inputs. Also hunt for regressions, scope shrinkage, repository convention violations, unsafe assumptions, and blockers that are real repeated impasses rather than ordinary remaining work.")
     ];
     let reviewResults;
-    let reviewerBatchFailed = false;
-    let reviewerExecutionDiagnostic;
+    let reviewerContractError;
     try {
       reviewResults = await ctx.parallel(reviewerSteps, {
         task: objective,
         failFast: true,
         group: `goal-reviewers-turn-${turn}`
       });
-    } catch (err) {
-      reviewerBatchFailed = true;
-      const failure = reviewerFailureText(err);
-      reviewerExecutionDiagnostic = failure.includes("referenced artifact does not exist") ? `Reviewer execution failed while resolving its reads contract: ${failure}` : `Reviewer execution failed before producing a decision: ${failure}`;
-      reviewResults = [
-        {
-          name: "reviewer-error",
-          stageName: "reviewer-error",
-          text: failure
-        }
-      ];
+    } catch (error) {
+      if (!isWorkflowStructuredOutputContractError(error))
+        throw error;
+      reviewerContractError = error;
+      reviewResults = [{ name: "reviewer-error", stageName: "reviewer-error", text: error.message }];
     }
     latestReviews = await Promise.all(reviewResults.map(async (result) => {
       const reviewerName = result.name ?? result.stageName;
       const normalizedReviewerName = reviewerName.replace(/-\d+$/u, "");
-      const parsed = reviewerBatchFailed ? {
-        decision: reviewerErrorDecision(reviewerExecutionDiagnostic ?? "Reviewer execution failed."),
-        parsed: false,
-        diagnostics: [reviewerExecutionDiagnostic ?? "Reviewer execution failed."]
-      } : parsedReviewDecisionFromResult(result, reviewerName);
+      const parsed = reviewerContractError === undefined ? parsedReviewDecisionFromResult(result, reviewerName) : { decision: reviewerErrorDecision(reviewerContractError.message), parsed: false, diagnostics: [reviewerContractError.message] };
       const reviewArtifactPath = join3(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
       const record = reviewDecisionToRecord({
         turn,
@@ -974,7 +984,7 @@ async function runGoalWorkflow(ctx, options) {
     const findings = latestReviews.flatMap((review) => review.findings);
     const traceability = latestReviews.flatMap((review) => review.requirements_traceability);
     ledger.convergence ??= [];
-    if (!replayingRecordedTurn && !reviewerBatchFailed && roundProducedDecisions) {
+    if (!replayingRecordedTurn && roundProducedDecisions) {
       ledger.convergence.push(record_convergence({
         unresolvedBlockingCount: reverified.batch.filter((entry) => entry.blocking).length,
         meanFindingConfidence: findings.length === 0 ? null : findings.reduce((total, finding) => total + finding.confidence_score, 0) / findings.length,
@@ -990,41 +1000,29 @@ async function runGoalWorkflow(ctx, options) {
     if (!replayingRecordedTurn) {
       appendLifecycleEvent(ledger, "reviews_recorded", `Recorded ${latestReviews.length} reviewer decisions.`, turn);
     }
-    if (reviewerBatchFailed) {
-      terminalRemainingWork = collectRemainingWork(latestReviews);
-      const reason = `Reviewer execution failed before quorum could be established. Remaining work: ${terminalRemainingWork}`;
-      const decision = reviewerExecutionFailedDecision({
-        turn,
-        reviewQuorum,
-        reviews: latestReviews,
-        reason,
-        convergence: ledger.convergence
-      });
-      ledger.decisions.push(decision);
-      ledger.status = "needs_human";
-      appendLifecycleEvent(ledger, "status_decided", decision.reason, turn);
-      await writeGoalLedger(ledgerPath, ledger);
-      break;
-    }
     if (replayingRecordedTurn)
       continue;
     const reducerOutcome = reduceGoalDecision(ledger, latestReviews, {
       turn,
-      maxTurns,
+      maxTurns: reviewerContractError === undefined ? maxTurns : turn,
       reviewQuorum,
       blockerThreshold,
       nextActionOnComplete: createPr ? "pull-request" : "finish",
       convergence: ledger.convergence
     });
+    const decision = reviewerContractError === undefined ? reducerOutcome.decision : {
+      ...reducerOutcome.decision,
+      reason: `Reviewer output contract exhausted before quorum could be established. ${reviewerContractError.message}`
+    };
     if (reducerOutcome.blockerObservation !== undefined) {
       ledger.blockers.push(reducerOutcome.blockerObservation);
     }
-    ledger.decisions.push(reducerOutcome.decision);
+    ledger.decisions.push(decision);
     ledger.status = reducerOutcome.status;
-    appendLifecycleEvent(ledger, "status_decided", reducerOutcome.decision.reason, turn);
+    appendLifecycleEvent(ledger, "status_decided", decision.reason, turn);
     await writeGoalLedger(ledgerPath, ledger);
   }
-  const remainingWork = ledger.status === "complete" ? "none" : terminalRemainingWork ?? collectRemainingWork(latestReviews);
+  const remainingWork = ledger.status === "complete" ? "none" : collectRemainingWork(latestReviews);
   const finalReport = renderFinalReport(ledger, ledgerPath, remainingWork);
   const reviewReport = formatReviewReport(latestReviews);
   let finalPrReport;

package/dist/builtin/workflows/builtin/{chunk-f61w0hpm.js → chunk-br4ac9a3.js}

@@ -39,7 +39,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-tecnpe8j.js";
+} from "./chunk-p3xmajmj.js";
 import {
   fold_usage
 } from "./chunk-tgt0s5e5.js";