muse-crew 0.4.3 → 0.4.5

package/workflows/chore.js

@@ -1,9 +1,10 @@
 export const meta = {
   name: "crew-chore",
-  description: "Chore workflow: Triage → Map → Build → Review → Integrate → Publish",
-  phases: ["Triage", "Map", "Build", "Review", "Integrate", "Publish"],
+  description: "Chore workflow: Triage → Capture → Map → Build → Review → Integrate → Publish",
+  phases: ["Triage", "Capture", "Map", "Build", "Review", "Integrate", "Publish"],
   steps: [
     { name: "Triage", identity: "sage" },
+    { name: "Capture", identity: "hazel" },
     { name: "Map", identity: "mara" },
     { name: "Build", identity: "wren" },
     { name: "Review", identity: "cass" },
@@ -17,7 +18,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
@@ -27,13 +27,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 || {};
@@ -41,6 +44,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/)";
@@ -50,17 +68,323 @@ 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", "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 };
+  }
+}
 
 // STEPS inline — export const meta is parsed as metadata, not a runtime binding
 const STEPS = [
   { name: "Triage", identity: "sage" },
+  { name: "Capture", identity: "hazel" },
   { name: "Map", identity: "mara" },
   { name: "Build", identity: "wren" },
   { name: "Review", identity: "cass" },
@@ -69,13 +393,23 @@ 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;
 const MAX_REWORK = 2;
 let reworkCount = 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). Chore has no QA
+// phase, so there is no visual-verdict function — Capture only.
+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.
@@ -89,26 +423,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];
@@ -139,15 +497,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" } }
       );
@@ -155,22 +512,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", reworkCount), 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", reworkCount)));
+      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", reworkCount), 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
@@ -180,15 +564,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", reworkCount), label: "Skipping Publish (release: no)", schema: { type: "object" } }
       );
       i++;
       continue;
@@ -204,26 +588,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, reworkCount), 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.");
     }
   }
 
+  // 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" +
@@ -231,7 +639,7 @@ while (i < STEPS.length) {
       "{ \"task_id\": \"" + taskId + "\", \"identity\": \"" + step.identity + "\", \"step\": \"" + step.name + "\", \"notes\": \"" + step.name + " step started" + (reworkCount > 0 ? " (rework #" + reworkCount + ")" : "") + "\" }.\n" +
       "Return the session_id from the response.",
       {
-        key: "claim-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : ""),
+        key: "claim-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
         label: "Claiming " + step.name,
         schema: {
           type: "object",
@@ -243,84 +651,184 @@ 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 the task continues without baseline comparison.
+  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 — continuing without baseline comparison\" }.\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");
+    }
+  }
+
   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 chore workflow assignment.\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 chore workflow assignment.\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. End your report with exactly one line on its own, lowercase, unrephrased: experiential: yes — or experiential: no. This line is machine-read.";
 
   } else if (step.name === "Map") {
-    instructions = "Research options, pick the path, write a clear spec for the builder.\nThe builder will edit source files in a git worktree of the project at " + REPO_PATH + ".\nProject: " + PROJECT_DESC + "\nTo understand the current code, read source files directly using the read tool. Do NOT use artifact_inspect — it is async and will not return in time.\nIdentify the exact files and changes needed. Be specific: file paths, what to add or change.\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 = "Research options, pick the path, write a clear spec for the builder.\nThe builder will edit source files in a git worktree of the project at " + REPO_PATH + ".\nProject: " + PROJECT_DESC + "\nTo understand the current code, read source files directly using the read tool. Do NOT use artifact_inspect — it is async and will not return in time.\nIdentify the exact files and changes needed. Be specific: file paths, what to add or change.\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.\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 \"chore: " + 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 ? "REWORK after rejection. Address:\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. No prior context 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.\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, 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 it passes, your final response MUST be valid JSON and nothing else: { \"passed\": true, \"summary\": \"approval notes\" }.\n" +
-      "If it fails, your final response MUST be valid JSON and nothing else: { \"passed\": false, \"summary\": \"rejection notes\" }.\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 it 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: chore: " + safeTitle + "\"\n\n" +
+      "Run: "+ LIFECYCLE_ENV + " integrate " + taskId + " \"merge: chore: " + 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") {
@@ -338,44 +846,146 @@ 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, reworkCount), 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, reworkCount), 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", reworkCount), 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, reworkCount), 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, reworkCount), 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, reworkCount), 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, reworkCount), 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.";
     }
   }
 
@@ -390,82 +1000,214 @@ 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 + "\nTask ID: " + taskId + "\nDescription: " + taskDescription + "\nStep: " + step.name + "\n" +
     (step.name !== "Review" ? "Dashboard slug: " + DASHBOARD_SLUG + "\n" : "") +
-    "\n## Instructions\n\n" + eventPreamble + instructions + "\n\nCONSTRAINT: Do NOT call logevent or upsertagentsession — the workflow handles all phase tracking after your step completes.\n\nStay in character. Do the work thoroughly.",
-    {
-      key: "work-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : ""),
-      label: step.identity + ": " + step.name + " on \"" + taskTitle + "\"",
-      timeoutMs: 3600000,
-      schema: WORK_SCHEMA
+    "\n## Instructions\n\n" + eventPreamble + instructions + "\n\nCONSTRAINT: Do NOT call logevent or upsertagentsession — the workflow handles all phase tracking after your step completes.\n\nStay 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 + (reworkCount > 0 ? "-r" + reworkCount : "");
+  var workerResult = null;
+  var workAttempts = [];
+  for (var workAttempt = 0; workAttempt <= 2; workAttempt++) {
+    var workKey = workAttempt === 0 ? workKeyBase : workRetryKey(step.name, (reworkCount > 0 ? "-r" + reworkCount : ""), 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, (reworkCount > 0 ? "-r" + reworkCount : ""), 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).
+  // 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, reworkCount), 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 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, reworkCount), 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, reworkCount), 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 { 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 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 : "");
+  }
+
   // 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 Sage's experiential flag (machine-read marker line).
+  if (step.name === "Triage" && passed) {
+    isExperiential = extractExperiential(workerText);
   }
 
-  // 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 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(
@@ -475,7 +1217,7 @@ 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 + (reworkCount > 0 ? "-r" + reworkCount : ""),
+      key: "record-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
       label: "Recording " + step.name + " result",
       schema: { type: "object" }
     }
@@ -484,8 +1226,8 @@ while (i < STEPS.length) {
   if (!passed && step.name === "Review") {
     reworkCount++;
     if (reworkCount > MAX_REWORK) {
-      log("Max rework attempts reached for task " + taskId + " — worktree preserved at .worktrees/" + taskId + " for manual inspection");
-      return { status: "blocked", task_id: taskId, reason: "Exceeded " + MAX_REWORK + " rework attempts after Review rejection. Worktree preserved." };
+      log("Max rework attempts reached for task " + taskId + " — worktree preserved at " + WORKTREE_PRESERVED_HINT + " for manual inspection");
+      return await parkTask("Exceeded " + MAX_REWORK + " rework attempts after Review rejection. Worktree preserved.");
     }
     rejectionNotes = summary;
     i = BUILD_INDEX;
@@ -495,12 +1237,12 @@ while (i < STEPS.length) {
 
   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 };
   }
 
   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++;