muse-crew 0.7.11 → 0.7.13

package/workflows/bugfix.js

@@ -28,6 +28,15 @@ const startStepIndex = inputs.start_step_index || 0;
 // resolution back via updatetask in the self-claim below.
 const RESOLVED_WORKFLOW = inputs.resolved_workflow || null;
 const WORKFLOW_WAS_NULL = inputs.workflow_was_null === true;
+// One-shot recovery routing: the dispatcher sets inputs.next_phase when it
+// routes this run via an explicit recover-task redirect. The value is
+// consumed (cleared) atomically by the successful self-claim below:
+// claim-task takes expected_next_phase and clears the matching next_phase in
+// the same transaction as the winning session insert, so no platform death
+// can slip between claim and consumption and replay the routing. A stale or
+// superseded routing survives — only an exact match clears.
+// what the dispatcher routed on.
+const NEXT_PHASE_ROUTED = (typeof inputs.next_phase === "string" && inputs.next_phase.length > 0) ? inputs.next_phase : null;
 const CLAIM_WORKFLOW_PERSIST = (WORKFLOW_WAS_NULL && RESOLVED_WORKFLOW) ? ", \"workflow\": \"" + RESOLVED_WORKFLOW + "\"" : "";
 
 // Visual verdict protocol availability — the workflow parks for parent-run
@@ -581,6 +590,18 @@ function extractMarkerLines(workerText) {
   return markers.join("\n");
 }
 
+// Already-merged idempotency (canary 2026-09-15, task 1d692d91): when the
+// builder correctly makes no commit because the deliverable is already on
+// main (a prior merge or hand-repair landed it), it declares
+// `repo_diff: none (already-merged: <sha>)` naming the main commit that
+// carries the work. The sha is hex-only (7-40 chars) so the workflow can
+// interpolate it into the mechanical ancestor check without injection
+// risk. Pure — pinned byte-identical across standard/bugfix/chore.
+function extractAlreadyMerged(workerText) {
+  var m = /^repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})\)/im.exec(workerText || "");
+  return m ? { sha: m[1].toLowerCase() } : { sha: null };
+}
+
 // Worktree confinement: the Build agent must declare the exact worktree
 // path it built in on a `worktree:` marker line. The workflow compares it
 // against WORKTREE_HINT mechanically (exact string match) — never by
@@ -769,6 +790,12 @@ let mapGateBounceCount = 0;
 // rationalized a skip against explicit instruction text — text alone did not
 // hold, so the decision now lives in workflow code, not agent judgment.
 let releaseDecision = null; // { release: "yes"|"no", version_bump: "patch"|"minor"|"major"|null }
+// Already-merged idempotency: the verified sha from the builder's
+// `repo_diff: none (already-merged: <sha>)` declaration (null when the
+// builder made commits or declared a runtime-state deliverable). The
+// workflow verifies the sha is an ancestor of main at Build closeout;
+// Review's no-diff branch reads this, never the builder's prose.
+let alreadyMergedSha = null;
 // Deterministic publish target — computed by the workflow (registry base +
 // bumpVersion), never by the Publish agent.
 let publishTarget = null; // { base, scope, target }
@@ -1000,7 +1027,7 @@ while (i < STEPS.length) {
     const claimResult = await agent(
       "Claim this task for the " + step.name + " step.\n" +
       "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", firstClaimUpdateArgs) + "\n" +
-      "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" }) + "\n" +
+      "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started", ...(NEXT_PHASE_ROUTED ? { expected_next_phase: NEXT_PHASE_ROUTED } : {}) }) + "\n" +
       "If the claim response has claimed=true, then run in shell and return the stdout verbatim:\n" + crewCmd("clear-reservation", { task_id: taskId }) + "\n" +
       "Do not interpret the claim response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
       "Return { claimed: <verbatim>, session_id: \"<...>\" }. If claimed is false there is no session_id; return { claimed: false, session_id: \"\" }.",
