muse-crew 0.7.10 → 0.7.12

package/workflows/bugfix.js

@@ -28,6 +28,15 @@ const startStepIndex = inputs.start_step_index || 0;
 // resolution back via updatetask in the self-claim below.
 const RESOLVED_WORKFLOW = inputs.resolved_workflow || null;
 const WORKFLOW_WAS_NULL = inputs.workflow_was_null === true;
+// One-shot recovery routing: the dispatcher sets inputs.next_phase when it
+// routes this run via an explicit recover-task redirect. The value is
+// consumed (cleared) atomically by the successful self-claim below:
+// claim-task takes expected_next_phase and clears the matching next_phase in
+// the same transaction as the winning session insert, so no platform death
+// can slip between claim and consumption and replay the routing. A stale or
+// superseded routing survives — only an exact match clears.
+// what the dispatcher routed on.
+const NEXT_PHASE_ROUTED = (typeof inputs.next_phase === "string" && inputs.next_phase.length > 0) ? inputs.next_phase : null;
 const CLAIM_WORKFLOW_PERSIST = (WORKFLOW_WAS_NULL && RESOLVED_WORKFLOW) ? ", \"workflow\": \"" + RESOLVED_WORKFLOW + "\"" : "";
 
 // Visual verdict protocol availability — the workflow parks for parent-run
@@ -472,52 +481,22 @@ function verifyAppliedChanges(expected, applied) {
   return { ok: true };
 }
 
-// Publish read-back request builder: the verbatim_request the workflow hands
-// to artifact_inspect (via a child) after the artifact build lands. Pure
-// function — no I/O, no clock. The request carries the merged diff as the
-// expected change and asks for an independent read of the artifact's actual
-// source: for each file, the exact current text of the changed regions plus
-// a per-line present/absent finding. The parent (docs/publish-verification.md)
-// compares these findings against the diff mechanically and stamps provenance
-// only on a match. This breaks the circularity that hollowed canary run 8
-// (2026-09-11): verifyAppliedChanges compares the builder's applied-report
-// against the diff the report was derived from — a fabricated report passes
-// by construction. Independent read-back cannot be fabricated from the diff;
-// it must match the artifact's real content.
-function buildPublishReadbackRequest(taskId, commit, diff, buildAgentId) {
-  // Build-ID correlation (2026-09-12): buildAgentId is the build.agent_id the
-  // workflow observed for the publish attempt (the artifact system's in-flight
-  // build correlation ID — not a durable post-completion identifier). The read-back request carries it so the parent can
-  // prove the read-back inspected the live build of THIS attempt — not a
-  // different build's output. Null/empty means the edit was accepted but
-  // never correlated to a builder run. Pure function of inputs — no I/O,
-  // no clock.
-  var buildIdLine = (typeof buildAgentId === "string" && buildAgentId.length > 0)
-    ? "Expected builder build agent_id: " + buildAgentId + " (the artifact system's in-flight correlation ID for this publish attempt — not a durable post-completion identifier).\n"
-    : "No build agent_id was observed for this publish attempt (the edit was accepted but never correlated to a builder run) — say so explicitly in your report.\n";
-  return (
-    "Publish content read-back for task " + taskId + ", merge commit " + commit + ".\n" +
-    "The unified diff below was supposed to be applied to this artifact's source tree and deployed. Do NOT modify anything.\n" +
-    "Do NOT rely on the builder's applied-changes report — it is derived from this same diff, so it cannot confirm the content. Read the artifact's CURRENT source directly.\n" +
-    "\n" +
-    buildIdLine +
-    "Report the live build's agent_id as seen in artifact_status (or state explicitly that no build/agent_id is visible). If an expected agent_id is given above and the live one differs, say so exactly — the read-back may be inspecting a different build's output.\n" +
-    "\n" +
-    "UNIFIED DIFF (expected change):\n" +
-    "```diff\n" + diff + "\n```\n" +
-    "\n" +
-    "For each file in the diff:\n" +
-    "1. Read the file's CURRENT content in the artifact source tree.\n" +
-    "2. Quote the exact current text of the regions around the changed lines.\n" +
-    "3. For every added (+) line in the diff, state whether that exact line is PRESENT in the current source.\n" +
-    "4. For every removed (-) line in the diff, state whether that exact line is ABSENT from the current source.\n" +
-    "5. Report build/deploy health and the console error count.\n" +
-    "\n" +
-    "Return the per-file present/absent findings with the quoted observed lines. Do not modify anything.\n" +
-    "This read-back feeds the parent content-verification protocol (docs/publish-verification.md): the parent stamps provenance only when every added line is present and every removed line is absent."
-  );
-}
-
+// Publish read-back request (currently unavailable): the verbatim_request
+// the parent protocol (docs/publish-verification.md) would hand to an
+// independent read-back tool after the artifact build lands. artifact_inspect
+// was removed by the platform (2026-09-14); artifact.inspect is malfunction
+// diagnosis, not a substitute — so no agent-callable read-back tool exists
+// and this request cannot currently be issued. Pure function — no I/O, no
+// clock. The request carries the merged diff as the expected change and asks
+// for an independent read of the artifact's actual source: for each file, the
+// exact current text of the changed regions plus a per-line present/absent
+// finding. Until a read-back path exists, the parent cannot independently
+// confirm content and verification parks at "publish: verification-requested"
+// (see docs/publish-verification.md). This preserves the circularity break
+// that hollowed canary run 8 (2026-09-11): verifyAppliedChanges compares the
+// builder's applied-report against the diff the report was derived from — a
+// fabricated report passes by construction. Independent read-back cannot be
+// fabricated from the diff; it must match the artifact's real content.
 // Pre-publish base observation (diagnostic, 2026-09-12): instruction fragment
 // for the builder's edit request, asking it to report the sha256 of each
 // touched file's CURRENT content BEFORE applying the diff. Pure function —
@@ -611,6 +590,18 @@ function extractMarkerLines(workerText) {
   return markers.join("\n");
 }
 
+// Already-merged idempotency (canary 2026-09-15, task 1d692d91): when the
+// builder correctly makes no commit because the deliverable is already on
+// main (a prior merge or hand-repair landed it), it declares
+// `repo_diff: none (already-merged: <sha>)` naming the main commit that
+// carries the work. The sha is hex-only (7-40 chars) so the workflow can
+// interpolate it into the mechanical ancestor check without injection
+// risk. Pure — pinned byte-identical across standard/bugfix/chore.
+function extractAlreadyMerged(workerText) {
+  var m = /^repo_diff:\s*none\s*\(already-merged:\s*([0-9a-f]{7,40})\)/im.exec(workerText || "");
+  return m ? { sha: m[1].toLowerCase() } : { sha: null };
+}
+
 // Worktree confinement: the Build agent must declare the exact worktree
 // path it built in on a `worktree:` marker line. The workflow compares it
 // against WORKTREE_HINT mechanically (exact string match) — never by
@@ -751,43 +742,14 @@ async function baselineStatus() {
     return { baseline_found: false, baseline_kind: "", baseline_refs: "", requested_count: 0, evidence_count: 0 };
   }
 }
-// Visual verdict status: the parent records the visual verdict as a note
-// event after the rendered post-change inspection results arrive. Finds the
-// latest step "QA" session's started_at, then note events NEWER than it
-// whose message starts exactly "visual_verdict: PASS" / "visual_verdict:
-// FAIL". Returns { found, verdict, detail }. A fresh key per call: the
-// verdict lands while this run is parked.
-let visualVerdictCallCount = 0;
-async function visualVerdictStatus() {
-  visualVerdictCallCount++;
-  try {
-    var vv = await agent(
-      "Read this task's QA session and note events from the crew API.\n" +
-      "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
-      "Find the LATEST session with task_id \"" + taskId + "\" and step \"QA\" in the returned sessions array and note its started_at timestamp (call it QA_START; use empty string if there is no QA session).\n" +
-      "Then run in shell and return the stdout verbatim:\n" + crewCmd("get-events", { task_id: taskId }) + "\n" +
-      "Consider only events with type \"note\" whose timestamp is newer than QA_START. Among them, find messages starting exactly with \"visual_verdict: PASS\" or \"visual_verdict: FAIL\" (exact prefix, case-sensitive); use the latest such message.\n" +
-      "Return JSON { \"found\": <true if such a message exists>, \"verdict\": \"<\"PASS\" or \"FAIL\" from that message, or empty string>\", \"detail\": \"<the text after the prefix in that message, or empty string>\" } and nothing else.",
-      {
-        key: "visual-verdict-status-" + taskId + "-" + visualVerdictCallCount,
-        label: "Reading visual verdict status",
-        schema: {
-          type: "object",
-          properties: {
-            found: { type: "boolean" },
-            verdict: { type: "string" },
-            detail: { type: "string" }
-          },
-          required: ["found", "verdict", "detail"]
-        }
-      }
-    );
-    return { found: !!(vv && vv.found), verdict: (vv && vv.verdict) || "", detail: (vv && vv.detail) || "" };
-  } catch (e) {
-    log("visualVerdictStatus: agent call failed (" + (e && e.message ? e.message : e) + ") — treating as not found");
-    return { found: false, verdict: "", detail: "" };
-  }
-}
+// The parent visual-verdict reader was removed 2026-09-15: Hazel (the QA
+// work agent) now owns the visual verdict experientially — she drives the
+// now owns the visual verdict experientially — she drives the see-act loop
+// herself and records verdict.json + the append-only verdicts.jsonl. The old
+// see-act loop herself and records verdict.json + the append-only
+// verdicts.jsonl. The old parent note gate is obsolete and has been
+// deleted from the QA closeout below. (See docs/visual-verdict.md.)
+// from the QA closeout below. (See docs/visual-verdict.md.)
 
 // STEPS inline — export const meta is parsed as metadata, not a runtime binding
 const STEPS = [
@@ -828,6 +790,12 @@ let mapGateBounceCount = 0;
 // rationalized a skip against explicit instruction text — text alone did not
 // hold, so the decision now lives in workflow code, not agent judgment.
 let releaseDecision = null; // { release: "yes"|"no", version_bump: "patch"|"minor"|"major"|null }
+// Already-merged idempotency: the verified sha from the builder's
+// `repo_diff: none (already-merged: <sha>)` declaration (null when the
+// builder made commits or declared a runtime-state deliverable). The
+// workflow verifies the sha is an ancestor of main at Build closeout;
+// Review's no-diff branch reads this, never the builder's prose.
+let alreadyMergedSha = null;
 // Deterministic publish target — computed by the workflow (registry base +
 // bumpVersion), never by the Publish agent.
 let publishTarget = null; // { base, scope, target }
@@ -1059,7 +1027,7 @@ while (i < STEPS.length) {
     const claimResult = await agent(
       "Claim this task for the " + step.name + " step.\n" +
       "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", firstClaimUpdateArgs) + "\n" +
-      "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" }) + "\n" +
+      "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started", ...(NEXT_PHASE_ROUTED ? { expected_next_phase: NEXT_PHASE_ROUTED } : {}) }) + "\n" +
       "If the claim response has claimed=true, then run in shell and return the stdout verbatim:\n" + crewCmd("clear-reservation", { task_id: taskId }) + "\n" +
       "Do not interpret the claim response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
       "Return { claimed: <verbatim>, session_id: \"<...>\" }. If claimed is false there is no session_id; return { claimed: false, session_id: \"\" }.",
