muse-crew 0.14.6 → 0.14.8

package/workflows/standard.js

@@ -163,6 +163,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;
@@ -264,6 +320,142 @@ function buildTransportRetryTrailer(stepName, repoPath, taskId, attempt, reason)
     "if the " + stepName + " work is already complete, report on what was done rather than duplicating side effects. " +
     "Then return your report as JSON in exactly the shape specified above.";
 }
+// parseClassifyFerry — room #26 blocker 42 (2026-09-21). Shape-constrained
+// ferry parser for the classify-branch agent() call. The schema buys SHAPE,
+// not provenance: the fields are LLM-authored, so the parser stays
+// defensive. Byte-identical across standard.js, bugfix.js, chore.js
+// (pinned by tests/already-merged.test.js). Triplication is structural:
+// each workflow ships as a standalone launch payload (240 KiB budget,
+// individually git-archived) — there is no shared module to hold it.
+// The schema is the guard; the prompt is instruction, never load-bearing.
+// Returns { state, diagField, diagText, failReason }:
+//   state: "has-work" | "already-merged:<40-hex>" | "empty-no-work" | null
+//     (null = unparseable/ambiguous/channel violation — UNKNOWN)
+//   diagField: "stderr" | "stdout" | null (which field sourced the DIAG pin)
+//   diagText: the matched DIAG line, or ""
+//   failReason: computed reason, for the retry trailer and the park note
+function parseClassifyFerry(bsResult) {
+  var bsStdout = (bsResult && typeof bsResult.stdout === "string") ? bsResult.stdout : null;
+  var bsStderr = (bsResult && typeof bsResult.stderr === "string") ? bsResult.stderr : null;
+  if (bsStdout === null || bsStderr === null) {
+    return { state: null, diagField: null, diagText: "",
+      failReason: "classifier return fields missing or non-string (stdout and stderr must both be strings)" };
+  }
+  // State channel: stdout ONLY. A BRANCH_STATE match on stderr is never
+  // trusted — workers merge streams constantly, and trusting a channel
+  // swap as truth is the wrong shape. Search, never anchor (blocker 11):
+  // the ferry labels output ("stdout: BRANCH_STATE: has-work"). Collect
+  // ALL matches and dedupe normalized values: exactly one distinct value
+  // is truth; zero or two-or-more is UNKNOWN — alternation order never
+  // adjudicates.
+  var bsRe = /\bBRANCH_STATE:\s*(has-work|already-merged:[0-9a-f]{40}|empty-no-work)(?![\w-])/gi;
+  var bsSeen = {};
+  var bsM;
+  while ((bsM = bsRe.exec(bsStdout)) !== null) {
+    bsSeen[bsM[1].toLowerCase()] = true;
+  }
+  var bsStates = Object.keys(bsSeen);
+  if (bsStates.length !== 1) {
+    return { state: null, diagField: null, diagText: "",
+      failReason: bsStates.length === 0
+        ? "no BRANCH_STATE match in the stdout field"
+        : "ambiguous BRANCH_STATE values in stdout (" + bsStates.length + " distinct)" };
+  }
+  var bsState = bsStates[0];
+  // DIAG pin: search both fields, stderr first. Keep the DIAG: prefix — a
+  // prose mention without it must not satisfy the pin.
+  var bsDiagRe = /DIAG:\s*classify-branch\s+records=\d+\s+resolvable=\d+/;
+  var bsDiagField = bsDiagRe.test(bsStderr) ? "stderr" : (bsDiagRe.test(bsStdout) ? "stdout" : null);
+  var bsDiagText = "";
+  if (bsDiagField !== null) {
+    bsDiagText = bsDiagRe.exec(bsDiagField === "stderr" ? bsStderr : bsStdout)[0];
+  }
+  if (bsState.indexOf("already-merged:") === 0 && bsDiagField === null) {
+    // already-merged's sha flows into Cass's `git diff <sha>^1 <sha>` — a
+    // hallucinated-but-well-formed sha is a false-PASS vector. The script
+    // emits exactly one DIAG on every path that emits a BRANCH_STATE, so a
+    // missing pin means stderr wasn't faithfully ferried: UNKNOWN.
+    // Residual risk, named (blocker-42 fib 4): a worker could fabricate
+    // BOTH fields wholesale — the pin is a tripwire, not proof of
+    // execution. The workflow has no exec channel for a deterministic
+    // cross-check; if the platform ever offers one, verify the sha
+    // against the task's durable merge records directly.
+    return { state: null, diagField: null, diagText: "",
+      failReason: "already-merged without the DIAG pin — stderr not faithfully ferried" };
+  }
+  return { state: bsState, diagField: bsDiagField, diagText: bsDiagText, failReason: "" };
+}
+
+// classifyRetryTrailer — room #26 blocker 42 (2026-09-21). Corrective (not
+// flat) trailer for the in-place classify retries. The failure mode was
+// systematic labeling, not a coin flip: the trailer carries the COMPUTED
+// parse-failure reason, the failed return truncated as a negative example,
+// and the explicit field mapping — feedback from the actual failure,
+// following the buildTransportRetryTrailer idiom. Bound: 2 retries
+// (unmeasured house convention, matches the shared rework bound of 2 —
+// against room retry data). Byte-identical across the three workflows
+// (pinned by tests/already-merged.test.js).
+function classifyRetryTrailer(reason, failedReturn) {
+  // Pass-2 simplification: the reason string already carries the truth
+  // (throw vs parse failure), so one neutral sentence replaces the
+  // throw/parse branch — the stringly-typed prefix contract between the
+  // call site and this function is deleted, not moved. Prompt accuracy,
+  // not prompt hardening.
+  return "\n\nCLASSIFY RETRY: the previous classifier attempt failed (" + reason + "). " +
+    "Return ONLY the two named fields: { \"stdout\": \"<the command's exact stdout>\", \"stderr\": \"<the command's exact stderr>\" }. " +
+    "Put each stream in its named field — do not add labels like \"stdout:\" in front of the content. " +
+    "Previous attempt detail (do not repeat this shape): " + String(failedReturn).slice(0, 200);
+}
+
+// parseVersionFerry — review pass 2, blocker-42 class (2026-09-21). The npm
+// version-check ferry had the full pre-42 shape: schema-less agent(),
+// line-anchored parser, and an unparseable fallback asserting a POSITIVE
+// touched claim that spent the shared rework budget. Same treatment as
+// parseClassifyFerry: shape-constrained {stdout} schema, search-and-dedupe
+// parse, UNKNOWN on unparseable with in-place retries, honest park.
+// Byte-identical across standard.js, bugfix.js, chore.js
+// (pinned by tests/already-merged.test.js).
+// Returns { versionState, failReason }:
+//   versionState: "touched" | "clean" | null (null = UNKNOWN)
+//   failReason: computed reason, for the retry trailer and the park note
+function parseVersionFerry(vtResult) {
+  var vtStdout = (vtResult && typeof vtResult.stdout === "string") ? vtResult.stdout : null;
+  if (vtStdout === null) {
+    return { versionState: null,
+      failReason: "version-check return field missing or non-string (stdout must be a string)" };
+  }
+  // Search, never anchor (blocker 11): the ferry labels output
+  // ("stdout: VERSION_CLEAN"). Collect ALL matches and dedupe normalized
+  // values: exactly one distinct value is truth; zero or two-or-more is
+  // UNKNOWN — alternation order never adjudicates.
+  var vtRe = /\bVERSION_(TOUCHED|CLEAN)(?![\w-])/gi;
+  var vtSeen = {};
+  var vtM;
+  while ((vtM = vtRe.exec(vtStdout)) !== null) {
+    vtSeen[vtM[1].toUpperCase()] = true;
+  }
+  var vtStates = Object.keys(vtSeen);
+  if (vtStates.length !== 1) {
+    return { versionState: null,
+      failReason: vtStates.length === 0
+        ? "no VERSION_(TOUCHED|CLEAN) match in the stdout field"
+        : "ambiguous VERSION values in stdout (" + vtStates.length + " distinct)" };
+  }
+  return { versionState: vtStates[0] === "CLEAN" ? "clean" : "touched", failReason: "" };
+}
+
+// versionRetryTrailer — review pass 2, blocker-42 class (2026-09-21).
+// Neutral corrective trailer for the in-place version-check retries: the
+// computed parse-failure reason plus the failed return as a negative
+// example. Byte-identical across the three workflows
+// (pinned by tests/already-merged.test.js).
+function versionRetryTrailer(reason, failedReturn) {
+  return "\n\nVERSION-CHECK RETRY: the previous version-check attempt failed (" + reason + "). " +
+    "Return ONLY the named field: { \"stdout\": \"<the command's exact stdout>\" }. " +
+    "Put the command's stdout in the named field — do not add labels like \"stdout:\" in front of the content. " +
+    "Previous attempt detail (do not repeat this shape): " + String(failedReturn).slice(0, 200);
+}
+
 // parseToolSignals - bug 3472bf36. The work agent's TOOL CHECK emits two
 // exact signal lines: artifact_tools: ok|missing and
 // shell_transport: ok|unavailable. The workflow reads ONLY these lines.