@@ -1217,7 +1244,7 @@ while (i < STEPS.length) {
       "Data-level fallback (only if the browser loop above is NOT POSSIBLE): run in shell and read the stdout JSON:\n" + crewCmd("get-state", {}) + "\n" +
       "This returns current sessions, events, and tasks — capture concrete evidence from the data you retrieve.\n" +
       "Report your reproduction steps and evidence as plain prose.\n" +
-      "End your report with exactly one line: VERDICT: PASS if you reproduced the reported bug (your frames show the reported misbehavior), VERDICT: FAIL if you could not. --expected names the bug as reported (its visible manifestation); --actual names what your frames actually showed. Checks you could not run are evidence gaps, not silent drops: name every one in --missing. First ensure the OODA log exists even if you logged zero steps (touch " + crewHome + "/task-evidence/" + taskId + "/repro/ooda-log.jsonl — an empty log is honest, an absent one is a broken report). Also write the same verdict machine-readably: node " + crewHome + "/current/lib/write-ooda-verdict.js --dir " + crewHome + "/task-evidence/" + taskId + "/repro/ --attempt \"1\" --verdict <PASS|FAIL|NOT_POSSIBLE> --summary \"<one line>\" --expected \"<the bug as reported — its visible manifestation>\" --actual \"<what your frames actually showed>\" --missing '[\"honest evidence gap, if any\"]' — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten).";
+      "End your report with exactly one line: VERDICT: PASS if you reproduced the reported bug (your frames show the reported misbehavior), VERDICT: FAIL if you could not. --expected names the bug as reported (its visible manifestation); --actual names what your frames actually showed. Checks you could not run are evidence gaps, not silent drops: name every one in --missing. First ensure the OODA log exists even if you logged zero steps (touch " + crewHome + "/task-evidence/" + taskId + "/repro/ooda-log.jsonl — an empty log is honest, an absent one is a broken report). Also write the same verdict machine-readably: node " + crewHome + "/current/lib/write-ooda-verdict.js --dir " + crewHome + "/task-evidence/" + taskId + "/repro/ --attempt \"1\" --verdict <PASS|FAIL|NOT_POSSIBLE> --summary \"<one line>\" --expected \"<the bug as reported — its visible manifestation>\" --actual \"<what your frames actually showed>\" --missing '[\"honest evidence gap, if any\"]' [--reason \"<why it failed — REQUIRED and non-empty when verdict is FAIL or NOT_POSSIBLE; the script rejects a reason-less negative verdict with exit 2>\"] — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten). A FAIL or NOT_POSSIBLE verdict without a machine-readable --reason cannot be written — state the reason.";
 
   } else if (step.name === "Map") {
     var mapGatePara = "";
@@ -1253,12 +1280,33 @@ while (i < STEPS.length) {
       "cd " + WORKTREE_HINT + "\n" +
       "git add -A\n" +
       "git commit -m \"fix: " + safeTitle + "\"\n\n" +
-      "If the task's deliverable is runtime state (a cron definition, scheduler change, or dashboard/config state created outside the repo) and the repository genuinely needs no change, do NOT fabricate a commit: leave the branch with no commits ahead of main and declare `repo_diff: none` in your report, naming the runtime-state deliverable. Otherwise commit your changes normally.\n\n" +
+      "If the task's deliverable is runtime state (a cron definition, scheduler change, or dashboard/config state created outside the repo) and the repository genuinely needs no change, do NOT fabricate a commit: leave the branch with no commits ahead of main and declare `repo_diff: none` in your report, naming the runtime-state deliverable. If you verified the deliverable is already on main (a prior merge or hand-repair landed it — do NOT re-implement working code), make no commit and declare `repo_diff: none (already-merged: <sha>)` naming the main commit that carries the work; the workflow verifies the sha is an ancestor of main, and a false declaration fails the phase. Otherwise commit your changes normally.\n\n" +
       (rejectionNotes ? "This is REWORK after rejection. Address these specific issues:\n" + rejectionNotes + "\n\n" : "") +
       "Report back in plain prose: what you built and the outcome." +
       (PUBLISH_TYPE === "npm" ? " End your report with the release: and version_bump: lines exactly as specified above — keep them on their own lines, lowercase, unrephrased — then a line `worktree: ` followed by the exact working directory path from above (copy it verbatim \u2014 it must match character-for-character), then a final line with exactly: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not." : " End your report with a line `worktree: ` followed by the exact working directory path from above (copy it verbatim \u2014 it must match character-for-character), then exactly one line: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not.");
 
   } else if (step.name === "Review") {
+    // Already-merged hydration: when this run did not execute Build itself
+    // (dispatcher resume at Review after a platform death between phases),
+    // recover the workflow-attested verification from the latest completed
+    // Build session notes. The `already_merged_verified:` line was written
+    // by the workflow after a mechanical ancestor check — it is trusted;
+    // the builder's bare declaration never is. Absent the line, the
+    // mechanical fact below reads "none declared" and Cass fails closed.
+    if (!alreadyMergedSha) {
+      var hydNotes = await agent(
+        "Read the latest completed Build session notes for task " + taskId + ".\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
+        "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return ONLY its notes field, verbatim, with no commentary.",
+        { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
+      );
+      var hydStr = (typeof hydNotes === "string") ? hydNotes : JSON.stringify(hydNotes);
+      var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
+      if (hvm) {
+        alreadyMergedSha = hvm[1].toLowerCase();
+        log("Hydrated already-merged verification from Build session notes: " + alreadyMergedSha);
+      }
+    }
     instructions = "Review independently and cold. You have NOT seen any reasoning from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
       (mapperSpec ? "MAPPER'S SPEC (the builder was asked to implement exactly this):\n" + mapperSpec + "\n\n" : "Read the spec (from the task description or spec files under " + crewHome + "/).\n\n") +
       "Examine the code changes by running:\n" +
@@ -1268,7 +1316,7 @@ while (i < STEPS.length) {
       WORKTREE_HINT + "/\n\n" +
       "Check quality, correctness, and spec compliance.\n" +
       "Check that public-affecting changes have matching public doc updates (API.md or the published API contract). If the docs are missing or inaccurate, report what is stale, then end your report with exactly this line: VERDICT: FAIL.\n" +
-      "If the branch has no commits ahead of main (inspect shows an empty commit log), approve ONLY if the Build summary declares `repo_diff: none` with a plausible runtime-state deliverable (e.g. a cron created via the cron tool). Otherwise report 'no commits ahead of main and no repo_diff: none declaration — the builder likely forgot to commit', then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "If the branch has no commits ahead of main (inspect shows an empty commit log), approve ONLY if the Build summary declares `repo_diff: none` with (a) a plausible runtime-state deliverable (e.g. a cron created via the cron tool), or (b) an already-merged declaration `repo_diff: none (already-merged: <sha>)` AND the mechanical fact below confirms the sha verified. MECHANICAL FACT (computed by the workflow, never by the builder): already_merged sha = " + (alreadyMergedSha ? alreadyMergedSha + " (verified ancestor of main: YES)" : "none declared") + ". Otherwise report 'no commits ahead of main and no valid repo_diff: none declaration — the builder likely forgot to commit', then end your report with exactly this line: VERDICT: FAIL.\n" +
       (PUBLISH_TYPE === "npm" ? "PACKAGE VERSION: this project publishes to the npm registry, and versions are assigned at publish time — never in branches. Two checks:\n" +
       "(a) The task branch must NOT have changed package.json's `version` field. Check: cd " + REPO_PATH + " && git diff main..." + TASK_BRANCH + " -- package.json. If the branch touched `version` in any way, report 'versions are assigned at publish time, never in branches — remove the version change' in your notes, then end your report with exactly this line: VERDICT: FAIL.\n" +
       "(b) The accepted Build report declares: " + releaseDecisionText() + ". " +
@@ -1282,7 +1330,7 @@ while (i < STEPS.length) {
       "Run: "+ LIFECYCLE_ENV + "WORKFLOW_RUN_ID=" + lockHolder + " integrate " + taskId + " \"merge: fix: " + safeTitle + "\"\n\n" +
       "Read the output:\n" +
       "- If it contains MERGED, integration succeeded. Report the merged commit hash.\n" +
-      "- If it contains MERGED_EMPTY, the branch had no commits ahead of main (a runtime-state deliverable, declared by Build as repo_diff: none). Integration succeeded vacuously: the merge lock was NOT taken and there is no new commit. Report 'merged empty: no repo changes — deliverable was runtime state', then end your report with exactly this line: VERDICT: PASS. SKIP STEP 2 (push): there is no new commit to push.\n" +
+      "- If it contains MERGED_EMPTY, the branch had no commits ahead of main (declared by Build as repo_diff: none — either a runtime-state deliverable or an already-merged sha the workflow verified). Integration succeeded vacuously: the merge lock was NOT taken and there is no new commit. Report 'merged empty: no repo changes — deliverable was runtime state or already on main', then end your report with exactly this line: VERDICT: PASS. SKIP STEP 2 (push): there is no new commit to push.\n" +
       "- If it contains LOCK_HELD, another task holds the merge lock (mid Integrate/Publish) and the 10-minute bounded backoff is exhausted. Report 'merge lock held after bounded backoff', then end your report with exactly this line: VERDICT: FAIL.\n" +
       "- If it contains CONFLICT, the plain merge failed — the merge was aborted, main is clean, and your task still holds the merge lock. Do NOT fail yet. Resolve it:\n" +
       "RESOLUTION:\n" +
@@ -1829,6 +1877,15 @@ while (i < STEPS.length) {
           // lock was lost: stop the run and park the task — never continue to
           // a provenance stamp or version assignment without holding the lock.
           var buildPoll = null;
+          // STEP 1b poll-signal accumulators (2026-09-15, task aadeccc3):
+          // the durable audit-dir fallback below needs the poll's own
+          // observations, not just its final verdict — whether our build was
+          // ever seen, whether a stranger's build was ever in flight, and
+          // what the last check observed. OR-ed across all three chunks so
+          // a signal seen in any chunk survives the chunk boundary.
+          var pollSawOurBuild = false;
+          var pollSawStranger = false;
+          var lastObservedAgentId = null;
           for (var chunk = 1; chunk <= 3; chunk++) {
             if (chunk > 1) {
               var refreshPoll = await agent(
@@ -1851,20 +1908,25 @@ while (i < STEPS.length) {
               : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, totalReworkCount);
             buildPoll = await agent(
               "First call tool_search.load_tool_namespace with paths [\"artifact\"]. Then poll artifact_status for slug \"" + PUBLISH_SLUG + "\" \u2014 for OUR build only, the one whose agent_id is \"" + rebuildAgentId + "\" (the receipt captured when the edit was accepted; the agent_id is the artifact system's in-flight build correlation ID, stable across polls while the build runs). Check every 30 seconds, up to 7 checks (3.5 minutes max). On each check, read the raw build object:\n" +
-              "- If no build is running (build is null): OUR build finished. Stop and report done.\n" +
+              "On every check, record whether you have positively OBSERVED our build: a running build whose agent_id equals \"" + rebuildAgentId + "\", or a completed-build record whose agent_id equals \"" + rebuildAgentId + "\" (if the tool surfaces one \u2014 match it mechanically, never assume).\n" +
+              "- If no build is running (build is null) and you have NOT observed our build: our build's completion is UNPROVEN. Absence of a running build is not evidence our build ran. Do NOT report done.\n" +
+              "- If no build is running (build is null) and you previously observed our build running: our build finished. Stop and report done.\n" +
               "- If the running build's agent_id equals \"" + rebuildAgentId + "\": still ours \u2014 keep waiting.\n" +
-              "- If the running build's agent_id is present but DIFFERENT: our build is gone (it finished before this one started). Do NOT wait on the stranger's build and do NOT attribute its completion to our attempt \u2014 stop and report done.\n" +
-              "Return JSON { \"build_done\": <true if our build is no longer running within budget, false on timeout>, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } and nothing else.",
+              "- If the running build's agent_id is present but DIFFERENT: that is a stranger's build. Do NOT attribute its completion to our attempt and do NOT wait on it \u2014 keep checking within budget; if the budget expires without observing our build, report done=false. Record it in saw_stranger regardless of what else you observe.\n" +
+              "Return JSON { \"build_done\": <true ONLY when you positively observed our build and it is no longer running, false otherwise>, \"saw_our_build\": <true if you observed our build at any check, false if never>, \"saw_stranger\": true if at ANY check a running build had an agent_id different from ours (\"" + rebuildAgentId + "\"), false otherwise, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } and nothing else.",
               { key: pollKey, label: "Waiting for artifact build to complete (chunk " + chunk + " of 3)",
-                schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
+                schema: { type: "object", properties: { build_done: { type: "boolean" }, saw_our_build: { type: "boolean" }, saw_stranger: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
                 timeoutMs: 270000 }
             );
+            pollSawOurBuild = pollSawOurBuild || (buildPoll && buildPoll.saw_our_build === true);
+            pollSawStranger = pollSawStranger || (buildPoll && buildPoll.saw_stranger === true);
+            lastObservedAgentId = (buildPoll && buildPoll.observed_agent_id) || null;
             if (buildPoll && buildPoll.build_done) { break; }
           }
           if (!buildPoll || !buildPoll.build_done) {
             buildPoll = { build_done: false, status: (buildPoll && buildPoll.status) || "build still running after the 10.5-minute bounded poll" };
           }
-          if (buildPoll.build_done) {
+          if (buildPoll.build_done && pollSawOurBuild) {
             // STEP 1c (mechanical): NO provenance stamp here. Canary run 8
             // (2026-09-11) proved the stamp cannot certify content: the
             // builder's applied-report is derived from the carried diff, so
@@ -1882,7 +1944,116 @@ while (i < STEPS.length) {
             artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
             log("Publish build landed for task " + taskId + " — provenance stamp deferred to parent content verification");
           } else {
-            publishFailure = "Artifact build did not complete within budget: " + (buildPoll.status || "timeout") + ". The publish may or may not have landed — provenance was not stamped.";
+            // STEP 1b durable audit-dir fallback (2026-09-15, task aadeccc3):
+            // the poll above only observes IN-FLIGHT builds. A build that
+            // finished between the receipt capture and the poll's first check
+            // leaves no in-flight trace — but the platform's audit harness
+            // leaves a durable one (~/workspace/ts-spaces/<slug>/audits/
+            // <timestamp>-<id>/ per completed build). Diff the audit-dir
+            // listing against the pre-trigger snapshot: a timestamped dir
+            // that appeared during the attempt window is evidence a build
+            // completed. Attribution is by window, not by build identity:
+            // the poll's saw_stranger signal only catches stranger builds in
+            // flight AT a check — a stranger that finished entirely inside
+            // the window is indistinguishable, so any observed stranger
+            // blocks attribution and the outcome stays unknown. This never
+            // re-issues the edit and never stamps provenance — ok=true only
+            // routes to the parent's independent content read-back, which
+            // remains the real verification.
+            //
+            // The poll end-state is read from the poll's own observations,
+            // not from build_done alone: a build in flight at the last check
+            // means the budget was shorter than the latency (or the build is
+            // stuck) — NOT that no build ever started; nothing observed at
+            // any check is the never-started signal.
+            var pollEndState = lastObservedAgentId ? "build-still-running-at-poll-end"
+              : (pollSawOurBuild ? "our-build-observed-then-unconfirmed" : "no-build-observed-in-window");
+            var strangerObserved = pollSawStranger;
+            var newAuditDirsAfterPoll = [];
+            try {
+              var auditAfterPoll = await agent(
+                "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
+                "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
+                "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
+                { key: attemptKey("publish-audit-after-poll-" + taskId, totalReworkCount), label: "Re-listing audit dirs after build poll",
+                  schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+              );
+              var auditDirsAfterPollList = String((auditAfterPoll && auditAfterPoll.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+              newAuditDirsAfterPoll = auditDirsAfterPollList.filter(function (d) {
+                return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
+              });
+              log("Publish audit-dir re-list after build poll for task " + taskId + ": " + newAuditDirsAfterPoll.length + " new timestamped dir(s)");
+            } catch (auditAfterPollErr) {
+              log("Publish audit-dir re-list after build poll failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterPollErr && auditAfterPollErr.message ? auditAfterPollErr.message : auditAfterPollErr));
+            }
+            // auditReportOk: pure tri-state read of a report.json body —
+            // true (build ok), false (build failed), null (missing or
+            // unreadable — not evidence either way). The child returns the
+            // raw body verbatim; interpretation lives here, never in prose.
+            var auditReportOk = function (raw) {
+              if (typeof raw !== "string") return null;
+              var trimmed = raw.trim();
+              if (trimmed === "" || trimmed === "MISSING") return null;
+              var parsed;
+              try { parsed = JSON.parse(trimmed); } catch (e) { return null; }
+              if (parsed && typeof parsed.ok === "boolean") return parsed.ok;
+              return null;
+            };
+            var auditOkAfterPoll = null;
+            var newestAuditDirAfterPoll = null;
+            if (newAuditDirsAfterPoll.length > 0 && !strangerObserved) {
+              newAuditDirsAfterPoll.sort();
+              newestAuditDirAfterPoll = newAuditDirsAfterPoll[newAuditDirsAfterPoll.length - 1];
+              try {
+                var auditOkRead = await agent(
+                  "Read the build report for artifact slug \"" + PUBLISH_SLUG + "\", audit dir \"" + newestAuditDirAfterPoll + "\" (verbatim read, never interpreted, never a gate).\n" +
+                  "Run: cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/" + newestAuditDirAfterPoll + "/report.json 2>/dev/null || echo MISSING\n" +
+                  "Return JSON { \"raw\": \"<verbatim file contents, or the literal string MISSING when the file does not exist>\" } and nothing else.",
+                  { key: attemptKey("publish-audit-ok-after-poll-" + taskId, totalReworkCount), label: "Reading build report after build poll",
+                    schema: { type: "object", properties: { raw: { type: "string" } }, required: ["raw"] } }
+                );
+                auditOkAfterPoll = auditReportOk(auditOkRead && auditOkRead.raw);
+              } catch (auditOkReadErr) {
+                log("Publish build-report read after build poll failed for task " + taskId + " (non-fatal, treated as unknown): " + (auditOkReadErr && auditOkReadErr.message ? auditOkReadErr.message : auditOkReadErr));
+                auditOkAfterPoll = null;
+              }
+            }
+            if (auditOkAfterPoll === true) {
+              publishBuildLanded = true;
+              artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
+              log("Publish build landed for task " + taskId + " via durable audit evidence — provenance stamp deferred to parent content verification");
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: rebuildAgentId,
+                applied_report: publishAppliedObservation,
+                outcome: "submitted",
+                detail: "durable audit evidence shows a build completed during the attempt window (audit dir " + newestAuditDirAfterPoll + ", report ok=true); routed to parent verification"
+              }, totalReworkCount);
+            } else if (auditOkAfterPoll === false) {
+              publishFailure = "Artifact build FAILED for slug " + PUBLISH_SLUG + " (audit dir " + newestAuditDirAfterPoll + ", report ok=false). Explicit negative evidence: a build ran and failed (attribution by window, not by build identity — no stranger build was observed in flight during the poll). The publish did not land — provenance was not stamped. Fail-closed.";
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: rebuildAgentId,
+                applied_report: publishAppliedObservation,
+                outcome: "failed",
+                detail: "a build ran and failed (attribution by window, not by build identity): audit dir " + newestAuditDirAfterPoll + " report ok=false; no stranger build observed in flight during the poll"
+              }, totalReworkCount);
+            } else {
+              var unattributableReason = strangerObserved ? "stranger-build-observed-during-poll"
+                : (pollEndState === "build-still-running-at-poll-end" ? "build-still-running-at-poll-end"
+                : (newAuditDirsAfterPoll.length === 0 ? "no-new-audit-dir-in-window" : "audit-report-unreadable-or-missing"));
+              publishFailure = "Artifact build completion unproven (fail-closed, no provenance stamped): unattributable_reason=" + unattributableReason + "; poll_end_state=" + pollEndState + "; " + "saw_our_build=" + pollSawOurBuild + "; new_audit_dirs=" + newAuditDirsAfterPoll.length + ". Attribution is by window, not by build identity. The publish may or may not have landed. Fail-closed.";
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: rebuildAgentId,
+                applied_report: publishAppliedObservation,
+                outcome: "unknown",
+                detail: "durable audit-dir fallback could not attribute a completed build to this attempt (unattributable_reason=" + unattributableReason + ", poll_end_state=" + pollEndState + ")"
+              }, totalReworkCount);
+            }
           }
         } else {
           publishFailure = "Artifact rebuild trigger failed: " + (rebuildTrigger.error || "artifact_edit not accepted") + ". The publish did not land.";
@@ -2008,7 +2179,7 @@ while (i < STEPS.length) {
         "File follow-up tasks by running in shell:\n" + crewCmd("create-task", { title: "<short title>", description: "<details>", project: "<project id>", workflow: "bugfix", filed_by: "hazel" }) + "\n(substitute the real values for the placeholders).\n\n" +
         "BASELINE SANITY: in the event history you fetched, the task's note events must contain a message starting with `baseline: captured` or `baseline: none`. If no message starts with either prefix, report 'baseline evidence missing at QA — the Map gate was bypassed', then end your report with exactly this line: VERDICT: FAIL.\n\n" +
         "Report your test results as plain prose.\n" +
-        "End your report with exactly one line: VERDICT: PASS if testing passes, VERDICT: FAIL if it fails on the visual or the mechanical checks. Checks you could not run are evidence gaps, not silent drops: name every one in --missing — unknown is neither PASS nor FAIL. First ensure the OODA log exists even if you logged zero steps (touch " + crewHome + "/task-evidence/" + taskId + "/postchange/ooda-log.jsonl — an empty log is honest, an absent one is a broken report). Also write the same verdict machine-readably: node " + crewHome + "/current/lib/write-ooda-verdict.js --dir " + crewHome + "/task-evidence/" + taskId + "/postchange/ --attempt \"1\" --verdict <PASS|FAIL|NOT_POSSIBLE> --summary \"<one line>\" --expected \"<the reported bug, fixed>\" --actual \"<what you observed>\" --missing '[\"honest evidence gap, if any\"]' — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten).";
+        "End your report with exactly one line: VERDICT: PASS if testing passes, VERDICT: FAIL if it fails on the visual or the mechanical checks. Checks you could not run are evidence gaps, not silent drops: name every one in --missing — unknown is neither PASS nor FAIL. First ensure the OODA log exists even if you logged zero steps (touch " + crewHome + "/task-evidence/" + taskId + "/postchange/ooda-log.jsonl — an empty log is honest, an absent one is a broken report). Also write the same verdict machine-readably: node " + crewHome + "/current/lib/write-ooda-verdict.js --dir " + crewHome + "/task-evidence/" + taskId + "/postchange/ --attempt \"1\" --verdict <PASS|FAIL|NOT_POSSIBLE> --summary \"<one line>\" --expected \"<the reported bug, fixed>\" --actual \"<what you observed>\" --missing '[\"honest evidence gap, if any\"]' [--reason \"<why it failed — REQUIRED and non-empty when verdict is FAIL or NOT_POSSIBLE; the script rejects a reason-less negative verdict with exit 2>\"] — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten). A FAIL verdict must carry a machine-readable reason: the workflow closeout cross-checks verdict.json against your prose VERDICT line, and an unreasoned or contradictory verdict fails the phase (never routes to rework).";
     }
     if (PUBLISH_TYPE === "artifact") {
       instructions = "PROVENANCE CHECK (this project publishes to a dashboard artifact).\n" +
@@ -2176,6 +2347,70 @@ while (i < STEPS.length) {
     verdictPassed = verdict.passed;
   }
 
+  // QA verdict.json closeout gate (task 30dceb78): the prose VERDICT: line is
+  // the routing signal, but verdict.json is the reason-carrying record the
+  // workflow actually reads. A FAIL verdict must carry a machine-readable
+  // reason; the workflow refuses to route to rework on an unreasoned or
+  // contradictory verdict. The deterministic cross-checker
+  // (lib/read-ooda-verdict.js) runs against the prose verdict: a missing,
+  // corrupt, contradictory, or reason-less record fails the phase for retry
+  // — the dispatcher re-runs QA at the same step under its
+  // consecutive-failure cap — instead of routing to rework. Without this
+  // gate, a bare VERDICT: FAIL with an all-positive report (canary
+  // 2026-09-15, task 1d692d91) rebuilt nothing and parked at Publish on an
+  // unobserved artifact build. The gate applies only to the experiential QA
+  // path (qaVisual), the only path that writes verdict.json.
+  if (step.name === "QA" && qaVisual && verdictPassed !== null) {
+    var qaVerdictDir = crewHome + "/task-evidence/" + taskId + "/postchange";
+    var qaVerdictExpect = verdictPassed ? "PASS" : "FAIL";
+    var qaVerdictOut = "";
+    try {
+      var qaVerdictCheck = await agent(
+        "Run: node " + crewHome + "/current/lib/read-ooda-verdict.js --dir " + qaVerdictDir + " --expect " + qaVerdictExpect + "\n" +
+        "Return JSON { \"output\": \"<the command's full stdout, trimmed>\" } and nothing else.",
+        { key: attemptKey("qa-verdict-check-" + taskId, totalReworkCount), label: "Cross-checking QA verdict.json",
+          schema: { type: "object", properties: { output: { type: "string" } }, required: ["output"] } }
+      );
+      qaVerdictOut = (qaVerdictCheck && qaVerdictCheck.output ? qaVerdictCheck.output : "").trim();
+    } catch (e) {
+      qaVerdictOut = "";
+    }
+    // The script prints exactly one JSON line; exit info does not survive
+    // the schema'd return, so ok:false on that line is the gate signal.
+    var qaVerdictGate = null;
+    try {
+      var qaVerdictLines = qaVerdictOut.split("\n");
+      qaVerdictGate = JSON.parse(qaVerdictLines[qaVerdictLines.length - 1]);
+    } catch (e) {
+      qaVerdictGate = null;
+    }
+    if (!qaVerdictGate || qaVerdictGate.ok !== true) {
+      var qaGateCode = (qaVerdictGate && qaVerdictGate.code) ? qaVerdictGate.code : "unreadable";
+      var qaGateDetail = (qaVerdictGate && qaVerdictGate.error) ? qaVerdictGate.error : (qaVerdictOut ? qaVerdictOut.slice(0, 200) : "cross-checker produced no usable output");
+      log("QA verdict.json closeout gate failed (" + qaGateCode + "): " + qaGateDetail + " — marking QA failed for retry, NOT routing to rework");
+      await agent(
+        "Record QA verdict gate failure.\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name,
+            status: "failed", notes: "QA verdict.json closeout gate failed (" + qaGateCode + "): " + qaGateDetail + ". The prose VERDICT line said " + qaVerdictExpect + " but verdict.json is missing, corrupt, contradictory, or (for FAIL) carries no machine-readable reason. Unreasoned or contradictory verdicts never route to rework; phase failed for retry" },
+          event: { task_id: taskId, type: "failed",
+            message: "QA verdict.json closeout gate failed (" + qaGateCode + ") — verdict unreasoned or contradictory, phase failed, dispatcher will retry QA" }
+        }),
+        { key: "record-qa-verdict-gate-fail-" + step.name, label: "Recording QA verdict gate failure" }
+      );
+      return {
+        __hatchWorkflowControl: "blocked",
+        result: {
+          blocked_reason: "QA verdict.json closeout gate failed (" + qaGateCode + ")",
+          message: "QA's prose VERDICT line said " + qaVerdictExpect + " but the machine-readable verdict.json is " + qaGateCode + " (" + qaGateDetail + "). A FAIL verdict must carry a machine-readable reason and the record must agree with the prose line. The phase is marked failed and the dispatcher will retry QA; it is not routed to rework.",
+          task_id: taskId
+        }
+      };
+    }
+    log("QA verdict.json closeout gate passed: verdict.json agrees with prose VERDICT: " + qaVerdictExpect);
+  }
+
 
   // Worktree confinement (Build only): the declared worktree path must
   // match WORKTREE_HINT exactly. A builder that worked in any other
@@ -2207,6 +2442,52 @@ while (i < STEPS.length) {
       };
     }
     log("Build worktree confinement passed: " + wt.path);
+
+    // Already-merged idempotency: a `repo_diff: none (already-merged:
+    // <sha>)` declaration is verified mechanically — <sha> must resolve
+    // and be an ancestor of main in the configured repo. A fabricated or
+    // mistaken declaration fails the phase here (the dispatcher retries
+    // Build under its consecutive-failure cap); a verified declaration is
+    // recorded in alreadyMergedSha for Review's no-diff branch. Without
+    // this guard, Build correctly doing nothing left Review with no
+    // mechanical way to accept an empty diff, and Cass rejected for "no
+    // commits ahead of main — the builder likely forgot to commit" while
+    // the deliverable sat on main (canary 2026-09-15, task 1d692d91).
+    // The sha is hex-only by construction (extractAlreadyMerged), so
+    // interpolating it into the shell command cannot inject.
+    var am = extractAlreadyMerged(workerText);
+    if (am.sha) {
+      var amCheck = await agent(
+        "Verify the builder's already-merged declaration.\n" +
+        "Run in shell and return the stdout verbatim:\n" +
+        "cd " + REPO_PATH + " && git rev-parse --verify --quiet " + am.sha + " >/dev/null && git merge-base --is-ancestor " + am.sha + " main && echo ALREADY_MERGED_YES || echo ALREADY_MERGED_NO",
+        { key: "verify-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Verifying already-merged declaration" }
+      );
+      var amOut = (typeof amCheck === "string") ? amCheck : JSON.stringify(amCheck);
+      if (!/ALREADY_MERGED_YES/.test(amOut)) {
+        log("Build already-merged declaration failed verification — " + am.sha + " is not an ancestor of main — marking failed for retry");
+        await agent(
+          "Record already-merged verification failure.\n" +
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+            task_id: taskId,
+            session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed",
+              notes: "Build declared repo_diff: none (already-merged: " + am.sha + ") but " + am.sha + " is not an ancestor of main in the configured repo. The declaration is fabricated or mistaken; the work is not on main. Phase failed for retry" },
+            event: { task_id: taskId, type: "failed", message: "Build already-merged declaration failed verification — " + am.sha + " not an ancestor of main, phase failed, dispatcher will retry" }
+          }),
+          { key: "record-already-merged-fail-" + step.name, label: "Recording already-merged verification failure" }
+        );
+        return {
+          __hatchWorkflowControl: "blocked",
+          result: {
+            blocked_reason: "Build already-merged declaration failed verification",
+            message: "The builder declared repo_diff: none (already-merged: " + am.sha + ") but " + am.sha + " is not an ancestor of main. The work is not on main; the phase is marked failed and the dispatcher will retry Build.",
+            task_id: taskId
+          }
+        };
+      }
+      alreadyMergedSha = am.sha;
+      log("Build already-merged declaration verified: " + am.sha + " is an ancestor of main");
+    }
   }
 
   // Deterministic closeout: no formatter agent. The verdict is mechanical
@@ -2370,6 +2651,15 @@ while (i < STEPS.length) {
   } else {
     summary = (stepResult.summary || "Step completed").slice(0, 2000 - workerMarkers.length - 1) + (workerMarkers ? "\n" + workerMarkers : "");
   }
+  // Already-merged attestation: when the Build gate verified the builder's
+  // already-merged declaration, the workflow records its own marker line in
+  // the session notes (like the builder markers above, it is appended after
+  // the slice so it can never be amputated). A later run resumed at Review
+  // hydrates alreadyMergedSha from this workflow-attested line — never from
+  // the builder's declaration alone.
+  if (step.name === "Build" && alreadyMergedSha) {
+    summary += "\nalready_merged_verified: " + alreadyMergedSha;
+  }
 
   // Visual verdict evidence (2026-09-15): no parent marker is appended. Hazel
   // records her own verdict.json + the append-only verdicts.jsonl in the