muse-crew 0.14.5 → 0.14.7

package/workflows/bugfix.js

@@ -155,6 +155,62 @@ function extractVerdict(workerText) {
   if (uniq.length !== 1) return { ok: false, count: matches.length };
   return { ok: true, passed: last.value === "PASS" };
 }
+// Room #26 blocker 38 (2026-09-21): content-finding attribution. Hazel
+// reports user-visible content observations in a machine-readable
+// CONTENT-FINDINGS block; the workflow classifies each against the task's
+// publish diff — mechanical set membership, never prose judgment. A finding
+// is attributable to the task's change iff its subject file is in the
+// publish diff. The special subject "live-data" (content in the artifact's
+// runtime data stores — decks, cards, rows) is never in a git diff, so it
+// always classifies environment-attributable: the crew has no live-DB write
+// path (blocker 32: QA writes go to a fresh per-run temp DB), so live
+// content is never the task's change. Findings are always recorded — never
+// suppressed for looking audit-y — but environment-attributable findings
+// never park the journey and never spawn an artifact bugfix. The
+// platform-side half (audit sessions writing to production via the
+// shared-concurrent path) is out of crew scope; see
+// docs/decisions/qa-reproduce.md#content-finding-attribution.
+function extractContentFindings(workerText) {
+  // The block is the LAST "CONTENT-FINDINGS:" line; the JSON array follows
+  // on the same line. Fail closed (ok:false) when missing or malformed —
+  // the caller blocks the phase for retry; unknown attribution must never
+  // degrade to "no findings" (the prose grounds stay preserved in the
+  // session notes).
+  var text = workerText || "";
+  var regex = /^CONTENT-FINDINGS:\s*(\[.*\])\s*$/gim;
+  var matches = [];
+  var m;
+  while ((m = regex.exec(text)) !== null) {
+    matches.push(m[1]);
+  }
+  if (matches.length === 0) return { ok: false, reason: "no CONTENT-FINDINGS block" };
+  var findings;
+  try {
+    findings = JSON.parse(matches[matches.length - 1]);
+  } catch (e) {
+    return { ok: false, reason: "CONTENT-FINDINGS block is not valid JSON" };
+  }
+  if (!Array.isArray(findings)) return { ok: false, reason: "CONTENT-FINDINGS is not an array" };
+  for (var i = 0; i < findings.length; i++) {
+    var f = findings[i];
+    if (!f || typeof f !== "object" || typeof f.subject !== "string" || typeof f.observation !== "string") {
+      return { ok: false, reason: "finding " + i + " needs string subject and observation" };
+    }
+  }
+  return { ok: true, findings: findings };
+}
+function classifyContentFinding(finding, diffFiles) {
+  // diffFiles: the task's publish-diff file set (repo-relative paths).
+  // Pure set membership — no prose, no judgment.
+  var subject = finding.subject;
+  if (subject === "live-data") {
+    return { attribution: "environment-attributable", reason: "live-data is never in a git publish diff — the crew has no live-DB write path (blocker 32)" };
+  }
+  if (diffFiles.indexOf(subject) !== -1) {
+    return { attribution: "task-change", reason: "subject is in the task's publish diff" };
+  }
+  return { attribution: "environment-attributable", reason: "subject is not in the task's publish diff" };
+}
 // See docs/decisions/workflow-core.md#verdict-reask: a report that fails extractVerdict gets bounded re-ask calls.
 function verdictReaskKey(stepName, reworkSuffix, attempt) {
   return "verdict-reask-" + stepName + reworkSuffix + "-a" + attempt;
@@ -237,14 +293,6 @@ var TOOL_CHECK_PREAMBLE =
   "2. Write exactly one line: artifact_tools: ok - or artifact_tools: missing if the call failed or the tool does not exist.\n" +
   "3. Run the shell command: echo tool-probe-ok - then write exactly one line: shell_transport: ok - or shell_transport: unavailable if you cannot run shell commands.\n" +
   "Then do the assignment below.\n\n";
-// ARTIFACT_LOAD_PREAMBLE - the one-line load instruction that precedes every
-// special-purpose prompt calling artifact tools (rebuild trigger, provenance
-// stamp, publish verification). The artifact tool namespace is deferred for
-// workflow children: present but invisible until the child loads it via
-// tool_search.load_tool_namespace (bug 3472bf36 root cause). Byte-identical
-// across standard/bugfix/chore - pinned by tests/artifact-tools.test.js.
-var ARTIFACT_LOAD_PREAMBLE =
-  "First call tool_search.load_tool_namespace with paths [\"artifact\"] - the artifact tool namespace is deferred and invisible until loaded.\n";
 function buildTransportRetryTrailer(stepName, repoPath, taskId, attempt, reason) {
   // reason: "discarded" (the runtime threw the output away - it could not be
   // machine-read), "empty" (agent() returned without throwing but produced
@@ -422,6 +470,11 @@ async function recordPublishLedger(entry, rework) {
       diff_path: entry.diff_path || null,
       diff_sha256: entry.diff_sha256 || null,
       base: entry.base || null,
+      // (0.14.6) Numeric publication attempt + the attempt's deterministic
+      // version. Attempt 1 is staged here by the workflow; attempts 2-3 are
+      // staged by scan-ack-pending's re-issue path with fresh versions.
+      publish_attempt: entry.publish_attempt || null,
+      version: entry.version || null,
     });
     var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
     var res = await agent(
@@ -433,9 +486,15 @@ async function recordPublishLedger(entry, rework) {
         label: "Recording publish attempt in ledger",
         schema: { type: "object", properties: { result: { type: "string" } }, required: ["result"] } }
     );
-    log("Noted publish outcome '" + entry.outcome + "' for task " + taskId + " in ledger");
+    // (2026-09-20 REVIEW) The intent entry is the machine's anchor — the
+    // caller gates on this return. LEDGER_OK in the agent's verbatim output
+    // is the only mechanical proof the line landed.
+    var ok = res && typeof res.result === "string" && res.result.indexOf("LEDGER_OK") !== -1;
+    log("Noted publish outcome '" + entry.outcome + "' for task " + taskId + " in ledger" + (ok ? "" : " (WRITE UNCONFIRMED)"));
+    return ok;
   } catch (e) {
     log("Publish ledger: write failed for task " + taskId + " (non-fatal, observability only): " + (e && e.message ? e.message : e));
+    return false;
   }
 }
 
@@ -455,13 +514,6 @@ function extractMarkerLines(workerText) {
   return markers.join("\n");
 }
 
