muse-crew 0.7.9 → 0.7.11

package/workflows/standard.js

@@ -472,52 +472,23 @@ 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;
+// 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.
-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."
-  );
-}
-
 // 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,44 +722,6 @@ 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.\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: "" };
-  }
-}
-
 // STEPS inline — export const meta is parsed as metadata, not a runtime binding
 const STEPS = [
   { name: "Triage", identity: "sage" },
@@ -1227,12 +1160,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.
+  // Experiential routing: experiential artifact tasks run the Hazel
+  // experiential QA prompt (built in the PUBLISH_TYPE === "artifact" branch
+  // of the QA step) — Hazel drives the artifact herself and owns the visual
+  // verdict through her OODA report and write-ooda-verdict ledger.
   var qaVisual = false;
   if (step.name === "QA") {
     qaVisual = (await resolveExperiential()) === "yes" && PUBLISH_TYPE === "artifact";
@@ -1243,7 +1174,7 @@ while (i < STEPS.length) {
   var instructions = "";
 
   if (step.name === "Triage") {
-    instructions = "Validate the task, check clarity, note dependencies, confirm the standard workflow assignment.\nWrite a brief triage assessment as notes for the next step.\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 standard workflow assignment.\nWrite a brief triage assessment as notes for the next step.\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 === "Map") {
     var mapGatePara = "";
@@ -1371,10 +1302,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;
@@ -1423,14 +1355,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.");
@@ -1441,11 +1404,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.");
         }
@@ -1458,12 +1425,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"] } }
@@ -1472,7 +1443,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));
         }
