muse-crew 0.14.7 → 0.14.9

package/docs/decisions/workflow-core.md

@@ -52,17 +52,24 @@ Applies to: standard, bugfix, chore.
 <a id="closeout-envelope"></a>
 ## Closeout transport envelope
 
-Invariant: the work agent returns the runtime's native transport envelope with no schema; the verdict is extracted mechanically by extractVerdict — never by an agent.
+Invariant: the schema-less work-agent courier returns prose; the workflow
+consumes the return as a plain string. Nothing parses a JSON envelope —
+the prompt names none (blocker 43, 2026-09-22: the old "Return your work as
+JSON in exactly this shape: {...}" invitation drew brace-shaped prose into
+a channel where the runtime's JSON-candidate scan threw, and three
+consecutive Integrate failures parked room #28's J1 at the retry cap; the
+second REVIEW pass then reworded the retry trailer's "discarded" why off
+"machine-read as JSON" to the true event — {...}-shaped fragments the scan
+could not parse — since the old framing was an implicit JSON invitation).
+The verdict is extracted mechanically by extractVerdict — never by an agent.
 
 Applies to: standard, bugfix, chore.
 
 ```
-  // Work agent returns the runtime's native envelope {"status": "ok",
-  // "result": "<prose>"} with no schema. The runtime requires JSON output;
-  // the envelope is its own documented shape, so there is nothing for the
-  // agent to improvise. The workflow receives the prose report as a plain
-  // string. The verdict is still extracted deterministically from the report
-  // text by extractVerdict below — never by an agent.
+  // Work agent returns prose on the schema-less courier; the workflow
+  // consumes the return as a plain string. The verdict is still extracted
+  // deterministically from the report text by extractVerdict — never by
+  // an agent.
 ```
 
 <a id="extract-verdict-contract"></a>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.14.7",
+  "version": "0.14.9",
   "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,

package/workflows/bugfix.js

@@ -131,7 +131,7 @@ if (!taskId) {
   throw new Error("task_id is required in args");
 }
 
-// See docs/decisions/workflow-core.md#closeout-envelope: the work agent returns the runtime's native envelope; verdict extracted mechanically.
+// See docs/decisions/workflow-core.md#closeout-envelope: the schema-less work courier returns prose, consumed as a plain string; verdict extracted mechanically.
 const VERDICT_STEPS = ["Build", "Review", "QA", "Reproduce", "Integrate", "Publish"];
 function extractVerdict(workerText) {
  // The verdict is the LAST VERDICT: PASS/FAIL in the report (contract: end
@@ -221,7 +221,6 @@ function buildVerdictReaskPrompt(stepName, workerText) {
     "Decide from the report's own content whether the " + stepName + " step clearly describes successful completion: " +
     "if it does, the verdict is PASS; otherwise — failure, error, unfinished work, or unclear — the verdict is FAIL. " +
     "Do NOT copy any VERDICT line from the report — decide from the content.\n\n" +
-    "Return your work as JSON in exactly this shape: {\"status\": \"ok\", \"result\": \"your verdict line here\"}. " +
     "The result must be exactly one line and nothing else: VERDICT: PASS or VERDICT: FAIL.";
 }
 async function reaskVerdict(stepName, reworkSuffix, workerText) {
@@ -294,8 +293,8 @@ var TOOL_CHECK_PREAMBLE =
   "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";
 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
+  // reason: "discarded" (the runtime threw the output away — the JSON-candidate
+  // scan found {...}-shaped fragments it could not parse), "empty" (agent() returned without throwing but produced
   // nothing usable), "no-tools" (the worker's TOOL CHECK reported
   // artifact_tools: missing), or "no-transport" (the worker's TOOL CHECK
   // reported shell_transport: unavailable).
@@ -306,12 +305,148 @@ function buildTransportRetryTrailer(stepName, repoPath, taskId, attempt, reason)
     ? "your previous attempt's TOOL CHECK reported artifact_tools: missing (this is a fresh launch, so run the TOOL CHECK's load step again before the work)"
     : reason === "no-transport"
     ? "your previous attempt's TOOL CHECK reported shell_transport: unavailable (this is a fresh launch, so run the TOOL CHECK's shell probe again before the work)"
-    : "your previous attempt's output could not be machine-read as JSON and was discarded";
+    : "your previous attempt's output was discarded by the transport because it contained {...}-shaped fragments the transport could not parse; write plain prose with no JSON-shaped fragments";
   return "\n\nTRANSPORT RETRY (attempt " + attempt + " of 2): " + why + ". " +
     "First check existing state (worktree/branch at " + repoPath + "/.worktrees/" + taskId + ", the task branch, dashboard sessions for this task) - " +
     "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.";
+    "Then return your report 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.
@@ -737,7 +872,7 @@ let alreadyMergedSha = null;
 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)
+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 }
@@ -1287,43 +1422,87 @@ while (i < STEPS.length) {
     // (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(
+    // 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 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);
-      }
-      // 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 {
-        log("classify-branch: no DIAG: record-scan counter returned (scan unverifiable)");
+        "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 {
+        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"] } }
+        );
+        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)");
+        }
       }
