muse-crew 0.7.9 → 0.7.11

package/workflows/bugfix.js

@@ -472,52 +472,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 —
@@ -751,43 +721,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 = [
@@ -1245,12 +1186,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 +1199,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\"]' — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten).";
 
   } else if (step.name === "Map") {
     var mapGatePara = "";
@@ -1399,10 +1345,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 +1398,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.");
@@ -1469,11 +1447,15 @@ while (i < STEPS.length) {
         if (/^rename from /m.test(mergeDiff)) {
           return await parkTask("Publish diff contains a rename — the diff transport cannot carry renames. Human attention needed.");
         }
-        var mergeDiffLines = mergeDiff.split("\n").length;
-        if (mergeDiffLines > 200) {
-          return await parkTask("Publish diff is " + mergeDiffLines + " lines (budget 200) — too large for the diff transport. Human attention needed.");
-        }
         var expectedChanges = parseUnifiedDiff(mergeDiff);
+        // Budget counts CHANGED lines (added + removed), not raw unified-diff
+        // output lines: context lines and file headers inflated the old
+        // split("\n").length count ~2x, parking a 95-line change against a
+        // 200-line budget (Gate 1 Journey 3 attempt 3, 2026-09-13).
+        var mergeDiffChangedLines = expectedChanges.reduce(function (n, f) { return n + f.added.length + f.removed.length; }, 0);
+        if (mergeDiffChangedLines > 200) {
+          return await parkTask("Publish diff changes " + mergeDiffChangedLines + " lines (budget 200) — too large for the diff transport. Human attention needed.");
+        }
         if (expectedChanges.length === 0) {
           return await parkTask("Publish diff parsed to zero files for commit " + (mergeCommitForPublish || "unknown") + " — cannot verify application. Human attention needed.");
         }
@@ -1486,12 +1468,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"] } }
@@ -1500,7 +1486,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));
         }
@@ -1558,6 +1544,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
@@ -1576,6 +1563,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 });
@@ -1634,7 +1647,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
@@ -1650,6 +1702,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") {
@@ -1719,7 +1772,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) {
@@ -1817,12 +1870,14 @@ while (i < STEPS.length) {
             // 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");
@@ -1920,32 +1975,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\"]' — this writes verdict.json (the latest verdict) and appends to verdicts.jsonl (the append-only ledger: every attempt's verdict is preserved, never overwritten).";
     }
     if (PUBLISH_TYPE === "artifact") {
       instructions = "PROVENANCE CHECK (this project publishes to a dashboard artifact).\n" +
@@ -2272,9 +2335,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
@@ -2282,38 +2346,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
@@ -2332,14 +2371,12 @@ while (i < STEPS.length) {
     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);
-  }
+  // 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) {
@@ -2383,40 +2420,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")) {
@@ -2457,10 +2466,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++;