@@ -1530,6 +1501,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
@@ -1548,6 +1520,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 });
@@ -1606,7 +1604,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
@@ -1622,6 +1659,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") {
@@ -1691,7 +1729,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) {
@@ -1789,12 +1827,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");
@@ -1892,12 +1932,19 @@ while (i < STEPS.length) {
       var safeDesc = taskDescription.replace(/"/g, "'").replace(/\\/g, "\\\\").slice(0, 500);
       instructions = "You are code-blind QA. You NEVER read source files.\n" +
         "Public docs (API.md, README, published action schemas) are NOT source code — read them freely, exactly as a user would.\n\n" +
-        "STEP 1: Trigger a visual inspection of the published artifact.\n" +
-        "Call artifact_inspect with:\n" +
-        "  slug: \"" + PUBLISH_SLUG + "\"\n" +
-        "  repair_authorized: false\n" +
-        "  verbatim_request: \"Verify task: " + safeTitle + ". " + safeDesc + "\"\n\n" +
-        "This call is asynchronous — it fires the inspection but results arrive outside this workflow. That is expected and correct.\n\n" +
+        "STEP 1: Experiential visual inspection — drive the artifact as a user would, one browser step at a time.\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: drive the artifact as a user would, one browser step at a time. 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 task's change needs such a sequence, report NOT POSSIBLE for that part and judge what you can.\n" +
+        "e. Judge as a user against the task description: does the change render correctly? 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" +
         "STEP 2: Verify data integrity via the crew API.\n" +
         "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
         "Use the returned tasks, sessions, and events to check the task's data-level effects.\n" +
@@ -1915,7 +1962,8 @@ while (i < STEPS.length) {
         "For each issue, run in shell:\n" +
         "node " + CREW_API + " --crew-home " + crewHome + " create-task --json '{\"title\": \"<issue title>\", \"description\": \"<issue details>\", \"project\": \"" + LAUNCH_PROJECT_ID + "\", \"workflow\": \"bugfix\", \"filed_by\": \"hazel\"}'\n" +
         "(replace <issue title> and <issue details> with the real values).\n\n" +
-        "Report back in plain prose — what checks you ran and their results. End your report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
+        "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 back in plain prose — what checks you ran and their results. Checks you could not run are evidence gaps, not silent drops: name every one in --missing — unknown is neither PASS nor FAIL. End your report with exactly one line: VERDICT: PASS or VERDICT: 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 \"<what the task required>\" --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).";
     } else {
       instructions = "Test from a user's perspective. You are CODE-BLIND — do NOT read source code.\n" +
         "Public docs (API.md, README) are NOT source code — read them freely, exactly as a user would.\n" +
@@ -1927,37 +1975,10 @@ while (i < STEPS.length) {
         npmPublishCheck +
         "Report back in plain prose — what you tested and found. End your report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
     }
-    // Visual verdict ownership (experiential artifact tasks only): the QA
-    // work agent covers the MECHANICAL CHECKS below — the artifact_inspect
-    // trigger prose is replaced, because the visual verdict is produced by
-    // the parent after the rendered post-change inspection results arrive.
-    // Mechanical checks are kept verbatim from the artifact path above.
-    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 (async; the parent triggers the post-change capture after your step).\n\n" +
-        "MECHANICAL CHECKS:\n" +
-        "STEP 2: Verify data integrity via the crew API.\n" +
-        "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
-        "Use the returned tasks, sessions, and events to check the task's data-level effects.\n" +
-        "DOCS GATE: If the change is public-affecting (it alters anything a user or consumer can observe: API actions, parameters, behavior, or errors), verify the public docs describe it. If public docs are missing or stale for a public-affecting change, report 'public docs missing/stale for [the change]', then end your report with exactly this line: VERDICT: FAIL. QA always fails when public-affecting changes lack public docs. Guide/tutorial gaps are lower priority — file a follow-up task for those instead of failing.\n\n" +
-        "PROVENANCE CHECK: Run in shell and return the stdout verbatim:\n" + crewCmd("get-provenance", {}) + "\n" +
-        "If provenance is null, report 'provenance missing — publish did not stamp source/crew release', then end your report with exactly this line: VERDICT: FAIL.\n" +
-        "Run: cd " + REPO_PATH + " && git rev-parse HEAD — call this LIVE_HEAD.\n" +
-        "Run: test -d " + crewHome + "/releases/<provenance.crew_release> (substitute the real stamped hash; do not run the literal placeholder). If the directory does not exist, FAIL: { \"passed\": false, \"summary\": \"provenance mismatch: crew_release [value from get-provenance] not found in release registry\" }.\n" +
-        "If provenance.source_commit equals LIVE_HEAD, the source check passes — continue to STEP 3.\n" +
-        "Otherwise the check is NOT failed yet: the parent stamps provenance AFTER post-deploy (docs/publish-verification.md), and post-deploy may commit an artifact-builder staging commit (\"rebuild: <task_id>\"), so LIVE_HEAD may sit ahead of the stamped commit ONLY IF every commit in between is such a rebuild marker. Verify exactly:\n" +
-        "1. Run: cd " + REPO_PATH + " && git merge-base --is-ancestor <provenance.source_commit> LIVE_HEAD && echo ANCESTOR_OK (substitute the real stamped hash and LIVE_HEAD; do not run the literal placeholders). If this command fails, FAIL: { \"passed\": false, \"summary\": \"provenance mismatch: stamped source_commit is not an ancestor of live HEAD\" }.\n" +
-        "2. Run: cd " + REPO_PATH + " && git log --format=%s <provenance.source_commit>..LIVE_HEAD (substitute real values). Every subject line MUST start with \"rebuild: \". If any line does not, report 'provenance mismatch: live HEAD moved past the stamped commit with non-rebuild source commits: [paste the offending subject lines]', then end your report with exactly this line: VERDICT: FAIL.\n" +
-        "If both pass, the source check passes — the only drift since the stamp is builder staging output committed by post-deploy. Continue to STEP 3.\n\n" +
-        "STEP 3: File follow-up tasks for any related issues you discover.\n" +
-        "For each issue, run in shell:\n" +
-        "node " + CREW_API + " --crew-home " + crewHome + " create-task --json '{\"title\": \"<issue title>\", \"description\": \"<issue details>\", \"project\": \"" + LAUNCH_PROJECT_ID + "\", \"workflow\": \"bugfix\", \"filed_by\": \"hazel\"}'\n" +
-        "(replace <issue title> and <issue details> with the real values).\n\n" +
-        "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" +
-        "File follow-up tasks as today.\n" +
-        "Report back in plain prose — what checks you ran and their results. End your report with exactly one line: VERDICT: PASS or VERDICT: FAIL on the mechanical checks.";
-    }
+    // qaVisual (experiential artifact tasks): Hazel owns the visual verdict
+    // through the experiential QA prompt built in the PUBLISH_TYPE ===
+    // "artifact" branch above (STEP 1 see-act loop + OODA report). There is
+    // no parent visual-verdict protocol anymore — no override here.
   }
 
   // Task event history — Review and Publish are excluded. Review is cold by
@@ -2266,9 +2287,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
@@ -2276,37 +2298,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
@@ -2329,11 +2327,7 @@ while (i < STEPS.length) {
   // 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);
-  }
+
 
   // Capture mapper's spec for Build and Review
   if (step.name === "Map" && passed) {
@@ -2368,41 +2362,6 @@ while (i < STEPS.length) {
     }
   );
 
-  // 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)");
-      }
-    }
-  }
-
   // Handle rejection — bounce back to Build
   if (!passed && (step.name === "Review" || step.name === "QA")) {
     totalReworkCount++;
@@ -2442,10 +2401,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++;