-    } 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) {
+    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 + " (mechanically verified) — Cass reviews the frozen merge diff");
+      log("Branch state already-merged: " + alreadyMergedSha + " (DIAG pin present — tripwire satisfied) — Cass reviews the frozen merge diff");
     } else {
       log("Branch state: " + branchState);
     }
@@ -1335,23 +1514,55 @@ while (i < STEPS.length) {
     // 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.
+    // 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") {
-      try {
-        var vtResult = await agent(
+      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 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");
+          "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
@@ -1674,13 +1885,26 @@ while (i < STEPS.length) {
         // 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:\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" }
+          { 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
@@ -1947,12 +2171,12 @@ while (i < STEPS.length) {
       "The returned events are filtered to this task. They contain notes and decisions from prior phases.\n\n";
   }
 
-  // Work agent returns the runtime's native envelope {"status": "ok",
-  // "result": "<prose>"} with no schema. The runtime requires JSON output;
-  // the envelope is its own documented shape, so there is nothing for the
-  // agent to improvise. The workflow receives the prose report as a plain
-  // string. The verdict is still extracted deterministically from the report
-  // text by extractVerdict below — never by an agent.
+  // Work agent returns prose on the schema-less courier; the workflow
+  // consumes the return as a plain string (blocker 43, 2026-09-22: the
+  // prompt names no JSON envelope — nothing parses one, and the runtime's
+  // JSON-candidate scan discards brace-shaped prose, which is what the
+  // transport retry guards). The verdict is still extracted deterministically
+  // from the report text by extractVerdict below — never by an agent.
   var workPromptBase =
     TOOL_CHECK_PREAMBLE +
     "Read the identity file at " + ORCH_PATH + "/identities/" + step.identity + ".md using the read tool, and embody that character fully.\n\n" +
@@ -1965,8 +2189,7 @@ while (i < STEPS.length) {
     "\n## Instructions\n\n" + eventPreamble + instructions + "\n\n" +
     "CONSTRAINT: Do NOT call logevent or upsertagentsession — the workflow handles all phase tracking after your step completes.\n\n" +
     "Stay in character. Do the work thoroughly.\n\n" +
-    "Return your work as JSON in exactly this shape: {\"status\": \"ok\", \"result\": \"your report here\"}. " +
-    "The result is plain prose describing what you did and found. For verdict steps, end the report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
+    "Your report is plain prose describing what you did and found. For verdict steps, end the report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
   var workKeyBase = "work-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : "");
   // See docs/decisions/qa-reproduce.md#wrong-layer-guard: reproduce must run at the correct layer.
   var reproEvidenceDir = crewHome + "/task-evidence/" + taskId + "/repro";