muse-crew 0.4.3 → 0.4.5

package/workflows/bugfix.js

@@ -1,9 +1,10 @@
 export const meta = {
   name: "crew-bugfix",
-  description: "Bugfix workflow: Triage → Reproduce → Map → Build → Review → Integrate → Publish → QA",
-  phases: ["Triage", "Reproduce", "Map", "Build", "Review", "Integrate", "Publish", "QA"],
+  description: "Bugfix workflow: Triage → Capture → Reproduce → Map → Build → Review → Integrate → Publish → QA",
+  phases: ["Triage", "Capture", "Reproduce", "Map", "Build", "Review", "Integrate", "Publish", "QA"],
   steps: [
     { name: "Triage", identity: "sage" },
+    { name: "Capture", identity: "hazel" },
     { name: "Reproduce", identity: "hazel" },
     { name: "Map", identity: "mara" },
     { name: "Build", identity: "wren" },
@@ -19,7 +20,6 @@ const inputs = args ?? {};
 const taskId = inputs.task_id;
 const taskTitle = inputs.task_title || "";
 const taskDescription = inputs.task_description || "";
-const firstSessionId = inputs.session_id || null;
 const startStepIndex = inputs.start_step_index || 0;
 
 // Config from args — backward-compatible fallbacks for manual launches
@@ -29,13 +29,16 @@ const ORCH_PATH = crewHome + "/.orchestration";
 // Pin lifecycle scripts to this run
 const LIFECYCLE_SRC = crewHome + "/lib/worktree-lifecycle.sh";
 const MERGE_LOCK_SRC = crewHome + "/lib/merge-lock.sh";
-const RUN_LIB = "/tmp/crew-lib-" + taskId;
+const RUN_LIB = crewHome + "/.pins/" + taskId; // persistent disk, NOT /tmp (tmpfs wiped by cell reboots — canary b5efd1b1); stale pins reaped by orphan-sweep
 const LIFECYCLE = RUN_LIB + "/worktree-lifecycle.sh";
 const MERGE_LOCK = RUN_LIB + "/merge-lock.sh";
 const PUBLISH_NPM_SRC = crewHome + "/lib/publish-npm.sh";
 const PUBLISH_NPM = RUN_LIB + "/publish-npm.sh";
 const ORPHAN_SWEEP_SRC = crewHome + "/lib/orphan-sweep.sh";
 const ORPHAN_SWEEP = RUN_LIB + "/orphan-sweep.sh";
+// The four basenames the pin step must materialize — asserted mechanically
+// by workflow code from the verbatim listing, never from agent prose.
+const PIN_BASENAMES = [LIFECYCLE, MERGE_LOCK, PUBLISH_NPM, ORPHAN_SWEEP].map(function (p) { return p.split("/").pop(); });
 
 // Project config — passed by dispatcher, falls back to dashboard defaults
 const projectConfig = inputs.project_config || {};
@@ -43,6 +46,21 @@ const projectConfig = inputs.project_config || {};
 // compares the task's live project against this on every phase boundary.
 const LAUNCH_PROJECT_ID = inputs.project_id || "";
 const REPO_PATH = projectConfig.repo_path || "~/workspace/ts-spaces/orchestra-dashboard";
+
+// Worktree layout: the task's worktree lives at
+// <repo>/.worktrees/<task_id> on branch task/<task_id>. The lifecycle
+// manager (lib/worktree-lifecycle.sh) owns creation and removal; the
+// registry at <repo>/.worktrees/.registry/<task_id> is the source of
+// truth for task→branch/path.
+// Env prefix baked into every lifecycle invocation the agents run.
+const LIFECYCLE_ENV = "CREW_REPO=" + REPO_PATH + " ";
+// The task branch is always task/<task_id>.
+const TASK_BRANCH = "task/" + taskId;
+// Where the agent works.
+const WORKTREE_HINT = REPO_PATH + "/.worktrees/" + taskId;
+// Where preserved work lives when the rework budget is exhausted.
+const WORKTREE_PRESERVED_HINT = ".worktrees/" + taskId;
+
 const PUBLISH_TYPE = projectConfig.deploy_type || "";
 const PUBLISH_SLUG = projectConfig.deploy_slug || DASHBOARD_SLUG;
 const PROJECT_DESC = projectConfig.description || "React + TypeScript web dashboard (client/src/, server/src/, drizzle/)";
@@ -52,17 +70,360 @@ if (!taskId) {
   throw new Error("task_id is required in args");
 }
 
-// Work-agent result schema. Runtime retries on non-JSON (structured outputs).
-// Workflow wraps in try/catch so exhausted retries block instead of crashing.
-const WORK_SCHEMA = {
-  type: "object",
-  properties: { passed: { type: "boolean" }, summary: { type: "string" } },
-  required: ["passed", "summary"]
-};
+// Closeout is deterministic: the work agent returns the runtime's native
+// transport envelope {"status": "ok", "result": "<prose report>"} with no
+// schema, so the workflow receives the report as a plain string. There is no
+// {"report"} wrapper: that invented shape invited agents to improvise sibling
+// keys (notably "status"), which the runtime duck-types as its own envelope
+// and fatally misparses. The envelope is the runtime's own documented shape
+// — not a demand for machine-structured reasoning.
+// The verdict is extracted mechanically by extractVerdict below — never by an
+// agent. The summary is the worker's report truncated. The release decision
+// comes from extractReleaseDecision. No formatter agent: it added a failure
+// mode while contributing nothing the workflow doesn't compute itself.
+// Steps whose passed=false drives a control-flow branch (rework bounce,
+// block) declare their verdict explicitly on a VERDICT: line. The verdict is
+// extracted DETERMINISTICALLY by workflow code (extractVerdict) — never by
+// an agent. Missing, malformed, or contradictory lines fail the phase (never silently pass).
+const VERDICT_STEPS = ["Build", "Review", "QA", "Reproduce", "Integrate", "Publish"];
+function extractVerdict(workerText) {
+  // The verdict is the LAST VERDICT: PASS/FAIL in the report (contract: end
+  // your report with the verdict). This ignores literal VERDICT strings echoed
+  // from the worker's instructions (which contain quoted examples). Fail
+  // closed if: no verdict found, the last verdict is not in the trailing 100
+  // chars (verdict must be at the end), or conflicting verdicts appear in the
+  // trailing 200 chars. Word boundary prevents "PASSING" matching as PASS.
+  var text = workerText || "";
+  var regex = /VERDICT:\s*(PASS|FAIL)\b/gi;
+  var matches = [];
+  var m;
+  while ((m = regex.exec(text)) !== null) {
+    matches.push({ value: /FAIL/i.test(m[0]) ? "FAIL" : "PASS", index: m.index });
+  }
+  if (matches.length === 0) return { ok: false, count: 0 };
+  var last = matches[matches.length - 1];
+  if (last.index < text.length - 100) return { ok: false, count: matches.length };
+  var trailing = matches.filter(function (x) { return x.index >= text.length - 200; });
+  var uniq = trailing.map(function (x) { return x.value; }).filter(function (v, i, a) { return a.indexOf(v) === i; });
+  if (uniq.length !== 1) return { ok: false, count: matches.length };
+  return { ok: true, passed: last.value === "PASS" };
+}
+// Verdict re-ask (bug cd18ccc2): a verdict-step report that fails
+// extractVerdict is not failed immediately. Stochastic verdict-line
+// non-compliance (the agent did the work but omitted or garbled the VERDICT
+// line) gets up to two bounded follow-up agent() calls whose only job is to
+// read the preserved report and emit exactly one VERDICT line. The verdict
+// is still extracted mechanically by extractVerdict — the re-ask agent
+// transcribes, never decides the phase outcome. Each attempt uses a fresh
+// stable-key suffix so a cached failure can never replay deterministically.
+// Exhaustion keeps the existing fail-closed behavior. This is structure, not
+// prompt hardening: no instruction text was stern-ified to get here.
+function verdictReaskKey(stepName, reworkSuffix, attempt) {
+  return "verdict-reask-" + stepName + reworkSuffix + "-a" + attempt;
+}
+function buildVerdictReaskPrompt(stepName, workerText) {
+  return "Mechanical transcription task. Read the work report below and emit its verdict.\n\n" +
+    "WORK REPORT (verbatim):\n" + workerText + "\n\n" +
+    "Decide from the report's own content whether the " + stepName + " step clearly describes successful completion: " +
+    "if it does, the verdict is PASS; otherwise — failure, error, unfinished work, or unclear — the verdict is FAIL. " +
+    "Do NOT copy any VERDICT line from the report — decide from the content.\n\n" +
+    "Return your work as JSON in exactly this shape: {\"status\": \"ok\", \"result\": \"your verdict line here\"}. " +
+    "The result must be exactly one line and nothing else: VERDICT: PASS or VERDICT: FAIL.";
+}
+async function reaskVerdict(stepName, reworkSuffix, workerText) {
+  var verdict = { ok: false, count: 0 };
+  for (var attempt = 1; attempt <= 2; attempt++) {
+    var reaskResult = null;
+    try {
+      reaskResult = await agent(buildVerdictReaskPrompt(stepName, workerText), {
+        key: verdictReaskKey(stepName, reworkSuffix, attempt),
+        label: "Verdict re-ask: " + stepName + " (attempt " + attempt + " of 2)",
+        timeoutMs: 180000
+      });
+    } catch (e) {
+      log(stepName + " verdict re-ask attempt " + attempt + " errored: " + ((e && e.message ? e.message : String(e)) || "").slice(0, 200));
+      continue;
+    }
+    var reaskText = (typeof reaskResult === "string") ? reaskResult : "";
+    verdict = extractVerdict(reaskText);
+    if (verdict.ok) {
+      log(stepName + " verdict re-ask attempt " + attempt + " recovered verdict: " + (verdict.passed ? "PASS" : "FAIL"));
+      return verdict;
+    }
+    log(stepName + " verdict re-ask attempt " + attempt + " produced no readable verdict (" + verdict.count + " trailing-window matches)");
+  }
+  return verdict;
+}
+// Transport retry: the work-agent agent() call can throw even when the agent
+// did the work. Stochastic envelope non-compliance (bare prose instead of
+// the native {"status":"ok","result":"..."} envelope) trips the runtime's
+// JSON-candidate heuristic when the prose contains a {...}-looking
+// substring — canary 39457ee9's QA report quoted the change's own
+// {/* ... */} JSX comment, the runtime tried to parse it as JSON, threw,
+// and the workflow discarded a complete VERDICT: PASS report as "no output".
+// The verdict re-ask covers an unreadable verdict inside a RECEIVED report;
+// this covers the report never arriving. The assignment is retried boundedly
+// with fresh keys (never a cached replay) before failing closed. Re-entry is
+// safe: lifecycle scripts answer REUSED for existing worktrees/branches, the
+// retry trailer tells the agent to check existing state first and report
+// rather than duplicate completed side effects, and the rework path already
+// re-runs Build after rejection — Build re-entry is an established pattern.
+function workRetryKey(stepName, reworkSuffix, attempt) {
+  return "work-" + stepName + reworkSuffix + "-t" + attempt;
+}
+// replay-key scoping for bug 1b8bb875 — runtime keys agent() calls by explicit key per workflow process; on in-process rework a re-executed phase must mint fresh keys; uses the same -r<N> suffix as the phase loop; pure function of inputs, no clock, no randomness (determinism contract). The count is a parameter because chore.js names the counter reworkCount while standard.js/bugfix.js name it totalReworkCount.
+function attemptKey(base, reworkCount) {
+  return base + (reworkCount > 0 ? "-r" + reworkCount : "");
+}
+// pinLifecycle(key) — snapshot the lifecycle scripts into RUN_LIB and return
+// the verbatim `ls -1` listing so WORKFLOW CODE asserts the four pinned
+// basenames; the agent cannot self-certify. (The pin step was the one place
+// the workflows trusted agent prose: task 24be1cd6 walked to Publish on an
+// empty pin dir.) Byte-identical across standard/bugfix/chore — pinned by
+// tests/pin-location.test.js.
+function pinLifecycle(key) {
+  return agent(
+    "Snapshot lifecycle scripts for version pinning.\n" +
+    "Run: mkdir -p " + RUN_LIB + " && cp " + LIFECYCLE_SRC + " " + LIFECYCLE + " && cp " + MERGE_LOCK_SRC + " " + MERGE_LOCK + " && cp " + PUBLISH_NPM_SRC + " " + PUBLISH_NPM + " && cp " + ORPHAN_SWEEP_SRC + " " + ORPHAN_SWEEP + " && chmod +x " + LIFECYCLE + " " + MERGE_LOCK + " " + PUBLISH_NPM + " " + ORPHAN_SWEEP + " && ls -1 " + RUN_LIB + "\n" +
+    "Return the verbatim output of the ls -1 command as { \"listing\": \"<verbatim output>\" } and nothing else.",
+    { key: key, label: "Pinning lifecycle scripts",
+      schema: { type: "object", properties: { listing: { type: "string" } }, required: ["listing"] } }
+  );
+}
+// parsePinListing(result) — basenames from a pin/verify listing.
+// Byte-identical across standard/bugfix/chore — pinned by
+// tests/pin-location.test.js.
+function parsePinListing(result) {
+  return (result && result.listing ? result.listing : "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+}
+function buildTransportRetryTrailer(stepName, repoPath, taskId, attempt, reason) {
+  // reason: "discarded" (the runtime threw the output away — it could not be
+  // machine-read) or "empty" (agent() returned without throwing but produced
+  // nothing usable). The trailer tells the retry what to expect, not just to
+  // try again.
+  var why = reason === "empty"
+    ? "your previous attempt returned no usable output"
+    : "your previous attempt's output could not be machine-read as JSON and was discarded";
+  return "\n\nTRANSPORT RETRY (attempt " + attempt + " of 2): " + why + ". " +
+    "First check existing state (worktree/branch at " + repoPath + "/.worktrees/" + taskId + ", the task branch, dashboard sessions for this task) — " +
+    "if the " + stepName + " work is already complete, report on what was done rather than duplicating side effects. " +
+    "Then return your report as JSON in exactly the shape specified above.";
+}
+function describeWorkAgentFailure(stepName, identity, attempts) {
+  // Honest classification of a work-agent call that yielded no usable
+  // report, with the per-attempt evidence preserved in the session notes.
+  // Two distinct cases:
+  // - agent() THREW: the runtime discarded output it could not machine-read
+  //   (e.g. prose tripping the JSON-candidate heuristic). The raw output is
+  //   gone — the workflow never received it — so the surviving error text is
+  //   recorded here instead. (An earlier comment claimed the raw output was
+  //   "preserved in the run record"; that was false — nothing preserved it —
+  //   and the claim is removed.)
+  // - agent() RETURNED EMPTY without throwing: the child produced nothing
+  //   usable. Each attempt's outcome is the evidence.
+  // attempts: [{threw, error, outcome}, ...], in order.
+  var parts = [];
+  for (var i = 0; i < attempts.length; i++) {
+    var a = attempts[i];
+    parts.push("attempt " + (i + 1) + "/" + attempts.length + ": " +
+      (a.threw ? "threw '" + a.error + "'" : "returned " + a.outcome));
+  }
+  var detail = parts.join("; ").replace(/"/g, "'").slice(0, 400);
+  var anyThrow = false;
+  for (var j = 0; j < attempts.length; j++) {
+    if (attempts[j].threw) { anyThrow = true; break; }
+  }
+  if (anyThrow) {
+    return {
+      notes: "Work agent produced no machine-readable report after " + attempts.length + " attempts; runtime discarded the output (" + detail + ")",
+      eventMessage: stepName + " work agent produced no machine-readable report after " + attempts.length + " attempts — phase failed, dispatcher will retry",
+      blockedReason: stepName + " work agent produced no machine-readable report after " + attempts.length + " attempts",
+      message: "The " + identity + " agent's output could not be machine-read (" + attempts.length + " attempts exhausted); the runtime discarded the raw output before the workflow could see it. Surviving evidence: " + detail
+    };
+  }
+  return {
+    notes: "Work agent returned no usable output after " + attempts.length + " attempts (" + detail + ")",
+    eventMessage: stepName + " work agent returned no usable output after " + attempts.length + " attempts — phase failed, dispatcher will retry",
+    blockedReason: stepName + " work agent returned no usable output",
+    message: "The " + identity + " agent returned no usable output after " + attempts.length + " attempts (" + detail + ")."
+  };
+}
+
+// Release declaration extraction: deterministic. The Build worker declares
+// release:/version_bump: in its report; workflow code reads them directly
+// from the full worker report. A missing or malformed declaration fails
+// closed to null (Review then rejects).
+function extractReleaseDecision(workerText) {
+  var t = workerText || "";
+  var r = /release:\s*(yes|no)\b/i.exec(t);
+  if (!r) return null;
+  var b = /version_bump:\s*(patch|minor|major)\b/i.exec(t);
+  var rel = r[1].toLowerCase();
+  if (rel === "yes" && !b) return null;
+  return { release: rel, version_bump: b ? b[1].toLowerCase() : null };
+}
+// Marker line preservation: machine-readable lines (repo_diff:, release:,
+// version_bump:, VERDICT:, TARGET_VERSION=, published:) are extracted from
+// the full worker report and appended after the summary slice, so a long
+// report can never amputate them. Later phases read these from session notes.
+function extractMarkerLines(workerText) {
+  var lines = (workerText || "").split("\n");
+  var markers = [];
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (/^(repo_diff:|release:|version_bump:|VERDICT:|TARGET_VERSION=|published:|experiential:|capture_targets:)/i.test(line)) {
+      markers.push(line);
+    }
+  }
+  return markers.join("\n");
+}
+
+// Visual verdict shared functions: byte-identical across standard.js,
+// bugfix.js, and chore.js (pinned by tests/visual-verdict.test.js — same
+// contract as buildTransportRetryTrailer).
+function extractExperiential(workerText) {
+  // Reads Sage's experiential: yes|no marker line. Missing or malformed
+  // fails closed to null — the flag is opt-in; null is treated as
+  // non-experiential (never silently parks a task on a garbled line).
+  var t = workerText || "";
+  var r = /experiential:\s*(yes|no)\b/i.exec(t);
+  if (!r) return null;
+  return r[1].toLowerCase() === "yes";
+}
+function buildVisualCapturePlan(taskTitle, taskDescription, kind, captureTargets) {
+  // Deterministic visual-capture frame. kind: "baseline" | "postchange".
+  // This string IS the capture script: fixed viewport matrix, scroll
+  // positions, and interaction states — the inspection agent executes it
+  // verbatim, nothing is improvised. Task-specific targets fill the slots.
+  var title = String(taskTitle || "").replace(/"/g, "'").slice(0, 120);
+  var targets = String(captureTargets || "").trim() ||
+    String(taskDescription || "").replace(/"/g, "'").slice(0, 300);
+  return "VISUAL CAPTURE — " + kind.toUpperCase() + " — task: " + title + ". " +
+    "Target views/controls: " + targets + ". " +
+    "For EACH target, capture exactly: " +
+    "(1) desktop 1440x900, full view, scrolled to top; " +
+    "(2) desktop 1440x900, scrolled so the target is vertically centered; " +
+    "(3) mobile 390x844, scrolled so the target is vertically centered; " +
+    "(4) desktop 1440x900, hover state on the target control; " +
+    "(5) desktop 1440x900, keyboard-focus state on the target control; " +
+    "(6) desktop 1440x900, active/pressed state if the target is a button or control. " +
+    "Also record: console error count, the ARIA tree of the target region, any horizontal overflow. " +
+    "Name captures " + kind + "-<n>-<viewport>-<state>. Return the captures, not a summary.";
+}
+// Experiential flag resolution: the task is experiential when Sage's Triage
+// report ends with the machine-read marker "experiential: yes". The flag is
+// opt-in — a missing or garbled line degrades to "unknown", which callers
+// treat as non-experiential. The task is never parked on a garbled line.
+async function resolveExperiential() {
+  if (isExperiential === true) return "yes";
+  if (isExperiential === false) return "no";
+  var expCheck = null;
+  try {
+    expCheck = await agent(
+      "Find this task's Triage step session notes from the dashboard.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }.\n" +
+      "Find the session with task_id \"" + taskId + "\" and step \"Triage\" (status completed) in the returned sessions array and read its notes field.\n" +
+      "Return JSON { \"experiential_line\": \"<the exact text of the experiential: marker line from the notes, or empty string if absent>\" } and nothing else.",
+      {
+        key: "resolve-experiential-" + taskId,
+        label: "Resolving experiential flag from Triage notes",
+        schema: { type: "object", properties: { experiential_line: { type: "string" } }, required: ["experiential_line"] }
+      }
+    );
+  } catch (e) {
+    log("resolveExperiential: agent call failed (" + (e && e.message ? e.message : e) + ") — treating as unknown");
+    return "unknown";
+  }
+  var marker = extractExperiential(expCheck && expCheck.experiential_line ? expCheck.experiential_line : "");
+  if (marker === true) return "yes";
+  if (marker === false) return "no";
+  return "unknown";
+}
+// Baseline evidence status: reads the task's note events for the exact
+// protocol prefixes (explicit state, never English matching). Returns
+// { baseline_found, baseline_kind, baseline_refs, requested_count }.
+// found = any note starting exactly "baseline: captured" or "baseline:
+// none" (kind/refs come from the LATEST such message); requested_count =
+// the number of notes starting exactly "baseline: requested". Each call
+// uses a fresh key: the evidence changes between calls (the parent logs
+// the capture while this run is parked), so a cached replay would lie.
+let baselineStatusCallCount = 0;
+async function baselineStatus() {
+  baselineStatusCallCount++;
+  try {
+    var ev = await agent(
+      "Read this task's note events from the dashboard.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getevents\", args: { \"task_id\": \"" + taskId + "\" }.\n" +
+      "Consider only events with type \"note\". For each message, check whether it starts exactly with \"baseline: captured\", \"baseline: none\", or \"baseline: requested\" (exact prefix, case-sensitive).\n" +
+      "Return JSON { \"baseline_found\": <true if any message starts exactly with \"baseline: captured\" or \"baseline: none\">, \"baseline_kind\": \"<\"captured\" or \"none\", from the LATEST such message, or empty string if none>\", \"baseline_refs\": \"<the text after the prefix in that latest message, or empty string>\", \"requested_count\": <count of messages starting exactly with \"baseline: requested\"> } and nothing else.",
+      {
+        key: "baseline-status-" + taskId + "-" + baselineStatusCallCount,
+        label: "Reading baseline evidence status",
+        schema: {
+          type: "object",
+          properties: {
+            baseline_found: { type: "boolean" },
+            baseline_kind: { type: "string" },
+            baseline_refs: { type: "string" },
+            requested_count: { type: "number" }
+          },
+          required: ["baseline_found", "baseline_kind", "baseline_refs", "requested_count"]
+        }
+      }
+    );
+    return {
+      baseline_found: !!(ev && ev.baseline_found),
+      baseline_kind: (ev && ev.baseline_kind) || "",
+      baseline_refs: (ev && ev.baseline_refs) || "",
+      requested_count: (ev && ev.requested_count) || 0
+    };
+  } catch (e) {
+    log("baselineStatus: agent call failed (" + (e && e.message ? e.message : e) + ") — treating as no evidence");
+    return { baseline_found: false, baseline_kind: "", baseline_refs: "", requested_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 dashboard.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"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 call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getevents\", args: { \"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" },
+  { name: "Capture", identity: "hazel" },
   { name: "Reproduce", identity: "hazel" },
   { name: "Map", identity: "mara" },
   { name: "Build", identity: "wren" },
@@ -73,6 +434,8 @@ const STEPS = [
 ];
 const BUILD_INDEX = STEPS.findIndex(s => s.name === 'Build');
 if (BUILD_INDEX < 0) throw new Error("STEPS missing 'Build' step");
+const CAPTURE_INDEX = STEPS.findIndex(s => s.name === 'Capture');
+if (CAPTURE_INDEX < 0) throw new Error("STEPS missing 'Capture' step");
 const REWORK_STEP = STEPS[BUILD_INDEX].name;
 // Shared rework budget: Review and QA rejections draw from the SAME pool of 2.
 // E.g. 2 Review bounces + 1 QA bounce = 3 total > budget -> task blocks.
@@ -80,8 +443,15 @@ const MAX_TOTAL_REWORK = 2;
 let totalReworkCount = 0;
 let rejectionNotes = inputs.rejection_notes || "";
 let mapperSpec = "";
+// Visual verdict state: Sage's experiential flag (true/false/null until the
+// Triage report is read), Mara's capture targets for the post-change capture
+// plan, and the Map-gate bounce counter (keeps agent stable-keys unique when
+// a Map-gate bounce re-runs Capture/Map in the same run).
+let isExperiential = null;
+let captureTargets = "";
+let mapGateBounceCount = 0;
 // Merge-time versioning: the release decision is extracted deterministically
-// from the accepted Build summary (extractReleaseDecision) so the Publish
+// from the accepted Build worker report (extractReleaseDecision) so the Publish
 // agent never decides whether to publish. Two consecutive Publish runs
 // rationalized a skip against explicit instruction text — text alone did not
 // hold, so the decision now lives in workflow code, not agent judgment.
@@ -95,26 +465,50 @@ function bumpVersion(base, scope) {
   if (scope === "minor") return p[0] + "." + (p[1] + 1) + ".0";
   return p[0] + "." + p[1] + "." + (p[2] + 1); // patch (default)
 }
-function extractReleaseDecision(text) {
-  const t = text || "";
-  const r = /^release:\s*(yes|no)\s*$/im.exec(t);
-  if (!r) return null;
-  const b = /^version_bump:\s*(patch|minor|major)\s*$/im.exec(t);
-  if (r[1].toLowerCase() === "yes" && !b) return null;
-  return { release: r[1].toLowerCase(), version_bump: b ? b[1].toLowerCase() : null };
-}
 function releaseDecisionText() {
-  if (!releaseDecision) return "no parseable release:/version_bump: decision";
+  if (!releaseDecision) return "no machine-readable release decision from the Build report";
   return "release: " + releaseDecision.release + (releaseDecision.version_bump ? ", version_bump: " + releaseDecision.version_bump : " (no version_bump line)");
 }
+// Park the task for human attention and end the run. "blocked" is never
+// manually authored — the dashboard derives it mechanically from unmet
+// dependencies — so a workflow outcome that needs a human parks the task
+// instead. Parking is one atomic dashboard action (parktask): the parked
+// state and the explanatory note land in one transaction, never half.
+// The dispatcher skips parked tasks; a human moving parked→todo
+// mechanically resets the retry counters. Returns the workflow result
+// envelope the launcher sees. If the park call itself fails, the run
+// reports "failed" (retryable) so the next tick re-attempts the park —
+// a lost park is never reported as parked.
+async function parkTask(reason) {
+  log("Parking task " + taskId + " for human attention: " + reason);
+  var parkMessage = ("Parked: " + reason).slice(0, 1000);
+  try {
+    await agent(
+      "Park this task for human attention.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"parktask\", args: " +
+      JSON.stringify({ task_id: taskId, message: parkMessage }) + ".\n" +
+      "The parked state is the human-attention signal — the dispatcher skips parked tasks.",
+      { key: "park-task", label: "Parking task for human attention", schema: { type: "object" } }
+    );
+  } catch (parkErr) {
+    log("PARK FAILED for task " + taskId + ": " + (parkErr && parkErr.message ? parkErr.message : parkErr) + " — park did not land, reporting failed so the next tick retries");
+    return { status: "failed", task_id: taskId, reason: "park failed: " + reason, park_failed: true };
+  }
+  return { status: "parked", task_id: taskId, reason: reason };
+}
 let i = startStepIndex;
 
-// Pin lifecycle scripts
-await agent(
-  "Snapshot lifecycle scripts for version pinning.\n" +
-  "Run: mkdir -p " + RUN_LIB + " && cp " + LIFECYCLE_SRC + " " + LIFECYCLE + " && cp " + MERGE_LOCK_SRC + " " + MERGE_LOCK + " && cp " + PUBLISH_NPM_SRC + " " + PUBLISH_NPM + " && cp " + ORPHAN_SWEEP_SRC + " " + ORPHAN_SWEEP + " && chmod +x " + LIFECYCLE + " " + MERGE_LOCK + " " + PUBLISH_NPM + " " + ORPHAN_SWEEP,
-  { key: "pin-lifecycle", label: "Pinning lifecycle scripts", schema: { type: "object" } }
-);
+// ── Pin lifecycle scripts ────────────────────────────────────────────
+// Copy lifecycle scripts into a per-task temp dir so this run is immune
+// to upgrades that land while it's in flight. Verified mechanically:
+// workflow code asserts the four basenames from the verbatim listing —
+// the agent cannot self-certify. Any miss parks the task before Triage.
+const initialPins = parsePinListing(await pinLifecycle("pin-lifecycle"));
+const missingInitialPins = PIN_BASENAMES.filter(function (b) { return initialPins.indexOf(b) === -1; });
+if (missingInitialPins.length > 0) {
+  return await parkTask("Lifecycle pin incomplete before Triage — missing " + missingInitialPins.join(", ") + " in " + RUN_LIB + ".");
+}
+log("Lifecycle scripts pinned to " + RUN_LIB);
 
 while (i < STEPS.length) {
   const step = STEPS[i];
@@ -145,15 +539,14 @@ while (i < STEPS.length) {
     if (currentProject !== LAUNCH_PROJECT_ID) {
       const abortMessage = "Task project changed mid-run from '" + LAUNCH_PROJECT_ID + "' to '" + currentProject + "' — aborting stale run. The dispatcher will re-launch from " + REWORK_STEP + " with the new project context.";
       log(abortMessage);
-      const abortSessionPatch = (isFirstClaim && firstSessionId) ? "\"id\": \"" + firstSessionId + "\", " : "";
       await agent(
         "Abort the stale run and remove its worktree from the old project's repo.\n" +
         "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
-        "{ \"task_id\": \"" + taskId + "\", " + abortSessionPatch + "\"identity\": \"" + step.identity + "\", \"step\": \"" + REWORK_STEP + "\", \"status\": \"failed\", " +
+        "{ \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + REWORK_STEP + "\", \"status\": \"failed\", " +
         "\"notes\": " + JSON.stringify(abortMessage + " Rebuild from the Map session notes in the task's event history.") + " }.\n" +
         "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
         "{ \"task_id\": \"" + taskId + "\", \"type\": \"failed\", \"identity\": \"" + step.identity + "\", \"message\": " + JSON.stringify(abortMessage) + " }.\n" +
-        "Then run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " cleanup " + taskId + "\n" +
+        "Then run: "+ LIFECYCLE_ENV + " cleanup " + taskId + "\n" +
         "The cleanup output should contain CLEANUP.",
         { key: "abort-project-change", label: "Aborting stale run (project changed)", schema: { type: "object" } }
       );
@@ -161,22 +554,49 @@ while (i < STEPS.length) {
     }
   }
 
+  // ── Pre-Publish pin guard ──────────────────────────────────────────
+  // Verify the pinned lifecycle scripts still exist on every Publish
+  // pass (first pass and rework passes): the pin step trusted agent
+  // prose instead of a mechanical check, so task 24be1cd6 walked to
+  // Publish on an empty pin dir. One re-pin and re-verify on a miss;
+  // still missing parks the task. Keys are attemptKey-scoped so a
+  // rework Publish never re-mints a first-pass key.
+  if (step.name === "Publish") {
+    let publishPins = parsePinListing(await agent(
+      "Verify the pinned lifecycle scripts are present.\n" +
+      "Run: ls -1 " + RUN_LIB + " 2>/dev/null || echo PIN_DIR_MISSING\n" +
+      "Return the verbatim output as { \"listing\": \"<verbatim output>\" } and nothing else.",
+      { key: attemptKey("pins-verify-publish", totalReworkCount), label: "Verifying pinned lifecycle scripts",
+        schema: { type: "object", properties: { listing: { type: "string" } }, required: ["listing"] } }
+    ));
+    let missingAtPublish = PIN_BASENAMES.filter(function (b) { return publishPins.indexOf(b) === -1; });
+    if (missingAtPublish.length > 0) {
+      log("Pin guard at Publish: missing " + missingAtPublish.join(", ") + " — re-pinning once");
+      publishPins = parsePinListing(await pinLifecycle(attemptKey("pin-lifecycle-republish", totalReworkCount)));
+      missingAtPublish = PIN_BASENAMES.filter(function (b) { return publishPins.indexOf(b) === -1; });
+    }
+    if (missingAtPublish.length > 0) {
+      return await parkTask("Pinned lifecycle scripts missing at Publish even after re-pin: " + missingAtPublish.join(", ") + " in " + RUN_LIB + ".");
+    }
+    log("Pin guard: all four lifecycle scripts present at Publish");
+  }
+
   // Publish is optional and target-based. Empty target = prototyping project: skip the phase.
   // Unknown target (incl. legacy "repo") = config error: block.
   if (step.name === "Publish" && !PUBLISH_TYPE) {
     log("Publish skipped for task " + taskId + " — no publish target configured (deploy_type empty)");
     await agent(
       "Release the merge lock and clean up without publishing.\n" +
-      "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
+      "Run: "+ LIFECYCLE_ENV + " post-deploy " + taskId + "\n" +
       "If the output contains DEPLOYED, the lock is released and the worktree is cleaned up.",
-      { key: "publish-skip-cleanup", label: "Skipping Publish (no target)", schema: { type: "object" } }
+      { key: attemptKey("publish-skip-cleanup", totalReworkCount), label: "Skipping Publish (no target)", schema: { type: "object" } }
     );
     i++;
     continue;
   }
   if (step.name === "Publish" && PUBLISH_TYPE !== "npm" && PUBLISH_TYPE !== "artifact" && PUBLISH_TYPE !== "vercel") {
     log("Unknown publish target for task " + taskId + ": " + PUBLISH_TYPE);
-    return { status: "blocked", task_id: taskId, reason: "Unknown publish target '" + PUBLISH_TYPE + "' — expected 'npm', 'artifact', 'vercel', or empty (skip publish)." };
+    return await parkTask("Unknown publish target '" + PUBLISH_TYPE + "' — expected 'npm', 'artifact', 'vercel', or empty (skip publish).");
   }
 
   // Merge-time versioning, decided deterministically: the release decision was
@@ -186,15 +606,15 @@ while (i < STEPS.length) {
   // therefore has no decision point to rationalize into a skip.
   if (step.name === "Publish" && PUBLISH_TYPE === "npm") {
     if (!releaseDecision) {
-      return { status: "blocked", task_id: taskId, reason: "Build summary has no parseable release:/version_bump: lines — cannot assign version at publish time." };
+      return await parkTask("Build report has no machine-readable release:/version_bump: declaration — cannot assign version at publish time.");
     }
     if (releaseDecision.release === "no") {
-      log("Publish skipped for task " + taskId + " — accepted Build summary declared release: no");
+      log("Publish skipped for task " + taskId + " — accepted Build report declared release: no");
       await agent(
         "Release the merge lock and clean up without publishing.\n" +
-        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
+        "Run: "+ LIFECYCLE_ENV + " post-deploy " + taskId + "\n" +
         "If the output contains DEPLOYED, the lock is released and the worktree is cleaned up.",
-        { key: "publish-skip-release-no", label: "Skipping Publish (release: no)", schema: { type: "object" } }
+        { key: attemptKey("publish-skip-release-no", totalReworkCount), label: "Skipping Publish (release: no)", schema: { type: "object" } }
       );
       i++;
       continue;
@@ -210,27 +630,50 @@ while (i < STEPS.length) {
         "Run: npm view muse-crew version 2>/dev/null || echo NOT_FOUND\n" +
         "If the output is NOT_FOUND, run: node -p \"require('" + REPO_PATH + "/package.json').version\"\n" +
         "Return JSON { \"base\": \"<the version string, trimmed>\" } and nothing else.",
-        { key: "publish-base-" + taskId, label: "Reading registry base version",
+        { key: attemptKey("publish-base-" + taskId, totalReworkCount), label: "Reading registry base version",
           schema: { type: "object", properties: { base: { type: "string" } }, required: ["base"] } }
       );
       var pubScope = releaseDecision.version_bump || "patch";
       var pubBase = (baseResult.base || "").trim();
       if (!/^\d+\.\d+\.\d+$/.test(pubBase)) {
-        return { status: "blocked", task_id: taskId,
-          reason: "Publish base version unreadable: '" + pubBase + "'. Fail-closed." };
+        return await parkTask("Publish base version unreadable: '" + pubBase + "'. Fail-closed.");
       }
       publishTarget = { base: pubBase, scope: pubScope, target: bumpVersion(pubBase, pubScope) };
       log("Publish target for task " + taskId + ": " + pubBase + " + " + pubScope + " -> " + publishTarget.target);
     } catch (e) {
-      return { status: "blocked", task_id: taskId,
-        reason: "Deterministic pre-publish failed: " + (e && e.message ? e.message : e) + ". Fail-closed." };
+      return await parkTask("Deterministic pre-publish failed: " + (e && e.message ? e.message : e) + ". Fail-closed.");
     }
   }
 
-  // Claim session
+  // Self-claim — the dispatcher only recommends; the launched workflow claims
+  // the task as its first action, so a claim can never exist without a launched
+  // agent behind it. If another run claimed the task first (two poll ticks
+  // raced in the window before this run's claim), claimtask returns
+  // claimed:false and this run stands down as a duplicate.
   let activeSessionId;
-  if (isFirstClaim && firstSessionId) {
-    activeSessionId = firstSessionId;
+  if (isFirstClaim) {
+    const claimResult = await agent(
+      "Claim this task for the " + step.name + " step.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updatetask\", args: { \"id\": \"" + taskId + "\", \"state\": \"in_progress\" }.\n" +
+      "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"claimtask\", args:\n" +
+      "{ \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"notes\": \"" + step.name + " step started\" }.\n" +
+      "Do not interpret the claim response. It already contains an explicit \"claimed\" field — copy it verbatim.\n" +
+      "Return { claimed: <verbatim>, session_id: \"<...>\" }. If claimed is false there is no session_id; return { claimed: false, session_id: \"\" }.",
+      {
+        key: "claim-" + step.name + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
+        label: "Claiming " + step.name,
+        schema: {
+          type: "object",
+          properties: { claimed: { type: "boolean" }, session_id: { type: "string" } },
+          required: ["claimed", "session_id"]
+        }
+      }
+    );
+    if (!claimResult.claimed) {
+      log("Standing down — task " + taskId + " was already claimed by another run");
+      return { status: "duplicate", task_id: taskId, reason: "task already claimed by another run" };
+    }
+    activeSessionId = claimResult.session_id;
   } else {
     const claimResult = await agent(
       "Claim a session for this task step.\n" +
@@ -238,7 +681,7 @@ while (i < STEPS.length) {
       "{ \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"notes\": \"" + step.name + " step started" + (totalReworkCount > 0 ? " (rework #" + totalReworkCount + ")" : "") + "\" }.\n" +
       "Return the session_id from the response.",
       {
-        key: "claim-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""),
+        key: "claim-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
         label: "Claiming " + step.name,
         schema: {
           type: "object",
@@ -250,11 +693,115 @@ while (i < STEPS.length) {
     activeSessionId = claimResult.session_id;
   }
 
+  // ── Capture: baseline evidence for experiential tasks ─────────────
+  // Hazel's QA capture pass runs right after Triage, before Map, for tasks
+  // Sage flagged experiential. The capture itself is parent-driven (the
+  // inspection handoff arrives at the root agent, outside this script), so
+  // when no baseline evidence is recorded yet the script logs a note event
+  // and parks with the exact parent protocol + resume path. Never fails the
+  // task over missing evidence: after two requests, baseline:none is
+  // recorded and final QA judges on the rubric alone.
+  if (step.name === "Capture") {
+    var capExp = await resolveExperiential();
+    var bounceSuffix = (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : "");
+    if (capExp !== "yes" || PUBLISH_TYPE !== "artifact") {
+      log("Capture skipped for task " + taskId + " — " + (capExp !== "yes" ? "not experiential" : "publish target is not artifact"));
+      await agent(
+        "Update the session and log the event.\n" +
+        "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+        "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"completed\", \"notes\": \"Capture skipped — not an experiential artifact task\" }.\n" +
+        "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+        "{ \"task_id\": \"" + taskId + "\", \"type\": \"completed\", \"identity\": \"" + step.identity + "\", \"message\": \"Capture completed by " + step.identity + "\" }.",
+        { key: "record-Capture" + bounceSuffix, label: "Recording Capture result", schema: { type: "object" } }
+      );
+      i++;
+      continue;
+    }
+    var capStatus = await baselineStatus();
+    if (capStatus.baseline_found) {
+      log("Capture: baseline evidence already recorded for task " + taskId + " (" + capStatus.baseline_kind + ")");
+      await agent(
+        "Update the session and log the event.\n" +
+        "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+        "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"completed\", \"notes\": " + JSON.stringify("Baseline evidence already recorded: " + capStatus.baseline_kind + " " + capStatus.baseline_refs) + " }.\n" +
+        "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+        "{ \"task_id\": \"" + taskId + "\", \"type\": \"completed\", \"identity\": \"" + step.identity + "\", \"message\": \"Capture completed by " + step.identity + "\" }.",
+        { key: "record-Capture" + bounceSuffix, label: "Recording Capture result", schema: { type: "object" } }
+      );
+      i++;
+      continue;
+    }
+    var attemptN = capStatus.requested_count + 1;
+    if (capStatus.requested_count >= 2) {
+      log("Capture: baseline capture unavailable after 2 requests for task " + taskId + " — recording baseline:none");
+      await agent(
+        "Record that no baseline was capturable.\n" +
+        "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+        "{ \"task_id\": \"" + taskId + "\", \"type\": \"note\", \"identity\": \"" + step.identity + "\", \"message\": \"baseline: none (capture unavailable after 2 attempts)\" }.\n" +
+        "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+        "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"completed\", \"notes\": \"baseline: none — final QA judges on rubric alone\" }.\n" +
+        "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+        "{ \"task_id\": \"" + taskId + "\", \"type\": \"completed\", \"identity\": \"" + step.identity + "\", \"message\": \"Capture completed by " + step.identity + "\" }.",
+        { key: "record-Capture-none" + bounceSuffix, label: "Recording baseline: none", schema: { type: "object" } }
+      );
+      i++;
+      continue;
+    }
+    log("Capture: requesting baseline capture (attempt " + attemptN + ") for task " + taskId);
+    await agent(
+      "Request the baseline capture and record the request.\n" +
+      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+      "{ \"task_id\": \"" + taskId + "\", \"type\": \"note\", \"identity\": \"" + step.identity + "\", \"message\": \"baseline: requested (attempt " + attemptN + ")\" }.\n" +
+      "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+      "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"failed\", \"notes\": " + JSON.stringify("Baseline capture requested (attempt " + attemptN + ") — parent protocol: run the baseline capture protocol in docs/visual-verdict.md, then re-queue the task at Map. The Capture step re-checks baseline evidence when re-run.") + " }.",
+      { key: "record-Capture-request" + bounceSuffix, label: "Recording baseline capture request", schema: { type: "object" } }
+    );
+    return await parkTask("Baseline capture requested (attempt " + attemptN + ") — parent: run the baseline capture protocol in docs/visual-verdict.md, then re-queue the task at Map");
+  }
+
+  // ── Map gate: experiential tasks need baseline evidence ────────────
+  // Mara must verify baseline evidence exists before writing the spec. If
+  // missing, bounce back to Capture — never to Build, never a task failure.
+  var mapBaselineRefs = "";
+  var mapBaselineNone = false;
+  if (step.name === "Map") {
+    if ((await resolveExperiential()) === "yes") {
+      var gateStatus = await baselineStatus();
+      if (!gateStatus.baseline_found) {
+        log("Map gate: no baseline evidence for experiential task " + taskId + " — bouncing to Capture");
+        await agent(
+          "Record the Map gate bounce.\n" +
+          "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+          "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"failed\", \"notes\": \"Map gate bounce: no baseline evidence recorded for this experiential task — no spec was written. Baseline evidence must be captured before the spec.\" }.\n" +
+          "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+          "{ \"task_id\": \"" + taskId + "\", \"type\": \"failed\", \"identity\": \"" + step.identity + "\", \"message\": \"Map gate bounce — baseline evidence missing, returning to Capture\" }.",
+          { key: "record-Map-bounce" + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""), label: "Recording Map gate bounce", schema: { type: "object" } }
+        );
+        mapGateBounceCount++;
+        i = CAPTURE_INDEX;
+        continue;
+      }
+      mapBaselineRefs = gateStatus.baseline_refs;
+      mapBaselineNone = (gateStatus.baseline_kind === "none");
+    }
+  }
+
+  // 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.
+  var qaVisual = false;
+  if (step.name === "QA") {
+    qaVisual = (await resolveExperiential()) === "yes" && PUBLISH_TYPE === "artifact";
+  }
+
   var safeTitle = taskTitle.replace(/"/g, "'").replace(/\\/g, "\\\\").replace(/`/g, "'");
   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.\nYour final response MUST be valid JSON and nothing else: { \"summary\": \"your assessment\", \"passed\": true }. No prose, no markdown, just the JSON object.";
+    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.";
 
   } else if (step.name === "Reproduce") {
     instructions = "Reproduce the bug from a user's perspective. You are CODE-BLIND — do NOT read source code.\n" +
@@ -263,82 +810,88 @@ while (i < STEPS.length) {
       "You can also check specific sessions with the getevents action for evidence.\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" +
-      "If reproduction succeeds, your final response MUST be valid JSON and nothing else: { \"passed\": true, \"summary\": \"reproduction evidence and steps\" }.\n" +
-      "If reproduction fails, your final response MUST be valid JSON and nothing else: { \"passed\": false, \"summary\": \"what you tried and why reproduction failed\" }.\n" +
-      "No prose, no markdown, just the JSON object.";
+      "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.";
 
   } else if (step.name === "Map") {
-    instructions = "Update the task with a solution-oriented spec. Research options, pick the shortest path.\nThe builder will edit source files in a git worktree.\nProject: " + PROJECT_DESC + "\nWrite it clearly enough that the builder does not need to ask questions.\nYour final response MUST be valid JSON and nothing else: { \"summary\": \"what you specified\", \"passed\": true }. No prose, no markdown, just the JSON object.";
+    var mapGatePara = "";
+    if (mapBaselineRefs || mapBaselineNone) {
+      mapGatePara = "\nBASELINE GATE (experiential task): " +
+        (mapBaselineNone
+          ? "no baseline was capturable (baseline: none recorded) — write the spec without baseline comparison and note it."
+          : "pre-change baseline captures: " + mapBaselineRefs + " — consult the affected views when writing the spec.") +
+        " If the baseline evidence is missing with no baseline:none recorded, do not write the spec — report 'baseline evidence missing — Map gate bounce required' and stop.\n" +
+        "Declare capture targets for the post-change visual capture: end your report with a line `capture_targets: <comma-separated views/controls this change affects>` (optional; falls back to the task description).";
+    }
+    instructions = "Update the task with a solution-oriented spec. Research options, pick the shortest path.\nThe builder will edit source files in a git worktree.\nProject: " + PROJECT_DESC + "\nWrite it clearly enough that the builder does not need to ask questions.\nReport back in plain prose — what you specified." + mapGatePara;
 
   } else if (step.name === "Build") {
     instructions = "STEP 1: Prepare your worktree.\n" +
-      "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " prepare " + taskId + "\n" +
-      "If the output says CREATED or REUSED, proceed. If it says ERROR, stop and set passed to false.\n\n" +
+      "Run: "+ LIFECYCLE_ENV + " prepare " + taskId + "\n" +
+      "If the output says CREATED or REUSED, proceed. If it says ERROR, stop and report the failure clearly.\n\n" +
       "STEP 2: Edit source files to implement the mapper's spec below.\n" +
       (mapperSpec ? "MAPPER'S SPEC (implement exactly this):\n" + mapperSpec + "\n\n" : "") +
-      "Your working directory: " + REPO_PATH + "/.worktrees/" + taskId + "/\n" +
+      "Your working directory: " + WORKTREE_HINT + "/\n" +
       "This is the project source: " + PROJECT_DESC + "\n" +
       "Edit the TypeScript source files directly. Do NOT use artifact_edit — that happens in the Publish phase.\n" +
       "Do not add unrequested features. Build exactly what the spec calls for.\n" +
       "PUBLIC DOCS: If your change is public-affecting (it alters anything a user or consumer can observe: API actions, parameters, behavior, or errors), update the public docs in the same commit — API.md for API changes. Documentation and implementation ship together.\n\n" +
-      (PUBLISH_TYPE === "npm" ? "PACKAGE VERSION: this project publishes to the npm registry. Versions are assigned at PUBLISH time — never in your branch. Do NOT touch the `version` field in package.json (or package-lock). Instead, end your summary with exactly these two lines:\n" +
+      (PUBLISH_TYPE === "npm" ? "PACKAGE VERSION: this project publishes to the npm registry. Versions are assigned at PUBLISH time — never in your branch. Do NOT touch the `version` field in package.json (or package-lock). Instead, end your report with exactly these two lines:\n" +
       "release: yes|no — 'yes' if this change warrants a published release (anything a consumer can observe: workflow behavior, phase lists, identities, published docs, API); 'no' if internal-only.\n" +
       "version_bump: patch|minor|major — patch for fixes (default), minor for new behavior, major for breaking changes. Omit this line only when release is no.\n" +
       "Example: release: yes\\nversion_bump: minor\n\n" : "") +
       "STEP 3: Commit your changes.\n" +
-      "cd " + REPO_PATH + "/.worktrees/" + taskId + "\n" +
+      "cd " + WORKTREE_HINT + "\n" +
       "git add -A\n" +
       "git commit -m \"fix: " + safeTitle + "\"\n\n" +
-      "If the task's deliverable is runtime state (a cron definition, scheduler change, or dashboard/config state created outside the repo) and the repository genuinely needs no change, do NOT fabricate a commit: leave the branch with no commits ahead of main and declare `repo_diff: none` in your summary, naming the runtime-state deliverable. Otherwise commit your changes normally.\n\n" +
+      "If the task's deliverable is runtime state (a cron definition, scheduler change, or dashboard/config state created outside the repo) and the repository genuinely needs no change, do NOT fabricate a commit: leave the branch with no commits ahead of main and declare `repo_diff: none` in your report, naming the runtime-state deliverable. Otherwise commit your changes normally.\n\n" +
       (rejectionNotes ? "This is REWORK after rejection. Address these specific issues:\n" + rejectionNotes + "\n\n" : "") +
-      "Your final response MUST be valid JSON and nothing else: { \"summary\": \"what you built\", \"passed\": true }. No prose, no markdown, just the JSON object.";
+      "Report back in plain prose: what you built and the outcome." +
+      (PUBLISH_TYPE === "npm" ? " End your report with the release: and version_bump: lines exactly as specified above — keep them on their own lines, lowercase, unrephrased — then a final line with exactly: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not." : " End your report with exactly one line: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not.");
 
   } else if (step.name === "Review") {
     instructions = "Review independently and cold. You have NOT seen any reasoning from the builder.\nDo NOT access the task dashboard, event log, or any comments. Your review is based solely on the spec and the code.\n\n" +
       (mapperSpec ? "MAPPER'S SPEC (the builder was asked to implement exactly this):\n" + mapperSpec + "\n\n" : "Read the spec (from the task description or spec files under " + crewHome + "/).\n\n") +
       "Examine the code changes by running:\n" +
-      "CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " inspect " + taskId + "\n\n" +
+      LIFECYCLE_ENV + LIFECYCLE + " inspect " + taskId + "\n\n" +
       "The inspect output is authoritative: it prints the task branch's actual tip commit (TIP) and every commit ahead of main. Base your review ONLY on this output — do NOT run git log yourself to pick commits, and do NOT discuss commit hashes from any other source (they may come from stale rework rounds or a different repo).\n\n" +
       "You can also read specific files in the worktree at:\n" +
-      REPO_PATH + "/.worktrees/" + taskId + "/\n\n" +
+      WORKTREE_HINT + "/\n\n" +
       "Check quality, correctness, and spec compliance.\n" +
-      "Check that public-affecting changes have matching public doc updates (API.md or the published API contract). If the docs are missing or inaccurate, reject with notes on what is stale.\n" +
-      "If the branch has no commits ahead of main (inspect shows an empty commit log), approve ONLY if the Build summary declares `repo_diff: none` with a plausible runtime-state deliverable (e.g. a cron created via the cron tool). Otherwise reject: 'no commits ahead of main and no repo_diff: none declaration — the builder likely forgot to commit'.\n" +
+      "Check that public-affecting changes have matching public doc updates (API.md or the published API contract). If the docs are missing or inaccurate, report what is stale, then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "If the branch has no commits ahead of main (inspect shows an empty commit log), approve ONLY if the Build summary declares `repo_diff: none` with a plausible runtime-state deliverable (e.g. a cron created via the cron tool). Otherwise report 'no commits ahead of main and no repo_diff: none declaration — the builder likely forgot to commit', then end your report with exactly this line: VERDICT: FAIL.\n" +
       (PUBLISH_TYPE === "npm" ? "PACKAGE VERSION: this project publishes to the npm registry, and versions are assigned at publish time — never in branches. Two checks:\n" +
-      "(a) The task branch must NOT have changed package.json's `version` field. Check: cd " + REPO_PATH + " && git diff main...task/" + taskId + " -- package.json. If the branch touched `version` in any way, REJECT with notes: 'versions are assigned at publish time, never in branches — remove the version change'.\n" +
-      "(b) The accepted Build summary declares: " + releaseDecisionText() + ". " +
+      "(a) The task branch must NOT have changed package.json's `version` field. Check: cd " + REPO_PATH + " && git diff main..." + TASK_BRANCH + " -- package.json. If the branch touched `version` in any way, report 'versions are assigned at publish time, never in branches — remove the version change' in your notes, then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "(b) The accepted Build report declares: " + releaseDecisionText() + ". " +
       (releaseDecision
-        ? "Validate this decision against the change: release must be 'yes' when the change is consumer-observable and 'no' when internal-only; the version_bump scope must fit the change (patch for fixes, minor for new behavior, major for breaking changes). If the decision is wrong or mis-scoped, reject with notes."
-        : "The decision is missing or malformed — REJECT with notes: 'Build summary must end with release: yes|no and (when release is yes) version_bump: patch|minor|major lines'.") + "\n" : "") +
-      "If the work passes review, your final response MUST be valid JSON and nothing else: { \"passed\": true, \"summary\": \"approval notes\" }.\n" +
-      "If the work fails review, your final response MUST be valid JSON and nothing else: { \"passed\": false, \"summary\": \"rejection notes explaining what needs to change\" }.\n" +
-      "No prose, no markdown, just the JSON object.";
+        ? "Validate this decision against the change: release must be 'yes' when the change is consumer-observable and 'no' when internal-only; the version_bump scope must fit the change (patch for fixes, minor for new behavior, major for breaking changes). If the decision is wrong or mis-scoped, report your notes, then end with exactly this line: VERDICT: FAIL."
+        : "The decision is missing or malformed — report 'Build report must end with release: yes|no and (when release is yes) version_bump: patch|minor|major lines', then end with exactly this line: VERDICT: FAIL.") + "\n" : "") +
+      "Write your review as plain prose — findings, then decision. End your report with exactly one line: VERDICT: PASS if the work passes, VERDICT: FAIL if it fails.";
 
   } else if (step.name === "Integrate") {
     instructions = "Merge the approved task branch into main.\n\n" +
-      "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " integrate " + taskId + " \"merge: fix: " + safeTitle + "\"\n\n" +
+      "Run: "+ LIFECYCLE_ENV + " integrate " + taskId + " \"merge: fix: " + safeTitle + "\"\n\n" +
       "Read the output:\n" +
       "- If it contains MERGED, integration succeeded. Report the merged commit hash.\n" +
-      "- If it contains MERGED_EMPTY, the branch had no commits ahead of main (a runtime-state deliverable, declared by Build as repo_diff: none). Integration succeeded vacuously: the merge lock was NOT taken and there is no new commit. Set passed to true with summary 'merged empty: no repo changes — deliverable was runtime state'. SKIP STEP 2 (push): there is no new commit to push.\n" +
-      "- If it contains LOCK_HELD, another task holds the merge lock (mid Integrate/Publish). Set passed to false.\n" +
+      "- If it contains MERGED_EMPTY, the branch had no commits ahead of main (a runtime-state deliverable, declared by Build as repo_diff: none). Integration succeeded vacuously: the merge lock was NOT taken and there is no new commit. Report 'merged empty: no repo changes — deliverable was runtime state', then end your report with exactly this line: VERDICT: PASS. SKIP STEP 2 (push): there is no new commit to push.\n" +
+      "- If it contains LOCK_HELD, another task holds the merge lock (mid Integrate/Publish). Report 'merge lock held', then end your report with exactly this line: VERDICT: FAIL.\n" +
       "- If it contains CONFLICT, the plain merge failed — the merge was aborted, main is clean, and your task still holds the merge lock. Do NOT fail yet. Resolve it:\n" +
       "RESOLUTION:\n" +
-      "R1. Refresh the merge lock FIRST (a long resolution must not silently lose the lock to the orphan sweep): CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " refresh-lock " + taskId + ". Create a scratch worktree WITH A NEW BRANCH (main is already checked out in the repo checkout, so git forbids checking it out a second time): cd " + REPO_PATH + " && git worktree add -b resolve/" + taskId + " /tmp/crew-resolve-" + taskId + " main. Reproduce the conflict in the scratch worktree: cd /tmp/crew-resolve-" + taskId + " && git merge task/" + taskId + ". This reproduces the exact conflict (main has not moved — the lock was held throughout). The task branch task/" + taskId + " is never modified.\n" +
+      "R1. Refresh the merge lock FIRST (a long resolution must not silently lose the lock to the orphan sweep): "+ LIFECYCLE_ENV + " refresh-lock " + taskId + ". Create a scratch worktree WITH A NEW BRANCH (main is already checked out in the repo checkout, so git forbids checking it out a second time): cd " + REPO_PATH + " && git worktree add -b resolve/" + taskId + " /tmp/crew-resolve-" + taskId + " main. Reproduce the conflict in the scratch worktree: cd /tmp/crew-resolve-" + taskId + " && git merge " + TASK_BRANCH + ". This reproduces the exact conflict (main has not moved — the lock was held throughout). The task branch " + TASK_BRANCH + " is never modified.\n" +
       "R2. For each conflicted file, read the three sides: git show :1:<file> (base), git show :2:<file> (ours = main), git show :3:<file> (theirs = task branch). Resolve each hunk by keeping both sides' changes when they do not semantically overlap. Version-only hunks resolve to the higher semver (safety net). Never invent new behavior. Leave no markers.\n" +
-      "R3. Verify in the scratch worktree, in this order: (a) git diff --check is clean; (b) git grep -n '^<<<<<<<' -- . returns nothing; (c) node --check every changed .js file (conflicted files plus everything listed by git diff --name-only). If any check fails, refresh the merge lock (CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " refresh-lock " + taskId + "), then retry the resolution using the failure output as context — max 3 attempts total.\n" +
+      "R3. Verify in the scratch worktree, in this order: (a) git diff --check is clean; (b) git grep -n '^<<<<<<<' -- . returns nothing; (c) node --check every changed .js file (conflicted files plus everything listed by git diff --name-only). If any check fails, refresh the merge lock ("+ LIFECYCLE_ENV + " refresh-lock " + taskId + "), then retry the resolution using the failure output as context — max 3 attempts total.\n" +
       "R4. Commit the resolution on resolve/" + taskId + ": git add -A && git commit -m \"resolve conflicts: " + taskId + "\".\n" +
       "R5. Back in " + REPO_PATH + ": git checkout main && git merge --ff-only resolve/" + taskId + ". This fast-forwards — main has not moved while the lock was held. Then STEP 2 applies: git push origin main. Report the merged commit hash.\n" +
       "R6. Clean up: cd " + REPO_PATH + " && git worktree remove --force /tmp/crew-resolve-" + taskId + " && git branch -D resolve/" + taskId + ".\n" +
-      "ESCALATE — return {\"passed\": false, \"summary\": \"conflict needs human resolution\"} — when: 3 attempts are exhausted; the conflict touches generated files, migrations, or public API contracts; or 'looks right + checks pass' is not sufficient for any other reason. On escalation, RELEASE THE LOCK so the task can be reworked later: run CREW_REPO=" + REPO_PATH + " " + MERGE_LOCK + " release " + taskId + " (release is keyed on task id; no PID needed). Do NOT run post-deploy on escalation — it would delete the untouched task branch the human still needs.\n" +
-      "- If it contains ERROR, something else failed. Set passed to false.\n\n" +
+      "ESCALATE — report 'conflict needs human resolution', then end your report with exactly this line: VERDICT: FAIL — when: 3 attempts are exhausted; the conflict touches generated files, migrations, or public API contracts; or 'looks right + checks pass' is not sufficient for any other reason. On escalation, RELEASE THE LOCK so the task can be reworked later: run CREW_REPO=" + REPO_PATH + " " + MERGE_LOCK + " release " + taskId + " (release is keyed on task id; no PID needed). Do NOT run post-deploy on escalation — it would delete the untouched task branch the human still needs.\n" +
+      "- If it contains ERROR, something else failed. Report the error, then end your report with exactly this line: VERDICT: FAIL.\n\n" +
       "\n" +
       "STEP 2: Push the merged main to the remote repository.\n" +
       "Run: cd " + REPO_PATH + " && git push origin main\n" +
       "- If the push succeeds, report the merged commit hash.\n" +
       "- If the push is rejected as non-fast-forward (the remote has commits not present locally),\n" +
-      "  NEVER force-push. Do not run any --force variant. Set passed to false with summary:\n" +
-      "  'git push origin main rejected as non-fast-forward — remote main has diverged; manual resolution required'.\n\n" +
-      "Your final response MUST be valid JSON and nothing else: { \"summary\": \"result\", \"passed\": true/false }. No prose, no markdown, just the JSON object.";
+      "  NEVER force-push. Do not run any --force variant. Report 'git push origin main rejected as non-fast-forward — remote main has diverged; manual resolution required' in your notes, then end your report with exactly this line: VERDICT: FAIL.\n\n" +
+      "Report back in plain prose — what happened at each step — and end your report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
 
   } else if (step.name === "Publish") {
     if (PUBLISH_TYPE === "npm") {
@@ -356,74 +909,199 @@ while (i < STEPS.length) {
         " CREW_HOME=" + crewHome + " LIFECYCLE=" + LIFECYCLE + " RELEASE_SCRIPT=" + RELEASE_SCRIPT +
         " bash " + PUBLISH_NPM + "\n\n" +
         "Do NOT run npm, npm pack, npm publish, or the python publish script yourself. Do NOT compare local and registry versions. Do NOT decide whether to publish.\n\n" +
-        "If the command exits nonzero, set passed to false and put the script's PUBLISH_FAILED line in your summary.\n" +
-        "If it exits zero, paste the script's COMPLETE marker block verbatim into your summary, then end your summary with exactly these two lines, in this order — lowercase, no trailing period, do not rephrase (the QA backstop extracts them by pattern):\n" +
+        "If the command exits nonzero, put the script's PUBLISH_FAILED line in your report, then end your report with exactly this line: VERDICT: FAIL.\n" +
+        "If it exits zero, paste the script's COMPLETE marker block verbatim into your report, then end your report with exactly these three lines, in this order — lowercase, no trailing period, do not rephrase:\n" +
         "TARGET_VERSION=" + publishTarget.target + " computed as " + publishTarget.base + " + " + publishTarget.scope + " → " + publishTarget.target + "\n" +
-        "published: muse-crew@" + publishTarget.target + "\n\n" +
-        "Your final response MUST be valid JSON and nothing else: { \"summary\": \"result\", \"passed\": true }.\n" +
-        "No prose, no markdown, just the JSON object.";
-    } else if (PUBLISH_TYPE === "artifact") {
-      // Artifact projects: rebuild the live artifact via artifact_edit, then finalize
+        "published: muse-crew@" + publishTarget.target + "\n" +
+        "VERDICT: PASS\n\n";
+        } else if (PUBLISH_TYPE === "artifact") {
+      // Deterministic artifact publish (canary b5efd1b1, 2026-09-10): the work
+      // agent claimed "Rebuilt and deployed" while no build ran and no
+      // provenance was stamped — prose-trusted side effects, the same failure
+      // class as the npm double-skip (bb739316). The npm path already runs one
+      // deterministic script; the artifact path now has the same shape. Lock
+      // refresh, rebuild trigger, build-completion poll, provenance stamp, and
+      // post-deploy are narrow schema'd bookkeeping calls owned by the
+      // workflow — the work agent reports on the mechanical outcome and
+      // cannot skip what it never owned. Any step failing parks with an
+      // honest, step-specific reason (fail-closed). The post-hoc
+      // getprovenance-vs-HEAD verification below stays as the final gate.
+      var artifactPublish = null;
+      var publishLockRefreshed = false;
+      try {
+        // STEP 0 (mechanical): refresh the merge lock so a long build cannot
+        // go stale mid-publish.
+        var lockRefresh = await agent(
+          "Run: "+ LIFECYCLE_ENV + " refresh-lock " + taskId + "\n" +
+          "Return JSON { \"refreshed\": <true if the command exited zero, false otherwise>, \"output\": \"<trimmed stdout>\" } and nothing else.",
+          { key: attemptKey("publish-lock-refresh-" + taskId, totalReworkCount), label: "Refreshing merge lock for publish",
+            schema: { type: "object", properties: { refreshed: { type: "boolean" }, output: { type: "string" } }, required: ["refreshed"] } }
+        );
+        if (!lockRefresh.refreshed) {
+          return await parkTask("Publish lock refresh failed: " + (lockRefresh.output || "no output") + ". Fail-closed — lock state unknown.");
+        }
+        publishLockRefreshed = true;
+        // STEP 1 (mechanical): trigger the rebuild with one narrow call. The
+        // agent only makes the artifact_edit call and reports whether it was
+        // accepted — 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.
+        var rebuildPrompt =
+          "Call artifact_edit with slug \"" + PUBLISH_SLUG + "\" and verbatim_request:\n" +
+          "'Rebuild the application from current source. Do not modify any source files — just rebuild and deploy what is on disk.'\n" +
+          "If the artifact_edit tool is not available in this session, do NOT improvise — return { \"edit_started\": false, \"error\": \"artifact_edit unavailable\" }.\n" +
+          "Make no other calls. Return JSON { \"edit_started\": <true if the edit was accepted, false otherwise>, \"error\": \"<details or empty string>\" } and nothing else.";
+        var rebuildSchema =
+          { type: "object", properties: { edit_started: { type: "boolean" }, error: { type: "string" } }, required: ["edit_started"] };
+        var rebuildTrigger = await agent(rebuildPrompt,
+          { key: attemptKey("publish-artifact-rebuild-" + taskId, totalReworkCount), label: "Triggering artifact rebuild", schema: rebuildSchema });
+        if (!rebuildTrigger.edit_started && rebuildTrigger.error === "artifact_edit unavailable") {
+          log("Publish rebuild trigger: artifact_edit unavailable — one bounded retry with a fresh key");
+          rebuildTrigger = await agent(rebuildPrompt,
+            { key: attemptKey("publish-artifact-rebuild-" + taskId + "-retry1", totalReworkCount), label: "Triggering artifact rebuild (retry)", schema: rebuildSchema });
+        }
+        var publishFailure = null;
+        if (rebuildTrigger.edit_started) {
+          // STEP 1b (mechanical): bounded poll for build completion.
+          var buildPoll = await agent(
+            "Poll artifact_status for slug \"" + PUBLISH_SLUG + "\" until no build is running. Check every 30 seconds, up to 20 checks (10 minutes max).\n" +
+            "Return JSON { \"build_done\": <true if no build is running within budget, false on timeout>, \"status\": \"<final status or timeout note>\" } and nothing else.",
+            { key: attemptKey("publish-artifact-poll-" + taskId, totalReworkCount), label: "Waiting for artifact build to complete",
+              schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" } }, required: ["build_done"] },
+              timeoutMs: 660000 }
+          );
+          if (buildPoll.build_done) {
+            // STEP 1c (mechanical): stamp provenance from workflow-computed values.
+            var provStamp = await agent(
+              "Run: cd " + REPO_PATH + " && git rev-parse HEAD — call this SRC.\n" +
+              "Run: basename $(readlink " + crewHome + "/current) — call this REL.\n" +
+              "Run: date -u +%Y-%m-%dT%H:%M:%SZ — call this TS.\n" +
+              "Call artifact_invoke_action on slug \"" + PUBLISH_SLUG + "\", action \"setprovenance\", args:\n" +
+              "{ \"source_commit\": \"<SRC trimmed>\", \"crew_release\": \"<REL trimmed>\", \"published_at\": \"<TS trimmed>\", \"task_id\": \"" + taskId + "\" }.\n" +
+              "Return JSON { \"stamped\": <true if the setprovenance response contains ok: true, false otherwise>, \"source_commit\": \"<SRC trimmed>\", \"crew_release\": \"<REL trimmed>\", \"published_at\": \"<TS trimmed>\" } and nothing else.",
+              { key: attemptKey("publish-artifact-stamp-" + taskId, totalReworkCount), label: "Stamping artifact provenance",
+                schema: { type: "object", properties: { stamped: { type: "boolean" }, source_commit: { type: "string" }, crew_release: { type: "string" }, published_at: { type: "string" } }, required: ["stamped", "source_commit", "crew_release", "published_at"] } }
+            );
+            if (provStamp.stamped) {
+              artifactPublish = { source_commit: provStamp.source_commit, crew_release: provStamp.crew_release, published_at: provStamp.published_at };
+            } else {
+              publishFailure = "Provenance stamp failed after a completed build (source_commit " + (provStamp.source_commit || "unknown") + "). The build landed but is unstamped — fail-closed.";
+            }
+          } else {
+            publishFailure = "Artifact build did not complete within budget: " + (buildPoll.status || "timeout") + ". The publish may or may not have landed — provenance was not stamped.";
+          }
+        } else {
+          publishFailure = "Artifact rebuild trigger failed: " + (rebuildTrigger.error || "artifact_edit not accepted") + ". The publish did not land.";
+        }
+        // STEP 2 (mechanical, always once the lock was refreshed): post-deploy
+        // commits builder leftovers if any, removes the worktree, and releases
+        // the merge lock — even when the publish itself failed, so a skipped
+        // or failed publish can never leave the lock held (canary b5efd1b1).
+        var postDeploy = await agent(
+          "Run: "+ LIFECYCLE_ENV + " post-deploy " + taskId + "\n" +
+          "Return JSON { \"deployed\": <true if the output contains DEPLOYED, false otherwise>, \"output\": \"<trimmed output>\" } and nothing else.",
+          { key: attemptKey("publish-postdeploy-" + taskId, totalReworkCount), label: "Finalizing publish (post-deploy)",
+            schema: { type: "object", properties: { deployed: { type: "boolean" }, output: { type: "string" } }, required: ["deployed"] } }
+        );
+        if (publishFailure) {
+          return await parkTask(publishFailure + (postDeploy.deployed
+            ? " Post-deploy finalized cleanup."
+            : " Post-deploy also failed (" + (postDeploy.output || "no output") + ") — worktree and lock state unknown."));
+        }
+        if (!postDeploy.deployed) {
+          return await parkTask("Post-deploy failed after a stamped publish: " + (postDeploy.output || "no output") + ". The publish landed but worktree cleanup and lock release are unknown — human attention needed.");
+        }
+        log("Deterministic artifact publish completed for task " + taskId + ": provenance at " + artifactPublish.source_commit);
+      } catch (pubErr) {
+        // Best-effort cleanup: if the lock was refreshed, try to release it
+        // before parking so the failure cannot wedge the next run.
+        if (publishLockRefreshed) {
+          try {
+            await agent(
+              "Run: "+ LIFECYCLE_ENV + " post-deploy " + taskId + "\n" +
+              "Return JSON { \"deployed\": <true if the output contains DEPLOYED, false otherwise> } and nothing else.",
+              { key: attemptKey("publish-postdeploy-cleanup-" + taskId, totalReworkCount), label: "Releasing lock after publish failure",
+                schema: { type: "object", properties: { deployed: { type: "boolean" } }, required: ["deployed"] } }
+            );
+          } catch (cleanupErr) {
+            log("Publish cleanup post-deploy also failed: " + (cleanupErr && cleanupErr.message ? cleanupErr.message : cleanupErr));
+          }
+        }
+        return await parkTask("Deterministic artifact publish failed: " + (pubErr && pubErr.message ? pubErr.message : pubErr) + ". Fail-closed.");
+      }
+      // The work agent no longer performs the publish — it reports on the
+      // mechanical outcome above. It must not rebuild or re-stamp: a second
+      // artifact_edit would trigger a duplicate build.
       instructions = "Publish the merged code to the live artifact.\n\n" +
+        "The publish was performed deterministically by the workflow before your step — do NOT call artifact_edit, artifact_status, setprovenance, or post-deploy yourself; doing so would trigger a duplicate build or disturb the finalized state. You perform no publish actions.\n\n" +
+        "For the change summary, run: cd " + REPO_PATH + " && git log -1 --stat\n\n" +
+        "Mechanical outcome (every step succeeded and was verified by the workflow):\n" +
+        "- merge lock refreshed: yes\n" +
+        "- artifact rebuild triggered and completed: yes\n" +
+        "- provenance stamped: yes — source_commit " + artifactPublish.source_commit + ", crew_release " + artifactPublish.crew_release + ", published_at " + artifactPublish.published_at + "\n" +
+        "- post-deploy finalized: yes (worktree removed, merge lock released)\n\n" +
         "POLICY: The live artifact is rebuilt only in this phase, from the repo. Never use artifact_edit to change the artifact directly — fixes go through the repo and the loop. A source fix is not done until the artifact is rebuilt from it here.\n\n" +
         "The repo push already happened in Integrate — do NOT push to git in this phase.\n\n" +
-        "STEP 0: Refresh the merge lock to prevent stale-lock breaking during publish.\n" +
-        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " refresh-lock " + taskId + "\n\n" +
-        "STEP 1: Publish to the live artifact.\n" +
-        "Get the change summary: cd " + REPO_PATH + " && git log -1 --stat\n" +
-        "Then call artifact_edit with slug \"" + PUBLISH_SLUG + "\" and verbatim_request:\n" +
-        "'Rebuild the application from current source. Do not modify any source files — just rebuild and deploy what is on disk.'\n" +
-        "Wait for the build to complete by polling artifact_status until it is no longer running.\n\n" +
-        "STEP 1B: Stamp publication provenance.\n" +
-        "Run: cd " + REPO_PATH + " && git rev-parse HEAD\n" +
-        "Run: basename $(readlink " + crewHome + "/current)\n" +
-        "Run: date -u +%Y-%m-%dT%H:%M:%SZ\n" +
-        "Call artifact_invoke_action on slug \"" + PUBLISH_SLUG + "\", action \"setprovenance\", args:\n" +
-        "{ \"source_commit\": \"<rev-parse output>\", \"crew_release\": \"<basename output>\", \"published_at\": \"<date output>\", \"task_id\": \"" + taskId + "\" }.\n" +
-        "Confirm the response contains ok: true. If setprovenance fails, report it in your summary but still run post-deploy to release the lock.\n\n" +
-        "STEP 2: Finalize.\n" +
-        "Run: CREW_REPO=" + REPO_PATH + " " + LIFECYCLE + " post-deploy " + taskId + "\n" +
-        "If the output contains DEPLOYED, publishing is complete.\n\n" +
-        "If artifact_edit failed, still run post-deploy to release the merge lock and clean up.\n" +
-        "Report the failure: { \"passed\": false, \"summary\": \"artifact publish failed: [details]\" }.\n\n" +
-        "Your final response MUST be valid JSON and nothing else: { \"summary\": \"published changes\", \"passed\": true }.\n" +
-        "No prose, no markdown, just the JSON object.";
-    } else if (PUBLISH_TYPE === "vercel") {
+        "Write plain prose describing what was published, then on its own line: VERDICT: PASS\n" +
+        "The VERDICT line must be the last line of your report.";
+} else if (PUBLISH_TYPE === "vercel") {
       // vercel publish is not yet implemented — block without inventing behavior
       instructions = "The project's publish target is \"vercel\", which is not yet implemented.\n" +
         "Do NOT invent publish behavior — do not guess CLI commands, APIs, or deployment steps.\n" +
-        "Your final response MUST be valid JSON and nothing else: { \"passed\": false, \"summary\": \"vercel publish not yet implemented\" }.\n" +
-        "No prose, no markdown, just the JSON object.";
+        "Report the situation in prose, then end your report with exactly this line: VERDICT: FAIL.";
     }
   } else if (step.name === "QA") {
     // Backstop for merge-time versioning: when the accepted Build summary
     // declared release: yes, QA verifies the registry actually moved. A silent
     // publish skip becomes a loud QA failure with evidence, not a pass.
     var npmPublishCheck = (PUBLISH_TYPE === "npm" && releaseDecision && releaseDecision.release === "yes")
-      ? "NPM PUBLISH CHECK: the accepted Build summary declared release: yes, so this run's Publish phase must have published. Find this task's recorded Publish result: call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }, then find the session for this task_id with step \"Publish\" (status completed) in the returned sessions array and read its session notes (the Publish agent's summary — event history does NOT carry it).\n" +
-      "Extract the line matching TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version>. If the line is missing, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: Publish summary did not echo its computed target version (STEP 3B)\" }.\n" +
-      "Verify the bump SCOPE: the <scope> in that line MUST equal the accepted version_bump scope \"" + releaseDecision.version_bump + "\" — if the Publish agent applied a different scope, FAIL. Verify the ARITHMETIC: <base> + <scope> must equal <new-version> (patch increments the last segment only, e.g. 0.3.0 + patch → 0.3.1; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0) — if the math is wrong, FAIL.\n" +
-      "Extract the published version from the notes line matching published: muse-crew@<version> (match case-insensitively and ignore any trailing period — agents sometimes rephrase it). It MUST equal <new-version> from the TARGET_VERSION line. Then run: npm view muse-crew version. The registry version MUST equal <new-version>. If any of these checks fails, FAIL with { \"passed\": false, \"summary\": \"npm publish verification failed: [details]\" }.\n"
+      ? "NPM PUBLISH CHECK: the accepted Build report declared release: yes, so this run's Publish phase must have published. Find this task's recorded Publish result: call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }, then find the session for this task_id with step \"Publish\" (status completed) in the returned sessions array and read its session notes (the Publish agent's summary — event history does NOT carry it).\n" +
+      "Extract the line matching TARGET_VERSION=<new-version> computed as <base> + <scope> → <new-version> (the workflow appends it to the Publish notes, so it is always present). If the line is missing, report 'npm publish verification failed: Publish notes did not carry the computed target version', then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "Verify the bump SCOPE: the <scope> in that line MUST equal the accepted version_bump scope \"" + releaseDecision.version_bump + "\" — if it differs, report the mismatch, then end your report with exactly this line: VERDICT: FAIL. Verify the ARITHMETIC: <base> + <scope> must equal <new-version> (patch increments the last segment only, e.g. 0.3.0 + patch → 0.3.1; minor increments the middle and resets the last to 0; major increments the first and resets the rest to 0) — if the math is wrong, report it, then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "Extract the published version from the notes line matching published: muse-crew@<version>. It MUST equal <new-version> from the TARGET_VERSION line. Then run: npm view muse-crew version. The registry version MUST equal <new-version>. If any of these checks fails, report 'npm publish verification failed: [details]', then end your report with exactly this line: VERDICT: FAIL.\n"
       : "";
     instructions = "Final QA testing. You are CODE-BLIND — do NOT read source code.\n" +
       "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, FAIL with { \"passed\": false, \"summary\": \"public docs missing/stale for [the change]\" }. 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" +
+      "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, use artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\" with action \"getstate\" (args {}) to read current sessions, events, and tasks.\n" +
       "Verify the fix by checking that session notes in the returned data now handle newlines correctly.\n" +
       "You can also check specific data with the getevents action.\n" +
       "Do NOT use artifact_inspect — it is async and will not return results inline.\n" +
       "File follow-up tasks via artifact_invoke_action createtask on slug \"" + DASHBOARD_SLUG + "\" for related issues.\n" +
       npmPublishCheck +
-      "If testing passes, your final response MUST be valid JSON and nothing else: { \"passed\": true, \"summary\": \"test results\" }.\n" +
-      "If testing fails, your final response MUST be valid JSON and nothing else: { \"passed\": false, \"summary\": \"failure details\" }.\n" +
-      "No prose, no markdown, just the JSON object.";
+      "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.
+    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" +
+        "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, use artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\" with action \"getstate\" (args {}) to read current sessions, events, and tasks.\n" +
+        "Verify the fix by checking that session notes in the returned data now handle newlines correctly.\n" +
+        "You can also check specific data with the getevents action.\n" +
+        npmPublishCheck +
+        "File follow-up tasks via artifact_invoke_action createtask on slug \"" + DASHBOARD_SLUG + "\" for related issues.\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.";
+    }
     if (PUBLISH_TYPE === "artifact") {
       instructions = "PROVENANCE CHECK (this project publishes to a dashboard artifact).\n" +
         "Call artifact_invoke_action on slug \"" + PUBLISH_SLUG + "\", action \"getprovenance\", args: {}.\n" +
-        "If provenance is null, FAIL: { \"passed\": false, \"summary\": \"provenance missing — publish did not stamp\" }.\n" +
-        "Run: cd " + REPO_PATH + " && git rev-parse HEAD\n" +
-        "Run: basename $(readlink " + crewHome + "/current)\n" +
-        "If either hash mismatches, FAIL: { \"passed\": false, \"summary\": \"provenance mismatch: [details]\" }.\n\n" +
+        "If provenance is null, report 'provenance missing — publish did not stamp', 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: basename $(readlink " + crewHome + "/current) — call this LIVE_CREW.\n" +
+        "If provenance.crew_release does not equal LIVE_CREW, report 'provenance mismatch: crew_release [value from getprovenance] != [LIVE_CREW]', then end your report with exactly this line: VERDICT: FAIL.\n" +
+        "If provenance.source_commit equals LIVE_HEAD, the source check passes.\n" +
+        "Otherwise the check is NOT failed yet: post-deploy commits an artifact-builder staging commit (\"rebuild: <task_id>\") AFTER the stamp, 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, report 'provenance mismatch: stamped source_commit is not an ancestor of live HEAD', then end your report with exactly this line: VERDICT: FAIL.\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\n" +
         instructions;
     }
   }
@@ -439,9 +1117,13 @@ while (i < STEPS.length) {
       "The returned events are filtered to this task. They contain notes and decisions from prior phases.\n\n";
   }
 
-  var stepResult;
-  try {
-    stepResult = await agent(
+  // Work agent returns the runtime's native envelope {"status": "ok",
+  // "result": "<prose>"} with no schema. The runtime requires JSON output;
+  // the envelope is its own documented shape, so there is nothing for the
+  // agent to improvise. The workflow receives the prose report as a plain
+  // string. The verdict is still extracted deterministically from the report
+  // text by extractVerdict below — never by an agent.
+  var workPromptBase =
     "Read the identity file at " + ORCH_PATH + "/identities/" + step.identity + ".md using the read tool, and embody that character fully.\n\n" +
     "## Your Assignment\n\n" +
     "Task: " + taskTitle + "\n" +
@@ -451,75 +1133,213 @@ while (i < STEPS.length) {
     (step.name !== "Review" ? "Dashboard slug: " + DASHBOARD_SLUG + "\n" : "") +
     "\n## Instructions\n\n" + eventPreamble + instructions + "\n\n" +
     "CONSTRAINT: Do NOT call logevent or upsertagentsession — the workflow handles all phase tracking after your step completes.\n\n" +
-    "Stay in character. Do the work thoroughly.",
-    {
-      key: "work-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""),
-      label: step.identity + ": " + step.name + " on \"" + taskTitle + "\"",
-      timeoutMs: 3600000,
-      schema: WORK_SCHEMA
+    "Stay in character. Do the work thoroughly.\n\n" +
+    "Return your work as JSON in exactly this shape: {\"status\": \"ok\", \"result\": \"your report here\"}. " +
+    "The result is plain prose describing what you did and found. For verdict steps, end the report with exactly one line: VERDICT: PASS or VERDICT: FAIL.";
+  var workKeyBase = "work-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : "");
+  var workerResult = null;
+  var workAttempts = [];
+  for (var workAttempt = 0; workAttempt <= 2; workAttempt++) {
+    var workKey = workAttempt === 0 ? workKeyBase : workRetryKey(step.name, (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), workAttempt);
+    var retryReason = workAttempt === 0 ? null : (workAttempts[workAttempt - 1].threw ? "discarded" : "empty");
+    try {
+      workerResult = await agent(
+        workPromptBase + (workAttempt === 0 ? "" : buildTransportRetryTrailer(step.name, REPO_PATH, taskId, workAttempt, retryReason)),
+        {
+          key: workKey,
+          label: step.identity + ": " + step.name + " on \"" + taskTitle + "\"" + (workAttempt === 0 ? "" : " (transport retry " + workAttempt + " of 2)"),
+          timeoutMs: 3600000
+        }
+      );
+      // Success path: a non-blank string report is usable — keep it and stop
+      // retrying. Without this branch every attempt is discarded and the phase
+      // always fails (regression shipped in ecef136 when Date.now() was
+      // removed from this loop).
+      if (typeof workerResult === "string" && workerResult.trim()) {
+        if (workAttempt > 0) log(step.name + " work agent transport retry " + workAttempt + " returned a machine-readable report");
+        break;
+      }
+      var emptyOutcome = workerResult === null ? "null" : (typeof workerResult === "string" ? "blank string" : typeof workerResult);
+      workAttempts.push({ threw: false, error: "", outcome: emptyOutcome });
+      log(step.name + " work agent attempt " + (workAttempt + 1) + " of 3 returned no usable output (" + emptyOutcome + ") — retrying with a fresh key");
+      workerResult = null;
+    } catch (e) {
+      var attemptErr = (e && e.message ? e.message : String(e)).replace(/"/g, "'").slice(0, 160);
+      workAttempts.push({ threw: true, error: attemptErr, outcome: "" });
+      log(step.name + " work agent attempt " + (workAttempt + 1) + " of 3 threw: " + attemptErr);
+      workerResult = null;
     }
-    );
-  } catch (e) {
-    log(step.name + " agent failed: " + (e.message || String(e)).slice(0, 500));
-    stepResult = null;
   }
+  // The report arrives as a plain string — the runtime unwraps the envelope.
+  var workerText = (typeof workerResult === "string") ? workerResult : null;
 
-  // If schema retries were exhausted, block gracefully
-  if (!stepResult || typeof stepResult.summary !== "string") {
-    log(step.name + " closeout unrecoverable — blocking");
+  if (typeof workerText !== "string" || !workerText.trim()) {
+    var workFailure = describeWorkAgentFailure(step.name, step.identity, workAttempts);
+    log(step.name + " " + workFailure.notes + " — marking failed for retry");
     await agent(
-      "Record closeout failure.\n" +
+      "Record work failure.\n" +
       "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
-      "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"blocked\", \"notes\": \"Agent failed to return structured result after retries\" }.\n" +
+      "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"failed\", \"notes\": \"" + workFailure.notes + "\" }.\n" +
       "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
-      "{ \"task_id\": \"" + taskId + "\", \"type\": \"blocked\", \"message\": \"" + step.name + " agent failed after retries — workflow blocked\" }.",
-      { key: "record-block-" + step.name, label: "Recording closeout failure", schema: { type: "object" } }
+      "{ \"task_id\": \"" + taskId + "\", \"type\": \"failed\", \"message\": \"" + workFailure.eventMessage + "\" }.",
+      { key: "record-block-" + step.name, label: "Recording work failure", schema: { type: "object" } }
     );
     return {
       __hatchWorkflowControl: "blocked",
       result: {
-        blocked_reason: step.name + " agent failed after retries",
-        message: "The " + step.identity + " agent's work may be valid — structured output failed.",
+        blocked_reason: workFailure.blockedReason,
+        message: workFailure.message,
         task_id: taskId
       }
     };
   }
+  // Verdict derivation (deterministic): for VERDICT_STEPS the workflow owns
+  // the verdict — extracted by regex from the trailing window from the worker's own report.
+  // A missing, malformed, or contradictory VERDICT line first gets a bounded
+  // mechanical re-ask (reaskVerdict); only if that is exhausted does the phase
+  // fail closed (blocked):
+  // On verdict failure the session is marked "failed", NOT "blocked":
+  // the dispatcher retries failed sessions at the same step, while a
+  // "blocked" session is never picked up again (blocked is reserved for
+  // unmet dependencies). The __hatchWorkflowControl: "blocked" return below
+  // stays — that is the runtime's halt-the-run signal, a separate vocabulary.
+  var verdictPassed = null;
+  if (VERDICT_STEPS.indexOf(step.name) >= 0) {
+    var verdict = extractVerdict(workerText);
+    if (!verdict.ok) {
+      // Bounded mechanical re-ask before failing the phase: the report may
+      // be valid with a stochastically omitted or garbled verdict line.
+      log(step.name + " verdict line missing or ambiguous (" + verdict.count + " trailing-window matches) — attempting bounded re-ask");
+      verdict = await reaskVerdict(step.name, (totalReworkCount > 0 ? "-r" + totalReworkCount : ""), workerText);
+    }
+    if (!verdict.ok) {
+      log(step.name + " verdict re-ask exhausted — marking failed for retry");
+      await agent(
+        "Record verdict failure.\n" +
+        "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"upsertagentsession\", args:\n" +
+        "{ \"id\": \"" + activeSessionId + "\", \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"status\": \"failed\", \"notes\": \"Worker report had no single unambiguous VERDICT: PASS/FAIL line (bounded re-ask exhausted)\" }.\n" +
+        "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
+        "{ \"task_id\": \"" + taskId + "\", \"type\": \"failed\", \"message\": \"" + step.name + " verdict line missing or ambiguous, re-ask exhausted — phase failed, dispatcher will retry\" }.",
+        { key: "record-block-" + step.name, label: "Recording verdict failure", schema: { type: "object" } }
+      );
+      return {
+        __hatchWorkflowControl: "blocked",
+        result: {
+          blocked_reason: step.name + " worker report had no single unambiguous VERDICT: PASS/FAIL line (bounded re-ask exhausted)",
+          message: "The " + step.identity + " agent's work may be valid — its report did not declare a verdict the workflow could read, and two bounded re-ask attempts could not transcribe one. The report is preserved in the workflow log.",
+          task_id: taskId
+        }
+      };
+    }
+    verdictPassed = verdict.passed;
+  }
 
-  const summary = (stepResult.summary || "Step completed").slice(0, 2000);
-  const passed = stepResult.passed !== false;
-  const status = passed ? "completed" : "rejected";
+  // Deterministic closeout: no formatter agent. The verdict is mechanical
+  // (extractVerdict above); the summary is the worker's report truncated.
+  // For verdict steps passed comes from the verdict; for non-verdict steps
+  // the worker producing output means the step passed.
+  var stepResult = {
+    passed: verdictPassed !== null ? verdictPassed : true,
+    summary: workerText
+  };
+  const passed = stepResult.passed === true;
+  // "rejected" is an explicit phase verdict routed through rework (Review/QA,
+  // and the Build/Reproduce reports that feed them). Integrate/Publish work
+  // that did not finish is operational — "failed", retryable under the
+  // dispatcher's consecutive-failure cap.
+  const status = passed ? "completed" : (step.name === "Integrate" || step.name === "Publish" ? "failed" : "rejected");
 
   // Deterministic publish verification: the agent cannot self-certify a publish.
+  var publishVerified = false;
   if (step.name === "Publish" && PUBLISH_TYPE === "npm" && publishTarget) {
     try {
       var verifyResult = await agent(
         "Run: npm view muse-crew version 2>/dev/null. Return JSON { \"registry_version\": \"<output trimmed>\" } and nothing else.",
-        { key: "verify-publish-" + taskId, label: "Verifying published version",
+        { key: attemptKey("verify-publish-" + taskId, totalReworkCount), label: "Verifying published version",
           schema: { type: "object", properties: { registry_version: { type: "string" } }, required: ["registry_version"] } }
       );
       var regVer = (verifyResult.registry_version || "").trim();
       if (regVer !== publishTarget.target) {
-        return { status: "blocked", task_id: taskId,
-          reason: "Publish verification failed: registry shows " + regVer + " but the release decision required " +
-            publishTarget.target + " (" + publishTarget.base + " + " + publishTarget.scope + "). The publish did not land." };
+        return await parkTask("Publish verification failed: registry shows " + regVer + " but the release decision required " +
+          publishTarget.target + " (" + publishTarget.base + " + " + publishTarget.scope + "). The publish did not land.");
       }
       log("Publish verified for task " + taskId + ": registry at " + regVer);
+      publishVerified = true;
     } catch (e) {
-      return { status: "blocked", task_id: taskId,
-        reason: "Publish verification failed: could not read the registry version (" + (e && e.message ? e.message : e) + "). Fail-closed." };
+      return await parkTask("Publish verification failed: could not read the registry version (" + (e && e.message ? e.message : e) + "). Fail-closed.");
     }
   }
 
+  // Artifact publish verification: the worker cannot self-certify a deploy.
+  // The workflow reads the artifact's provenance and confirms it points at the
+  // integrated commit. A stale or missing provenance means the publish did not
+  // land — fail closed, do not trust the worker's prose.
+  if (step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG) {
+    try {
+      var headResult = await agent(
+        "Run: cd " + REPO_PATH + " && git rev-parse HEAD. Return JSON { \"head\": \"<output trimmed>\" } and nothing else.",
+        { key: attemptKey("verify-publish-head-" + taskId, totalReworkCount), label: "Reading integrated commit",
+          schema: { type: "object", properties: { head: { type: "string" } }, required: ["head"] } }
+      );
+      var expectedCommit = (headResult.head || "").trim();
+      var provResult = await agent(
+        "Call artifact_invoke_action on slug \"" + PUBLISH_SLUG + "\", action \"getprovenance\", args: {}. " +
+        "Return JSON { \"source_commit\": \"<provenance.source_commit>\", \"published_at\": \"<provenance.published_at>\" } and nothing else.",
+        { key: attemptKey("verify-publish-prov-" + taskId, totalReworkCount), label: "Verifying artifact provenance",
+          schema: { type: "object", properties: { source_commit: { type: "string" }, published_at: { type: "string" } }, required: ["source_commit"] } }
+      );
+      var provCommit = (provResult.source_commit || "").trim();
+      if (!provCommit || provCommit !== expectedCommit) {
+        return await parkTask("Publish verification failed: artifact provenance shows source_commit '" + provCommit +
+          "' but the integrated HEAD is '" + expectedCommit + "'. The publish did not land or provenance was not stamped.");
+      }
+      log("Publish verified for task " + taskId + ": artifact provenance at " + provCommit);
+      publishVerified = true;
+    } catch (e) {
+      return await parkTask("Publish verification failed: could not read artifact provenance (" + (e && e.message ? e.message : e) + "). Fail-closed.");
+    }
+  }
+
+  // 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
+  // reading TARGET_VERSION=) depend on them.
+  let summary;
+  var workerMarkers = extractMarkerLines(workerText);
+  if (step.name === "Publish" && PUBLISH_TYPE === "npm" && publishTarget && publishVerified) {
+    const markerLines = "TARGET_VERSION=" + publishTarget.target + " computed as " + publishTarget.base + " + " + publishTarget.scope + " → " + publishTarget.target + "\n" +
+      "published: muse-crew@" + publishTarget.target;
+    summary = (stepResult.summary || "Step completed").slice(0, 2000 - markerLines.length - workerMarkers.length - 2) + "\n" + markerLines + (workerMarkers ? "\n" + workerMarkers : "");
+  } else {
+    summary = (stepResult.summary || "Step completed").slice(0, 2000 - workerMarkers.length - 1) + (workerMarkers ? "\n" + workerMarkers : "");
+  }
+
+  // Visual verdict evidence: for experiential artifact tasks, append the
+  // deterministic post-change capture plan to the QA session notes. The
+  // parent protocol (docs/visual-verdict.md) triggers the inspection with
+  // this plan; "visual: pending" marks the owed verdict.
+  if (step.name === "QA" && passed && qaVisual) {
+    summary = (summary + "\nvisual: pending\ncapture_plan: " +
+      buildVisualCapturePlan(taskTitle, taskDescription, "postchange", captureTargets).replace(/\s+/g, " ")).slice(0, 2900);
+  }
+
   // Capture mapper's spec for Build and Review
   if (step.name === "Map" && passed) {
     mapperSpec = summary;
+    var ctm = /capture_targets:\s*(.+)/i.exec(workerText);
+    captureTargets = ctm ? ctm[1].trim().slice(0, 300) : "";
   }
 
-  // Capture the accepted Build summary's machine-readable release decision.
-  // Parsed from the RAW summary (before the 2000-char slice above) — the
-  // release:/version_bump: lines sit at the very end and must survive truncation.
+  // Capture Sage's experiential flag (machine-read marker line).
+  if (step.name === "Triage" && passed) {
+    isExperiential = extractExperiential(workerText);
+  }
+
+  // Capture the accepted Build report's machine-readable release decision.
+  // Deterministic extraction from the full worker report. A missing or
+  // malformed declaration fails closed to null and Review rejects.
   if (step.name === "Build" && passed) {
-    releaseDecision = extractReleaseDecision(stepResult.summary || "");
+    releaseDecision = extractReleaseDecision(workerText);
   }
 
   await agent(
@@ -529,30 +1349,57 @@ while (i < STEPS.length) {
     "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
     "{ \"task_id\": \"" + taskId + "\", \"type\": \"" + status + "\", \"identity\": \"" + step.identity + "\", \"message\": \"" + step.name + " " + status + " by " + step.identity + "\" }.",
     {
-      key: "record-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : ""),
+      key: "record-" + step.name + (totalReworkCount > 0 ? "-r" + totalReworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
       label: "Recording " + step.name + " result",
       schema: { type: "object" }
     }
   );
 
-  // Reproduce failure blocks the task
+  // Reproduce failure needs a human (PM attention): park the task. The
+// "blocked" event type is not used — blocked is mechanically derived from
+// unmet dependencies, never manually authored.
   if (!passed && step.name === "Reproduce") {
-    log("Reproduction failed for task " + taskId + " — blocking");
-    await agent(
-      "Mark this task as blocked because reproduction failed.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
-      "{ \"task_id\": \"" + taskId + "\", \"type\": \"blocked\", \"message\": \"Reproduction failed — needs PM attention\" }.",
-      { key: "block-repro", label: "Blocking: reproduction failed", schema: { type: "object" } }
-    );
-    return { status: "blocked", task_id: taskId, reason: "Reproduction failed" };
+    log("Reproduction failed for task " + taskId + " — parking for PM attention");
+    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 {
+      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)");
+    }
   }
 
   // Review/QA rejection bounces to Build
   if (!passed && (step.name === "Review" || step.name === "QA")) {
     totalReworkCount++;
     if (totalReworkCount > MAX_TOTAL_REWORK) {
-      log("Shared rework budget exhausted for task " + taskId + " — worktree preserved at .worktrees/" + taskId + " for manual inspection");
-      return { status: "blocked", task_id: taskId, reason: "Exceeded shared rework budget (" + MAX_TOTAL_REWORK + " total rework attempts across Review and QA) after " + step.name + " rejection. Worktree preserved." };
+      log("Shared rework budget exhausted for task " + taskId + " — worktree preserved at " + WORKTREE_PRESERVED_HINT + " for manual inspection");
+      return await parkTask("Exceeded shared rework budget (" + MAX_TOTAL_REWORK + " total rework attempts across Review and QA) after " + step.name + " rejection. Worktree preserved.");
     }
     rejectionNotes = summary;
     i = BUILD_INDEX;
@@ -560,16 +1407,19 @@ while (i < STEPS.length) {
     continue;
   }
 
-  // Integrate failure blocks the task
+  // Integrate failure is operational (the merge did not finish), not a verdict:
+  // the session above is recorded "failed" and the dispatcher retries the
+  // phase under its consecutive-failure cap, parking after the cap.
   if (!passed && step.name === "Integrate") {
     log("Integration failed for task " + taskId + ": " + summary);
-    return { status: "blocked", task_id: taskId, reason: "Integration failed: " + summary };
+    return { status: "failed", task_id: taskId, reason: "Integration failed: " + summary };
   }
 
-  // Publish failure blocks the task
+  // Publish failure is operational (the publish did not finish), not a
+  // verdict: recorded "failed" above, retried under the dispatcher's cap.
   if (!passed && step.name === "Publish") {
     log("Publish failed for task " + taskId + ": " + summary);
-    return { status: "blocked", task_id: taskId, reason: "Publish failed: " + summary };
+    return { status: "failed", task_id: taskId, reason: "Publish failed: " + summary };
   }
 
   i++;