@@ -1245,12 +1213,10 @@ while (i < STEPS.length) {
     }
   }
 
-  // Visual verdict routing: experiential artifact tasks get their visual
-  // verdict from the parent AFTER the rendered post-change inspection
-  // results arrive (this script cannot receive the async handoff). The QA
-  // work agent covers mechanical checks only; the visual-verdict gate below
-  // parks for the parent protocol when no visual_verdict: note event exists
-  // yet.
+  // Visual verdict routing (2026-09-15): experiential artifact tasks route
+  // to Hazel's own experiential QA instructions below — she drives the
+  // see-act loop herself and owns the visual verdict (verdict.json +
+  // verdicts.jsonl). No parent verdict gate remains.
   var qaVisual = false;
   if (step.name === "QA") {
     qaVisual = (await resolveExperiential()) === "yes" && PUBLISH_TYPE === "artifact";
@@ -1260,18 +1226,25 @@ while (i < STEPS.length) {
   var instructions = "";
 
   if (step.name === "Triage") {
-    instructions = "Validate the task, check clarity, note dependencies, confirm the bugfix workflow assignment.\nIf the task needs decomposition, note that in your assessment.\nReport back in plain prose — what you found.\nEXPERIENTIAL FLAG: does this task change anything rendered and visible in the project's user-facing artifact (pages, components, styles, layout, copy, visual states)? If yes it is experiential and gets baseline captures (plus a visual verdict where the workflow has a QA phase). End your report with exactly one line on its own, lowercase, unrephrased: experiential: yes — or experiential: no. This line is machine-read.";
+    instructions = "Validate the task against the project's repo at " + REPO_PATH + " — that exact checkout, not any other copy of the project on disk. If you run git commands, cd " + REPO_PATH + " first.\nCheck clarity, note dependencies, confirm the bugfix workflow assignment.\nIf the task needs decomposition, note that in your assessment.\nReport back in plain prose — what you found.\nEXPERIENTIAL FLAG: does this task change anything rendered and visible in the project's user-facing artifact (pages, components, styles, layout, copy, visual states)? If yes it is experiential and gets baseline captures (plus a visual verdict where the workflow has a QA phase). End your report with exactly one line on its own, lowercase, unrephrased: experiential: yes — or experiential: no. This line is machine-read.";
 
   } else if (step.name === "Reproduce") {
-    instructions = "Reproduce the bug from a user's perspective. You are CODE-BLIND — do NOT read source code.\n" +
-      "To investigate, run in shell and read the stdout JSON:\n" + crewCmd("get-state", {}) + "\n" +
-      "This returns current sessions, events, and tasks.\n" +
-      "Look at session notes in the returned data — check whether multiline content has newlines preserved or runs together.\n" +
-      "You can also check a specific task's events with: node " + CREW_API + " --crew-home " + crewHome + " get-events --json '{\"task_id\":\"<the task id>\"}'.\n" +
-      "Do NOT use artifact_inspect — it is async and will not return results inline.\n" +
-      "Capture concrete evidence from the data you retrieve.\n" +
-      "Report your reproduction evidence and steps as plain prose.\n" +
-      "End your report with exactly one line: VERDICT: PASS if reproduction succeeded, VERDICT: FAIL if it failed.";
+    instructions = "Reproduce the bug from a user's perspective — by USING the artifact, not by reading data. You are CODE-BLIND — do NOT read source code.\n" +
+      "You have a see-act driver: " + crewHome + "/current/lib/see-act.js (a node script; one browser action per invocation; it prints one JSON line to stdout). It launches its own Chromium through a self-contained loopback proxy — the ONLY url you may give it is the local artifact server you start below. Never point it at any other URL.\n" +
+      "Actions: aria | shot [--out <png>] [--full] | click [--out <png>] --selector <css> | scroll [--out <png>] --y <pixels|bottom> | type [--out <png>] --selector <css> --text <text>. Add --viewport mobile for a 390x844 frame. The JSON reports console_errors — treat any as a defect signal. Exit code 3 with not_possible set (a \"NOT POSSIBLE: <reason>\" string) means this environment cannot drive a browser: report NOT POSSIBLE: <reason> and fall back to the data-level investigation at the end.\n" +
+      "a. Verify the built artifact exists: test -d ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/client/dist && test -f ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/server/dist/actions.js — if either is missing, report NOT POSSIBLE: built artifact not present at ~/workspace/ts-spaces/" + PUBLISH_SLUG + " and fall back to the data-level investigation.\n" +
+      "b. Start the local artifact server detached with a log file, then poll the log for readiness (single shell invocation): CREW_HOME=" + crewHome + " setsid nohup node " + crewHome + "/current/lib/serve-artifact.js --space-dir ~/workspace/ts-spaces/" + PUBLISH_SLUG + " --port 0 --tag " + taskId + "-repro > /tmp/repro-server-" + taskId + ".log 2>&1 < /dev/null & for i in $(seq 1 30); do grep -q READY /tmp/repro-server-" + taskId + ".log && break; sleep 1; done; grep -o 'READY port=[0-9]*' /tmp/repro-server-" + taskId + ".log | cut -d= -f2 — the printed number is <N>. If no READY appears, report NOT POSSIBLE: local artifact server did not start (see /tmp/repro-server-" + taskId + ".log) and fall back to the data-level investigation.\n" +
+      "c. Bounded see-act loop, at most 8 steps: drive the artifact to TRIGGER the reported bug. Prefix EVERY see-act invocation with SEE_ACT_ARCHIVE_DIR=" + crewHome + "/task-evidence/" + taskId + "/repro/ (shell env vars do not persist between your commands, so prefix each one) — every screenshot is then archived automatically as 001-shot-desktop.png, 002-click-desktop.png, ..., so no frame can be lost. Omit --out; the JSON's screenshot field is the path to READ with your read tool (you can see images).\n" +
+        "c2. After EVERY see-act invocation, append it to the OODA report: node " + crewHome + "/current/lib/append-ooda-step.js --log " + crewHome + "/task-evidence/" + taskId + "/repro/ooda-log.jsonl --attempt \"1\" --step <N> --action <aria|shot|click|scroll|type> --exit <exit-code> --screenshot <screenshot-from-JSON> --observation \"<1-2 sentences: what the frame showed and what you concluded>\" (omit --screenshot for aria). Steps are strictly monotonic: your first step is --step 1, then 2, 3, ... — the script rejects anything else. If you run the loop again (a new idea, after a restart), that run is --attempt \"2\": attempts never overwrite, they accumulate. Your observation is the payload — say what you saw and what it means, not just what you did. A step you ran but did not log is invisible to everyone after you. If the server stops responding mid-loop (curl --max-time 3 http://localhost:<N>/ fails), restart it per (b).\n" +
+"c2b. IMAGE TOOLS (when a raw screenshot is not enough evidence): python3 " + crewHome + "/current/lib/edit-image.py crop --in <frame.png> --out <crop.png> --region x,y,w,h — pixel-exact crop; zoom --factor <f> --center x,y — pixel-crisp zoom back to the original frame size; label --text \"<caption>\" — caption bar; nup --cols 2 --in <a.png> --in <b.png> --labels \"before|after\" — side-by-side grid. Deterministic, no network. Log each with --action crop|zoom|label|nup, --attempt \"1\", and --screenshot <the derivative you READ>. For rich compositions (before/after with real typography, annotated callouts), write an HTML page and render it: node " + crewHome + "/current/lib/render-html.js --in <page.html> --out <composed.png> [--width 1200] — headless Chromium, hermetic (remote assets are blocked and fail the render), deterministic; log with --action compose and --screenshot <the composition you READ>. Derivatives supplement, never replace: keep the source frame archived and name it in --args. READ every derivative you log — an unread image is not evidence.\n" +
+        "c3. Start with: SEE_ACT_ARCHIVE_DIR=" + crewHome + "/task-evidence/" + taskId + "/repro/ node " + crewHome + "/current/lib/see-act.js --url http://localhost:<N>/ aria — read the JSON, log the step. Then: SEE_ACT_ARCHIVE_DIR=" + crewHome + "/task-evidence/" + taskId + "/repro/ node " + crewHome + "/current/lib/see-act.js --url http://localhost:<N>/ shot — READ the screenshot, log the step. Act on what you see: click, scroll, type, then re-observe, logging each step. Prefer aria (cheap text) to find controls; screenshot when the view changes and for your final verdict frames (one desktop, one mobile). If a click exits non-zero, do NOT retry the same ref blindly: re-run aria first (refs go stale between invocations), then click the fresh ref exactly once. If it still fails, log the failure and move on — a flaky control is a finding, not a loop.\n" +
+        "d. One action per invocation, fresh browser each time: anything reachable by (navigate, one action) is testable — e.g. clicking any tab or button from the landing page. Sequences needing prior in-page state (open a dialog, then confirm it) are not; if the bug needs such a sequence, report NOT POSSIBLE for that part and reproduce what you can.\n" +
+      "e. Every frame you captured is already archived under " + crewHome + "/task-evidence/" + taskId + "/repro/ and indexed in ooda-log.jsonl — that log plus the frames is your OODA report for this reproduction. A frame you did not read is not evidence. Loading, error, or blank frames never reproduce anything.\n" +
+      "f. Kill ONLY the server you started: pkill -f 'serve-artifact[.]js.*--tag " + taskId + "-repro' — never another task's server. (The [.] keeps pkill from matching its own command line.) Do not leave it running.\n" +
+      "Data-level fallback (only if the browser loop above is NOT POSSIBLE): run in shell and read the stdout JSON:\n" + crewCmd("get-state", {}) + "\n" +
+      "This returns current sessions, events, and tasks — capture concrete evidence from the data you retrieve.\n" +
+      "Report your reproduction steps and evidence as plain prose.\n" +
+      "End your report with exactly one line: VERDICT: PASS if you reproduced the reported bug (your frames show the reported misbehavior), VERDICT: FAIL if you could not. --expected names the bug as reported (its visible manifestation); --actual names what your frames actually showed. Checks you could not run are evidence gaps, not silent drops: name every one in --missing. First ensure the OODA log exists even if you logged zero steps (touch " + crewHome + "/task-evidence/" + taskId + "/repro/ooda-log.jsonl — an empty log is honest, an absent one is a broken report). Also write the same verdict machine-readably: node " + crewHome + "/current/lib/write-ooda-verdict.js --dir " + crewHome + "/task-evidence/" + taskId + "/repro/ --attempt \"1\" --verdict <PASS|FAIL|NOT_POSSIBLE> --summary \"<one line>\" --expected \"<the bug as reported — its visible manifestation>\" --actual \"<what your frames actually showed>\" --missing '[\"honest evidence gap, if any\"]' [--reason \"<why it failed — REQUIRED and non-empty when verdict is FAIL or NOT_POSSIBLE; the script rejects a reason-less negative verdict with exit 2>\"] — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten). A FAIL or NOT_POSSIBLE verdict without a machine-readable --reason cannot be written — state the reason.";
 
   } else if (step.name === "Map") {
     var mapGatePara = "";
@@ -1307,12 +1280,33 @@ while (i < STEPS.length) {
       "cd " + WORKTREE_HINT + "\n" +
       "git add -A\n" +
       "git commit -m \"fix: " + safeTitle + "\"\n\n" +
-      "If the task's deliverable is runtime state (a cron definition, scheduler change, or dashboard/config state created outside the repo) and the repository genuinely needs no change, do NOT fabricate a commit: leave the branch with no commits ahead of main and declare `repo_diff: none` in your report, naming the runtime-state deliverable. Otherwise commit your changes normally.\n\n" +
+      "If the task's deliverable is runtime state (a cron definition, scheduler change, or dashboard/config state created outside the repo) and the repository genuinely needs no change, do NOT fabricate a commit: leave the branch with no commits ahead of main and declare `repo_diff: none` in your report, naming the runtime-state deliverable. If you verified the deliverable is already on main (a prior merge or hand-repair landed it — do NOT re-implement working code), make no commit and declare `repo_diff: none (already-merged: <sha>)` naming the main commit that carries the work; the workflow verifies the sha is an ancestor of main, and a false declaration fails the phase. Otherwise commit your changes normally.\n\n" +
       (rejectionNotes ? "This is REWORK after rejection. Address these specific issues:\n" + rejectionNotes + "\n\n" : "") +
       "Report back in plain prose: what you built and the outcome." +
       (PUBLISH_TYPE === "npm" ? " End your report with the release: and version_bump: lines exactly as specified above — keep them on their own lines, lowercase, unrephrased — then a line `worktree: ` followed by the exact working directory path from above (copy it verbatim \u2014 it must match character-for-character), then a final line with exactly: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not." : " End your report with a line `worktree: ` followed by the exact working directory path from above (copy it verbatim \u2014 it must match character-for-character), then exactly one line: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not.");
 
   } else if (step.name === "Review") {
+    // Already-merged hydration: when this run did not execute Build itself
+    // (dispatcher resume at Review after a platform death between phases),
+    // recover the workflow-attested verification from the latest completed
+    // Build session notes. The `already_merged_verified:` line was written
+    // by the workflow after a mechanical ancestor check — it is trusted;
+    // the builder's bare declaration never is. Absent the line, the
+    // mechanical fact below reads "none declared" and Cass fails closed.
+    if (!alreadyMergedSha) {
+      var hydNotes = await agent(
+        "Read the latest completed Build session notes for task " + taskId + ".\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
+        "In the returned sessions array, find the most recent session (by started_at) with task_id \"" + taskId + "\", step \"Build\", and status \"completed\". Return ONLY its notes field, verbatim, with no commentary.",
+        { key: "hydrate-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Hydrating already-merged verification" }
+      );
+      var hydStr = (typeof hydNotes === "string") ? hydNotes : JSON.stringify(hydNotes);
+      var hvm = /already_merged_verified:\s*([0-9a-f]{7,40})/i.exec(hydStr);
+      if (hvm) {
+        alreadyMergedSha = hvm[1].toLowerCase();
+        log("Hydrated already-merged verification from Build session notes: " + alreadyMergedSha);
+      }
+    }
     instructions = "Review independently and cold. You have NOT seen any reasoning from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
       (mapperSpec ? "MAPPER'S SPEC (the builder was asked to implement exactly this):\n" + mapperSpec + "\n\n" : "Read the spec (from the task description or spec files under " + crewHome + "/).\n\n") +
       "Examine the code changes by running:\n" +
@@ -1322,7 +1316,7 @@ while (i < STEPS.length) {
       WORKTREE_HINT + "/\n\n" +
       "Check quality, correctness, and spec compliance.\n" +
       "Check that public-affecting changes have matching public doc updates (API.md or the published API contract). If the docs are missing or inaccurate, report what is stale, then end your report with exactly this line: VERDICT: FAIL.\n" +
-      "If the branch has no commits ahead of main (inspect shows an empty commit log), approve ONLY if the Build summary declares `repo_diff: none` with a plausible runtime-state deliverable (e.g. a cron created via the cron tool). Otherwise report 'no commits ahead of main and no repo_diff: none declaration — the builder likely forgot to commit', then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "If the branch has no commits ahead of main (inspect shows an empty commit log), approve ONLY if the Build summary declares `repo_diff: none` with (a) a plausible runtime-state deliverable (e.g. a cron created via the cron tool), or (b) an already-merged declaration `repo_diff: none (already-merged: <sha>)` AND the mechanical fact below confirms the sha verified. MECHANICAL FACT (computed by the workflow, never by the builder): already_merged sha = " + (alreadyMergedSha ? alreadyMergedSha + " (verified ancestor of main: YES)" : "none declared") + ". Otherwise report 'no commits ahead of main and no valid repo_diff: none declaration — the builder likely forgot to commit', then end your report with exactly this line: VERDICT: FAIL.\n" +
       (PUBLISH_TYPE === "npm" ? "PACKAGE VERSION: this project publishes to the npm registry, and versions are assigned at publish time — never in branches. Two checks:\n" +
       "(a) The task branch must NOT have changed package.json's `version` field. Check: cd " + REPO_PATH + " && git diff main..." + TASK_BRANCH + " -- package.json. If the branch touched `version` in any way, report 'versions are assigned at publish time, never in branches — remove the version change' in your notes, then end your report with exactly this line: VERDICT: FAIL.\n" +
       "(b) The accepted Build report declares: " + releaseDecisionText() + ". " +
@@ -1336,7 +1330,7 @@ while (i < STEPS.length) {
       "Run: "+ LIFECYCLE_ENV + "WORKFLOW_RUN_ID=" + lockHolder + " integrate " + taskId + " \"merge: fix: " + safeTitle + "\"\n\n" +
       "Read the output:\n" +
       "- If it contains MERGED, integration succeeded. Report the merged commit hash.\n" +
-      "- If it contains MERGED_EMPTY, the branch had no commits ahead of main (a runtime-state deliverable, declared by Build as repo_diff: none). Integration succeeded vacuously: the merge lock was NOT taken and there is no new commit. Report 'merged empty: no repo changes — deliverable was runtime state', then end your report with exactly this line: VERDICT: PASS. SKIP STEP 2 (push): there is no new commit to push.\n" +
+      "- If it contains MERGED_EMPTY, the branch had no commits ahead of main (declared by Build as repo_diff: none — either a runtime-state deliverable or an already-merged sha the workflow verified). Integration succeeded vacuously: the merge lock was NOT taken and there is no new commit. Report 'merged empty: no repo changes — deliverable was runtime state or already on main', then end your report with exactly this line: VERDICT: PASS. SKIP STEP 2 (push): there is no new commit to push.\n" +
       "- If it contains LOCK_HELD, another task holds the merge lock (mid Integrate/Publish) and the 10-minute bounded backoff is exhausted. Report 'merge lock held after bounded backoff', then end your report with exactly this line: VERDICT: FAIL.\n" +
       "- If it contains CONFLICT, the plain merge failed — the merge was aborted, main is clean, and your task still holds the merge lock. Do NOT fail yet. Resolve it:\n" +
       "RESOLUTION:\n" +
@@ -1399,10 +1393,11 @@ while (i < STEPS.length) {
       // (fail-closed). There is deliberately NO workflow-side provenance
       // stamp: the builder's applied-report is circular (canary run 8,
       // 2026-09-11), so the stamp moved to the parent — after the build
-      // lands, the workflow triggers an independent artifact_inspect
-      // read-back, records the session completed, and parks with
-      // "publish: verification-requested". The parent stamps provenance only
-      // after the read-back confirms the content (docs/publish-verification.md);
+      // lands, the workflow records the session completed and parks with
+      // "publish: verification-requested". The parent owns verification
+      // (docs/publish-verification.md); the independent read-back step is
+      // currently unavailable (no agent-callable read-back tool exists —
+      // artifact_inspect was removed by the platform 2026-09-14).
       // QA's provenance check enforces the stamp mechanically.
       var artifactPublish = null;
       var publishLockRefreshed = false;
@@ -1451,14 +1446,45 @@ while (i < STEPS.length) {
         // changes — no prose claim to trust. If the artifact tool namespace
         // is missing from this child it reports honestly and the workflow
         // retries once with a fresh key (bounded); anything else parks.
+        // Publish diff base (2026-09-14, task 0c53af4e): the carried diff is
+        // BASE..HEAD where BASE is the previously-stamped provenance
+        // source_commit — NOT HEAD^1. A push-time reconcile merge puts the
+        // task's own changes behind an intermediate merge, so HEAD^1..HEAD
+        // silently drops the task's fix while the artifact builds without
+        // it. The stamped base is the artifact's actual content; BASE..HEAD
+        // is the complete unpublished delta. Empty tree only for a genuine
+        // first publish (no provenance stamped yet).
+        var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+        var provResult = await agent(
+          crewCmd("get-provenance", {}) + "\n" +
+          "Return JSON { \"provenance\": <the CLI's provenance object, or null when nothing is stamped> } and nothing else. Do not interpret it.",
+          { key: attemptKey("publish-provenance-base-" + taskId, totalReworkCount), label: "Reading stamped publish base",
+            schema: { type: "object", properties: { provenance: { type: ["object", "null"] } }, required: ["provenance"] } }
+        );
+        var publishBase = (provResult.provenance && provResult.provenance.source_commit) || "";
+        publishBase = String(publishBase).trim();
+        if (!publishBase) {
+          publishBase = EMPTY_TREE_SHA;
+          log("Publish base for task " + taskId + ": no provenance stamped yet — using empty tree (first publish)");
+        } else if (!/^[0-9a-f]{40}$/.test(publishBase)) {
+          return await parkTask("Publish base '" + publishBase + "' is not a valid commit SHA — cannot compute the publish diff. Human attention needed.");
+        }
         var diffResult = await agent(
-          "Run: cd " + REPO_PATH + " && git rev-parse HEAD && echo '---PARENT---' && git rev-parse HEAD^1 && echo '---DIFF---' && git diff HEAD^1 HEAD && echo '---NAMES---' && git diff-tree --no-commit-id --name-only -r HEAD\n" +
-          "Return JSON { \"commit\": \"<HEAD trimmed>\", \"parent\": \"<HEAD^1 trimmed>\", \"diff\": \"<raw unified diff, may be multi-line>\", \"files\": \"<newline-separated paths>\" } and nothing else.",
-          { key: attemptKey("publish-artifact-diff-" + taskId, totalReworkCount), label: "Computing merged diff for publish",
-            schema: { type: "object", properties: { commit: { type: "string" }, parent: { type: "string" }, diff: { type: "string" }, files: { type: "string" } }, required: ["commit", "diff"] } }
+          "Run: cd " + REPO_PATH + " && BASE='" + publishBase + "' && HEAD=$(git rev-parse HEAD) && " +
+          "if [ \"$BASE\" = '" + EMPTY_TREE_SHA + "' ]; then ANCESTOR=yes; else git merge-base --is-ancestor \"$BASE\" \"$HEAD\" && ANCESTOR=yes || ANCESTOR=no; fi && " +
+          "echo '---COMMIT---' && echo \"$HEAD\" && echo '---BASE---' && echo \"$BASE\" && echo '---ANCESTOR---' && echo \"$ANCESTOR\" && " +
+          "if [ \"$ANCESTOR\" = yes ]; then echo '---DIFF---' && git diff \"$BASE\" \"$HEAD\" && echo '---NAMES---' && git diff-tree --no-commit-id --name-only -r \"$BASE\" \"$HEAD\"; fi\n" +
+          "Return JSON { \"commit\": \"<HEAD trimmed>\", \"base\": \"<BASE trimmed>\", \"ancestor\": \"<yes|no>\", \"diff\": \"<raw unified diff, may be multi-line>\", \"files\": \"<newline-separated paths>\" } and nothing else.",
+          { key: attemptKey("publish-artifact-diff-" + taskId, totalReworkCount), label: "Computing publish diff from stamped base",
+            schema: { type: "object", properties: { commit: { type: "string" }, base: { type: "string" }, ancestor: { type: "string" }, diff: { type: "string" }, files: { type: "string" } }, required: ["commit", "base", "ancestor", "diff"] } }
         );
+        if ((diffResult.ancestor || "").trim() !== "yes") {
+          return await parkTask("Publish base " + publishBase.slice(0, 12) + " is not an ancestor of HEAD " + (diffResult.commit || "").trim().slice(0, 12) + " — the stamped provenance does not lead to the integrated commit. Human attention needed.");
+        }
+        if ((diffResult.base || "").trim() !== publishBase) {
+          return await parkTask("Publish diff base mismatch: agent reported '" + (diffResult.base || "").trim().slice(0, 12) + "' but the stamped base is '" + publishBase.slice(0, 12) + "'. Human attention needed.");
+        }
         var mergeCommitForPublish = (diffResult.commit || "").trim();
-        var mergeParentForPublish = (diffResult.parent || "").trim();
         var mergeDiff = diffResult.diff || "";
         if (!mergeDiff.trim()) {
           return await parkTask("Publish diff is empty for commit " + (mergeCommitForPublish || "unknown") + " — a merge lock was held but there is no change to carry. Human attention needed.");
@@ -1490,12 +1516,16 @@ while (i < STEPS.length) {
         // but never parks. The observation tells us what the publish actually
         // reads, so the subsequent fix can require the right base.
         var expectedBaseHashes = {};
-        try {
+        if (publishBase === EMPTY_TREE_SHA) {
+          // First publish: every file in the diff is new to the artifact.
+          expectedChanges.forEach(function (f) { expectedBaseHashes[f.path] = "NEW-FILE"; });
+          log("Publish expected base hashes for task " + taskId + ": empty tree (first publish) — all " + expectedChanges.length + " file(s) new");
+        } else try {
           // Shell-quote helper (no regex-with-quote: the test parser does not
           // understand regex literals containing quotes).
           var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
           var baseHashResult = await agent(
-            "Run: cd " + REPO_PATH + " && parent=" + sq(mergeParentForPublish) + " && for f in " + expectedChanges.map(function(f) { return sq(f.path); }).join(" ") + "; do printf '%s:' \"$f\"; git show \"$parent:$f\" 2>/dev/null | sha256sum | cut -d' ' -f1; done\n" +
+            "Run: cd " + REPO_PATH + " && parent=" + sq(publishBase) + " && for f in " + expectedChanges.map(function(f) { return sq(f.path); }).join(" ") + "; do printf '%s:' \"$f\"; git show \"$parent:$f\" 2>/dev/null | sha256sum | cut -d' ' -f1; done\n" +
             "Return JSON { \"hashes\": \"<newline-separated <path>:<sha256> lines, empty hash means the file is new in this diff>\" } and nothing else.",
             { key: attemptKey("publish-base-hashes-" + taskId, totalReworkCount), label: "Computing expected base content hashes",
               schema: { type: "object", properties: { hashes: { type: "string" } }, required: ["hashes"] } }
@@ -1504,7 +1534,7 @@ while (i < STEPS.length) {
             var m = /^([^:]+):([0-9a-f]*)$/.exec(line.trim());
             if (m) expectedBaseHashes[m[1]] = m[2] || "NEW-FILE";
           });
-          log("Publish expected base hashes for task " + taskId + " (merge parent " + (mergeParentForPublish || "unknown").slice(0, 12) + "): " + JSON.stringify(expectedBaseHashes));
+          log("Publish expected base hashes for task " + taskId + " (stamped base " + publishBase.slice(0, 12) + "): " + JSON.stringify(expectedBaseHashes));
         } catch (e) {
           log("Publish expected base hash computation failed for task " + taskId + " (non-fatal, observation degraded): " + (e && e.message ? e.message : e));
         }
@@ -1562,6 +1592,7 @@ while (i < STEPS.length) {
             required: ["edit_started", "build_agent_id", "applied"] };
         var rebuildTrigger = null;
         var rebuildReportMissing = false; // true if the edit went through but the agent returned no applied report (structured-output failure) — the smoke-check is skipped; the parent's independent read-back is the verification
+        var rebuildEvidenceNote = null; // human-readable evidence line for the ledger when the edit is confirmed via fallback evidence (in-flight poll or durable audit dir) rather than the trigger's own report
         // The trigger key of the attempt that last ran, for the publish ledger.
         // Minted once here (not re-minted per use site) so the ledger always
         // records the exact key that was issued — and so a re-minted duplicate
@@ -1580,6 +1611,32 @@ while (i < STEPS.length) {
         // (2026-09-12, task 23ca8f3f): computed once the trigger outcome is
         // known, logged loudly, never a park.
         var publishAppliedObservation = null; // "match" | "mismatch: <reason>" | "missing-report" — observation only, never a park
+        // Durable-evidence snapshot (2026-09-14): the structured-output
+        // fallback below only observes IN-FLIGHT builds. A build that
+        // finished before the poll leaves no in-flight trace — but the
+        // platform's audit harness leaves a durable one:
+        // ~/workspace/ts-spaces/<slug>/audits/<timestamp>-<id>/ per
+        // completed build. Snapshot the listing BEFORE the trigger so the
+        // fallback can diff before/after: a directory appearing during the
+        // trigger window is positive evidence the edit went through and
+        // the build completed. Best-effort and non-gating: if the snapshot
+        // fails, the durable check is skipped and the fallback behaves as
+        // before. No wall-clock in-script (deterministic replay) — the
+        // comparison is a pure before/after set diff.
+        var auditDirsBeforeTrigger = [];
+        try {
+          var auditBefore = await agent(
+            "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort snapshot, never a gate).\n" +
+            "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
+            "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
+            { key: attemptKey("publish-audit-before-" + taskId, totalReworkCount), label: "Snapshotting audit dirs before rebuild trigger",
+              schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+          );
+          auditDirsBeforeTrigger = String((auditBefore && auditBefore.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+          log("Publish audit-dir snapshot before trigger for task " + taskId + ": " + auditDirsBeforeTrigger.length + " entries");
+        } catch (auditBeforeErr) {
+          log("Publish audit-dir snapshot before trigger failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditBeforeErr && auditBeforeErr.message ? auditBeforeErr.message : auditBeforeErr));
+        }
         try {
           rebuildTrigger = await agent(rebuildPrompt,
             { key: rebuildAttemptKey, label: "Triggering artifact rebuild", schema: rebuildSchema });
@@ -1638,7 +1695,46 @@ while (i < STEPS.length) {
             rebuildTrigger = { edit_started: true, error: "", applied: null };
             rebuildReportMissing = true;
             rebuildAgentId = acceptedAgentId;
+            rebuildEvidenceNote = "edit confirmed via build-state poll after structured-output failure (build " + acceptedAgentId + "); builder applied-report missing";
           } else {
+            // Durable completion check (2026-09-14): the in-flight poll
+            // above only sees RUNNING builds. Attempt 7 (2026-09-14) proved
+            // the gap: the trigger child applied the edit, the build ran
+            // and completed — the platform's audit harness captured it
+            // mid-window — then the child failed to return JSON. The
+            // fallback poll saw no in-flight build, so a successful publish
+            // parked as "unknown". Diff the audit-dir listing against the
+            // pre-trigger snapshot: a timestamped directory that appeared
+            // during the trigger window is positive evidence the edit went
+            // through and the build completed. This never re-issues the
+            // edit and never stamps provenance — it only routes to the
+            // parent's independent content read-back, which remains the
+            // real verification.
+            var newAuditDirs = [];
+            try {
+              var auditAfter = await agent(
+                "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
+                "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
+                "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
+                { key: attemptKey("publish-audit-after-" + taskId, totalReworkCount), label: "Re-listing audit dirs after trigger failure",
+                  schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+              );
+              var auditDirsAfterTrigger = String((auditAfter && auditAfter.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+              // Only timestamped build dirs count — the "latest" symlink
+              // and anything else are not builds.
+              newAuditDirs = auditDirsAfterTrigger.filter(function (d) {
+                return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
+              });
+            } catch (auditAfterErr) {
+              log("Publish audit-dir re-list after trigger failure failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterErr && auditAfterErr.message ? auditAfterErr.message : auditAfterErr));
+            }
+            if (newAuditDirs.length > 0) {
+              log("Publish rebuild trigger: new audit dir(s) during the trigger window (" + newAuditDirs.join(", ") + ") — the edit went through and the build completed despite the structured-output failure. Skipping applied-report smoke-check; parent read-back is the verification.");
+              rebuildTrigger = { edit_started: true, error: "", applied: null };
+              rebuildReportMissing = true;
+              rebuildAgentId = null;
+              rebuildEvidenceNote = "edit confirmed via durable audit evidence after structured-output failure (new audit dir " + newAuditDirs[0] + "); builder applied-report missing";
+            } else {
             // No build observed — but that proves nothing (a fast-completing
             // build can finish between polls, or the check itself failed). The
             // outcome is UNKNOWN. No retry: re-issuing the edit here duplicated
@@ -1654,6 +1750,7 @@ while (i < STEPS.length) {
               detail: "structured-output failure on rebuild trigger; build-state poll saw no build (or the check itself failed); edit may have been accepted as pending_init"
             }, totalReworkCount);
             return await parkTask("Publish outcome unknown: the rebuild trigger's child did not return JSON, and the follow-up build-state poll could not observe a build for slug " + PUBLISH_SLUG + ". The edit may have been accepted as pending_init, so no retry was issued — a blind retry duplicated the edit on 2026-09-12. The attempt is recorded in the publish ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl (commit " + String(mergeCommitForPublish || "unknown").slice(0, 12) + "). Correlate the accepted edit via the ledger and the builder's eventual completion before re-driving Publish. Fail-closed.");
+            }
           }
         }
         if (!rebuildReportMissing && !rebuildTrigger.edit_started && rebuildTrigger.error === "artifact_tools missing after load") {
@@ -1723,7 +1820,7 @@ while (i < STEPS.length) {
             applied_report: publishAppliedObservation,
             outcome: "submitted",
             detail: rebuildReportMissing
-              ? "edit confirmed via build-state poll after structured-output failure (build " + (rebuildAgentId || "agent_id unknown") + "); builder applied-report missing"
+              ? (rebuildEvidenceNote || "edit confirmed via build-state poll after structured-output failure (build " + (rebuildAgentId || "agent_id unknown") + "); builder applied-report missing")
               : "edit accepted; builder applied-report received"
           }, totalReworkCount);
         } else if (rebuildTrigger) {
@@ -1780,6 +1877,15 @@ while (i < STEPS.length) {
           // lock was lost: stop the run and park the task — never continue to
           // a provenance stamp or version assignment without holding the lock.
           var buildPoll = null;
+          // STEP 1b poll-signal accumulators (2026-09-15, task aadeccc3):
+          // the durable audit-dir fallback below needs the poll's own
+          // observations, not just its final verdict — whether our build was
+          // ever seen, whether a stranger's build was ever in flight, and
+          // what the last check observed. OR-ed across all three chunks so
+          // a signal seen in any chunk survives the chunk boundary.
+          var pollSawOurBuild = false;
+          var pollSawStranger = false;
+          var lastObservedAgentId = null;
           for (var chunk = 1; chunk <= 3; chunk++) {
             if (chunk > 1) {
               var refreshPoll = await agent(
@@ -1802,36 +1908,152 @@ while (i < STEPS.length) {
               : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, totalReworkCount);
             buildPoll = await agent(
               "First call tool_search.load_tool_namespace with paths [\"artifact\"]. Then poll artifact_status for slug \"" + PUBLISH_SLUG + "\" \u2014 for OUR build only, the one whose agent_id is \"" + rebuildAgentId + "\" (the receipt captured when the edit was accepted; the agent_id is the artifact system's in-flight build correlation ID, stable across polls while the build runs). Check every 30 seconds, up to 7 checks (3.5 minutes max). On each check, read the raw build object:\n" +
-              "- If no build is running (build is null): OUR build finished. Stop and report done.\n" +
+              "On every check, record whether you have positively OBSERVED our build: a running build whose agent_id equals \"" + rebuildAgentId + "\", or a completed-build record whose agent_id equals \"" + rebuildAgentId + "\" (if the tool surfaces one \u2014 match it mechanically, never assume).\n" +
+              "- If no build is running (build is null) and you have NOT observed our build: our build's completion is UNPROVEN. Absence of a running build is not evidence our build ran. Do NOT report done.\n" +
+              "- If no build is running (build is null) and you previously observed our build running: our build finished. Stop and report done.\n" +
               "- If the running build's agent_id equals \"" + rebuildAgentId + "\": still ours \u2014 keep waiting.\n" +
-              "- If the running build's agent_id is present but DIFFERENT: our build is gone (it finished before this one started). Do NOT wait on the stranger's build and do NOT attribute its completion to our attempt \u2014 stop and report done.\n" +
-              "Return JSON { \"build_done\": <true if our build is no longer running within budget, false on timeout>, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } and nothing else.",
+              "- If the running build's agent_id is present but DIFFERENT: that is a stranger's build. Do NOT attribute its completion to our attempt and do NOT wait on it \u2014 keep checking within budget; if the budget expires without observing our build, report done=false. Record it in saw_stranger regardless of what else you observe.\n" +
+              "Return JSON { \"build_done\": <true ONLY when you positively observed our build and it is no longer running, false otherwise>, \"saw_our_build\": <true if you observed our build at any check, false if never>, \"saw_stranger\": true if at ANY check a running build had an agent_id different from ours (\"" + rebuildAgentId + "\"), false otherwise, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } and nothing else.",
               { key: pollKey, label: "Waiting for artifact build to complete (chunk " + chunk + " of 3)",
-                schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
+                schema: { type: "object", properties: { build_done: { type: "boolean" }, saw_our_build: { type: "boolean" }, saw_stranger: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
                 timeoutMs: 270000 }
             );
+            pollSawOurBuild = pollSawOurBuild || (buildPoll && buildPoll.saw_our_build === true);
+            pollSawStranger = pollSawStranger || (buildPoll && buildPoll.saw_stranger === true);
+            lastObservedAgentId = (buildPoll && buildPoll.observed_agent_id) || null;
             if (buildPoll && buildPoll.build_done) { break; }
           }
           if (!buildPoll || !buildPoll.build_done) {
             buildPoll = { build_done: false, status: (buildPoll && buildPoll.status) || "build still running after the 10.5-minute bounded poll" };
           }
-          if (buildPoll.build_done) {
+          if (buildPoll.build_done && pollSawOurBuild) {
             // STEP 1c (mechanical): NO provenance stamp here. Canary run 8
             // (2026-09-11) proved the stamp cannot certify content: the
             // builder's applied-report is derived from the carried diff, so
             // verifyAppliedChanges above is circular — a fabricated report
             // passes by construction, and every phase went green on a hollow
-            // build. The stamp moves to the parent (docs/publish-verification.md):
-            // after an independent artifact_inspect read-back confirms the
-            // artifact's actual content matches the merged diff, the parent
-            // stamps provenance and re-queues; QA's provenance check then
-            // enforces the stamp mechanically, so an unverified publish fails
-            // loudly in QA instead of passing silently here.
+            // build. The stamp moves to the parent (docs/publish-verification.md);
+            // the independent read-back step is currently unavailable (no
+            // agent-callable read-back tool exists — artifact_inspect was
+            // removed by the platform 2026-09-14), so the parent cannot
+            // confirm content and the task parks for verification.
+            // QA's provenance check enforces the stamp mechanically.
+            // An unverified publish fails loudly in QA instead of passing
+            // silently here.
             publishBuildLanded = true;
             artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
             log("Publish build landed for task " + taskId + " — provenance stamp deferred to parent content verification");
           } else {
-            publishFailure = "Artifact build did not complete within budget: " + (buildPoll.status || "timeout") + ". The publish may or may not have landed — provenance was not stamped.";
+            // STEP 1b durable audit-dir fallback (2026-09-15, task aadeccc3):
+            // the poll above only observes IN-FLIGHT builds. A build that
+            // finished between the receipt capture and the poll's first check
+            // leaves no in-flight trace — but the platform's audit harness
+            // leaves a durable one (~/workspace/ts-spaces/<slug>/audits/
+            // <timestamp>-<id>/ per completed build). Diff the audit-dir
+            // listing against the pre-trigger snapshot: a timestamped dir
+            // that appeared during the attempt window is evidence a build
+            // completed. Attribution is by window, not by build identity:
+            // the poll's saw_stranger signal only catches stranger builds in
+            // flight AT a check — a stranger that finished entirely inside
+            // the window is indistinguishable, so any observed stranger
+            // blocks attribution and the outcome stays unknown. This never
+            // re-issues the edit and never stamps provenance — ok=true only
+            // routes to the parent's independent content read-back, which
+            // remains the real verification.
+            //
+            // The poll end-state is read from the poll's own observations,
+            // not from build_done alone: a build in flight at the last check
+            // means the budget was shorter than the latency (or the build is
+            // stuck) — NOT that no build ever started; nothing observed at
+            // any check is the never-started signal.
+            var pollEndState = lastObservedAgentId ? "build-still-running-at-poll-end"
+              : (pollSawOurBuild ? "our-build-observed-then-unconfirmed" : "no-build-observed-in-window");
+            var strangerObserved = pollSawStranger;
+            var newAuditDirsAfterPoll = [];
+            try {
+              var auditAfterPoll = await agent(
+                "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
+                "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
+                "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
+                { key: attemptKey("publish-audit-after-poll-" + taskId, totalReworkCount), label: "Re-listing audit dirs after build poll",
+                  schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+              );
+              var auditDirsAfterPollList = String((auditAfterPoll && auditAfterPoll.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+              newAuditDirsAfterPoll = auditDirsAfterPollList.filter(function (d) {
+                return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
+              });
+              log("Publish audit-dir re-list after build poll for task " + taskId + ": " + newAuditDirsAfterPoll.length + " new timestamped dir(s)");
+            } catch (auditAfterPollErr) {
+              log("Publish audit-dir re-list after build poll failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterPollErr && auditAfterPollErr.message ? auditAfterPollErr.message : auditAfterPollErr));
+            }
+            // auditReportOk: pure tri-state read of a report.json body —
+            // true (build ok), false (build failed), null (missing or
+            // unreadable — not evidence either way). The child returns the
+            // raw body verbatim; interpretation lives here, never in prose.
+            var auditReportOk = function (raw) {
+              if (typeof raw !== "string") return null;
+              var trimmed = raw.trim();
+              if (trimmed === "" || trimmed === "MISSING") return null;
+              var parsed;
+              try { parsed = JSON.parse(trimmed); } catch (e) { return null; }
+              if (parsed && typeof parsed.ok === "boolean") return parsed.ok;
+              return null;
+            };
+            var auditOkAfterPoll = null;
+            var newestAuditDirAfterPoll = null;
+            if (newAuditDirsAfterPoll.length > 0 && !strangerObserved) {
+              newAuditDirsAfterPoll.sort();
+              newestAuditDirAfterPoll = newAuditDirsAfterPoll[newAuditDirsAfterPoll.length - 1];
+              try {
+                var auditOkRead = await agent(
+                  "Read the build report for artifact slug \"" + PUBLISH_SLUG + "\", audit dir \"" + newestAuditDirAfterPoll + "\" (verbatim read, never interpreted, never a gate).\n" +
+                  "Run: cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/" + newestAuditDirAfterPoll + "/report.json 2>/dev/null || echo MISSING\n" +
+                  "Return JSON { \"raw\": \"<verbatim file contents, or the literal string MISSING when the file does not exist>\" } and nothing else.",
+                  { key: attemptKey("publish-audit-ok-after-poll-" + taskId, totalReworkCount), label: "Reading build report after build poll",
+                    schema: { type: "object", properties: { raw: { type: "string" } }, required: ["raw"] } }
+                );
+                auditOkAfterPoll = auditReportOk(auditOkRead && auditOkRead.raw);
+              } catch (auditOkReadErr) {
+                log("Publish build-report read after build poll failed for task " + taskId + " (non-fatal, treated as unknown): " + (auditOkReadErr && auditOkReadErr.message ? auditOkReadErr.message : auditOkReadErr));
+                auditOkAfterPoll = null;
+              }
+            }
+            if (auditOkAfterPoll === true) {
+              publishBuildLanded = true;
+              artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
+              log("Publish build landed for task " + taskId + " via durable audit evidence — provenance stamp deferred to parent content verification");
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: rebuildAgentId,
+                applied_report: publishAppliedObservation,
+                outcome: "submitted",
+                detail: "durable audit evidence shows a build completed during the attempt window (audit dir " + newestAuditDirAfterPoll + ", report ok=true); routed to parent verification"
+              }, totalReworkCount);
+            } else if (auditOkAfterPoll === false) {
+              publishFailure = "Artifact build FAILED for slug " + PUBLISH_SLUG + " (audit dir " + newestAuditDirAfterPoll + ", report ok=false). Explicit negative evidence: a build ran and failed (attribution by window, not by build identity — no stranger build was observed in flight during the poll). The publish did not land — provenance was not stamped. Fail-closed.";
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: rebuildAgentId,
+                applied_report: publishAppliedObservation,
+                outcome: "failed",
+                detail: "a build ran and failed (attribution by window, not by build identity): audit dir " + newestAuditDirAfterPoll + " report ok=false; no stranger build observed in flight during the poll"
+              }, totalReworkCount);
+            } else {
+              var unattributableReason = strangerObserved ? "stranger-build-observed-during-poll"
+                : (pollEndState === "build-still-running-at-poll-end" ? "build-still-running-at-poll-end"
+                : (newAuditDirsAfterPoll.length === 0 ? "no-new-audit-dir-in-window" : "audit-report-unreadable-or-missing"));
+              publishFailure = "Artifact build completion unproven (fail-closed, no provenance stamped): unattributable_reason=" + unattributableReason + "; poll_end_state=" + pollEndState + "; " + "saw_our_build=" + pollSawOurBuild + "; new_audit_dirs=" + newAuditDirsAfterPoll.length + ". Attribution is by window, not by build identity. The publish may or may not have landed. Fail-closed.";
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: rebuildAgentId,
+                applied_report: publishAppliedObservation,
+                outcome: "unknown",
+                detail: "durable audit-dir fallback could not attribute a completed build to this attempt (unattributable_reason=" + unattributableReason + ", poll_end_state=" + pollEndState + ")"
+              }, totalReworkCount);
+            }
           }
         } else {
           publishFailure = "Artifact rebuild trigger failed: " + (rebuildTrigger.error || "artifact_edit not accepted") + ". The publish did not land.";
@@ -1924,32 +2146,40 @@ while (i < STEPS.length) {
       "Public docs (API.md, README, published action schemas) are NOT source code — read them freely, exactly as a user would.\n" +
       "DOCS GATE: If the fix 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" +
       "To test, run in shell and read the stdout JSON:\n" + crewCmd("get-state", {}) + "\nThis returns current sessions, events, and tasks.\n" +
-      "Verify the fix by checking that session notes in the returned data now handle newlines correctly.\n" +
+      "Verify the fix against the task description in the returned data: the state the bug corrupted should now read correctly, and the task's own expected behavior should hold.\n" +
       "You can also check specific data with: node " + CREW_API + " --crew-home " + crewHome + " get-events --json '{\"task_id\":\"<the task id>\"}'.\n" +
-      "Do NOT use artifact_inspect — it is async and will not return results inline.\n" +
+      "Do NOT use artifact_inspect — it was removed by the platform (2026-09-14) and does not exist; do not substitute artifact.inspect (malfunction diagnosis, not an inspection tool).\n" +
       "File follow-up tasks by running in shell:\n" + crewCmd("create-task", { title: "<short title>", description: "<details>", project: "<project id>", workflow: "bugfix", filed_by: "hazel" }) + "\n(substitute the real values for the placeholders).\n" +
       npmPublishCheck +
       "Report your test results as plain prose.\n" +
       "End your report with exactly one line: VERDICT: PASS if testing passes, VERDICT: FAIL if it fails.";
-    // Visual verdict ownership (experiential artifact tasks only): the QA
-    // work agent covers the MECHANICAL CHECKS below — it does not call
-    // artifact_inspect (async; the parent triggers the post-change capture
-    // after this step). The visual verdict is produced by the parent after
-    // the rendered post-change inspection results arrive.
+    // qaVisual: Hazel runs the experiential see-act loop herself (STEP 1
+    // below) and owns the visual verdict — no parent capture protocol.
     if (qaVisual) {
       instructions = "You are code-blind QA. You NEVER read source files. Public docs are not source — read them as a user would.\n" +
-        "VISUAL VERDICT OWNERSHIP: this task is experiential. The visual verdict is NOT yours to issue — it is produced after the rendered post-change inspection results arrive, by Hazel with the baseline and post-change evidence in hand.\n" +
-        "Your VERDICT below covers the MECHANICAL CHECKS only. Do NOT call artifact_inspect.\n\n" +
+        "STEP 1: Experiential visual inspection — drive the fixed artifact as a user would, one browser step at a time, and verify the reported bug is actually fixed.\n" +
+        "You have a see-act driver: " + crewHome + "/current/lib/see-act.js (a node script; one browser action per invocation; it prints one JSON line to stdout). It launches its own Chromium through a self-contained loopback proxy — the ONLY url you may give it is the local artifact server you start below. Never point it at any other URL.\n" +
+        "Actions: aria | shot [--out <png>] [--full] | click [--out <png>] --selector <css> | scroll [--out <png>] --y <pixels|bottom> | type [--out <png>] --selector <css> --text <text>. Add --viewport mobile for a 390x844 frame. The JSON reports console_errors — treat any as a defect signal. Exit code 3 with not_possible set (a \"NOT POSSIBLE: <reason>\" string) means this environment cannot drive a browser: report NOT POSSIBLE: <reason> and continue with the mechanical checks — your VERDICT then covers mechanical checks only.\n" +
+        "a. Verify the built artifact exists: test -d ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/client/dist && test -f ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/server/dist/actions.js — if either is missing, report NOT POSSIBLE: built artifact not present at ~/workspace/ts-spaces/" + PUBLISH_SLUG + " and continue with the mechanical checks.\n" +
+        "b. Start the local artifact server detached with a log file, then poll the log for readiness (single shell invocation): CREW_HOME=" + crewHome + " setsid nohup node " + crewHome + "/current/lib/serve-artifact.js --space-dir ~/workspace/ts-spaces/" + PUBLISH_SLUG + " --port 0 --tag " + taskId + "-qa > /tmp/qa-server-" + taskId + ".log 2>&1 < /dev/null & for i in $(seq 1 30); do grep -q READY /tmp/qa-server-" + taskId + ".log && break; sleep 1; done; grep -o 'READY port=[0-9]*' /tmp/qa-server-" + taskId + ".log | cut -d= -f2 — the printed number is <N>. If no READY appears, report NOT POSSIBLE: local artifact server did not start (see /tmp/qa-server-" + taskId + ".log) and continue with the mechanical checks.\n" +
+        "c. Bounded see-act loop, at most 8 steps: re-run the reproduction steps for the reported bug — does it still occur? Then check the surrounding views for regressions. Prefix EVERY see-act invocation with SEE_ACT_ARCHIVE_DIR=" + crewHome + "/task-evidence/" + taskId + "/postchange/ (shell env vars do not persist between your commands, so prefix each one) — every screenshot is then archived automatically as 001-shot-desktop.png, 002-click-desktop.png, ..., so no frame can be lost. Omit --out; the JSON's screenshot field is the path to READ with your read tool (you can see images).\n" +
+        "c2. After EVERY see-act invocation, append it to the OODA report: node " + crewHome + "/current/lib/append-ooda-step.js --log " + crewHome + "/task-evidence/" + taskId + "/postchange/ooda-log.jsonl --attempt \"1\" --step <N> --action <aria|shot|click|scroll|type> --exit <exit-code> --screenshot <screenshot-from-JSON> --observation \"<1-2 sentences: what the frame showed and what you concluded>\" (omit --screenshot for aria). Steps are strictly monotonic: your first step is --step 1, then 2, 3, ... — the script rejects anything else. If you run the loop again (a new idea, after a restart), that run is --attempt \"2\": attempts never overwrite, they accumulate. Your observation is the payload — say what you saw and what it means, not just what you did. A step you ran but did not log is invisible to everyone after you.\n" +
+"c2b. IMAGE TOOLS (when a raw screenshot is not enough evidence): python3 " + crewHome + "/current/lib/edit-image.py crop --in <frame.png> --out <crop.png> --region x,y,w,h — pixel-exact crop; zoom --factor <f> --center x,y — pixel-crisp zoom back to the original frame size; label --text \"<caption>\" — caption bar; nup --cols 2 --in <a.png> --in <b.png> --labels \"before|after\" — side-by-side grid. Deterministic, no network. Log each with --action crop|zoom|label|nup, --attempt \"1\", and --screenshot <the derivative you READ>. For rich compositions (before/after with real typography, annotated callouts), write an HTML page and render it: node " + crewHome + "/current/lib/render-html.js --in <page.html> --out <composed.png> [--width 1200] — headless Chromium, hermetic (remote assets are blocked and fail the render), deterministic; log with --action compose and --screenshot <the composition you READ>. Derivatives supplement, never replace: keep the source frame archived and name it in --args. READ every derivative you log — an unread image is not evidence.\n" +
+        "c3. Start with: SEE_ACT_ARCHIVE_DIR=" + crewHome + "/task-evidence/" + taskId + "/postchange/ node " + crewHome + "/current/lib/see-act.js --url http://localhost:<N>/ aria — read the JSON, log the step. Then: SEE_ACT_ARCHIVE_DIR=" + crewHome + "/task-evidence/" + taskId + "/postchange/ node " + crewHome + "/current/lib/see-act.js --url http://localhost:<N>/ shot — READ the screenshot, log the step. Act on what you see: click, scroll, type, then re-observe, logging each step. Prefer aria (cheap text) to find controls; screenshot when the view changes and for your final verdict frames (one desktop, one mobile). If a click exits non-zero, do NOT retry the same ref blindly: re-run aria first (refs go stale between invocations), then click the fresh ref exactly once. If it still fails, log the failure and move on — a flaky control is a finding, not a loop.\n" +
+        "d. One action per invocation, fresh browser each time: anything reachable by (navigate, one action) is testable — e.g. clicking any tab or button from the landing page. Sequences needing prior in-page state (open a dialog, then confirm it) are not; if the fix needs such a sequence to verify, report NOT POSSIBLE for that part and judge what you can.\n" +
+        "e. Judge as a user against the task description: is the reported bug fixed AND is nothing else visibly broken? Look for broken layout, overflow, missing or wrong content, stale data, and console errors. Compare against the task's expected behavior, never against source code (you are code-blind). Every frame you captured is already archived under " + crewHome + "/task-evidence/" + taskId + "/postchange/ and indexed in ooda-log.jsonl. A frame you did not read is not evidence. Loading, error, or blank frames never pass. If you cannot complete the loop, say exactly which steps are missing — unknown is not PASS.\n" +
+        "f. Kill ONLY the server you started: pkill -f 'serve-artifact[.]js.*--tag " + taskId + "-qa' — never another task's server. (The [.] keeps pkill from matching its own command line.) Do not leave it running.\n" +
+        "Then continue with the mechanical checks below. Your VERDICT covers both the visual and the mechanical checks.\n\n" +
         "MECHANICAL CHECKS:\n" +
         "DOCS GATE: If the fix 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" +
         "To test, run in shell and read the stdout JSON:\n" + crewCmd("get-state", {}) + "\nThis returns current sessions, events, and tasks.\n" +
-        "Verify the fix by checking that session notes in the returned data now handle newlines correctly.\n" +
+        "Verify the fix against the task description in the returned data: the state the bug corrupted should now read correctly, and the task's own expected behavior should hold.\n" +
         "You can also check specific data with: node " + CREW_API + " --crew-home " + crewHome + " get-events --json '{\"task_id\":\"<the task id>\"}'.\n" +
         npmPublishCheck +
         "File follow-up tasks by running in shell:\n" + crewCmd("create-task", { title: "<short title>", description: "<details>", project: "<project id>", workflow: "bugfix", filed_by: "hazel" }) + "\n(substitute the real values for the placeholders).\n\n" +
         "BASELINE SANITY: in the event history you fetched, the task's note events must contain a message starting with `baseline: captured` or `baseline: none`. If no message starts with either prefix, report 'baseline evidence missing at QA — the Map gate was bypassed', then end your report with exactly this line: VERDICT: FAIL.\n\n" +
         "Report your test results as plain prose.\n" +
-        "End your report with exactly one line: VERDICT: PASS if testing passes, VERDICT: FAIL if it fails on the mechanical checks.";
+        "End your report with exactly one line: VERDICT: PASS if testing passes, VERDICT: FAIL if it fails on the visual or the mechanical checks. Checks you could not run are evidence gaps, not silent drops: name every one in --missing — unknown is neither PASS nor FAIL. First ensure the OODA log exists even if you logged zero steps (touch " + crewHome + "/task-evidence/" + taskId + "/postchange/ooda-log.jsonl — an empty log is honest, an absent one is a broken report). Also write the same verdict machine-readably: node " + crewHome + "/current/lib/write-ooda-verdict.js --dir " + crewHome + "/task-evidence/" + taskId + "/postchange/ --attempt \"1\" --verdict <PASS|FAIL|NOT_POSSIBLE> --summary \"<one line>\" --expected \"<the reported bug, fixed>\" --actual \"<what you observed>\" --missing '[\"honest evidence gap, if any\"]' [--reason \"<why it failed — REQUIRED and non-empty when verdict is FAIL or NOT_POSSIBLE; the script rejects a reason-less negative verdict with exit 2>\"] — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten). A FAIL verdict must carry a machine-readable reason: the workflow closeout cross-checks verdict.json against your prose VERDICT line, and an unreasoned or contradictory verdict fails the phase (never routes to rework).";
     }
     if (PUBLISH_TYPE === "artifact") {
       instructions = "PROVENANCE CHECK (this project publishes to a dashboard artifact).\n" +
@@ -2117,6 +2347,70 @@ while (i < STEPS.length) {
     verdictPassed = verdict.passed;
   }
 
+  // QA verdict.json closeout gate (task 30dceb78): the prose VERDICT: line is
+  // the routing signal, but verdict.json is the reason-carrying record the
+  // workflow actually reads. A FAIL verdict must carry a machine-readable
+  // reason; the workflow refuses to route to rework on an unreasoned or
+  // contradictory verdict. The deterministic cross-checker
+  // (lib/read-ooda-verdict.js) runs against the prose verdict: a missing,
+  // corrupt, contradictory, or reason-less record fails the phase for retry
+  // — the dispatcher re-runs QA at the same step under its
+  // consecutive-failure cap — instead of routing to rework. Without this
+  // gate, a bare VERDICT: FAIL with an all-positive report (canary
+  // 2026-09-15, task 1d692d91) rebuilt nothing and parked at Publish on an
+  // unobserved artifact build. The gate applies only to the experiential QA
+  // path (qaVisual), the only path that writes verdict.json.
+  if (step.name === "QA" && qaVisual && verdictPassed !== null) {
+    var qaVerdictDir = crewHome + "/task-evidence/" + taskId + "/postchange";
+    var qaVerdictExpect = verdictPassed ? "PASS" : "FAIL";
+    var qaVerdictOut = "";
+    try {
+      var qaVerdictCheck = await agent(
+        "Run: node " + crewHome + "/current/lib/read-ooda-verdict.js --dir " + qaVerdictDir + " --expect " + qaVerdictExpect + "\n" +
+        "Return JSON { \"output\": \"<the command's full stdout, trimmed>\" } and nothing else.",
+        { key: attemptKey("qa-verdict-check-" + taskId, totalReworkCount), label: "Cross-checking QA verdict.json",
+          schema: { type: "object", properties: { output: { type: "string" } }, required: ["output"] } }
+      );
+      qaVerdictOut = (qaVerdictCheck && qaVerdictCheck.output ? qaVerdictCheck.output : "").trim();
+    } catch (e) {
+      qaVerdictOut = "";
+    }
+    // The script prints exactly one JSON line; exit info does not survive
+    // the schema'd return, so ok:false on that line is the gate signal.
+    var qaVerdictGate = null;
+    try {
+      var qaVerdictLines = qaVerdictOut.split("\n");
+      qaVerdictGate = JSON.parse(qaVerdictLines[qaVerdictLines.length - 1]);
+    } catch (e) {
+      qaVerdictGate = null;
+    }
+    if (!qaVerdictGate || qaVerdictGate.ok !== true) {
+      var qaGateCode = (qaVerdictGate && qaVerdictGate.code) ? qaVerdictGate.code : "unreadable";
+      var qaGateDetail = (qaVerdictGate && qaVerdictGate.error) ? qaVerdictGate.error : (qaVerdictOut ? qaVerdictOut.slice(0, 200) : "cross-checker produced no usable output");
+      log("QA verdict.json closeout gate failed (" + qaGateCode + "): " + qaGateDetail + " — marking QA failed for retry, NOT routing to rework");
+      await agent(
+        "Record QA verdict gate failure.\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name,
+            status: "failed", notes: "QA verdict.json closeout gate failed (" + qaGateCode + "): " + qaGateDetail + ". The prose VERDICT line said " + qaVerdictExpect + " but verdict.json is missing, corrupt, contradictory, or (for FAIL) carries no machine-readable reason. Unreasoned or contradictory verdicts never route to rework; phase failed for retry" },
+          event: { task_id: taskId, type: "failed",
+            message: "QA verdict.json closeout gate failed (" + qaGateCode + ") — verdict unreasoned or contradictory, phase failed, dispatcher will retry QA" }
+        }),
+        { key: "record-qa-verdict-gate-fail-" + step.name, label: "Recording QA verdict gate failure" }
+      );
+      return {
+        __hatchWorkflowControl: "blocked",
+        result: {
+          blocked_reason: "QA verdict.json closeout gate failed (" + qaGateCode + ")",
+          message: "QA's prose VERDICT line said " + qaVerdictExpect + " but the machine-readable verdict.json is " + qaGateCode + " (" + qaGateDetail + "). A FAIL verdict must carry a machine-readable reason and the record must agree with the prose line. The phase is marked failed and the dispatcher will retry QA; it is not routed to rework.",
+          task_id: taskId
+        }
+      };
+    }
+    log("QA verdict.json closeout gate passed: verdict.json agrees with prose VERDICT: " + qaVerdictExpect);
+  }
+
 
   // Worktree confinement (Build only): the declared worktree path must
   // match WORKTREE_HINT exactly. A builder that worked in any other
@@ -2148,6 +2442,52 @@ while (i < STEPS.length) {
       };
     }
     log("Build worktree confinement passed: " + wt.path);
+
+    // Already-merged idempotency: a `repo_diff: none (already-merged:
+    // <sha>)` declaration is verified mechanically — <sha> must resolve
+    // and be an ancestor of main in the configured repo. A fabricated or
+    // mistaken declaration fails the phase here (the dispatcher retries
+    // Build under its consecutive-failure cap); a verified declaration is
+    // recorded in alreadyMergedSha for Review's no-diff branch. Without
+    // this guard, Build correctly doing nothing left Review with no
+    // mechanical way to accept an empty diff, and Cass rejected for "no
+    // commits ahead of main — the builder likely forgot to commit" while
+    // the deliverable sat on main (canary 2026-09-15, task 1d692d91).
+    // The sha is hex-only by construction (extractAlreadyMerged), so
+    // interpolating it into the shell command cannot inject.
+    var am = extractAlreadyMerged(workerText);
+    if (am.sha) {
+      var amCheck = await agent(
+        "Verify the builder's already-merged declaration.\n" +
+        "Run in shell and return the stdout verbatim:\n" +
+        "cd " + REPO_PATH + " && git rev-parse --verify --quiet " + am.sha + " >/dev/null && git merge-base --is-ancestor " + am.sha + " main && echo ALREADY_MERGED_YES || echo ALREADY_MERGED_NO",
+        { key: "verify-already-merged" + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), label: "Verifying already-merged declaration" }
+      );
+      var amOut = (typeof amCheck === "string") ? amCheck : JSON.stringify(amCheck);
+      if (!/ALREADY_MERGED_YES/.test(amOut)) {
+        log("Build already-merged declaration failed verification — " + am.sha + " is not an ancestor of main — marking failed for retry");
+        await agent(
+          "Record already-merged verification failure.\n" +
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+            task_id: taskId,
+            session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed",
+              notes: "Build declared repo_diff: none (already-merged: " + am.sha + ") but " + am.sha + " is not an ancestor of main in the configured repo. The declaration is fabricated or mistaken; the work is not on main. Phase failed for retry" },
+            event: { task_id: taskId, type: "failed", message: "Build already-merged declaration failed verification — " + am.sha + " not an ancestor of main, phase failed, dispatcher will retry" }
+          }),
+          { key: "record-already-merged-fail-" + step.name, label: "Recording already-merged verification failure" }
+        );
+        return {
+          __hatchWorkflowControl: "blocked",
+          result: {
+            blocked_reason: "Build already-merged declaration failed verification",
+            message: "The builder declared repo_diff: none (already-merged: " + am.sha + ") but " + am.sha + " is not an ancestor of main. The work is not on main; the phase is marked failed and the dispatcher will retry Build.",
+            task_id: taskId
+          }
+        };
+      }
+      alreadyMergedSha = am.sha;
+      log("Build already-merged declaration verified: " + am.sha + " is an ancestor of main");
+    }
   }
 
   // Deterministic closeout: no formatter agent. The verdict is mechanical
@@ -2276,9 +2616,10 @@ while (i < STEPS.length) {
   // it to HEAD: that verifies the stamp, not the content. Canary run 8
   // (2026-09-11) passed it with a hollow build — the stamp was honest, the
   // artifact was stale, all eight phases green. The stamp now moves to the
-  // parent: trigger an independent artifact_inspect read-back of the changed
-  // regions here; the parent stamps provenance only after mechanically
-  // confirming the artifact's actual content matches the merged diff. QA's
+  // parent (docs/publish-verification.md); the independent read-back step
+  // is currently unavailable (no agent-callable read-back tool exists —
+  // artifact_inspect was removed by the platform 2026-09-14), so the parent
+  // cannot confirm content and the task parks for verification. QA's
   // provenance check enforces the stamp — an unverified publish fails loudly
   // there instead of passing silently here.
   // Skip-aware (park 2026-09-11): an empty-diff Integrate takes no merge
@@ -2286,38 +2627,13 @@ while (i < STEPS.length) {
   // there is no new content to verify, so verification is vacuous.
   // publishSkippedNoLock is workflow-computed state from the explicit
   // lock-status read in STEP 0, not agent prose.
-  var publishVerifyInspect = { triggered: false, inspection_id: "", error: "" };
-  if (step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG) {
-    if (publishSkippedNoLock) {
-      log("Publish skipped for task " + taskId + " (no merge lock held — empty-diff Integrate): content verification vacuous, nothing was shipped");
-    } else if (!publishBuildLanded) {
-      log("Publish build did not land for task " + taskId + " — no content to verify (the failure park above already fired)");
-    } else {
-    try {
-      var inspectResult = await agent(
-        ARTIFACT_LOAD_PREAMBLE +
-        "Call artifact_inspect with slug \"" + PUBLISH_SLUG + "\", repair_authorized false, and verbatim_request exactly as follows:\n" +
-        "<<<READBACK_REQUEST\n" + buildPublishReadbackRequest(taskId, mergeCommitForPublish, mergeDiff, rebuildAgentId) + "\nREADBACK_REQUEST\n" +
-        "If artifact_inspect is still not available after the load, do NOT improvise — return { \"triggered\": false, \"inspection_id\": \"\", \"error\": \"artifact_tools missing after load\" } and nothing else.\n" +
-        "Return JSON { \"triggered\": <true if the inspection started, false otherwise>, \"inspection_id\": \"<the inspection id, or empty string>\", \"error\": \"<details or empty string>\" } and nothing else.",
-        { key: attemptKey("publish-verify-inspect-" + taskId, totalReworkCount), label: "Triggering publish content read-back",
-          schema: { type: "object", properties: { triggered: { type: "boolean" }, inspection_id: { type: "string" }, error: { type: "string" } }, required: ["triggered"] } }
-      );
-      publishVerifyInspect.triggered = !!(inspectResult && inspectResult.triggered);
-      publishVerifyInspect.inspection_id = (inspectResult && inspectResult.inspection_id) || "";
-      publishVerifyInspect.error = (inspectResult && inspectResult.error) || "";
-      if (publishVerifyInspect.triggered) {
-        log("Publish content read-back inspection triggered for task " + taskId + ": " + publishVerifyInspect.inspection_id);
-      } else {
-        log("Publish content read-back inspect trigger failed for task " + taskId + ": " + (publishVerifyInspect.error || "not started") + " — the park below asks the parent to trigger it manually");
-      }
-    } catch (e) {
-      publishVerifyInspect.error = (e && e.message ? e.message : String(e)).slice(0, 200);
-      log("Publish content read-back inspect trigger threw for task " + taskId + ": " + publishVerifyInspect.error + " — the park below asks the parent to trigger it manually");
-    }
-    } // end: !publishSkippedNoLock && publishBuildLanded — a skipped or failed publish has nothing to verify
-  }
-
+  // The parent (tick worker) triggers the ONE read-back inspection it can
+  // actually receive (async results go to the root agent, never into a
+  // workflow run — a workflow-side trigger would be an orphan). The workflow
+  // only parks; the parent's scan builds the request deterministically via
+  // lib/build-readback-request.js and ferries the inspection.
+  // publishBuildLanded and publishSkippedNoLock are workflow-computed state;
+  // a skipped or failed publish has nothing to verify.
   // Session notes. Machine-readable marker lines are extracted from the full
   // worker report and appended AFTER the slice so a long report can never
   // amputate them; later phases (Review reading repo_diff:, QA backstop
@@ -2335,16 +2651,23 @@ while (i < STEPS.length) {
   } else {
     summary = (stepResult.summary || "Step completed").slice(0, 2000 - workerMarkers.length - 1) + (workerMarkers ? "\n" + workerMarkers : "");
   }
-
-  // Visual verdict evidence: for experiential artifact tasks, append the
-  // deterministic post-change capture plan to the QA session notes. The
-  // parent protocol (docs/visual-verdict.md) triggers the inspection with
-  // this plan; "visual: pending" marks the owed verdict.
-  if (step.name === "QA" && passed && qaVisual) {
-    summary = (summary + "\nvisual: pending\ncapture_plan: " +
-      buildVisualCapturePlan(taskTitle, taskDescription, "postchange", captureTargets).replace(/\s+/g, " ")).slice(0, 2900);
+  // Already-merged attestation: when the Build gate verified the builder's
+  // already-merged declaration, the workflow records its own marker line in
+  // the session notes (like the builder markers above, it is appended after
+  // the slice so it can never be amputated). A later run resumed at Review
+  // hydrates alreadyMergedSha from this workflow-attested line — never from
+  // the builder's declaration alone.
+  if (step.name === "Build" && alreadyMergedSha) {
+    summary += "\nalready_merged_verified: " + alreadyMergedSha;
   }
 
+  // Visual verdict evidence (2026-09-15): no parent marker is appended. Hazel
+  // records her own verdict.json + the append-only verdicts.jsonl in the
+  // task-evidence dir during the QA loop itself — the QA session notes carry
+  // her prose report, and the OODA report carries the machine-readable state.
+  // The old parent-protocol marker for the QA closeout is deleted.
+  // is deleted.
+
   // Capture mapper's spec for Build and Review
   if (step.name === "Map" && passed) {
     mapperSpec = summary;
@@ -2387,40 +2710,12 @@ while (i < STEPS.length) {
     return await parkTask("Reproduction failed — needs PM attention");
   }
 
-  // Visual-verdict gate: for experiential artifact tasks the task is done
-  // only when the parent has recorded a visual_verdict: note event. The QA
-  // work agent above covered the mechanical checks only. No recorded
-  // verdict → park for the parent protocol (never mark done on a pending
-  // visual verdict). A recorded FAIL with budget left → rework at Build.
-  if (step.name === "QA" && passed && qaVisual) {
-    var vvStatus = await visualVerdictStatus();
-    if (vvStatus.found && vvStatus.verdict === "PASS") {
-      log("Visual verdict PASS recorded for task " + taskId + (vvStatus.detail ? " — " + vvStatus.detail : ""));
-    } else if (vvStatus.found && vvStatus.verdict === "FAIL") {
-      // A FAIL whose reason begins exactly "rendering impossible:" is not
-      // reworkable — there is no rendered evidence to fix against. Park for
-      // human attention instead of bouncing to Build.
-      if (vvStatus.detail.indexOf("rendering impossible:") === 0) {
-        log("Visual verdict FAIL (rendering impossible) for task " + taskId + " — parking for human attention");
-        return await parkTask("Visual verdict FAIL — rendering impossible, human attention required: " + vvStatus.detail);
-      }
-      totalReworkCount++;
-      if (totalReworkCount > MAX_TOTAL_REWORK) {
-        log("Shared rework budget exhausted for task " + taskId + " — parking after visual verdict FAIL");
-        return await parkTask("Exceeded shared rework budget (" + MAX_TOTAL_REWORK + " total rework attempts across Review and QA) after visual verdict FAIL: " + vvStatus.detail);
-      }
-      rejectionNotes = "Visual verdict FAIL: " + vvStatus.detail;
-      i = BUILD_INDEX;
-      log("Visual verdict FAIL — bouncing to Build (rework #" + totalReworkCount + " of " + MAX_TOTAL_REWORK + ")");
-      continue;
-    } else {
-      if (!VISUAL_PROTOCOL_AVAILABLE) {
-        log("Visual verdict protocol not available (VISUAL_PROTOCOL_AVAILABLE=false) for task " + taskId + " — skipping visual gate, QA mechanical checks already passed");
-      } else {
-        return await parkTask("Visual verdict pending — parent: run the post-change capture + visual verdict protocol in docs/visual-verdict.md (capture plan is in the QA session notes)");
-      }
-    }
-  }
+  // Visual verdict ownership (2026-09-15): Hazel owns the visual verdict
+  // experientially — the QA instructions above have her drive the see-act
+  // loop herself and record verdict.json + the append-only verdicts.jsonl.
+  // Her prose VERDICT: line drives `passed` via extractVerdict; a FAIL
+  // bounces to Build through the standard Review/QA rejection path below.
+  // The old parent-recorded note gate is deleted.
 
   // Review/QA rejection bounces to Build
   if (!passed && (step.name === "Review" || step.name === "QA")) {
@@ -2461,10 +2756,7 @@ while (i < STEPS.length) {
   if (passed && step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG && !publishSkippedNoLock && publishBuildLanded) {
     return await parkTask("publish: verification-requested " + mergeCommitForPublish +
       " (build " + (rebuildAgentId || "agent_id unobserved") + ")" +
-      " — artifact build landed, post-deploy finalized, provenance NOT stamped. Parent: run docs/publish-verification.md" +
-      (publishVerifyInspect.triggered
-        ? " (content read-back inspection " + publishVerifyInspect.inspection_id + " already triggered)."
-        : " (read-back inspect trigger failed: " + (publishVerifyInspect.error || "not started") + " — parent: trigger artifact_inspect manually)."));
+      " — artifact build landed, post-deploy finalized, provenance NOT stamped. Parent: run docs/publish-verification.md.");
   }
 
   i++;