@@ -466,13 +658,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");
@@ -630,12 +815,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 (retry trailer + park note grounds)
 // Deterministic publish target — computed by the workflow (registry base +
 // bumpVersion), never by the Publish agent.
 let publishTarget = null; // { base, scope, target }
@@ -1104,55 +1301,202 @@ while (i < STEPS.length) {
       "cd " + WORKTREE_HINT + "\n" +
       "git add -A\n" +
       "git commit -m \"" + 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;
+    // 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.
+    // Blocker 42 (2026-09-21): the classifier output crosses an agent()
+    // ferry — the old comment's "no cross-process hydration ferry" was a
+    // fib. Machine facts travel in structured fields ({stdout, stderr}
+    // schema) now, never in prose to be "returned verbatim". The schema
+    // is the guard; the prompt is instruction, never load-bearing.
+    // Unparseable is UNKNOWN, never a positive empty-no-work claim (room
+    // #27: a labeled ferry — "stdout: BRANCH_STATE: has-work" — defeated
+    // the ^-anchored parsers, and the empty-no-work fallback burned the
+    // whole shared rework budget on a branch with real work). UNKNOWN
+    // retries the classify call IN PLACE (up to 2, fresh -u1/-u2 keys — a
+    // full Build round cannot fix an instrument failure, and the only
+    // in-process bounce path spends the shared budget unconditionally).
+    // Instrumentation failures NEVER touch totalReworkCount: an instrument
+    // failure is not a build-quality failure. Exhaustion parks honestly
+    // as unclassifiable — "unknown keeps the task alive (bounded)"; the
+    // park on exhaustion is the fail-closed part. The UNKNOWN path never
+    // asserts empty-no-work: no log line or park note presents it as the
+    // classification. The string can still appear inside quoted evidence
+    // (the verbatim failed return travels in the trailer and the note).
+    // INVARIANT: branchState leaves this block holding a known value, or
+    // the step has parked — unknown never reaches any consumer below.
+    // Re-classify on EVERY Review entry: rework rewinds this step
+    // in-process, and the branch changed between rounds. The loop's
+    // null-gate governs only the in-place instrument retries within
+    // this pass — without the reset, a second Review pass would trust
+    // the first pass's stale classification and a real fix commit
+    // would never "become has-work".
+    branchState = null;
+    branchStateErr = "";
+    alreadyMergedSha = null;
+    var classifyFailedReturn = "";
+    for (var classifyAttempt = 0; classifyAttempt <= 2 && branchState === null; classifyAttempt++) {
+      var classifyPrompt =
+        "Classify the task branch state. This is a mechanical git check, not a judgment call.\n" +
+        "Run in shell: " + LIFECYCLE_ENV + LIFECYCLE + " classify-branch " + taskId + "\n" +
+        "Return the two streams as the two named fields and nothing else: { \"stdout\": \"<the command's exact stdout>\", \"stderr\": \"<the command's exact stderr>\" }." +
+        (classifyAttempt === 0 ? "" : classifyRetryTrailer(branchStateErr, classifyFailedReturn));
       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" }
+        var bsResult = await agent(
+          classifyPrompt,
+          { key: "classify-branch" + (classifyAttempt === 0 ? "" : "-u" + classifyAttempt) + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""),
+            label: "Classifying branch state (mechanical)" + (classifyAttempt === 0 ? "" : " (instrument retry " + classifyAttempt + " of 2)"),
+            schema: { type: "object", properties: { stdout: { type: "string" }, stderr: { type: "string" } }, required: ["stdout", "stderr"] } }
         );
-      } catch (hydErr) {
-        log("Hydration read failed (" + String(hydErr && hydErr.message || hydErr) + "); treating as none declared.");
+        classifyFailedReturn = (bsResult && typeof bsResult === "object" ? JSON.stringify(bsResult) : String(bsResult)).slice(0, 500);
+        var classifyParsed = parseClassifyFerry(bsResult);
+        if (classifyParsed.state !== null) {
+          branchState = classifyParsed.state;
+          branchStateErr = "";
+          // DIAG pin: advisory for has-work/empty-no-work (blocker-34 v2.1
+          // semantics — logged with its source field so silent record loss
+          // surfaces in the evidence); already-merged is gated on the pin
+          // inside parseClassifyFerry.
+          if (classifyParsed.diagField !== null) {
+            log("classify-branch DIAG pin (" + classifyParsed.diagField + " field): " + classifyParsed.diagText);
+          } else {
+            log("classify-branch: no DIAG: record-scan counter returned (scan unverifiable)");
+          }
+        } else {
+          branchStateErr = classifyParsed.failReason;
+          if (classifyAttempt < 2) {
+            log("classify-branch unparseable (" + branchStateErr + ") — retrying in place (attempt " + (classifyAttempt + 1) + " of 2)");
+          }
+        }
+      } catch (bsErr) {
+        classifyFailedReturn = String(bsErr && bsErr.message || bsErr).slice(0, 500);
+        branchStateErr = "classifier call failed: " + String(bsErr && bsErr.message || bsErr).slice(0, 120);
+        if (classifyAttempt < 2) {
+          log("classify-branch instrument failure (" + branchStateErr + ") — retrying in place (attempt " + (classifyAttempt + 1) + " of 2)");
+        }
       }