-// See docs/decisions/publish-path.md#already-merged-idem2: idempotency for already-merged tasks.
-function extractAlreadyMerged(workerText) {
-  var m = /repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})(?=[\s)]|$)/i.exec(workerText || "");
-  return m ? { sha: m[1].toLowerCase() } : { sha: null };
-}
-
-
 // See docs/decisions/qa-reproduce.md#worktree-confinement: the Build agent must declare its worktree.
 function extractWorktree(workerText) {
   var lines = (workerText || "").split("\n");
@@ -668,12 +720,24 @@ 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 the integration target at Build closeout;
-// Review's no-diff branch reads this, never the builder's prose.
+// Already-merged attribution (blocker 34, 2026-09-21): the sha of the
+// task-attributed merge when classify-branch reports already-merged.
+// Set ONLY from the classifier's mechanical output — never from agent
+// prose. The agent-authored sha-bearing repo_diff declaration path is
+// deleted; attribution is identity-first from git, then the task's own
+// durable merge records.
 let alreadyMergedSha = null;
+// Room #26 blocker 34 (redesign, 2026-09-21): mechanical branch-state
+// classification at Review entry. Git facts are never adjudicated by a
+// reviewer — the workflow classifies the branch with `classify-branch`
+// (pure git) before Cass is dispatched: "has-work",
+// "already-merged:<sha>", or "empty-no-work". An empty branch with no
+// verified sha and no `repo_diff: none` claim fails mechanically without
+// dispatching Cass; reviewer prose is never parsed for git identity.
+let branchState = null; // "has-work" | "already-merged:<sha>" | "empty-no-work"
+let buildClaimedNoDiff = false; // Build declared plain `repo_diff: none` (no repo change — runtime-state deliverable, or believed already-merged). Same-process Build report only; there is no cross-process hydration — an empty branch on a fresh dispatch with no task-attributed merge fails mechanically.
+let versionTouched = false; // npm: branch changed package.json's `version` (mechanical git fact, blocker-34 follow-up)
+let branchStateErr = ""; // classifier failure detail (fail-closed grounds)
 // Deterministic publish target — computed by the workflow (registry base +
 // bumpVersion), never by the Publish agent.
 let publishTarget = null; // { base, scope, target }
@@ -1212,55 +1276,126 @@ 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 the integration target and declare `repo_diff: none` in your report, naming the runtime-state deliverable. If you verified the deliverable is already on the integration target (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 integration-target commit that carries the work; the workflow verifies the sha is an ancestor of the integration target, and a false declaration fails the phase. 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 the integration target and declare `repo_diff: none` in your report, naming the runtime-state deliverable. If you verified the deliverable is already on the integration target (a prior merge landed it — do NOT re-implement working code), make no commit and declare `repo_diff: none` in your report. The workflow verifies the claim mechanically from git — the task's own merge records, never your declaration, are the proof of delivery. 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") {
-    // See docs/decisions/publish-path.md#already-merged-hydra: when this run did not execute, hydration uses the existing merge.
-    if (!alreadyMergedSha) {
-      var hydResult = null;
-      try {
-        hydResult = await agent(
-          "Read the latest completed Build session 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 exactly two sections, verbatim, with no commentary:\n" +
-          "SHA: <the session's already_merged_sha field value, or the word null when it is null>\n" +
-          "NOTES:\n<the session's notes field, verbatim>",
-          { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
-        );
-      } catch (hydErr) {
-        log("Hydration read failed (" + String(hydErr && hydErr.message || hydErr) + "); treating as none declared.");
+    // Room #26 blocker 34 (redesign, 2026-09-21): classify the branch
+    // mechanically BEFORE Cass is dispatched. The classifier is pure git
+    // (classify-branch in the lifecycle script): has-work |
+    // already-merged:<sha> | empty-no-work. Attribution is identity-first
+    // from git, then the task's own durable merge records — there is no
+    // agent-authored declared-sha input and no cross-process hydration
+    // ferry (the re-entry case it served is covered by the durable record
+    // → classifier directly). An unparseable result fails closed as
+    // empty-no-work — an empty branch never passes Review silently, and
+    // the bounce to Build gives the next round a chance to classify.
+    try {
+      var bsResult = await agent(
+        "Classify the task branch state. This is a mechanical git check, not a judgment call.\n" +
+        "Run in shell and return the stdout verbatim, then the single stderr line starting with `DIAG:` verbatim:\n" +
+        LIFECYCLE_ENV + LIFECYCLE + " classify-branch " + taskId,
+        { key: "classify-branch" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Classifying branch state (mechanical)" }
+      );
+      var bsStr = (typeof bsResult === "string") ? bsResult : JSON.stringify(bsResult);
+      var bsMatch = /^\s*BRANCH_STATE:\s*(has-work|already-merged:[0-9a-f]{40}|empty-no-work)\s*$/im.exec(bsStr);
+      if (bsMatch) {
+        branchState = bsMatch[1].toLowerCase();
+      } else {
+        branchStateErr = "unparseable classifier output: " + bsStr.slice(0, 120);
       }
-      var hydStr = hydResult ? ((typeof hydResult === "string") ? hydResult : JSON.stringify(hydResult)) : "";
-      var hydSha = /^SHA:\s*([0-9a-f]{7,40})\s*$/im.exec(hydStr);
-      if (hydSha) {
-        alreadyMergedSha = hydSha[1].toLowerCase();
-        log("Hydrated already-merged verification from structured session field: " + alreadyMergedSha);
+      // DIAG pin (blocker 34 design v2.1): the merge-record scan is
+      // load-bearing with no fallback — the classifier's stderr counter is
+      // logged verbatim so silent record loss surfaces in the evidence.
+      var bsDiagMatch = /^[ \t]*DIAG:\s*classify-branch\s+records=\d+\s+resolvable=\d+[ \t]*$/im.exec(bsStr);
+      if (bsDiagMatch) {
+        log(bsDiagMatch[0].trim());
       } else {
-        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 (fallback): " + alreadyMergedSha);
-        }
+        log("classify-branch: no DIAG: record-scan counter returned (scan unverifiable)");
       }
+    } catch (bsErr) {
+      branchStateErr = "classifier call failed: " + String(bsErr && bsErr.message || bsErr).slice(0, 120);
+    }
+    if (!branchState) {
+      branchState = "empty-no-work";
+      log("Branch-state classification failed (" + branchStateErr + ") — failing closed as empty-no-work");
+    } else if (branchState.indexOf("already-merged:") === 0) {
+      alreadyMergedSha = branchState.slice("already-merged:".length);
+      log("Branch state already-merged: " + alreadyMergedSha + " (mechanically verified) — Cass reviews the frozen merge diff");
+    } else {
+      log("Branch state: " + branchState);
+    }
+    // buildClaimedNoDiff was set at the Build gate from the full Build
+    // report (same process only). Only an empty branch WITH this claim
+    // goes to Cass for a plausibility judgment; without it, empty-no-work
+    // fails mechanically and Cass is never dispatched.
+    // Blocker-34 follow-up: the package.json `version` check is a mechanical
+    // git fact, not a reviewer judgment. For npm projects the workflow checks
+    // it here, before Cass is dispatched — a touched `version` fails Review
+    // mechanically (versions are assigned at publish time, never in
+    // branches). Fail closed: anything but an explicit VERSION_CLEAN counts
+    // as touched.
+    if (PUBLISH_TYPE === "npm") {
+      try {
+        var vtResult = await agent(
+          "Check whether the task branch changed package.json's `version` field. This is a mechanical git check, not a judgment call.\n" +
+          "Run in shell and return the stdout verbatim:\n" +
+          LIFECYCLE_ENV + LIFECYCLE + " version-check " + taskId,
+          { key: "version-check" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Checking package.json version (mechanical)" }
+        );
+        var vtStr = (typeof vtResult === "string") ? vtResult : JSON.stringify(vtResult);
+        var vtMatch = /^\s*VERSION_(TOUCHED|CLEAN)\s*$/im.exec(vtStr);
+        versionTouched = !(vtMatch && vtMatch[1].toUpperCase() === "CLEAN");
+      } catch (vtErr) {
+        versionTouched = true;
+        log("Version check failed (" + String(vtErr && vtErr.message || vtErr).slice(0, 120) + ") — failing closed as touched");
+      }
+      log("Review: package.json `version` " + (versionTouched ? "touched by the branch — mechanical FAIL, Cass not dispatched" : "untouched — mechanical check clean"));
+    }
+    // The empty-branch rule Cass used to adjudicate is gone. What she
+    // examines and what rule she applies depend on the classified state —
+    // never on her own judgment of git identity.
+    var reviewChangeExam, reviewBranchRule;
+    if (branchState === "has-work") {
+      reviewChangeExam =
+        "Examine the code changes by running:\n" +
+        LIFECYCLE_ENV + LIFECYCLE + " inspect " + taskId + "\n\n" +
+        "The inspect output is authoritative: it prints the task branch's actual tip commit (TIP) and every commit ahead of the integration target (inspect prints the target name). Base your review ONLY on this output — do NOT run git log yourself to pick commits, and do NOT discuss commit hashes from any other source (they may come from stale rework rounds or a different repo).\n\n";
+      reviewBranchRule =
+        "MECHANICAL FACT (computed by the workflow from git — never by a reviewer): branch state = has-work. The branch has commits ahead of the integration target. Review their content; branch emptiness is settled and is not yours to judge.\n";
+    } else if (branchState.indexOf("already-merged:") === 0) {
+      reviewChangeExam =
+        "The change under review is the frozen merge " + alreadyMergedSha + " — it is already on the integration target (see MECHANICAL FACT below). Examine it by running:\n" +
+        "cd " + REPO_PATH + " && git diff " + alreadyMergedSha + "^1 " + alreadyMergedSha + "\n\n" +
+        "That first-parent diff is the frozen, attributable change. Base your review ONLY on this diff — do NOT run git log to pick commits, and do NOT discuss commit hashes from any other source (they may come from stale rework rounds or a different repo).\n\n";
+      reviewBranchRule =
+        "MECHANICAL FACT (computed by the workflow from git — never by a reviewer): branch state = already-merged:" + alreadyMergedSha + ". The deliverable landed on the integration target via this task's own prior merge " + alreadyMergedSha + " (verified ancestor of the integration target). The branch is empty by design — emptiness is settled fact, not a finding.\n";
+    } else if (buildClaimedNoDiff) {
+      reviewChangeExam =
+        "The branch has no commits ahead of the integration target (see MECHANICAL FACT below) — there is no diff to examine. Judge the Build report's `repo_diff: none` claim on its plausibility.\n\n";
+      reviewBranchRule =
+        "MECHANICAL FACT (computed by the workflow from git — never by a reviewer): the branch has no commits ahead of the integration target and no task-attributed merge on the target was verified; the Build report declares `repo_diff: none` (no repo change). Approve ONLY if the task's deliverable is plausibly runtime state (e.g. a cron definition, scheduler change, or dashboard/config state created outside the repo). Otherwise report 'no commits ahead of the integration target and no plausible runtime-state deliverable — the builder likely forgot to commit', then end your report with exactly this line: VERDICT: FAIL.\n";
+    } else {
+      // Mechanical FAIL — Cass is never dispatched (see the dispatch gate
+      // below). Instructions are unused; keep the shape.
+      reviewChangeExam = "";
+      reviewBranchRule = "";
     }
     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" +
-      LIFECYCLE_ENV + LIFECYCLE + " inspect " + taskId + "\n\n" +
-      "The inspect output is authoritative: it prints the task branch's actual tip commit (TIP) and every commit ahead of the integration target (inspect prints the target name). Base your review ONLY on this output — do NOT run git log yourself to pick commits, and do NOT discuss commit hashes from any other source (they may come from stale rework rounds or a different repo).\n\n" +
+      reviewChangeExam +
       "You can also read specific files in the worktree at:\n" +
       WORKTREE_HINT + "/\n\n" +
       "Check quality, correctness, and spec compliance.\n" +
       (SURFACE_TERMINAL ? "TERMINAL UX REVIEW: judge the CLI surface against " + UX_DOCTRINE_PATH + " — help accuracy, error quality, exit codes, output clarity. Reject when the bar is not met.\n" : "") +
       (SURFACE_ARTIFACT ? "ARTIFACT UX REVIEW: judge the rendered surface against " + UX_DOCTRINE_PATH + " — alignment, spacing, hierarchy, composition, balance, finish, correctness. Reject when the bar is not met.\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 the integration target (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 the integration target: YES)" : "none declared") + ". Otherwise report 'no commits ahead of the integration target 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. First resolve the integration target: " + LIFECYCLE_ENV + LIFECYCLE + " integration-target. Then check: cd " + REPO_PATH + " && git diff <target>..." + TASK_BRANCH + " -- package.json (substitute the exact token integration-target printed — when it prints HEAD, use the literal word HEAD: `git diff HEAD...<branch>` diffs the detached checkout against the branch). 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() + ". " +
+      reviewBranchRule +
+      (PUBLISH_TYPE === "npm" ? "PACKAGE VERSION: this project publishes to the npm registry, and versions are assigned at publish time — never in branches.\n" +
+      "MECHANICAL FACT (computed by the workflow from git — never by a reviewer): the task branch did not change package.json's `version` field. A branch that touches `version` fails Review mechanically before any reviewer is dispatched, so this is settled — do not re-check it.\n" +
+      "The accepted Build report declares: " + releaseDecisionText() + ". " +
       (releaseDecision
         ? "Validate this decision against the change: release must be 'yes' when the change is consumer-observable and 'no' when internal-only; the version_bump scope must fit the change (patch for fixes, minor for new behavior, major for breaking changes). If the decision is wrong or mis-scoped, report your notes, then end with exactly this line: VERDICT: FAIL."
         : "The decision is missing or malformed — report 'Build report must end with release: yes|no and (when release is yes) version_bump: patch|minor|major lines', then end with exactly this line: VERDICT: FAIL.") + "\n" : "") +
@@ -1274,8 +1409,9 @@ while (i < STEPS.length) {
       "Then run: "+ LIFECYCLE_ENV + "WORKFLOW_RUN_ID=" + lockHolder + " CREW_STAGED_BASE=<provenance.source_commit, empty when null> integrate " + taskId + " \"merge: fix: " + safeTitle + "\\\"\\n" +
       "The script merges, reconciles, records, and pushes under the merge lock. Informational only: RECONCILED, NO_REMOTE, NO_REMOTE_RECONCILE. Read the output:\n" +
       "- STAGED_BASE_MISMATCH: the line left the staged base (stray checkout). VERDICT: FAIL.\n" +
-      "- MERGED_EMPTY — check FIRST (it contains the word MERGED): either a runtime-state deliverable or an already-merged sha the workflow verified (Build declared repo_diff: none). No lock taken, no new commit. Report 'merged empty: no repo changes'. VERDICT: PASS.\n" +
+      "- MERGED_EMPTY — check FIRST (it contains the word MERGED): either a runtime-state deliverable or a task-attributed merge the workflow verified from the task's own merge records. No lock taken, no new commit. Report 'merged empty: no repo changes'. VERDICT: PASS.\n" +
       "- MERGED: the merge landed; the script pushed inline. Read the push line: PUSHED — report the hash (detached prints PUSHED: origin/main (refspec HEAD:main)), VERDICT: PASS; NO_REMOTE_PUSH — no remote configured, VERDICT: PASS; ERROR after MERGED — a retry recovers the push; report it, VERDICT: FAIL.\n" +
+      "- STALE_MERGE: the recorded merge no longer matches the task branch (rework moved it after the merge) — the script refused to push stale state. Report the STALE_MERGE line, VERDICT: FAIL.\n" +
       "- LOCK_HELD: 10-minute backoff exhausted. VERDICT: FAIL.\n" +
       "- CONFLICT: the plain merge failed — aborted, the target is clean, and your task still holds the merge lock. Do NOT fail yet. Resolve it:\n" +
       "RESOLUTION:\n" +
@@ -1325,8 +1461,9 @@ while (i < STEPS.length) {
       // See docs/decisions/publish-path.md#deterministic-artifact-publish: the work agent never publishes; the parent runs the deterministic publish script.
       // Blocker 22 (one-party publish, room #24): verified re-entry guard.
       // The workflow parks at publish intent; the tick worker issues
-      // artifact_edit, verifies by read-back, stamps provenance, and
-      // re-queues. The dispatcher resumes this task at the Publish step
+      // artifact_edit; the ack scan stamps provenance on exact per-attempt
+      // version acknowledgement (sole positive completion criterion; no
+      // read-back — docs/publish-verification.md) and re-queues. The dispatcher resumes this task at the Publish step
       // (the parked session's own step — the failed→retry path). If the
       // stamped provenance names THIS task and its source_commit is the
       // repo's current HEAD, the merge commit was already published and
@@ -1382,8 +1519,10 @@ while (i < STEPS.length) {
         }
         // See docs/decisions/publish-path.md#step1-builder-source: the builder's source tree is NOT the crew's repo; verify report before stamping.
         // (2026-09-20, one-party worker-owned publish) A verified re-entry
-        // skips the whole issuance tail: the edit already went out, was
-        // verified by the parent read-back, and was stamped. The empty-diff
+        // skips the whole issuance tail: the edit already went out, the
+        // ack scan saw the exact per-attempt version acknowledged (sole
+        // positive completion criterion; no read-back) and it was stamped.
+        // The empty-diff
         // park must not fire on this branch.
         if (!publishSkippedNoLock && !publishAlreadyVerified) {
         // The trigger key of the attempt that last ran, for the publish ledger.
@@ -1485,7 +1624,7 @@ while (i < STEPS.length) {
         var publishDiffFile = crewHome + "/.publish-diffs/" + taskId + (totalReworkCount > 0 ? "-r" + totalReworkCount : "") + ".diff";
         var diffResult = await agent(
           "Run exactly one command and nothing else:\n" +
-          "node " + COMPUTE_DIFF + " --repo-path \"" + REPO_PATH + "\" --base " + publishBase + " --out \"" + publishDiffFile + "\"\n" +
+          "node " + COMPUTE_DIFF + " --repo-path \"" + REPO_PATH + "\" --base " + publishBase + " --task-id \"" + taskId + "\" --attempt 1 --out \"" + publishDiffFile + "\"\n" +
           "The script prints one small JSON object to stdout. Return the stdout verbatim as { \"output\": \"<verbatim stdout>\" } and nothing else. Do not interpret it.",
           { key: attemptKey("publish-artifact-diff-" + taskId, totalReworkCount), label: "Computing publish diff from stamped base",
             schema: { type: "object", properties: { output: { type: "string" } }, required: ["output"] } }
@@ -1508,6 +1647,18 @@ while (i < STEPS.length) {
         var mergeCommitForPublish = String(diffSummary.commit || "").trim();
         var mergeCommitShortForPublish = String(mergeCommitForPublish).substring(0, 7) || "unknown";
         var publishDiffSha256 = String(diffSummary.sha256 || "");
+        // (0.14.6) The per-attempt publish version, synthesized into the
+        // staged diff as .crew-publish-version-<task_id> (per-task receipt —
+        // two same-project tasks can publish concurrently) by the
+        // deterministic script.
+        // The workflow never invents it: the script derives it from
+        // task+commit+attempt, and the intent scan re-derives it before
+        // claiming. A missing/malformed version parks — never publish blind.
+        var publishVersion = String(diffSummary.version || "");
+        // Mirrors isPublishVersion() in lib/crew-api.js: <40-hex commit>:<attempt>.
+        if (!/^[0-9a-f]{40}:[1-9][0-9]*$/.test(publishVersion)) {
+          return await parkTask("Publish diff for commit " + (mergeCommitForPublish || "unknown") + " carries no usable publish version — cannot stage a verifiable intent. Human attention needed.");
+        }
         if (!diffSummary.bytes) {
           return await parkTask("Publish diff is empty for commit " + (mergeCommitForPublish || "unknown") + " — a merge lock was held but there is no change to carry. Human attention needed.");
         }
@@ -1517,6 +1668,20 @@ while (i < STEPS.length) {
         if (diffSummary.has_rename) {
           return await parkTask("Publish diff contains a rename — the diff transport cannot carry renames. Human attention needed.");
         }
+        // Room #26 blocker 38 (2026-09-21): persist the publish-diff file
+        // set for QA content-finding attribution. The workflow classifies
+        // Hazel's content findings against this set mechanically at QA
+        // closeout — the file list is the complete record of what the task
+        // changed. The courier is pure hands: it writes the deterministic
+        // script's own file list, never interprets it.
+        var publishDiffFilesPath = crewHome + "/.publish-diffs/" + taskId + ".files.json";
+        await agent(
+          "Write the publish diff file list.\n" +
+          "Run exactly this and return the stdout verbatim:\n" +
+          "mkdir -p " + crewHome + "/.publish-diffs && cat > \"" + publishDiffFilesPath + "\" <<'DIFFFILES_EOF'\n" +
+          JSON.stringify(diffSummary.files || []) + "\nDIFFFILES_EOF\n",
+          { key: attemptKey("publish-diff-files-" + taskId, totalReworkCount), label: "Persisting publish diff file list" }
+        );
         // Budget counts CHANGED lines (added + removed), not raw unified-diff
         // output lines: context lines and file headers inflated the old
         // split("\n").length count ~2x, parking a 95-line change against a
@@ -1535,131 +1700,53 @@ while (i < STEPS.length) {
         // worker verifies the sha256 from the intent entry before issuing;
         // a mismatch stops issuance. (2026-09-20, one-party worker-owned
         // publish: the workflow no longer issues the edit itself.)
-        // See docs/decisions/publish-path.md#durable-evidence-snapshot: snapshot the audit-dir listing BEFORE the trigger; fallback diffs before/after.
-        var auditDirsBeforeTrigger = [];
-        var auditBeforeOk = false;
-        // Pre-trigger baselines (design §1.9): the audit-dir listing and the
-        // manifest snapshot. The verified-path freshness check compares the
-        // post-trigger manifest against the baseline (built_at advance +
-        // content_sha256 change). Best-effort, never gates — a missing
-        // manifest baseline fails the verified path closed.
-        var preTriggerManifest = null;
-        try {
-          var auditBefore = await agent(
-            "Capture pre-trigger baselines for slug \"" + PUBLISH_SLUG + "\" (best-effort snapshots, never gates).\n" +
-            "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null; echo ---MANIFEST---; cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/.space-build/manifest.json 2>/dev/null\n" +
-            "Return JSON { \"dirs\": \"<newline-separated names, empty string when missing>\", \"manifest\": \"<the manifest's full text, or empty string when missing/unreadable>\" } and nothing else.",
-            { key: attemptKey("publish-baseline-before-" + taskId, totalReworkCount), label: "Snapshotting baselines before rebuild trigger",
-              schema: { type: "object", properties: { dirs: { type: "string" }, manifest: { type: "string" } }, required: ["dirs", "manifest"] } }
-          );
-          auditDirsBeforeTrigger = String((auditBefore && auditBefore.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
-          var manifestText = String((auditBefore && auditBefore.manifest) || "").trim();
-          if (manifestText) {
-            var manifestJson = JSON.parse(manifestText);
-            preTriggerManifest = {
-              built_at: typeof manifestJson.built_at === "string" ? manifestJson.built_at : null,
-              content_sha256: typeof manifestJson.content_sha256 === "string" ? manifestJson.content_sha256 : null,
-            };
-          }
-          // Arm only after both baselines parse.
-          auditBeforeOk = true;
-          log("Publish pre-trigger baselines for task " + taskId + ": " + auditDirsBeforeTrigger.length + " audit dirs, manifest " + (preTriggerManifest ? "built_at=" + preTriggerManifest.built_at : "none"));
-        } catch (auditBeforeErr) {
-          log("Publish pre-trigger baselines failed for task " + taskId + " (non-fatal): audit fallback DISABLED for this attempt — without a baseline, historical dirs would look new: " + (auditBeforeErr && auditBeforeErr.message ? auditBeforeErr.message : auditBeforeErr));
-        }
-
-        // See docs/decisions/publish-path.md#fire-and-forget-trigger: the trigger child returns immediately; the workflow owns observation and verdict.
-        var publishToolsOk = false;
-        var publishToolsMissing = false;
-        for (var toolcheckAttempt = 1; toolcheckAttempt <= 2 && !publishToolsOk; toolcheckAttempt++) {
-          try {
-            var toolcheckResult = await agent(
-              "Check whether the artifact tool namespace is available.\n" +
-              "Call tool_search.load_tool_namespace with paths [\"artifact\"].\n" +
-              "Then emit exactly one line and nothing else: ARTIFACT_TOOLS: <ok if the load succeeded and artifact_edit and artifact_status are now functions, missing otherwise>.\n" +
-              "Return JSON { \"signal\": \"<the exact ARTIFACT_TOOLS line>\" } and nothing else.",
-              { key: attemptKey("publish-artifact-toolcheck-" + taskId + (toolcheckAttempt === 1 ? "" : "-retry2"), totalReworkCount),
-                label: "Checking artifact tool availability" + (toolcheckAttempt === 1 ? "" : " (retry)"),
-                schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] } }
-            );
-            var toolSignal = String((toolcheckResult && toolcheckResult.signal) || "");
-            if (/ARTIFACT_TOOLS:\s*ok/.test(toolSignal)) {
-              publishToolsOk = true;
-            } else if (/ARTIFACT_TOOLS:\s*missing/.test(toolSignal)) {
-              publishToolsMissing = true;
-            }
-            log("Publish artifact toolcheck for task " + taskId + " (attempt " + toolcheckAttempt + " of 2): " +
-              (publishToolsOk ? "tools ok" : publishToolsMissing ? "tools missing (explicit parsed signal)" : "inconclusive (no ARTIFACT_TOOLS signal parsed)"));
-          } catch (toolcheckErr) {
-            log("Publish artifact toolcheck for task " + taskId + " (attempt " + toolcheckAttempt + " of 2) threw (" + (toolcheckErr && toolcheckErr.message ? toolcheckErr.message : toolcheckErr) + ") — inconclusive: a throw proves nothing about tool availability, never counted as missing");
-          }
-        }
-        if (!publishToolsOk && !publishToolsMissing) {
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            agent_id: null,
-            applied_report: null,
-            outcome: "unknown",
-            detail: "artifact toolcheck inconclusive after two attempts (throws or unparseable signals — never an explicit ARTIFACT_TOOLS: missing): tool availability unproven, so the trigger was NOT issued; unknown parks fail closed with no blind retry"
-          }, totalReworkCount);
-          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact toolcheck was inconclusive after two attempts (no explicit ARTIFACT_TOOLS signal parsed — a throw is transport noise, not evidence). Tool availability is unproven, so no edit was issued and nothing was retried blindly. Human attention needed.");
-        }
-        if (!publishToolsOk) {
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            agent_id: null,
-            applied_report: null,
-            outcome: "rejected",
-            detail: "artifact tool namespace explicitly missing (parsed ARTIFACT_TOOLS: missing signal, one bounded retry spent): the edit provably did not go through — no trigger issued, no blind retry"
-          }, totalReworkCount);
-          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact tool namespace was explicitly missing (parsed signal — the edit provably did not go through, so no trigger was issued and nothing was retried blindly). Human attention needed.");
-        }
-        // See docs/decisions/publish-path.md#pretrigger-baseline: a tiny schema'd baseline is captured before the trigger.
-        var baselineAgentId = null;
-        var baselineFailed = false;
-        try {
-          var publishBaseline = await agent(
-            ARTIFACT_LOAD_PREAMBLE +
-            "Call artifact_status with slug \"" + PUBLISH_SLUG + "\" once.\n" +
-            "Return JSON { \"build\": <the raw \"build\" value exactly as returned, or null when there is none> } and nothing else.",
-            { key: attemptKey("publish-artifact-baseline-" + taskId, totalReworkCount), label: "Reading pre-trigger build state",
-              schema: { type: "object", properties: { build: { type: ["object", "null"] } }, required: ["build"] } }
-          );
-          baselineAgentId = (publishBaseline && publishBaseline.build && typeof publishBaseline.build.agent_id === "string" && publishBaseline.build.agent_id) || null;
-          log("Publish pre-trigger baseline for task " + taskId + ": " + (baselineAgentId ? "build " + baselineAgentId + " already in flight (predates the trigger — never attributed to this edit)" : "no build in flight"));
-        } catch (baselineErr) {
-          baselineFailed = true;
-          log("Publish pre-trigger baseline read failed for task " + taskId + " (" + (baselineErr && baselineErr.message ? baselineErr.message : baselineErr) + ") — receipt attribution skipped; durable audit-dir evidence is the only positive signal");
-        }
         // (2026-09-20, one-party worker-owned publish) The workflow exits
         // Publish at intent. Everything above — preflight, provenance base,
+        // checksummed diff — is read-only. (2026-09-20 REVIEW: the
+        // pre-trigger baselines, artifact toolcheck, and pre-trigger build
+        // state agent steps were deleted — their outputs fed only the
+        // retired content-verdict/receipt-attribution machinery, and the
+        // toolcheck ran in a workflow child that cannot reach artifact_edit.
+        // Issuance belongs to the session-carrying tick worker, which
+        // handles tool-unavailability as inconclusive per the tick protocol.)
+        // Publish at intent. Everything above — preflight, provenance base,
         // checksummed diff, toolcheck, pre-trigger baselines — is read-only.
         // Issuance belongs to the session-carrying tick worker
-        // (scan-publish-unknown's intent bucket), the only caller class that
+        // (scan-publish-intent's intent bucket), the only caller class that
         // can reach artifact_edit. This entry is issuer-written BY THE
         // WORKFLOW and names the intent: outcome "publish-intent", never
         // "submitted" — the workflow issued nothing. The worker claims it
         // via the park note below.
-        await recordPublishLedger({
+        // (2026-09-20 REVIEW) The intent ledger entry is the anchor the
+        // whole machine depends on. If the ferry drops it, the task would
+        // park with publish-requested and no anchor — unclaimable forever.
+        // Fail loudly instead of parking an orphan intent.
+        var intentAnchored = await recordPublishLedger({
           commit: mergeCommitForPublish,
           attempt: rebuildAttemptKey,
+          // (0.14.6) Attempt 1, staged here. The version is the attempt's
+          // deterministic receipt string, synthesized into the staged diff;
+          // the ack scan re-derives it from task+commit+attempt before the
+          // tick worker may issue the edit.
+          publish_attempt: 1,
+          version: publishVersion,
           agent_id: null,
           applied_report: null,
-          manifest_before: preTriggerManifest,
           outcome: "publish-intent",
           issuer: "workflow",
           diff_path: publishDiffFile,
           diff_sha256: publishDiffSha256,
           // (2026-09-20, critic-0145 F-A4) The base the diff was computed
-          // against: scan-publish-unknown's intent branch compares it with
+          // against: scan-publish-intent's intent branch compares it with
           // current stamped provenance and re-queues the task when it went
           // stale — never issues the stale diff.
           base: publishBase,
-          detail: "publish intent: preflight, checksummed diff, toolcheck, and pre-trigger baselines are complete; issuance is owned by the session-carrying tick worker. The workflow performed no artifact_edit and wrote no issuance."
+          detail: "publish intent: preflight and checksummed diff are complete; issuance is owned by the session-carrying tick worker. The workflow performed no artifact_edit and wrote no issuance."
         }, totalReworkCount);
-        return await parkTask("publish: publish-requested " + mergeCommitForPublish + " " + rebuildAttemptKey + " — Publish intent recorded for task " + taskId + ": the merged change is staged as a checksummed diff (" + publishDiffFile + ", sha256 " + publishDiffSha256 + ") for the crew's publish worker to issue. The worker verifies the build and stamps provenance before this task resumes; no action needed.");
+        if (!intentAnchored) {
+          throw new Error("publish-intent ledger anchor write unconfirmed for task " + taskId + " — refusing to park an unclaimable intent; the Publish phase fails loudly instead");
+        }
+        return await parkTask("publish: publish-requested " + mergeCommitForPublish + " attempt=1 — Publish intent recorded for task " + taskId + ": the merged change is staged as a checksummed diff (" + publishDiffFile + ", sha256 " + publishDiffSha256 + ") carrying the per-attempt publish version for the crew's publish worker to issue. The worker issues the edit directly and the acknowledgement scan owns the task from there; no action needed.");
         } // end: publishSkippedNoLock — no rebuild, no stamp, nothing to ship
         // STEP 2 (mechanical, always — skip path included): post-deploy
         // commits builder leftovers if any, removes the worktree, and releases
@@ -1704,11 +1791,13 @@ while (i < STEPS.length) {
       // mechanical outcome above. It must not rebuild or re-stamp: a second
       // artifact_edit would trigger a duplicate build.
       // (2026-09-20, one-party worker-owned publish) On a verified re-entry
-      // the publish was issued by the crew worker, verified by the parent
-      // read-back, and stamped — the work agent reports that, VERDICT: PASS.
+      // the publish was issued, the ack scan observed the artifact's exact
+      // version acknowledgement, and provenance was stamped — already
+      // verified, nothing to issue. The work agent reports that,
+      // VERDICT: PASS.
       if (publishAlreadyVerified) {
         instructions = "Publish was already completed and verified for this task — do NOT call artifact_edit, artifact_status, setprovenance, or post-deploy yourself; doing so would disturb the finalized state.\n\n" +
-          "The crew's publish worker issued the artifact edit for the merged commit, the parent's independent content read-back confirmed the artifact contains the merged change, and provenance was stamped (docs/publish-verification.md). This Publish pass is a verified re-entry after the stamp: there is nothing to issue and nothing to re-verify.\n\n" +
+          "Provenance stamps this task's merge commit as published (docs/publish-verification.md): the tick worker issued the edit, the ack scan observed the artifact's exact version acknowledgement — the sole positive completion criterion — and the publish was stamped. Already verified, nothing to issue and nothing to re-verify.\n\n" +
           "For the change summary, run: cd " + REPO_PATH + " && git log -1 --stat\n\n" +
           "Write plain prose describing what was published, then on its own line: VERDICT: PASS\n" +
           "The VERDICT line must be the last line of your report.";
@@ -1721,10 +1810,10 @@ while (i < STEPS.length) {
       instructions = "Publish the merged code to the live artifact.\n\n" +
         "The publish was performed deterministically by the workflow before your step — do NOT call artifact_edit, artifact_status, setprovenance, or post-deploy yourself; doing so would trigger a duplicate build or disturb the finalized state. You perform no publish actions.\n\n" +
         "For the change summary, run: cd " + REPO_PATH + " && git log -1 --stat\n\n" +
-        "Mechanical outcome (the workflow's mechanical steps; content verification is the parent's, still pending):\n" +
+        "Mechanical outcome (the workflow's mechanical steps; the ack scan's version-acknowledgement check is still pending):\n" +
         "- merge lock refreshed: yes\n" +
         "- artifact rebuild triggered and completed: yes\n" +
-        "- provenance stamped: NO — not yet, and you must NOT stamp it. The stamp moved to the parent, which stamps it only after an independent content read-back confirms the artifact actually contains the merged change (docs/publish-verification.md). A stamped-but-hollow build is exactly how canary run 8 (2026-09-11) went green on stale content.\n" +
+        "- provenance stamped: NO — not yet, and you must NOT stamp it. The ack scan stamps it when it observes the artifact's exact on-disk acknowledgement of this attempt's version — version acknowledgement is the sole positive completion criterion (docs/publish-verification.md). A stamped-but-hollow build is exactly how canary run 8 (2026-09-11) went green on stale content.\n" +
         "- post-deploy finalized: yes (worktree removed, merge lock released)\n\n" +
         "POLICY: The live artifact is rebuilt only in this phase, from the repo. Never use artifact_edit to change the artifact directly — fixes go through the repo and the loop. A source fix is not done until the artifact is rebuilt from it here.\n\n" +
         "The repo push already happened in Integrate — do NOT push to git in this phase.\n\n" +
@@ -1756,7 +1845,7 @@ while (i < STEPS.length) {
       "Verify the fix against the task description in the returned data: the state the bug corrupted should now read correctly, and the task's own expected behavior should hold.\n" +
       "You can also check specific data with: node " + CREW_API + " --crew-home " + crewHome + " get-events --json '{\"task_id\":\"<the task id>\"}'.\n" +
       "Do NOT use artifact_inspect — it was removed by the platform (2026-09-14) and does not exist; do not substitute artifact.inspect (malfunction diagnosis, not an inspection tool).\n" +
-      "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" +
+      "File follow-up tasks by running in shell (EXCEPT content findings — user-visible content/data goes in the CONTENT-FINDINGS block at the end of these instructions, never through create-task):\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" +
       npmPublishCheck +
       "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.";
@@ -1784,7 +1873,7 @@ while (i < STEPS.length) {
         "Verify the fix against the task description in the returned data: the state the bug corrupted should now read correctly, and the task's own expected behavior should hold.\n" +
         "You can also check specific data with: node " + CREW_API + " --crew-home " + crewHome + " get-events --json '{\"task_id\":\"<the task id>\"}'.\n" +
         npmPublishCheck +
-        "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" +
+        "File follow-up tasks by running in shell (EXCEPT content findings — user-visible content/data goes in the CONTENT-FINDINGS block at the end of these instructions, never through create-task):\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\"]' [--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).";
@@ -1811,7 +1900,7 @@ while (i < STEPS.length) {
         "Use the returned tasks, sessions, and events to check the task's data-level effects.\n" +
         "DOCS GATE: If the change is public-affecting (it alters anything a user or consumer can observe: API actions, parameters, behavior, or errors), verify the public docs describe it. If public docs are missing or stale for a public-affecting change, report 'public docs missing/stale for [the change]', then end your report with exactly this line: VERDICT: FAIL. QA always fails when public-affecting changes lack public docs. Guide/tutorial gaps are lower priority — file a follow-up task for those instead of failing.\n\n" +
         "STEP 3: File follow-up tasks for any related issues you discover.\n" +
-        "For each issue, run in shell:\n" +
+        "For each issue (EXCEPT content findings — user-visible content/data goes in the CONTENT-FINDINGS block at the end of these instructions, never through create-task), run in shell:\n" +
         "node " + CREW_API + " --crew-home " + crewHome + " create-task --json '{\"title\": \"<issue title>\", \"description\": \"<issue details>\", \"project\": \"" + LAUNCH_PROJECT_ID + "\", \"workflow\": \"bugfix\", \"filed_by\": \"hazel\"}'\n" +
         "(replace <issue title> and <issue details> with the real values).\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. When the baseline is terminal transcripts, confirm every terminal target you judged has a baseline transcript: a target with no pre-change transcript is an evidence gap — name it in --missing, never invent the baseline.\n\n" +
@@ -1830,6 +1919,21 @@ while (i < STEPS.length) {
         "2. Run: cd " + REPO_PATH + " && git log --format=%s <provenance.source_commit>..LIVE_HEAD (substitute real values). Every subject line MUST start with \"rebuild: \". If any line does not, report 'provenance mismatch: live HEAD moved past the stamped commit with non-rebuild source commits: [paste the offending subject lines]', then end your report with exactly this line: VERDICT: FAIL.\n\n" +
         instructions;
     }
+    // Room #26 blocker 38 (2026-09-21): content-finding attribution
+    // protocol. Hazel reports user-visible content/data observations in a
+    // machine-readable CONTENT-FINDINGS block; the workflow classifies each
+    // against the task's publish diff and files follow-ups itself — Hazel
+    // never files bugfixes for content findings directly, and
+    // environment-attributable content never fails her verdict alone.
+    var contentFindingsProtocol =
+      "CONTENT FINDINGS (machine-read — room #26 blocker 38): if you observe user-visible content or data that looks wrong, stale, or out of place (decks, cards, rows, text, files in the artifact — anything this task did not obviously produce), report it here — do NOT file a follow-up task for it yourself and do NOT fail your verdict for it alone. Emit exactly one line in this shape, immediately BEFORE your final VERDICT line (the verdict stays the last line of your report):\n" +
+      "CONTENT-FINDINGS: [{\"subject\": \"<repo-relative file path, or the literal live-data for content in the artifact's runtime data stores>\", \"observation\": \"<what you saw, one line>\"}, ...]\n" +
+      "Use subject \"live-data\" for anything you saw in the running artifact (UI content, database rows, uploaded files) — you are code-blind and cannot name its file. Use a repo-relative file path only when you know the content lives in a specific file (e.g. from the task description or public docs). When you saw no such content, emit the empty array: CONTENT-FINDINGS: [].\n" +
+      "The workflow classifies each finding against the task's publish diff: a finding whose subject file is in the diff is attributable to this task's change and the workflow files a bugfix for it; anything else is recorded with its attribution (environment-attributable, or unknown when the diff is unavailable) — the finding itself never spawns an artifact bugfix. No finding is ever dropped for looking like test residue: it is classified by attribution and recorded with it. Your VERDICT judges this task's change; content you cannot attribute to it is not a failure of this task.\n";
+    // The content-findings block is machine-read at closeout (blocker 38).
+    // Hazel emits it immediately before the VERDICT line, so the verdict
+    // keeps its trailing-window contract with extractVerdict.
+    instructions += "\n" + contentFindingsProtocol;
   }
 
   // Task event history — Review and Publish are excluded. Review is cold by
@@ -1888,7 +1992,31 @@ while (i < STEPS.length) {
   }
   var workerResult = null;
   var workAttempts = [];
-  for (var workAttempt = 0; workAttempt <= 2; workAttempt++) {
+  // Room #26 blocker 34 (redesign): an empty branch with no verified sha and
+  // no repo_diff: none claim fails Review mechanically — Cass is never
+  // dispatched, so no reviewer adjudicates the emptiness. The synthetic
+  // report below is written by the workflow and flows through the same
+  // verdict extraction, structured verdict recording, and rejection/bounce
+  // path as a real FAIL.
+  // Blocker-34 follow-up: the npm `version` check joins the mechanical gate.
+  // Either mechanical fact fails Review without dispatching Cass.
+  var mechanicalFailReason = (versionTouched ? "version-touched" : (branchState === "empty-no-work" && !buildClaimedNoDiff ? "empty-no-work" : null));
+  var mechanicalReviewFail = (step.name === "Review" && mechanicalFailReason !== null);
+  if (mechanicalReviewFail) {
+    log("Review: " + mechanicalFailReason + " — mechanical FAIL, Cass not dispatched");
+    workerResult =
+      "MECHANICAL REVIEW VERDICT (written by the workflow — no reviewer was dispatched).\n" +
+      (mechanicalFailReason === "version-touched"
+        ? "Package.json `version` (checked by the workflow from git): the task branch changed the `version` field. Versions are assigned at publish time — never in branches. Remove the version change.\n"
+        : "Branch state (classified by the workflow from git): empty-no-work — the task branch has no commits ahead of the integration target, " +
+          "no task-attributed merge on the target was verified" + (branchStateErr ? " (branch classification itself failed: " + branchStateErr + ")" : "") + ", " +
+          "and the accepted Build report declared no `repo_diff: none` deliverable. " +
+          "No change was reviewed because there is no change to review. The builder likely forgot to commit.\n") +
+      "Worktree: " + WORKTREE_HINT + "\n" +
+      "Recovery: commit the deliverable on the task branch in the worktree above and re-run Review. If the deliverable is genuinely runtime state outside the repo, declare `repo_diff: none` in the Build report instead of leaving the branch empty without a declaration.\n" +
+      "VERDICT: FAIL";
+  }
+  for (var workAttempt = 0; workAttempt <= 2 && !mechanicalReviewFail; workAttempt++) {
     var workKey = workAttempt === 0 ? workKeyBase : workRetryKey(step.name, (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), workAttempt);
     var prevAttempt = workAttempt === 0 ? null : workAttempts[workAttempt - 1];
     var retryReason = workAttempt === 0 ? null : (prevAttempt.threw ? "discarded" : (prevAttempt.outcome === "missing-artifact-tools" ? "no-tools" : (prevAttempt.outcome === "unavailable-shell-transport" ? "no-transport" : "empty")));
@@ -1989,7 +2117,18 @@ while (i < STEPS.length) {
           session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name,
             status: "failed", notes: "Worker report had no single unambiguous VERDICT: PASS/FAIL line (bounded re-ask exhausted)" },
           event: { task_id: taskId, type: "failed",
-            message: step.name + " verdict line missing or ambiguous, re-ask exhausted — phase failed, dispatcher will retry" }
+            message: step.name + " verdict line missing or ambiguous, re-ask exhausted — phase failed, dispatcher will retry" },
+          // Room #26 blocker 33: INDETERMINATE verdict record — the report
+          // could not be read at all, but its full text is still preserved
+          // as grounds. Review-scoped; other verdict steps keep the
+          // existing failed-session behavior with no verdict row.
+          verdict: (step.name === "Review" ? {
+            step: "Review",
+            attempt: totalReworkCount,
+            reviewer: step.identity,
+            verdict: "INDETERMINATE",
+            grounds: workerText
+          } : null)
         }),
         { key: "record-block-" + step.name, label: "Recording verdict failure" }
       );
@@ -2190,40 +2329,123 @@ while (i < STEPS.length) {
     }
     log("Build worktree confinement passed: " + wt.path);
 
-    // See docs/decisions/publish-path.md#already-merged-idem: an already-merged repo_diff is idempotent; no rebuild.
-    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" +
-        "TARGET=$(" + LIFECYCLE_ENV + LIFECYCLE + " integration-target) && cd " + REPO_PATH + " && git rev-parse --verify --quiet " + am.sha + " >/dev/null && git merge-base --is-ancestor " + am.sha + " $TARGET && echo ALREADY_MERGED_YES || echo ALREADY_MERGED_NO",
-        { key: "verify-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Verifying already-merged declaration" }
+    // Room #26 blocker 34 (redesign, 2026-09-21): capture the plain
+    // `repo_diff: none` (no repo change) claim from the FULL Build report.
+    // Each Build round sets this fresh from its own report; there is no
+    // cross-process fallback. The agent-authored already-merged
+    // declaration and its Build-closeout verification are deleted —
+    // attribution is the classifier's job at Review entry.
+    buildClaimedNoDiff = /repo_diff:\s*none/im.test(workerText || "");
+  }
+
+  // Room #26 blocker 38 (2026-09-21): content-finding attribution at QA
+  // closeout. Hazel's CONTENT-FINDINGS block is extracted deterministically
+  // and each finding is classified against the task's publish-diff file set
+  // (persisted at Publish). Attributable findings become bugfix tasks filed
+  // by the workflow; environment-attributable findings are recorded as task
+  // note events with their attribution — never suppressed, never a bugfix,
+  // never a park. No automatic FAIL override: if the QA agent still
+  // reports FAIL, it stands — finding attribution informs follow-up
+  // filing only.
+  if (step.name === "QA") {
+    var contentFindings = extractContentFindings(workerText);
+    if (!contentFindings.ok) {
+      // Unknown attribution fails closed: a missing or malformed
+      // CONTENT-FINDINGS block blocks the phase for retry — the way an
+      // unreadable VERDICT line does (record-phase failed + halted run).
+      // It must never degrade to "no findings" (fail-open): unknown
+      // attribution converted to an empty set silently drops the
+      // observations the prose grounds carry. Do NOT re-ask an LLM to
+      // repair a machine-readable contract — enforce the contract.
+      log("QA CONTENT-FINDINGS unreadable (" + contentFindings.reason + ") — marking failed for retry");
+      await agent(
+        "Record content-findings 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 report had no machine-readable CONTENT-FINDINGS block (" + contentFindings.reason + "); phase failed for retry" },
+          event: { task_id: taskId, type: "failed", message: "QA CONTENT-FINDINGS block unreadable (" + contentFindings.reason + ") — phase failed, dispatcher will retry" }
+        }),
+        { key: "record-block-" + step.name, label: "Recording content-findings failure" }
       );
-      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 the integration target — marking failed for retry");
+      return {
+        __hatchWorkflowControl: "blocked",
+        result: {
+          blocked_reason: "QA worker report had no machine-readable CONTENT-FINDINGS block (" + contentFindings.reason + ")",
+          message: "The " + step.identity + " agent's work may be valid — its report did not carry a CONTENT-FINDINGS block the workflow could read, and the attribution contract fails closed rather than degrading to \"no findings\". The report is preserved in the workflow log.",
+          task_id: taskId
+        }
+      };
+    }
+    // The publish-diff file set, persisted at Publish. Unreadable →
+    // attribution unknown: every finding records "unknown" with the
+    // reason naming the missing diff (never environment-attributable,
+    // never a bugfix). The QA verdict stands on its own.
+    var qaDiffFiles = [];
+    var qaDiffFilesOk = false;
+    try {
+      var qaDiffFilesOut = await agent(
+        "Run exactly one command and return the stdout verbatim:\n" +
+        "cat \"" + crewHome + "/.publish-diffs/" + taskId + ".files.json\" 2>/dev/null || echo DIFF_FILES_MISSING\n" +
+        "Return JSON { \"output\": \"<the command's full stdout, trimmed>\" } and nothing else.",
+        { key: attemptKey("qa-diff-files-" + taskId, totalReworkCount), label: "Loading publish diff file list",
+          schema: { type: "object", properties: { output: { type: "string" } }, required: ["output"] } }
+      );
+      var qaDiffFilesRaw = ((qaDiffFilesOut && qaDiffFilesOut.output) || "").trim();
+      if (qaDiffFilesRaw && qaDiffFilesRaw !== "DIFF_FILES_MISSING") {
+        var qaDiffParsed = JSON.parse(qaDiffFilesRaw);
+        if (Array.isArray(qaDiffParsed)) {
+          qaDiffFiles = qaDiffParsed;
+          qaDiffFilesOk = true;
+        }
+      }
+    } catch (e) {
+      log("QA diff file list unreadable: " + ((e && e.message ? e.message : String(e)) || "").slice(0, 200));
+    }
+    if (!qaDiffFilesOk) {
+      log("QA publish diff file list unavailable — content findings record attribution unknown");
+    }
+    for (var cfi = 0; cfi < contentFindings.findings.length; cfi++) {
+      var cf = contentFindings.findings[cfi];
+      // Unknown attribution fails closed: when the diff file set is
+      // unavailable we cannot attribute, so the finding is recorded as
+      // "unknown" (never environment-attributable, never a bugfix) and the
+      // QA verdict stands — the journey does not continue on unproven
+      // attribution.
+      var cfc = qaDiffFilesOk ? classifyContentFinding(cf, qaDiffFiles)
+        : { attribution: "unknown", reason: "publish diff file set unavailable — cannot attribute" };
+      if (cfc.attribution === "task-change") {
+        log("QA content finding attributable to task change — filing bugfix: " + cf.subject + " :: " + cf.observation.slice(0, 120));
         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 the integration target in the configured repo. The declaration is fabricated or mistaken; the work is not on the integration target. Phase failed for retry" },
-            event: { task_id: taskId, type: "failed", message: "Build already-merged declaration failed verification — " + am.sha + " not an ancestor of the integration target, phase failed, dispatcher will retry" }
-          }),
-          { key: "record-already-merged-fail-" + step.name, label: "Recording already-merged verification failure" }
+          "File the follow-up task.\n" +
+          "Run in shell and return the stdout verbatim:\n" +
+          "node " + CREW_API + " --crew-home " + crewHome + " create-task --json '" +
+          JSON.stringify({ title: "QA content finding: " + cf.observation.slice(0, 120), description: "Content finding from QA on task " + taskId + " (subject: " + cf.subject + ", classified task-change: " + cfc.reason + "). Observation: " + cf.observation, project: LAUNCH_PROJECT_ID, workflow: "bugfix", filed_by: "hazel" }).split("'").join("'\\''") + "'\n" ,
+          { key: attemptKey("qa-content-bugfix-" + taskId + "-" + cfi, totalReworkCount), label: "Filing attributable content bugfix" }
+        );
+      } else {
+        // environment-attributable and unknown findings are recorded as task
+        // note events with their attribution — never suppressed, never a
+        // bugfix, never a park by themselves. The QA verdict stands on its
+        // own: we do not override a FAIL based on finding attribution, because
+        // the verdict may rest on functional grounds the findings do not capture.
+        log("QA content finding " + cfc.attribution + " — recording, no bugfix: " + cf.subject + " :: " + cf.observation.slice(0, 120));
+        await agent(
+          "Record the " + cfc.attribution + " content finding.\n" +
+          "Run in shell and return the stdout verbatim:\n" +
+          crewCmd("log-event", { task_id: taskId, type: "note", message: "content-finding: " + cfc.attribution + " — subject: " + cf.subject + " — " + cf.observation + " (" + cfc.reason + ")" }) + "\n" ,
+          { key: attemptKey("qa-content-record-" + taskId + "-" + cfi, totalReworkCount), label: "Recording " + cfc.attribution + " finding" }
         );
-        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 the integration target. The work is not on the integration target; 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 the integration target");
     }
+    // No automatic FAIL override. The QA prompt instructs Hazel that her
+    // VERDICT judges this task's change and unattributable content is not a
+    // failure of this task; if she still reports FAIL, it stands. The
+    // recorded finding attributions (above) give the human the evidence to
+    // distinguish environment residue from task failure. Overriding a FAIL
+    // merely because all listed findings are environment-attributable would
+    // be too broad — the prose may name functional failures the findings do
+    // not capture.
   }
 
   // Deterministic closeout: no formatter agent. The verdict is mechanical
@@ -2235,6 +2457,9 @@ while (i < STEPS.length) {
     summary: workerText
   };
   let passed = stepResult.passed === true;
+  // Blocker 38: content findings are recorded with their attribution in the
+  // session notes above; the QA verdict stands on its own and is never
+  // overridden by finding attribution.
 
   // See docs/decisions/publish-path.md#integrate-verify: the agent cannot verify integrate mechanically; the workflow checks the diff.
   if (step.name === "Integrate" && passed) {
@@ -2320,10 +2545,10 @@ while (i < STEPS.length) {
     } // end: !npmPublishSkipped — a skipped publish has nothing to verify
   }
 
-  // Parent-owned verification (docs/publish-verification.md): the parent's
-  // scan builds the request via lib/build-readback-request.js and ferries
-  // the inspection; a skipped or failed publish has nothing to verify.
-  // See docs/decisions/publish-path.md#parent-owned-verification for history.
+  // Version acknowledgement (docs/publish-verification.md): the tick worker
+  // issues the edit directly and the ack scan owns the task from there —
+  // the exact per-attempt version on the artifact's disk is the sole positive
+  // completion criterion. A skipped or failed publish has nothing to ack.
   let summary;
   var workerMarkers = extractMarkerLines(workerText);
   if (step.name === "Publish" && PUBLISH_TYPE === "npm" && publishTarget && (publishVerified || npmPublishSkipped)) {
@@ -2337,9 +2562,23 @@ while (i < STEPS.length) {
   } else {
     summary = (stepResult.summary || "Step completed").slice(0, 2000 - workerMarkers.length - 1) + (workerMarkers ? "\n" + workerMarkers : "");
   }
-  // See docs/decisions/publish-path.md#already-merged: when the Build gate verifies already-merged, attestation is recorded.
-  if (step.name === "Build" && alreadyMergedSha) {
-    summary += "\nalready_merged_verified: " + alreadyMergedSha;
+  // Room #26 blocker 34 (redesign, 2026-09-21): machine-readable review
+  // basis, prepended to Review session notes for observability (proof
+  // rooms read the summary to see what Review examined and why a
+  // reviewer was or was not dispatched).
+  if (step.name === "Review" && branchState) {
+    var reviewBasisNote;
+    if (mechanicalReviewFail) {
+      reviewBasisNote = "REVIEW_BASIS: none — mechanical FAIL (" + mechanicalFailReason + "), no reviewer dispatched";
+    } else if (branchState.indexOf("already-merged:") === 0) {
+      var rbSha = branchState.slice("already-merged:".length);
+      reviewBasisNote = "REVIEW_BASIS: frozen merge " + rbSha + " — reviewed via git diff " + rbSha + "^1 " + rbSha;
+    } else if (branchState === "has-work") {
+      reviewBasisNote = "REVIEW_BASIS: branch diff — reviewed via inspect output (task branch vs integration target)";
+    } else {
+      reviewBasisNote = "REVIEW_BASIS: runtime-state-none — no repo change; plausibility of Build's repo_diff: none claim";
+    }
+    summary = reviewBasisNote + "\n" + summary;
   }
 
   // Visual verdict evidence (2026-09-15): no parent marker is appended. Hazel
@@ -2374,18 +2613,45 @@ while (i < STEPS.length) {
     releaseDecision = extractReleaseDecision(workerText);
   }
 
+  // Room #26 blocker 34 (redesign, 2026-09-21): structured review basis
+  // for the verdict row — what the review actually examined. A mechanical
+  // FAIL has no reviewer and no basis beyond the mechanical fact. Only
+  // computed for Review (branchState is null on other steps).
+  var reviewBasis = null;
+  if (step.name === "Review" && branchState) {
+    reviewBasis =
+      mechanicalReviewFail ? "mechanical-fail" :
+      branchState.indexOf("already-merged:") === 0 ? "frozen-merge:" + branchState.slice("already-merged:".length) :
+      branchState === "has-work" ? "branch-diff" : "runtime-state-none";
+  }
+
   await agent(
     "Update the session and log the event.\n" +
     "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
       task_id: taskId,
-      // Room #16 blocker 11: the workflow-verified already-merged sha as
-      // structured control state. Only the Build gate sets alreadyMergedSha
-      // (after the mechanical ancestor check); the API validates the shape
-      // and a later write without the field never clears it (COALESCE).
+      // Room #26 blocker 34 (2026-09-21): the already_merged_sha session
+      // field is no longer written — the agent-authored declaration path
+      // is deleted and nothing reads it. Removing the Crew API/database
+      // column is a separate API-surface follow-up, not bundled here.
       session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name,
-        status: status, notes: summary, already_merged_sha: (step.name === "Build" ? alreadyMergedSha : null) },
+        status: status, notes: summary },
       event: { task_id: taskId, type: status, identity: step.identity,
-        message: step.name + " " + status + " by " + step.identity }
+        message: step.name + " " + status + " by " + step.identity },
+      // Room #26 blocker 33: structured, non-lossy Review verdict record.
+      // The session note above is truncated; the verdict row carries the
+      // full worker report as grounds, written in the same transaction.
+      // attempt is the rework round (0 = first Review).
+      verdict: (step.name === "Review" && verdictPassed !== null ? {
+        step: "Review",
+        attempt: totalReworkCount,
+        // Room #26 blocker 34 (redesign): a mechanical FAIL has no
+        // reviewer — the workflow wrote the verdict. Identity rows still say
+        // the Review step ran.
+        reviewer: mechanicalReviewFail ? "workflow" : step.identity,
+        verdict: verdictPassed ? "PASS" : "FAIL",
+        review_basis: reviewBasis,
+        grounds: workerText
+      } : null)
     }),
     {
       key: "record-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
@@ -2405,21 +2671,20 @@ while (i < STEPS.length) {
 
   // Review/QA rejection bounces to Build
   if (!passed && (step.name === "Review" || step.name === "QA")) {
+    // Room #26 blocker 34 (redesign, 2026-09-21): the false-negative guard,
+    // the Case B budget skip, and the already-merged corrective are all
+    // gone. Emptiness is classified mechanically before Review, so a
+    // rejected Review is never re-adjudicated here — the workflow owns the
+    // git facts, the reviewer owns quality/spec compliance, and the budget
+    // applies uniformly to every rejection. A rejected frozen merge
+    // bounces with the reviewer's notes; a real fix commit becomes
+    // has-work, and a do-nothing loop exhausts the normal budget.
     totalReworkCount++;
     if (totalReworkCount > MAX_TOTAL_REWORK) {
       log("Shared rework budget exhausted for task " + taskId + " — worktree preserved at " + WORKTREE_PRESERVED_HINT + " for manual inspection");
       return await parkTask("Exceeded shared rework budget (" + MAX_TOTAL_REWORK + " total rework attempts across Review and QA) after " + step.name + " rejection. Worktree preserved.");
     }
     rejectionNotes = summary;
-    // Already-merged corrective (room #16 blocker 11): when Review rejected
-    // an empty branch but the work is already on the integration target (the workflow verified
-    // the sha), Wren must declare it — not re-implement or re-commit
-    // already-landed work. Scoped to the empty-branch rejection; any other
-    // rejection already carries its own specific notes.
-    if (step.name === "Review" && alreadyMergedSha && /no commits ahead of (main|the integration target)/i.test(summary)) {
-      rejectionNotes += "\n\nCORRECTIVE (from the workflow, not the reviewer): the deliverable is already on the integration target — the workflow mechanically verified that " + alreadyMergedSha + " is an ancestor of the integration target. Do NOT re-implement the work and do NOT create a new commit for it. In your Build report, declare exactly: repo_diff: none (already-merged: " + alreadyMergedSha + ") — then end with VERDICT: PASS.";
-      log("Rework corrective appended for task " + taskId + ": already-merged " + alreadyMergedSha + " — Wren must declare, not rebuild");
-    }
     i = BUILD_INDEX;
     log(step.name + " rejected — bouncing to Build (rework #" + totalReworkCount + " of " + MAX_TOTAL_REWORK + ")");
     continue;