-      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);
-      } 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);
+    }
+    if (branchState === null) {
+      // Exhaustion: park honestly. An instrument failure is not a
+      // measurement of emptiness — never "empty-no-work".
+      return await parkTask("Branch state unclassifiable after 2 instrument retries (" + branchStateErr + "; last failure: " + classifyFailedReturn + ") — the classifier instrument failed, not the branch. Human attention needed: inspect the task branch directly to determine its state — no trustworthy branch classification was produced.");
+    }
+    if (branchState.indexOf("already-merged:") === 0) {
+      alreadyMergedSha = branchState.slice("already-merged:".length);
+      log("Branch state already-merged: " + alreadyMergedSha + " (DIAG pin present — tripwire satisfied) — 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). Review pass 2 (blocker-42 class): this ferry had the full
+    // pre-42 shape — schema-less agent(), line-anchored parser, and an
+    // unparseable fallback asserting a POSITIVE touched claim that spent the
+    // shared rework budget. Same treatment as the classifier:
+    // shape-constrained {stdout} schema, search-and-dedupe parse, UNKNOWN
+    // with in-place retries, honest park. An instrument failure is not a
+    // measurement of touched — never assert touched from unparseable output.
+    if (PUBLISH_TYPE === "npm") {
+      var versionState = null; // "touched" | "clean" | null (null = UNKNOWN)
+      var versionStateErr = "";
+      var versionFailedReturn = "";
+      for (var versionAttempt = 0; versionAttempt <= 2 && versionState === null; versionAttempt++) {
+        var versionPrompt =
+          "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: " + LIFECYCLE_ENV + LIFECYCLE + " version-check " + taskId + "\n" +
+          "Return the command's exact stdout as the single named field and nothing else: { \"stdout\": \"<the command's exact stdout>\" }." +
+          (versionAttempt === 0 ? "" : versionRetryTrailer(versionStateErr, versionFailedReturn));
+        try {
+          var vtResult = await agent(
+            versionPrompt,
+            { key: "version-check" + (versionAttempt === 0 ? "" : "-u" + versionAttempt) + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""),
+              label: "Checking package.json version (mechanical)" + (versionAttempt === 0 ? "" : " (instrument retry " + versionAttempt + " of 2)"),
+              schema: { type: "object", properties: { stdout: { type: "string" } }, required: ["stdout"] } }
+          );
+          versionFailedReturn = (vtResult && typeof vtResult === "object" ? JSON.stringify(vtResult) : String(vtResult)).slice(0, 500);
+          var vtParsed = parseVersionFerry(vtResult);
+          if (vtParsed.versionState !== null) {
+            versionState = vtParsed.versionState;
+            versionStateErr = "";
+          } else {
+            versionStateErr = vtParsed.failReason;
+            if (versionAttempt < 2) {
+              log("version-check unparseable (" + versionStateErr + ") — retrying in place (attempt " + (versionAttempt + 1) + " of 2)");
+            }
+          }
+        } catch (vtErr) {
+          versionFailedReturn = String(vtErr && vtErr.message || vtErr).slice(0, 500);
+          versionStateErr = "version-check call failed: " + String(vtErr && vtErr.message || vtErr).slice(0, 120);
+          if (versionAttempt < 2) {
+            log("version-check instrument failure (" + versionStateErr + ") — retrying in place (attempt " + (versionAttempt + 1) + " of 2)");
+          }
         }
       }
+      if (versionState === null) {
+        // Exhaustion: park honestly. An instrument failure is not a
+        // measurement of touched — never assert touched.
+        return await parkTask("package.json `version` state unclassifiable after 2 instrument retries (" + versionStateErr + "; last failure: " + versionFailedReturn + ") — the version-check instrument failed, not the branch. Human attention needed: inspect the task branch directly to determine its state — no trustworthy version classification was produced.");
+      }
+      versionTouched = (versionState === "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 at exactly " + SPEC_PATH + " (fall back to the task description if the file is absent).\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" : "") +
@@ -1166,8 +1510,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: " + 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" +
@@ -1217,8 +1562,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
@@ -1274,8 +1620,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.
@@ -1421,6 +1769,33 @@ 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.
+        // Blocker 40 (2026-09-21): this courier carries the same
+        // {output: string} schema as the sibling diff-computation call.
+        // The command is stdout-silent; schema-less, the runtime's
+        // non-empty-result contract throws on the empty string and the
+        // workflow parks fail-closed for a side effect that landed. Empty
+        // stdout is schema-valid, so the contract no longer fires. "The
+        // schema bypasses the contract" is INFERRED, not observed —
+        // falsification: if a schema-carrying courier still parks on
+        // silent stdout, the platform contract is deeper than the schema
+        // and this is wrong; room evidence decides. (The file on disk is
+        // not read as proof until QA closeout — the QA loader fails
+        // closed to "unknown" attribution when it is absent.)
+        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 as { \"output\": \"<verbatim stdout>\" } and nothing else. Do not interpret it:\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",
+            schema: { type: "object", properties: { output: { type: "string" } }, required: ["output"] } }
+        );
         // 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
@@ -1530,11 +1905,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.";
@@ -1547,10 +1924,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" +
@@ -1564,6 +1941,17 @@ while (i < STEPS.length) {
         "Report the situation in prose, then end your report with exactly this line: VERDICT: FAIL.";
     }
   } else if (step.name === "QA") {
+    // 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";
     // Backstop for merge-time versioning: when the accepted Build summary
     // declared release: yes, QA verifies the registry actually moved. A silent
     // publish skip becomes a loud QA failure with evidence, not a pass.
@@ -1606,7 +1994,7 @@ while (i < STEPS.length) {
         "1. Run: cd " + REPO_PATH + " && git merge-base --is-ancestor <provenance.source_commit> LIVE_HEAD && echo ANCESTOR_OK (substitute the real stamped hash and LIVE_HEAD; do not run the literal placeholders). If this command fails, FAIL: { \"passed\": false, \"summary\": \"provenance mismatch: stamped source_commit is not an ancestor of live HEAD\" }.\n" +
         "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" +
         "If both pass, the source check passes — the only drift since the stamp is builder staging output committed by post-deploy. Continue to STEP 3.\n\n" +
-        "STEP 3: File follow-up tasks for any related issues you discover.\n" +
+        "STEP 3: File follow-up tasks for any related issues you discover — EXCEPT content findings (user-visible content/data): those go in the CONTENT-FINDINGS block at the end of these instructions, never through create-task. The workflow files follow-ups for attributable content itself.\n" +
         "For each issue, 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" +
@@ -1634,7 +2022,7 @@ while (i < STEPS.length) {
         "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
         "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" +
+        "STEP 3: File follow-up tasks for any related issues you discover — EXCEPT content findings (user-visible content/data): those go in the CONTENT-FINDINGS block at the end of these instructions, never through create-task. The workflow files follow-ups for attributable content itself.\n" +
         "For each issue, 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" +
@@ -1646,12 +2034,16 @@ while (i < STEPS.length) {
         "Public docs (API.md, README) are NOT source code — read them freely, exactly as a user would.\n" +
         "Verify the change is working as described in the task.\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, 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" +
-        "File follow-up tasks for related issues found by running in shell:\n" +
+        "File follow-up tasks for related issues found (EXCEPT content findings — user-visible content/data goes in the CONTENT-FINDINGS block at the end of these instructions, never through create-task) by running 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" +
         npmPublishCheck +
         "Report back in plain prose — what you tested and found. End your report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
     }
+    // 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;
     // qaExperiential: Hazel owns the experiential verdict through the QA
     // prompt built in the SURFACE_ARTIFACT / SURFACE_TERMINAL branches above
     // (see-act loop or terminal loop + OODA report). There is no parent
@@ -1692,7 +2084,31 @@ while (i < STEPS.length) {
   var workKeyBase = "work-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : "");
   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")));
@@ -1790,7 +2206,18 @@ while (i < STEPS.length) {
         "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: "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" }
+          event: { task_id: taskId, type: "failed", 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" }
       );
@@ -1837,40 +2264,13 @@ 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" }
-      );
-      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");
-        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" }
-        );
-        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");
-    }
+    // 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 || "");
   }
 
   // See docs/decisions/qa-reproduce.md#experiential-loop-guard: a PASS with missing experiential evidence parks fail-closed.
@@ -1915,6 +2315,116 @@ while (i < STEPS.length) {
     log("QA " + qaLoopSurface + "-loop guard passed: experiential evidence present");
   }
 
+  // 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" }
+      );
+      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(
+          "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" }
+        );
+      }
+    }
+    // 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
   // (extractVerdict above); the summary is the worker's report truncated.
   // For verdict steps passed comes from the verdict; for non-verdict steps
@@ -1924,6 +2434,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) {
@@ -2064,9 +2577,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: for experiential artifact tasks, append the
@@ -2096,17 +2623,44 @@ 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";
+  }
+
   // Record session result
   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).
-      session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: status, notes: summary, already_merged_sha: (step.name === "Build" ? alreadyMergedSha : null) },
-      event: { task_id: taskId, type: status, identity: step.identity, message: step.name + " " + status + " by " + step.identity }
+      // 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 },
+      event: { task_id: taskId, type: status, identity: 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 : ""),
@@ -2116,21 +2670,20 @@ while (i < STEPS.length) {
 
   // Handle rejection — bounce back 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;