muse-crew 0.6.6 → 0.6.7

package/workflows/chore.js

@@ -26,32 +26,57 @@ const startStepIndex = inputs.start_step_index || 0;
 // resolution back via updatetask in the self-claim below.
 const RESOLVED_WORKFLOW = inputs.resolved_workflow || null;
 const WORKFLOW_WAS_NULL = inputs.workflow_was_null === true;
-const CLAIM_WORKFLOW_PERSIST = (WORKFLOW_WAS_NULL && RESOLVED_WORKFLOW) ? ", \"workflow\": \"" + RESOLVED_WORKFLOW + "\"" : "";
+
+// Visual verdict protocol availability — the workflow parks for parent-run
+// baseline capture ONLY when the protocol is fully shipped. The protocol
+// requires docs/visual-verdict.md in the release AND the parent-side
+// capture tooling (task b309a97d, "QA owns the visual verdict"). Until both
+// exist, the park would deadlock waiting for a parent who cannot fulfill
+// it.
+// Effective value for this run, resolved by the dispatcher from the
+// project's visual_protocol setting (null=inherits crew default=off).
+// Manual launches without the arg default to off (previous behavior).
+var VISUAL_PROTOCOL_AVAILABLE = inputs.visual_protocol === true;
 
 // Config from args — backward-compatible fallbacks for manual launches
-const DASHBOARD_SLUG = inputs.dashboardSlug || "orchestra-dashboard";
 const crewHome = inputs.crewHome || "~/workspace/.jarvis";
+// Crew API: the workflow calls the crew-owned CLI, not the dashboard.
+// The CLI implements the API.md contract against $CREW_HOME/crew-state.db.
+const CREW_API = crewHome + "/current/lib/crew-api.js";
+// Build a shell command invoking the CLI. Args are JSON-encoded and
+// single-quote-wrapped for safe shell passing. The agent runs this and
+// returns the stdout verbatim (the CLI emits JSON on stdout).
+function crewCmd(command, args) {
+  var json = JSON.stringify(args || {}).replace(/'/g, "'\\''");
+  return "node " + CREW_API + " --crew-home " + crewHome + " " + command + " --json '" + json + "'";
+}
 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 = crewHome + "/.pins/" + taskId; // persistent disk, NOT /tmp (tmpfs wiped by cell reboots — canary b5efd1b1); stale pins reaped by orphan-sweep
+const RUN_LIB = crewHome + "/.pins/" + taskId; // persistent disk, NOT /tmp (tmpfs wiped by cell reboots — canary b5efd1b1)
 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(); });
+const PIN_BASENAMES = [LIFECYCLE, MERGE_LOCK, PUBLISH_NPM].map(function (p) { return p.split("/").pop(); });
 
 // Project config — passed by dispatcher, falls back to dashboard defaults
 const projectConfig = inputs.project_config || {};
 // Project this run was dispatched for — the mid-run project-change guard
 // 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";
+// Fail closed on a missing repo_path — never silently fall back to
+// another checkout (the canary's wrong-repo Build, 2026-09-11: prepare
+// failed in the npm package and the builder freelanced into a dashboard
+// clone). The dispatcher skips unconfigured projects; this is the
+// backstop for direct launches.
+const REPO_PATH = projectConfig.repo_path || "";
+if (!REPO_PATH) {
+  throw new Error("Project '" + (inputs.project_id || "unknown") + "' has no repo_path configured — set it via updateproject before dispatching tasks.");
+}
 
 // Worktree layout: the task's worktree lives at
 // <repo>/.worktrees/<task_id> on branch task/<task_id>. The lifecycle
@@ -59,7 +84,7 @@ const REPO_PATH = projectConfig.repo_path || "~/workspace/ts-spaces/orchestra-da
 // 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 + " ";
+const LIFECYCLE_ENV = "CREW_HOME=" + crewHome + " CREW_REPO=" + REPO_PATH + " ";
 // The task branch is always task/<task_id>.
 const TASK_BRANCH = "task/" + taskId;
 // Where the agent works.
@@ -68,7 +93,7 @@ const WORKTREE_HINT = REPO_PATH + "/.worktrees/" + taskId;
 const WORKTREE_PRESERVED_HINT = ".worktrees/" + taskId;
 
 const PUBLISH_TYPE = projectConfig.deploy_type || "";
-const PUBLISH_SLUG = projectConfig.deploy_slug || DASHBOARD_SLUG;
+const PUBLISH_SLUG = projectConfig.deploy_slug || "";
 const PROJECT_DESC = projectConfig.description || "React + TypeScript web dashboard (client/src/, server/src/, drizzle/)";
 const RELEASE_SCRIPT = crewHome + "/crew-release.sh";
 
@@ -190,7 +215,7 @@ function attemptKey(base, reworkCount) {
 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" +
+    "Run: mkdir -p " + RUN_LIB + " && cp " + LIFECYCLE_SRC + " " + LIFECYCLE + " && cp " + MERGE_LOCK_SRC + " " + MERGE_LOCK + " && cp " + PUBLISH_NPM_SRC + " " + PUBLISH_NPM + " && chmod +x " + LIFECYCLE + " " + MERGE_LOCK + " " + PUBLISH_NPM + " && 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"] } }
@@ -202,19 +227,65 @@ function pinLifecycle(key) {
 function parsePinListing(result) {
   return (result && result.listing ? result.listing : "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
 }
+// TOOL_CHECK_PREAMBLE - every work agent runs this first. The artifact tool
+// namespace is deferred for workflow children: present but invisible until
+// the child loads it via tool_search.load_tool_namespace (bug 3472bf36 root
+// cause, verified 2026-09-11 by direct probe: 5/5 children self-loaded it;
+// the "non-deterministic platform flake" was children never being told to
+// load it). The two signal lines are the ONLY machine-read tool-availability
+// evidence - the workflow never guesses from English prose.
+// Byte-identical across standard/bugfix/chore/docs - pinned by
+// tests/artifact-tools.test.js.
+var TOOL_CHECK_PREAMBLE =
+  "TOOL CHECK (do this first, before any other work):\n" +
+  "1. Call tool_search.load_tool_namespace with paths [\"artifact\"].\n" +
+  "2. Write exactly one line: artifact_tools: ok - or artifact_tools: missing if the call failed or the tool does not exist.\n" +
+  "3. Run the shell command: echo tool-probe-ok - then write exactly one line: shell_transport: ok - or shell_transport: unavailable if you cannot run shell commands.\n" +
+  "Then do the assignment below.\n\n";
+// ARTIFACT_LOAD_PREAMBLE - the one-line load instruction that precedes every
+// special-purpose prompt calling artifact tools (rebuild trigger, provenance
+// stamp, publish verification). The artifact tool namespace is deferred for
+// workflow children: present but invisible until the child loads it via
+// tool_search.load_tool_namespace (bug 3472bf36 root cause). Byte-identical
+// across standard/bugfix/chore - pinned by tests/artifact-tools.test.js.
+var ARTIFACT_LOAD_PREAMBLE =
+  "First call tool_search.load_tool_namespace with paths [\"artifact\"] - the artifact tool namespace is deferred and invisible until loaded.\n";
 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.
+  // reason: "discarded" (the runtime threw the output away - it could not be
+  // machine-read), "empty" (agent() returned without throwing but produced
+  // nothing usable), "no-tools" (the worker's TOOL CHECK reported
+  // artifact_tools: missing), or "no-transport" (the worker's TOOL CHECK
+  // reported shell_transport: unavailable).
+  // The trailer tells the retry what to expect, not just to try again.
   var why = reason === "empty"
     ? "your previous attempt returned no usable output"
+    : reason === "no-tools"
+    ? "your previous attempt's TOOL CHECK reported artifact_tools: missing (this is a fresh launch, so run the TOOL CHECK's load step again before the work)"
+    : reason === "no-transport"
+    ? "your previous attempt's TOOL CHECK reported shell_transport: unavailable (this is a fresh launch, so run the TOOL CHECK's shell probe again before the work)"
     : "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) — " +
+    "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.";
 }
+// parseToolSignals - bug 3472bf36. The work agent's TOOL CHECK emits two
+// exact signal lines: artifact_tools: ok|missing and
+// shell_transport: ok|unavailable. The workflow reads ONLY these lines.
+// It never guesses tool availability from English prose: the old regex
+// misclassified ordinary inability-prose (e.g. a Map agent describing what
+// it could not inspect) and burned all three attempts on useless retries.
+// Byte-identical across standard/bugfix/chore/docs - pinned by
+// tests/artifact-tools.test.js.
+function parseToolSignals(text) {
+  var t = String(text || "");
+  var out = { artifactTools: "unknown", shellTransport: "unknown" };
+  var am = t.match(/^artifact_tools:\s*(ok|missing)\s*$/m);
+  if (am) out.artifactTools = am[1];
+  var sm = t.match(/^shell_transport:\s*(ok|unavailable)\s*$/m);
+  if (sm) out.shellTransport = sm[1];
+  return out;
+}
 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.
@@ -268,6 +339,259 @@ function extractReleaseDecision(workerText) {
   if (rel === "yes" && !b) return null;
   return { release: rel, version_bump: b ? b[1].toLowerCase() : null };
 }
+// Merge-record helpers (merge-lease fix, 2026-09-12): the integrate step
+// records the exact merged commit in $CREW_HOME/.merge-records/<task_id>,
+// so a re-dispatched run can verify a landed merge and publish it even
+// after the branch was reclaimed under an expired lease. All pure — no I/O,
+// no clock. Byte-identical in standard.js, bugfix.js, chore.js.
+function parseMergeRecord(text) {
+  var t = (text || "").trim();
+  if (!t || t === "NO_RECORD") return null;
+  // Append-only record; last occurrence of each key wins.
+  function lastVal(prefix) {
+    var v = null, found = false;
+    var lines = t.split("\n");
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i].trim();
+      if (line.indexOf(prefix) === 0) { v = line.slice(prefix.length).trim(); found = true; }
+    }
+    return found ? v : null;
+  }
+  var commit = lastVal("merge_commit=");
+  var release = lastVal("release=");
+  var bump = lastVal("version_bump=");
+  var malformed = false;
+  if (commit === null || !/^[0-9a-f]{40}$/.test(commit)) malformed = true;
+  if (release !== null && !/^(yes|no|unknown)$/.test(release)) malformed = true;
+  if (bump !== null && !/^(patch|minor|major|none)$/.test(bump)) malformed = true;
+  if (malformed) return { malformed: true };
+  return { merge_commit: commit, merged_at: lastVal("merged_at="), release: release, version_bump: bump };
+}
+// Publish lock decision table: what the merge record + lock state say about
+// the publish window. Pure — pinned by tests/merge-record.test.js.
+function decidePublishLockPath(o) {
+  var rec = o.rec, ancestor = !!o.ancestor, lockHeld = !!o.lockHeld;
+  if (rec === null) return lockHeld ? "refresh" : "skip";
+  if (rec.malformed) return "park";
+  if (!ancestor) return "park";
+  return lockHeld ? "refresh" : "reacquire";
+}
+// Integrate retry decision: a landed merge must route to Publish, not
+// re-integrate (the branch may be gone — reclaimed under an expired lease).
+// Pure — pinned by tests/merge-record.test.js.
+function decideIntegrateRetry(o) {
+  var rec = o.rec, ancestor = !!o.ancestor;
+  if (rec === null) return "proceed";
+  if (rec.malformed) return "park";
+  return ancestor ? "skip-to-publish" : "proceed";
+}
+// On a dispatcher retry resumed at Integrate, the run-local releaseDecision
+// is null (Build doesn't re-run). Hydrate it from the merge record so the
+// npm Publish gate doesn't park a publishable merge. Pure — pinned by
+// tests/merge-record.test.js.
+function hydrateReleaseDecision(rec) {
+  if (rec && (rec.release === "yes" || rec.release === "no")) {
+    return { release: rec.release, version_bump: rec.version_bump === "none" ? null : rec.version_bump };
+  }
+  return null;
+}
+
+// Publish diff transport: parse a unified diff into per-file {path, added,
+// removed} line lists. Pure function — no I/O, no clock. Used by Publish to
+// verify the artifact builder applied the carried change (canary run 4,
+// 2026-09-11: the builder's source tree was stale and disconnected from the
+// crew's repo; "rebuild from current source" rebuilt stale code and the
+// workflow stamped the new commit hash on it — provenance fiction).
+function parseUnifiedDiff(diffText) {
+  var files = [];
+  var current = null;
+  var lines = (diffText || "").split("\n");
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+    var m = /^diff --git a\/(.*) b\/(.*)$/.exec(line);
+    if (m) {
+      current = { path: m[2], added: [], removed: [] };
+      files.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (/^--- /.test(line) || /^\+\+\+ /.test(line)) continue;
+    if (/^@@ /.test(line)) continue;
+    if (line.charAt(0) === "+") {
+      current.added.push(line.slice(1));
+    } else if (line.charAt(0) === "-") {
+      current.removed.push(line.slice(1));
+    }
+  }
+  return files;
+}
+
+// Compare the artifact builder's reported applied-changes against the diff's
+// expected changes. Every added/removed line must match exactly per path,
+// and the file counts must match — the builder applies exactly the carried
+// change, nothing more, nothing less. Pure function — no I/O, no clock.
+// OBSERVATION INPUT ONLY (2026-09-12, task 23ca8f3f): the applied report
+// has a demonstrated false-negative mode (applied:[] for a diff the builder
+// had actually applied), and it is derived from the carried diff, so a match
+// certifies nothing either. A mismatch is logged as observation; it never
+// parks and never blocks the stamp. The verification is the independent
+// read-back (docs/publish-verification.md).
+function verifyAppliedChanges(expected, applied) {
+  if (!Array.isArray(applied)) {
+    return { ok: false, reason: "builder returned no applied-changes list" };
+  }
+  function sorted(a) { return (a || []).slice().sort(); }
+  function eq(a, b) {
+    a = sorted(a); b = sorted(b);
+    if (a.length !== b.length) return false;
+    for (var i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
+  for (var i = 0; i < expected.length; i++) {
+    var exp = expected[i];
+    var got = null;
+    for (var j = 0; j < applied.length; j++) {
+      if (applied[j] && applied[j].path === exp.path) { got = applied[j]; break; }
+    }
+    if (!got) {
+      return { ok: false, reason: "builder did not report changing '" + exp.path + "'" };
+    }
+    if (!eq(exp.added, got.added)) {
+      return { ok: false, reason: "added lines for '" + exp.path + "' do not match the carried diff" };
+    }
+    if (!eq(exp.removed, got.removed)) {
+      return { ok: false, reason: "removed lines for '" + exp.path + "' do not match the carried diff" };
+    }
+  }
+  if (applied.length !== expected.length) {
+    return { ok: false, reason: "builder reported changing " + applied.length + " file(s), diff carries " + expected.length };
+  }
+  return { ok: true };
+}
+
+// Publish read-back request builder: the verbatim_request the workflow hands
+// to artifact_inspect (via a child) after the artifact build lands. Pure
+// function — no I/O, no clock. The request carries the merged diff as the
+// expected change and asks for an independent read of the artifact's actual
+// source: for each file, the exact current text of the changed regions plus
+// a per-line present/absent finding. The parent (docs/publish-verification.md)
+// compares these findings against the diff mechanically and stamps provenance
+// only on a match. This breaks the circularity that hollowed canary run 8
+// (2026-09-11): verifyAppliedChanges compares the builder's applied-report
+// against the diff the report was derived from — a fabricated report passes
+// by construction. Independent read-back cannot be fabricated from the diff;
+// it must match the artifact's real content.
+function buildPublishReadbackRequest(taskId, commit, diff, buildAgentId) {
+  // Build-ID correlation (2026-09-12): buildAgentId is the build.agent_id the
+  // workflow observed for the publish attempt (the artifact system's durable
+  // build identifier). The read-back request carries it so the parent can
+  // prove the read-back inspected the live build of THIS attempt — not a
+  // different build's output. Null/empty means the edit was accepted but
+  // never correlated to a builder run. Pure function of inputs — no I/O,
+  // no clock.
+  var buildIdLine = (typeof buildAgentId === "string" && buildAgentId.length > 0)
+    ? "Expected builder build agent_id: " + buildAgentId + " (the artifact system's in-flight correlation ID for this publish attempt — not a durable post-completion identifier).\n"
+    : "No build agent_id was observed for this publish attempt (the edit was accepted but never correlated to a builder run) — say so explicitly in your report.\n";
+  return (
+    "Publish content read-back for task " + taskId + ", merge commit " + commit + ".\n" +
+    "The unified diff below was supposed to be applied to this artifact's source tree and deployed. Do NOT modify anything.\n" +
+    "Do NOT rely on the builder's applied-changes report — it is derived from this same diff, so it cannot confirm the content. Read the artifact's CURRENT source directly.\n" +
+    "\n" +
+    buildIdLine +
+    "Report the live build's agent_id as seen in artifact_status (or state explicitly that no build/agent_id is visible). If an expected agent_id is given above and the live one differs, say so exactly — the read-back may be inspecting a different build's output.\n" +
+    "\n" +
+    "UNIFIED DIFF (expected change):\n" +
+    "```diff\n" + diff + "\n```\n" +
+    "\n" +
+    "For each file in the diff:\n" +
+    "1. Read the file's CURRENT content in the artifact source tree.\n" +
+    "2. Quote the exact current text of the regions around the changed lines.\n" +
+    "3. For every added (+) line in the diff, state whether that exact line is PRESENT in the current source.\n" +
+    "4. For every removed (-) line in the diff, state whether that exact line is ABSENT from the current source.\n" +
+    "5. Report build/deploy health and the console error count.\n" +
+    "\n" +
+    "Return the per-file present/absent findings with the quoted observed lines. Do not modify anything.\n" +
+    "This read-back feeds the parent content-verification protocol (docs/publish-verification.md): the parent stamps provenance only when every added line is present and every removed line is absent."
+  );
+}
+
+// Pre-publish base observation (diagnostic, 2026-09-12): instruction fragment
+// for the builder's edit request, asking it to report the sha256 of each
+// touched file's CURRENT content BEFORE applying the diff. Pure function —
+// no I/O, no clock.
+//
+// Why: the builder applies the carried diff to its own source tree, whose
+// base state is unrecorded. The post-hoc read-back only checks the changed
+// regions AFTER the edit; it cannot tell us what base the diff landed on.
+// If the tree was dirty or drifted before the edit, the read-back still
+// passes (the diff's lines are present) while the artifact silently carries
+// uncommitted content — the production validateRepoPath incident
+// (2026-09-12), where the live artifact contained code absent from every git
+// ref. These pre-hashes, compared against the workflow-computed expected
+// base hashes (merge parent), reveal what the publish actually read.
+// Observation only — the workflow logs mismatches but never parks on them.
+function buildPreHashInstruction(files) {
+  var paths = files.map(function(f) { return f.path; }).join(", ");
+  return (
+    "- BEFORE applying anything, compute the sha256 hash of each file below as it CURRENTLY exists in your source tree (before your changes). Use the exact bytes of the current file content.\n" +
+    "- Report these hashes in the \"pre_hashes\" field of your return JSON, as { \"<path>\": \"<sha256 hex>\" }.\n" +
+    "- If a file does not exist in your tree, report its hash as the string \"MISSING\".\n" +
+    "- Do this BEFORE applying the diff — the hashes must reflect the pre-edit state.\n" +
+    "  Files: " + paths + "\n"
+  );
+}
+
+// Durable publish-attempt ledger (2026-09-12): every artifact publish
+// attempt is recorded append-only at $CREW_HOME/.publish-ledger/<slug>.jsonl
+// on persistent disk (NOT /tmp). The ledger is the correlation record for
+// publish attempts whose outcome is UNKNOWN. When the rebuild trigger's
+// child returns prose instead of JSON (structured-output failure), the edit
+// may already have been accepted as pending_init — and artifact_status
+// cannot see pending_init (diagnostic canary 2026-09-12: an edit accepted
+// as pending_init was immediately followed by an all-false status check,
+// and the old retry issued a DUPLICATE edit). "No build visible" is NOT
+// evidence the edit did not go through, so the workflow never blind-retries
+// on an unknown outcome: it records the attempt and parks fail-closed. A
+// human or a later run correlates the accepted edit via the ledger (commit
+// hash + attempt key + the artifact build's agent_id when one was observed)
+// instead of guessing from a blind status poll.
+// Best-effort observability: a failed write is logged loudly but never
+// throws — the caller's park/proceed decision never depends on the ledger.
+// Byte-identical across standard/bugfix/chore — pinned by
+// tests/publish-ledger.test.js.
+async function recordPublishLedger(entry, rework) {
+  try {
+    var ledgerDir = crewHome + "/.publish-ledger";
+    var line = JSON.stringify({
+      ts: "@LEDGER_TS@",
+      task_id: taskId,
+      workflow: RESOLVED_WORKFLOW || "unknown",
+      slug: PUBLISH_SLUG,
+      commit: entry.commit || null,
+      attempt: entry.attempt || null,
+      agent_id: entry.agent_id || null,
+      applied_report: entry.applied_report || null,
+      outcome: entry.outcome,
+      detail: entry.detail || ""
+    });
+    var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
+    var res = await agent(
+      "Append one line to the publish-attempt ledger (best-effort observability, not a gate).\n" +
+      "Run: mkdir -p " + sq(ledgerDir) + " && printf '%s\n' " + sq(line) +
+      " | sed \"s/@LEDGER_TS@/$(date -u +%Y-%m-%dT%H:%M:%SZ)/\" >> " + sq(ledgerDir + "/" + PUBLISH_SLUG + ".jsonl") + " && echo LEDGER_OK\n" +
+      "Return JSON { \"result\": \"<verbatim output>\" } and nothing else.",
+      { key: attemptKey("publish-ledger-" + taskId + "-" + entry.outcome, rework),
+        label: "Recording publish attempt in ledger",
+        schema: { type: "object", properties: { result: { type: "string" } }, required: ["result"] } }
+    );
+    var ok = !!(res && res.result && res.result.indexOf("LEDGER_OK") !== -1);
+    log("Publish ledger: outcome '" + entry.outcome + "' for task " + taskId +
+      (ok ? " recorded." : " NOT confirmed (" + ((res && res.result) || "no output") + ")"));
+  } catch (e) {
+    log("Publish ledger: write failed for task " + taskId + " (non-fatal, observability only): " + (e && e.message ? e.message : e));
+  }
+}
+
 // 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
@@ -277,13 +601,37 @@ function extractMarkerLines(workerText) {
   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)) {
+    if (/^(repo_diff:|release:|version_bump:|VERDICT:|TARGET_VERSION=|published:|experiential:|capture_targets:|worktree:)/i.test(line)) {
       markers.push(line);
     }
   }
   return markers.join("\n");
 }
 
+// Worktree confinement: the Build agent must declare the exact worktree
+// path it built in on a `worktree:` marker line. The workflow compares it
+// against WORKTREE_HINT mechanically (exact string match) — never by
+// reading agent prose. This closes the hole where a builder whose prepare
+// failed freelanced into a different checkout (canary, 2026-09-11): the
+// honest-but-confused case fails here, and a fabricated path is caught one
+// phase later when Review's inspect finds no commits in the configured repo.
+function extractWorktree(workerText) {
+  var lines = (workerText || "").split("\n");
+  var found = null;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    var m = /^worktree:\s*(\S.*)$/i.exec(line);
+    if (m) found = m[1].trim();
+  }
+  if (!found) return { ok: false };
+  // Normalize trailing slashes: ".../<task_id>/" and ".../<task_id>"
+  // name the same directory. Compare locations, not spellings — a
+  // builder that emits the trailing slash still worked in the right
+  // place. (Canary 2026-09-11: an exact comparison rejected a correct
+  // declaration over one trailing slash.)
+  return { ok: true, path: found.replace(/\/+$/, "") };
+}
+
 // 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).
@@ -332,8 +680,8 @@ async function resolveExperiential() {
   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 this task's Triage step session notes from the crew API.\n" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { 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.",
       {
@@ -355,10 +703,12 @@ async function resolveExperiential() {
 }
 // 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 }.
+// { baseline_found, baseline_kind, baseline_refs, requested_count, evidence_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
+// the number of notes starting exactly "baseline: requested";
+// evidence_count = the number of notes starting exactly "baseline: captured" or
+// "baseline: none" (the per-attempt evidence chain; state-derived, no wall clock). 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;
@@ -366,10 +716,10 @@ 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" +
+      "Read this task's note events from the crew API.\n" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("get-events", { 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.",
+      "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\">, \"evidence_count\": <count of messages starting exactly with \"baseline: captured\" or \"baseline: none\"> } and nothing else.",
       {
         key: "baseline-status-" + taskId + "-" + baselineStatusCallCount,
         label: "Reading baseline evidence status",
@@ -379,9 +729,10 @@ async function baselineStatus() {
             baseline_found: { type: "boolean" },
             baseline_kind: { type: "string" },
             baseline_refs: { type: "string" },
-            requested_count: { type: "number" }
+            requested_count: { type: "number" },
+            evidence_count: { type: "number" }
           },
-          required: ["baseline_found", "baseline_kind", "baseline_refs", "requested_count"]
+          required: ["baseline_found", "baseline_kind", "baseline_refs", "requested_count", "evidence_count"]
         }
       }
     );
@@ -389,11 +740,12 @@ async function baselineStatus() {
       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
+      requested_count: (ev && ev.requested_count) || 0,
+      evidence_count: (ev && ev.evidence_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 };
+    return { baseline_found: false, baseline_kind: "", baseline_refs: "", requested_count: 0, evidence_count: 0 };
   }
 }
 
@@ -456,21 +808,44 @@ function releaseDecisionText() {
 // 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.
+// Terminal cleanup: the run's last act at every park/fail boundary. A run
+// that parks or fails must not leak its worktree, branch, or merge lock.
+// The lifecycle's terminal-cleanup releases the lock unconditionally and
+// reclaims the worktree+branch ONLY when the task branch is fully merged
+// into main (then it is redundant); unmerged work is preserved for the
+// human by design. Fire-and-forget with one bounded retry — the merge-lock
+// lease expiry and the orphan sweep are the backstop for a dead transport.
+async function terminalCleanup() {
+  for (var attempt = 1; attempt <= 2; attempt++) {
+    try {
+      await agent(
+        "Run in shell and return the stdout verbatim:\n" + LIFECYCLE_ENV + " terminal-cleanup " + taskId,
+        { key: "terminal-cleanup" + (attempt > 1 ? "-retry" : ""),
+          label: "Terminal cleanup (merged-branch reclamation)" + (attempt > 1 ? " (retry)" : "") }
+      );
+      return;
+    } catch (cleanupErr) {
+      log("Terminal cleanup attempt " + attempt + " failed for task " + taskId + ": " + (cleanupErr && cleanupErr.message ? cleanupErr.message : cleanupErr));
+    }
+  }
+  log("Terminal cleanup exhausted for task " + taskId + " — merge-lock lease expiry and orphan sweep are the backstop");
+}
 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" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("park-task", { 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" } }
+      { key: "park-task", label: "Parking task for human attention" }
     );
   } 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");
+    await terminalCleanup();
     return { status: "failed", task_id: taskId, reason: "park failed: " + reason, park_failed: true };
   }
+  await terminalCleanup();
   return { status: "parked", task_id: taskId, reason: reason };
 }
 let i = startStepIndex;
@@ -508,8 +883,8 @@ while (i < STEPS.length) {
   // re-launches the step with the new project's config.
   if (LAUNCH_PROJECT_ID) {
     const projectCheck = await agent(
-      "Read this task's current project from the dashboard.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getstate\", args: { \"events_limit\": 1 }.\n" +
+      "Read this task's current project from the crew API.\n" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("get-state", { events_limit: 1 }) + "\n" +
       "Find the task with id \"" + taskId + "\" in the returned tasks array.\n" +
       "Return exactly { \"project\": \"<the task's project field, or empty string if absent>\" } and nothing else.",
       {
@@ -524,14 +899,15 @@ while (i < STEPS.length) {
       log(abortMessage);
       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 + "\", \"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" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { task_id: taskId, identity: step.identity, step: REWORK_STEP, status: "failed",
+            notes: abortMessage + " Rebuild from the Map session notes in the task's event history." },
+          event: { task_id: taskId, type: "failed", identity: step.identity, message: abortMessage }
+        }) + "\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" } }
+        { key: "abort-project-change", label: "Aborting stale run (project changed)" }
       );
       return { status: "failed", task_id: taskId, reason: abortMessage };
     }
@@ -572,7 +948,7 @@ while (i < STEPS.length) {
       "Release the merge lock and clean up without publishing.\n" +
       "Run: "+ LIFECYCLE_ENV + " post-deploy " + taskId + "\n" +
       "If the output contains DEPLOYED, the lock is released and the worktree is cleaned up.",
-      { key: attemptKey("publish-skip-cleanup", reworkCount), label: "Skipping Publish (no target)", schema: { type: "object" } }
+      { key: attemptKey("publish-skip-cleanup", reworkCount), label: "Skipping Publish (no target)" }
     );
     i++;
     continue;
@@ -597,7 +973,7 @@ while (i < STEPS.length) {
         "Release the merge lock and clean up without publishing.\n" +
         "Run: "+ LIFECYCLE_ENV + " post-deploy " + taskId + "\n" +
         "If the output contains DEPLOYED, the lock is released and the worktree is cleaned up.",
-        { key: attemptKey("publish-skip-release-no", reworkCount), label: "Skipping Publish (release: no)", schema: { type: "object" } }
+        { key: attemptKey("publish-skip-release-no", reworkCount), label: "Skipping Publish (release: no)" }
       );
       i++;
       continue;
@@ -635,11 +1011,12 @@ while (i < STEPS.length) {
   // claimed:false and this run stands down as a duplicate.
   let activeSessionId;
   if (isFirstClaim) {
+    var firstClaimUpdateArgs = { id: taskId, state: "in_progress" };
+    if (WORKFLOW_WAS_NULL && RESOLVED_WORKFLOW) firstClaimUpdateArgs.workflow = RESOLVED_WORKFLOW;
     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\"" + CLAIM_WORKFLOW_PERSIST + " }.\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" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", firstClaimUpdateArgs) + "\n" +
+      "Then run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" }) + "\n" +
       "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: \"\" }.",
       {
@@ -660,8 +1037,7 @@ while (i < STEPS.length) {
   } else {
     const claimResult = await agent(
       "Claim a session for this task step.\n" +
-      "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" + (reworkCount > 0 ? " (rework #" + reworkCount + ")" : "") + "\" }.\n" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("claim-task", { task_id: taskId, identity: step.identity, step: step.name, notes: step.name + " step started" + (reworkCount > 0 ? " (rework #" + reworkCount + ")" : "") }) + "\n" +
       "Return the session_id from the response.",
       {
         key: "claim-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
@@ -698,25 +1074,40 @@ while (i < STEPS.length) {
       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" } }
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "completed", notes: "Capture skipped — not an experiential artifact task" },
+          event: { task_id: taskId, type: "completed", identity: step.identity, message: "Capture completed by " + step.identity }
+        }) + "\n",
+        { key: "record-Capture" + bounceSuffix, label: "Recording Capture result" }
       );
       i++;
       continue;
     }
     var capStatus = await baselineStatus();
-    if (capStatus.baseline_found) {
-      log("Capture: baseline evidence already recorded for task " + taskId + " (" + capStatus.baseline_kind + ")");
+    // Stale-decision guard: a "baseline: none (visual protocol unavailable)"
+    // note is only durable while the protocol is unavailable. When
+    // VISUAL_PROTOCOL_AVAILABLE is true, that old decision no longer
+    // stands — fall through to the request path for a fresh capture
+    // attempt. Exact-string trim comparison against the workflow's own
+    // written message (explicit state, never English matching).
+    var baselineLatestMessage = ("baseline: " + capStatus.baseline_kind + capStatus.baseline_refs).trim();
+    var baselineStale = VISUAL_PROTOCOL_AVAILABLE && baselineLatestMessage === "baseline: none (visual protocol unavailable)";
+    if (capStatus.baseline_found && !baselineStale) {
+      var evidenceN = capStatus.evidence_count + 1;
+      var carryNote = "baseline: " + capStatus.baseline_kind + " (#" + evidenceN + " carries forward prior:" + capStatus.baseline_refs + ")";
+      log("Capture: baseline evidence already recorded for task " + taskId + " (" + capStatus.baseline_kind + ") — logging per-attempt carry-forward note (evidence #" + evidenceN + ")");
       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" } }
+        "Log the per-attempt baseline carry-forward note, then record the phase.\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("log-event", {
+          task_id: taskId, type: "note", identity: step.identity, message: carryNote
+        }) + "\n" +
+        "Then run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "completed", notes: "Baseline evidence already recorded: " + capStatus.baseline_kind + " " + capStatus.baseline_refs + " (evidence #" + evidenceN + ")" },
+          event: { task_id: taskId, type: "completed", identity: step.identity, message: "Capture completed by " + step.identity }
+        }),
+        { key: "record-Capture" + bounceSuffix, label: "Recording Capture result" }
       );
       i++;
       continue;
@@ -726,13 +1117,13 @@ while (i < STEPS.length) {
       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" } }
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("log-event", { task_id: taskId, type: "note", identity: step.identity, message: "baseline: none (capture unavailable after 2 attempts)" }) + "\n" +
+        "Then run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "completed", notes: "baseline: none — continuing without baseline comparison" },
+          event: { task_id: taskId, type: "completed", identity: step.identity, message: "Capture completed by " + step.identity }
+        }),
+        { key: "record-Capture-none" + bounceSuffix, label: "Recording baseline: none" }
       );
       i++;
       continue;
@@ -740,12 +1131,26 @@ while (i < STEPS.length) {
     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" } }
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("log-event", { task_id: taskId, type: "note", identity: step.identity, message: "baseline: requested (attempt " + attemptN + ")" }) + "\n" +
+      "Then run in shell and return the stdout verbatim:\n" + crewCmd("upsert-session", { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed",
+        notes: "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" }
     );
+    if (!VISUAL_PROTOCOL_AVAILABLE) {
+      log("Capture: visual protocol not available (VISUAL_PROTOCOL_AVAILABLE=false) — recording baseline:none instead of parking for task " + taskId);
+      await agent(
+        "Record that baseline capture was skipped (protocol unavailable).\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("log-event", { task_id: taskId, type: "note", identity: step.identity, message: "baseline: none (visual protocol unavailable)" }) + "\n" +
+        "Then run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "completed", notes: "baseline: none — visual protocol unavailable, final QA judges on rubric alone" },
+          event: { task_id: taskId, type: "completed", identity: step.identity, message: "Capture completed by " + step.identity }
+        }),
+        { key: "record-Capture-none-protocol" + bounceSuffix, label: "Recording baseline: none (protocol unavailable)" }
+      );
+      i++;
+      continue;
+    }
     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");
   }
 
@@ -761,11 +1166,12 @@ while (i < STEPS.length) {
         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" } }
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+            task_id: taskId,
+            session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed", notes: "Map gate bounce: no baseline evidence recorded for this experiential task — no spec was written. Baseline evidence must be captured before the spec." },
+            event: { task_id: taskId, type: "failed", identity: step.identity, message: "Map gate bounce — baseline evidence missing, returning to Capture" }
+          }) + "\n",
+          { key: "record-Map-bounce" + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""), label: "Recording Map gate bounce" }
         );
         mapGateBounceCount++;
         i = CAPTURE_INDEX;
@@ -798,6 +1204,9 @@ while (i < STEPS.length) {
     instructions = "STEP 1: Prepare your worktree.\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" +
+      "HEARTBEAT: Start a background heartbeat loop NOW (before STEP 2) to signal you are still alive during this build. Run this once:\n" +
+      "(while node " + CREW_API + " --crew-home " + crewHome + " heartbeat-session --json '{\"id\": \"" + activeSessionId + "\"}' >/dev/null 2>&1; do sleep 900; done) &\n" +
+      "The loop heartbeats every 15 minutes and exits on its own when the session ends. This prevents the dispatcher from mistaking a long build for a dead session and launching a duplicate.\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: " + WORKTREE_HINT + "/\n" +
@@ -816,7 +1225,7 @@ while (i < STEPS.length) {
       "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" : "") +
       "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.");
+      (PUBLISH_TYPE === "npm" ? " End your report with the release: and version_bump: lines exactly as specified above — keep them on their own lines, lowercase, unrephrased — then a line `worktree: ` followed by the exact working directory path from above (copy it verbatim \u2014 it must match character-for-character), then a final line with exactly: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not." : " End your report with a line `worktree: ` followed by the exact working directory path from above (copy it verbatim \u2014 it must match character-for-character), then exactly one line: VERDICT: PASS if the build is complete, VERDICT: FAIL if it is not.");
 
   } else if (step.name === "Review") {
     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" +
@@ -852,14 +1261,19 @@ while (i < STEPS.length) {
       "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 — 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" +
+      "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_HOME=" + crewHome + " 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" +
+      "First, refresh the merge lock — a slow push must not let the 600s lease expire under you: " + LIFECYCLE_ENV + LIFECYCLE + " refresh-lock " + taskId + ". If the refresh fails, report 'merge lock lost before push' and end your report with exactly this line: VERDICT: FAIL. Do not push without the lock.\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. 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" +
+      "  NEVER force-push. Do not run any --force variant. The lifecycle's `integrate` already reconciled origin/main under the merge lock, so a rejection means the remote advanced after that reconcile — recover mechanically while you still hold the lock:\n" +
+      "  1. Run: cd " + REPO_PATH + " && git fetch origin main && git merge --no-edit origin/main -m \"merge: push-time reconcile (" + taskId + ")\".\n" +
+      "  2. If the merge conflicts, abort it (git merge --abort), report 'push-time reconcile conflicted — manual resolution required', then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "  3. If it merges cleanly, retry the push exactly once: git push origin main. If the second push still rejects, report 'push rejected twice as non-fast-forward', then end your report with exactly this line: VERDICT: FAIL.\n" +
+      "  4. If the retry succeeds, report the merged commit hash.\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") {
@@ -893,15 +1307,22 @@ while (i < STEPS.length) {
       // 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.
+      // refresh, rebuild trigger, build-completion poll, 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). There is deliberately NO workflow-side provenance
+      // stamp: the builder's applied-report is circular (canary run 8,
+      // 2026-09-11), so the stamp moved to the parent — after the build
+      // lands, the workflow triggers an independent artifact_inspect
+      // read-back, records the session completed, and parks with
+      // "publish: verification-requested". The parent stamps provenance only
+      // after the read-back confirms the content (docs/publish-verification.md);
+      // Chore has no QA: the parent's stamp read-back is the final gate.
       var artifactPublish = null;
       var publishLockRefreshed = false;
       var publishSkippedNoLock = false;
+      var publishBuildLanded = false; // true once the artifact build poll completes: content exists to verify; the provenance stamp is deferred to the parent (docs/publish-verification.md)
       try {
         // STEP 0 (mechanical): read the merge-lock state explicitly — never
         // infer it from prose. An empty-diff Integrate (MERGED_EMPTY)
@@ -924,31 +1345,297 @@ while (i < STEPS.length) {
           }
           publishLockRefreshed = true;
         }
-        // STEP 1 (mechanical): trigger the rebuild with one narrow call.
+        // STEP 1 (mechanical): carry the merged change to the artifact
+        // builder. The builder's source tree is NOT the crew's repo —
+        // canary run 4 (2026-09-11) proved it: Publish asked for "rebuild
+        // from current source. Do not modify any source files" and the
+        // builder rebuilt a stale copy predating the canary's changes, then
+        // the workflow stamped the new commit hash on the stale build.
+        // Provenance fiction; all eight phases passed. The merge diff is
+        // embedded in the edit request; the builder applies it to its own
+        // tree and reports the applied changes; the workflow verifies the
+        // report matches the diff BEFORE stamping provenance. A mismatch
+        // parks without stamping — the stamp must never certify a build
+        // whose content was not verified.
         // Skipped entirely when no lock was held — nothing merged, nothing
         // to ship.
         if (!publishSkippedNoLock) {
-        // (below) the rebuild trigger, bounded poll, and provenance stamp
-        // agent only makes the artifact_edit call and reports whether it was
-        // accepted — no prose claim to trust. If the artifact tool namespace
+        // (below) the diff computation, rebuild trigger, application
+        // verification, bounded poll, and provenance stamp. The builder
+        // only makes the artifact_edit call and reports the applied
+        // changes — no prose claim to trust. If the artifact tool namespace
         // is missing from this child it reports honestly and the workflow
         // retries once with a fresh key (bounded); anything else parks.
+        var diffResult = await agent(
+          "Run: cd " + REPO_PATH + " && git rev-parse HEAD && echo '---PARENT---' && git rev-parse HEAD^1 && echo '---DIFF---' && git diff HEAD^1 HEAD && echo '---NAMES---' && git diff-tree --no-commit-id --name-only -r HEAD\n" +
+          "Return JSON { \"commit\": \"<HEAD trimmed>\", \"parent\": \"<HEAD^1 trimmed>\", \"diff\": \"<raw unified diff, may be multi-line>\", \"files\": \"<newline-separated paths>\" } and nothing else.",
+          { key: attemptKey("publish-artifact-diff-" + taskId, reworkCount), label: "Computing merged diff for publish",
+            schema: { type: "object", properties: { commit: { type: "string" }, parent: { type: "string" }, diff: { type: "string" }, files: { type: "string" } }, required: ["commit", "diff"] } }
+        );
+        var mergeCommitForPublish = (diffResult.commit || "").trim();
+        var mergeParentForPublish = (diffResult.parent || "").trim();
+        var mergeDiff = diffResult.diff || "";
+        if (!mergeDiff.trim()) {
+          return await parkTask("Publish diff is empty for commit " + (mergeCommitForPublish || "unknown") + " — a merge lock was held but there is no change to carry. Human attention needed.");
+        }
+        if (/^Binary files /m.test(mergeDiff)) {
+          return await parkTask("Publish diff contains binary files — the text diff transport cannot carry them. Human attention needed.");
+        }
+        if (/^rename from /m.test(mergeDiff)) {
+          return await parkTask("Publish diff contains a rename — the diff transport cannot carry renames. Human attention needed.");
+        }
+        var mergeDiffLines = mergeDiff.split("\n").length;
+        if (mergeDiffLines > 200) {
+          return await parkTask("Publish diff is " + mergeDiffLines + " lines (budget 200) — too large for the diff transport. Human attention needed.");
+        }
+        var expectedChanges = parseUnifiedDiff(mergeDiff);
+        if (expectedChanges.length === 0) {
+          return await parkTask("Publish diff parsed to zero files for commit " + (mergeCommitForPublish || "unknown") + " — cannot verify application. Human attention needed.");
+        }
+        // Pre-publish base observation (diagnostic, 2026-09-12): the builder
+        // applies the diff to its own source tree, whose base state is
+        // unrecorded. Compute the trustworthy expected base — the sha256 of
+        // each touched file at the merge parent commit — so the builder's
+        // self-reported pre-edit hashes (see buildPreHashInstruction) can be
+        // compared against it. Observation only: a mismatch is logged loudly
+        // but never parks. The observation tells us what the publish actually
+        // reads, so the subsequent fix can require the right base.
+        var expectedBaseHashes = {};
+        try {
+          // Shell-quote helper (no regex-with-quote: the test parser does not
+          // understand regex literals containing quotes).
+          var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
+          var baseHashResult = await agent(
+            "Run: cd " + REPO_PATH + " && parent=" + sq(mergeParentForPublish) + " && for f in " + expectedChanges.map(function(f) { return sq(f.path); }).join(" ") + "; do printf '%s:' \"$f\"; git show \"$parent:$f\" 2>/dev/null | sha256sum | cut -d' ' -f1; done\n" +
+            "Return JSON { \"hashes\": \"<newline-separated <path>:<sha256> lines, empty hash means the file is new in this diff>\" } and nothing else.",
+            { key: attemptKey("publish-base-hashes-" + taskId, reworkCount), label: "Computing expected base content hashes",
+              schema: { type: "object", properties: { hashes: { type: "string" } }, required: ["hashes"] } }
+          );
+          (baseHashResult.hashes || "").split("\n").forEach(function(line) {
+            var m = /^([^:]+):([0-9a-f]*)$/.exec(line.trim());
+            if (m) expectedBaseHashes[m[1]] = m[2] || "NEW-FILE";
+          });
+          log("Publish expected base hashes for task " + taskId + " (merge parent " + (mergeParentForPublish || "unknown").slice(0, 12) + "): " + JSON.stringify(expectedBaseHashes));
+        } catch (e) {
+          log("Publish expected base hash computation failed for task " + taskId + " (non-fatal, observation degraded): " + (e && e.message ? e.message : e));
+        }
         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.";
+          "'Apply the following change to your source tree, then rebuild and deploy.\n" +
+          "\n" +
+          "UNIFIED DIFF (relative to your source tree):\n" +
+          "```diff\n" + mergeDiff + "\n```\n" +
+          "\n" +
+          "Rules:\n" +
+          "- For each file in the diff, apply its hunks to the same path in your source tree (use git apply or equivalent).\n" +
+          "- For a new file (--- /dev/null), create it with the added (+) lines as its full content.\n" +
+          "- For a deleted file (+++ /dev/null), delete it.\n" +
+          "- If any hunk does not apply cleanly, STOP and report the failure — do not improvise or skip hunks.\n" +
+          "- Do not make any other source changes.\n" +
+          "- After applying, rebuild and deploy.\n" +
+          "- Report, for each file you changed: its path, the exact lines you added, and the exact lines you removed.\n" +
+          buildPreHashInstruction(expectedChanges) + "'\n" +
+          ARTIFACT_LOAD_PREAMBLE +
+          "If artifact_edit is still not available after the load, do NOT improvise — return { \"edit_started\": false, \"error\": \"artifact_tools missing after load\", \"applied\": [] }.\n" +
+          "Make no other calls. Return JSON { \"edit_started\": <true if the edit was accepted, false otherwise>, \"error\": \"<details or empty string>\", \"applied\": [{\"path\": \"<file path>\", \"added\": [\"<added lines>\"], \"removed\": [\"<removed lines>\"]}], \"pre_hashes\": {\"<file path>\": \"<sha256 of that file's content BEFORE you applied the diff, or \"MISSING\">\"} } 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");
+          { type: "object",
+            properties: {
+              edit_started: { type: "boolean" },
+              error: { type: "string" },
+              applied: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    path: { type: "string" },
+                    added: { type: "array", items: { type: "string" } },
+                    removed: { type: "array", items: { type: "string" } }
+                  },
+                  required: ["path", "added", "removed"]
+                }
+              },
+              pre_hashes: {
+                type: "object",
+                description: "Diagnostic (2026-09-12): sha256 of each touched file's content BEFORE the builder applied the diff, as reported by the builder. Compared against the workflow-computed expected base hashes (merge parent) — observation only, never gating."
+              }
+            },
+            required: ["edit_started", "applied"] };
+        var rebuildTrigger = null;
+        var rebuildReportMissing = false; // true if the edit went through but the agent returned no applied report (structured-output failure) — the smoke-check is skipped; the parent's independent read-back is the verification
+        // The trigger key of the attempt that last ran, for the publish ledger.
+        // Minted once here (not re-minted per use site) so the ledger always
+        // records the exact key that was issued — and so a re-minted duplicate
+        // can never drift from it.
+        var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, reworkCount);
+        // The artifact build's agent_id, captured from artifact_status when the
+        // trigger's outcome is ambiguous (structured-output failure). The
+        // agent_id is the artifact system's in-flight correlation ID (not durable post-completion)
+        // (research 2026-09-12): artifact.edit returns pending_init with NO
+        // agent_id, but artifact_status exposes build.agent_id immediately
+        // after acceptance, stable across polls. Recorded in the ledger so an
+        // ambiguous attempt correlates to the exact builder run; null when no
+        // build was ever observed.
+        var rebuildAgentId = null;
+        // The builder's applied-report is an observation, not a gate
+        // (2026-09-12, task 23ca8f3f): computed once the trigger outcome is
+        // known, logged loudly, never a park.
+        var publishAppliedObservation = null; // "match" | "mismatch: <reason>" | "missing-report" — observation only, never a park
+        try {
+          rebuildTrigger = await agent(rebuildPrompt,
+            { key: rebuildAttemptKey, label: "Triggering artifact rebuild", schema: rebuildSchema });
+        } catch (rebuildErr) {
+          // Structured-output failure (canary run 9, 2026-09-11): the agent
+          // called artifact_edit (tool_call_count > 0) but returned prose
+          // instead of JSON. The side effect may have happened — the outcome
+          // is UNKNOWN, not "did not go through". The old code asked a child
+          // for derived booleans and retried on all-false; that check issued
+          // the DUPLICATE artifact_edit on 2026-09-12.
+          //
+          // Build-ID research (2026-09-12) corrected the model: artifact.edit
+          // returns pending_init with NO agent_id, but artifact_status exposes
+          // the build's agent_id (the artifact system's durable build
+          // identifier, stable across polls) immediately after acceptance.
+          // So the recovery no longer asks the child to derive booleans —
+          // the layer where the 2026-09-12 signal was lost. It reads the RAW
+          // build object and extracts build.agent_id mechanically in the
+          // workflow script. An observed agent_id is positive evidence the
+          // edit went through; no build after a bounded poll is still
+          // inconclusive (unknown), never proof the edit failed. Mechanical
+          // rule: never blind-retry on unknown — record the attempt and park
+          // fail-closed; correlate via the ledger, never by re-issuing.
+          log("Publish rebuild trigger: structured-output failure (" + (rebuildErr && rebuildErr.message ? rebuildErr.message : rebuildErr) + ") — checking build state before deciding; outcome unknown until state confirms it");
+          var buildState = null;
+          var buildStateFailed = false;
+          try {
+            buildState = await agent(
+              ARTIFACT_LOAD_PREAMBLE +
+              "Call artifact_status with slug \"" + PUBLISH_SLUG + "\".\n" +
+              "Poll up to 3 times, about 20 seconds apart, until the response shows a build (the \"build\" value is an object, not null). " +
+              "Return the raw \"build\" value verbatim as JSON — the build object exactly as returned, with its agent_id, operation, status, and any other fields untouched. " +
+              "Do not summarize, interpret, or derive booleans from it. " +
+              "If no build appears after 3 polls, return null. " +
+              "Return JSON { \"build\": <the raw build object or null> } and nothing else.",
+              { key: attemptKey("publish-artifact-buildcheck-" + taskId, reworkCount), label: "Reading artifact build state after trigger failure",
+                schema: { type: "object", properties: { build: { type: ["object", "null"] } }, required: ["build"] } }
+            );
+          } catch (buildCheckErr) {
+            buildStateFailed = true;
+            log("Publish rebuild trigger: build-state check itself failed (" + (buildCheckErr && buildCheckErr.message ? buildCheckErr.message : buildCheckErr) + ") — treating the outcome as unknown");
+          }
+          var acceptedAgentId = (buildState && buildState.build && typeof buildState.build.agent_id === "string" && buildState.build.agent_id) || null;
+          if (!buildStateFailed && acceptedAgentId) {
+            // The edit went through — the agent just failed to return JSON.
+            // The build's agent_id is positive evidence: it appears in
+            // artifact_status immediately after our accepted edit (pending_init
+            // acceptance is followed by a visible build with a stable agent_id,
+            // per the 2026-09-12 research). No applied report to smoke-check;
+            // the parent's independent read-back (docs/publish-verification.md)
+            // is the real verification, not the circular applied-report. The
+            // agent_id is recorded in the ledger so this attempt correlates to
+            // the exact builder run, not just commit + attempt key.
+            log("Publish rebuild trigger: artifact_status shows build " + acceptedAgentId + " for slug " + PUBLISH_SLUG + " — the edit went through despite the structured-output failure. Skipping applied-report smoke-check; parent read-back is the verification.");
+            rebuildTrigger = { edit_started: true, error: "", applied: null };
+            rebuildReportMissing = true;
+            rebuildAgentId = acceptedAgentId;
+          } else {
+            // No build observed — but that proves nothing (a fast-completing
+            // build can finish between polls, or the check itself failed). The
+            // outcome is UNKNOWN. No retry: re-issuing the edit here duplicated
+            // it on 2026-09-12. Record the attempt durably and park fail-closed;
+            // correlate via the ledger, never by guessing from a blind poll.
+            log("Publish rebuild trigger: no build observed after structured-output failure — outcome UNKNOWN. Recording the attempt and parking fail-closed; no blind retry.");
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: null,
+              outcome: "unknown",
+              detail: "structured-output failure on rebuild trigger; build-state poll saw no build (or the check itself failed); edit may have been accepted as pending_init"
+            }, reworkCount);
+            return await parkTask("Publish outcome unknown: the rebuild trigger's child did not return JSON, and the follow-up build-state poll could not observe a build for slug " + PUBLISH_SLUG + ". The edit may have been accepted as pending_init, so no retry was issued — a blind retry duplicated the edit on 2026-09-12. The attempt is recorded in the publish ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl (commit " + String(mergeCommitForPublish || "unknown").slice(0, 12) + "). Correlate the accepted edit via the ledger and the builder's eventual completion before re-driving Publish. Fail-closed.");
+          }
+        }
+        if (!rebuildReportMissing && !rebuildTrigger.edit_started && rebuildTrigger.error === "artifact_tools missing after load") {
+          log("Publish rebuild trigger: artifact_tools missing after load — 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 });
+            { key: attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", reworkCount), label: "Triggering artifact rebuild (retry)", schema: rebuildSchema });
+          rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", reworkCount);
+        }
+        // Durable publish-attempt ledger: record the trigger outcome while the
+        // attempt key and commit are in scope. Every attempt lands here with
+        // its outcome — submitted, rejected, or unknown (unknown is recorded
+        // at the park site above). A later run or human matches commit hash +
+        // attempt key against the builder's eventual completion.
+        if (rebuildTrigger && rebuildTrigger.edit_started) {
+          // Applied-report observation (2026-09-12, task 23ca8f3f): the
+          // builder's applied-report is logged as observation only — it
+          // never parks. The report is derived from the carried diff, so a
+          // "match" certifies nothing (canary run 8); and it has a
+          // demonstrated false-negative mode (applied:[] for a diff the
+          // builder had actually applied). The independent read-back below
+          // plus the parent protocol (docs/publish-verification.md) are the
+          // verification — this block always proceeds to them.
+          publishAppliedObservation = rebuildReportMissing
+            ? "missing-report"
+            : (function () { var c = verifyAppliedChanges(expectedChanges, rebuildTrigger.applied); return c.ok ? "match" : "mismatch: " + c.reason; })();
+          log("Publish applied-report observation for task " + taskId + ": " + publishAppliedObservation + " — observation only, never a park: the applied report is derived from the carried diff and proved unreliable in the false-negative direction (task 23ca8f3f, 2026-09-12: applied:[] for a diff the builder had applied). The independent read-back below plus the parent protocol are the verification.");
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: rebuildAgentId,
+            applied_report: publishAppliedObservation,
+            outcome: "submitted",
+            detail: rebuildReportMissing
+              ? "edit confirmed via build-state poll after structured-output failure (build " + (rebuildAgentId || "agent_id unknown") + "); builder applied-report missing"
+              : "edit accepted; builder applied-report received"
+          }, reworkCount);
+        } else if (rebuildTrigger) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            applied_report: null,
+            outcome: "rejected",
+            detail: "edit not accepted: " + (rebuildTrigger.error || "no error detail")
+          }, reworkCount);
         }
         var publishFailure = null;
         if (rebuildTrigger.edit_started) {
+          // STEP 1b (observation only): publishAppliedObservation was
+          // computed and logged above, inside the ledger block — the
+          // builder's applied-report never parks and never blocks the stamp.
+          // Task 23ca8f3f (2026-09-12) proved its false-negative mode:
+          // applied:[] for a diff the builder had actually applied, which
+          // parked a successful publish as unverified. A "match" certifies
+          // nothing either — the report is derived from the carried diff
+          // (canary run 8). The flow proceeds to the build poll and the
+          // independent read-back trigger regardless of what the report
+          // claimed; real verification is the parent's read-back
+          // (docs/publish-verification.md) before the provenance stamp.
+          // Pre-publish base observation (diagnostic, 2026-09-12): compare
+          // the builder's self-reported pre-edit hashes against the
+          // workflow-computed expected base (merge parent). This tells us
+          // what base state the publish actually read. OBSERVATION ONLY —
+          // a mismatch is logged loudly but never parks and never blocks
+          // the stamp. If the tree was dirty or drifted, the evidence is
+          // here; the fix (requiring the right base) comes after we see it.
+          try {
+            var preHashes = (rebuildTrigger && rebuildTrigger.pre_hashes) || {};
+            var baseLines = expectedChanges.map(function(f) {
+              var expected = expectedBaseHashes[f.path];
+              var actual = preHashes[f.path];
+              var expShort = (expected || "UNKNOWN").slice(0, 12);
+              var actShort = String(actual || "NOT-REPORTED").slice(0, 12);
+              var match = (expected !== undefined && actual !== undefined) ? (expected === actual) : "unknown";
+              return "  " + f.path + ": expected_base=" + expShort + " builder_pre=" + actShort + " match=" + match;
+            });
+            var anyMismatch = expectedChanges.some(function(f) {
+              return expectedBaseHashes[f.path] !== undefined && preHashes[f.path] !== undefined && expectedBaseHashes[f.path] !== preHashes[f.path];
+            });
+            log("Publish pre-tree base observation for task " + taskId + (anyMismatch ? " — BASE MISMATCH DETECTED (tree was not at the expected merge-parent state when the diff was applied):" : " — base matches expected merge-parent state:") + "\n" + baseLines.join("\n"));
+          } catch (e) {
+            log("Publish pre-tree base observation failed for task " + taskId + " (non-fatal): " + (e && e.message ? e.message : e));
+          }
           // STEP 1b (mechanical): bounded poll for build completion, chunked so
           // the merge-lock lease is refreshed before it can expire. The 600s
           // lease is shorter than the worst-case 10-minute build poll, so the
@@ -978,7 +1665,7 @@ while (i < STEPS.length) {
               ? attemptKey("publish-artifact-poll-" + taskId, reworkCount)
               : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, reworkCount);
             buildPoll = await agent(
-              "Poll artifact_status for slug \"" + PUBLISH_SLUG + "\" until no build is running. Check every 30 seconds, up to 7 checks (3.5 minutes max).\n" +
+              "First call tool_search.load_tool_namespace with paths [\"artifact\"]. Then poll artifact_status for slug \"" + PUBLISH_SLUG + "\" until no build is running. Check every 30 seconds, up to 7 checks (3.5 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: pollKey, label: "Waiting for artifact build to complete (chunk " + chunk + " of 3)",
                 schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" } }, required: ["build_done"] },
@@ -990,22 +1677,20 @@ while (i < STEPS.length) {
             buildPoll = { build_done: false, status: (buildPoll && buildPoll.status) || "build still running after the 10.5-minute bounded poll" };
           }
           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.";
-            }
+            // STEP 1c (mechanical): NO provenance stamp here. Canary run 8
+            // (2026-09-11) proved the stamp cannot certify content: the
+            // builder's applied-report is derived from the carried diff, so
+            // verifyAppliedChanges above is circular — a fabricated report
+            // passes by construction, and every phase went green on a hollow
+            // build. The stamp moves to the parent (docs/publish-verification.md):
+            // after an independent artifact_inspect read-back confirms the
+            // artifact's actual content matches the merged diff, the parent
+            // stamps provenance and re-queues; QA's provenance check then
+            // enforces the stamp mechanically, so an unverified publish fails
+            // loudly in QA instead of passing silently here.
+            publishBuildLanded = true;
+            artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
+            log("Publish build landed for task " + taskId + " — provenance stamp deferred to parent content verification");
           } else {
             publishFailure = "Artifact build did not complete within budget: " + (buildPoll.status || "timeout") + ". The publish may or may not have landed — provenance was not stamped.";
           }
@@ -1036,9 +1721,9 @@ while (i < STEPS.length) {
               : " 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.");
+            return await parkTask("Post-deploy failed after the artifact build landed: " + (postDeploy.output || "no output") + ". The build may have 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);
+          log("Deterministic artifact publish completed for task " + taskId + ": build at " + artifactPublish.source_commit + ", provenance PENDING parent content verification");
         }
       } catch (pubErr) {
         // Best-effort cleanup: if the lock was refreshed, try to release it
@@ -1048,8 +1733,7 @@ while (i < STEPS.length) {
             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"] } }
+              { key: attemptKey("publish-postdeploy-cleanup-" + taskId, reworkCount), label: "Releasing lock after publish failure" }
             );
           } catch (cleanupErr) {
             log("Publish cleanup post-deploy also failed: " + (cleanupErr && cleanupErr.message ? cleanupErr.message : cleanupErr));
@@ -1069,10 +1753,10 @@ while (i < STEPS.length) {
       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" +
+        "Mechanical outcome (the workflow's mechanical steps; content verification is the parent's, still pending):\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" +
+        "- provenance stamped: NO — not yet, and you must NOT stamp it. The stamp moved to the parent, which stamps it only after an independent content read-back confirms the artifact actually contains the merged change (docs/publish-verification.md). A stamped-but-hollow build is exactly how canary run 8 (2026-09-11) went green on stale content.\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" +
@@ -1094,7 +1778,7 @@ while (i < STEPS.length) {
   var eventPreamble = "";
   if (step.name !== "Review" && step.name !== "Publish") {
     eventPreamble = "CONTEXT: First, fetch this task's event history for background.\n" +
-      "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getevents\", args: { \"task_id\": \"" + taskId + "\" }.\n" +
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("get-events", { task_id: taskId }) + "\n" +
       "The returned events are filtered to this task. They contain notes and decisions from prior phases.\n\n";
   }
 
@@ -1105,10 +1789,11 @@ while (i < STEPS.length) {
   // string. The verdict is still extracted deterministically from the report
   // text by extractVerdict below — never by an agent.
   var workPromptBase =
+    TOOL_CHECK_PREAMBLE +
     "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" : "") +
+    (step.name !== "Review" ? "Crew API: " + CREW_API + "\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.\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.";
@@ -1117,7 +1802,8 @@ while (i < STEPS.length) {
   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");
+    var prevAttempt = workAttempt === 0 ? null : workAttempts[workAttempt - 1];
+    var retryReason = workAttempt === 0 ? null : (prevAttempt.threw ? "discarded" : (prevAttempt.outcome === "missing-artifact-tools" ? "no-tools" : (prevAttempt.outcome === "unavailable-shell-transport" ? "no-transport" : "empty")));
     try {
       workerResult = await agent(
         workPromptBase + (workAttempt === 0 ? "" : buildTransportRetryTrailer(step.name, REPO_PATH, taskId, workAttempt, retryReason)),
@@ -1132,6 +1818,22 @@ while (i < STEPS.length) {
       // always fails (regression shipped in ecef136 when Date.now() was
       // removed from this loop).
       if (typeof workerResult === "string" && workerResult.trim()) {
+        // Bug 3472bf36: a worker whose TOOL CHECK reports artifact_tools: missing
+        // (or shell_transport: unavailable) gets a fresh launch - the load is
+        // per-launch - instead of a useless report.
+        var toolSignals = parseToolSignals(workerResult);
+        if (toolSignals.artifactTools === "missing") {
+          workAttempts.push({ threw: false, error: "", outcome: "missing-artifact-tools" });
+          log(step.name + " work agent attempt " + (workAttempt + 1) + " of 3 reported artifact_tools: missing — retrying with a fresh launch");
+          workerResult = null;
+          continue;
+        }
+        if (toolSignals.shellTransport === "unavailable") {
+          workAttempts.push({ threw: false, error: "", outcome: "unavailable-shell-transport" });
+          log(step.name + " work agent attempt " + (workAttempt + 1) + " of 3 reported shell_transport: unavailable — retrying with a fresh launch");
+          workerResult = null;
+          continue;
+        }
         if (workAttempt > 0) log(step.name + " work agent transport retry " + workAttempt + " returned a machine-readable report");
         break;
       }
@@ -1154,11 +1856,12 @@ while (i < STEPS.length) {
     log(step.name + " " + workFailure.notes + " — marking failed for retry");
     await agent(
       "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\": \"failed\", \"notes\": \"" + workFailure.notes + "\" }.\n" +
-      "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
-      "{ \"task_id\": \"" + taskId + "\", \"type\": \"failed\", \"message\": \"" + workFailure.eventMessage + "\" }.",
-      { key: "record-block-" + step.name, label: "Recording work failure", schema: { type: "object" } }
+      "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+        task_id: taskId,
+        session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed", notes: workFailure.notes },
+        event: { task_id: taskId, type: "failed", message: workFailure.eventMessage }
+      }) + "\n",
+      { key: "record-block-" + step.name, label: "Recording work failure" }
     );
     return {
       __hatchWorkflowControl: "blocked",
@@ -1192,11 +1895,12 @@ while (i < STEPS.length) {
       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" } }
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed", notes: "Worker report had no single unambiguous VERDICT: PASS/FAIL line (bounded re-ask exhausted)" },
+          event: { task_id: taskId, type: "failed", message: step.name + " verdict line missing or ambiguous, re-ask exhausted — phase failed, dispatcher will retry" }
+        }) + "\n",
+        { key: "record-block-" + step.name, label: "Recording verdict failure" }
       );
       return {
         __hatchWorkflowControl: "blocked",
@@ -1210,6 +1914,37 @@ while (i < STEPS.length) {
     verdictPassed = verdict.passed;
   }
 
+
+  // Worktree confinement (Build only): the declared worktree path must
+  // match WORKTREE_HINT exactly. A builder that worked in any other
+  // checkout fails the phase here — the dispatcher retries Build under
+  // its consecutive-failure cap, and the retry re-runs prepare against
+  // the configured repo. Missing or mismatched lines fail closed.
+  if (step.name === "Build" && verdictPassed === true) {
+    var wt = extractWorktree(workerText);
+    if (!wt.ok || wt.path !== WORKTREE_HINT) {
+      log("Build worktree confinement failed — declared: " + (wt.ok ? wt.path : "<none>") + ", expected: " + WORKTREE_HINT + " — marking failed for retry");
+      await agent(
+        "Record worktree confinement failure.\n" +
+        "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+          task_id: taskId,
+          session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: "failed", notes: "Build declared worktree " + (wt.ok ? wt.path : "<none>") + " — expected " + WORKTREE_HINT + ". The builder worked outside the configured repo checkout; phase failed for retry" },
+          event: { task_id: taskId, type: "failed", message: "Build worktree confinement failed — builder worked outside " + WORKTREE_HINT + ", phase failed, dispatcher will retry" }
+        }) + "\n",
+        { key: "record-worktree-fail-" + step.name, label: "Recording worktree confinement failure" }
+      );
+      return {
+        __hatchWorkflowControl: "blocked",
+        result: {
+          blocked_reason: "Build worked outside the configured repo checkout",
+          message: "The builder declared worktree " + (wt.ok ? wt.path : "<none>") + " but the task's worktree is " + WORKTREE_HINT + ". The phase is marked failed; the dispatcher will retry Build against the configured repo.",
+          task_id: taskId
+        }
+      };
+    }
+    log("Build worktree confinement passed: " + wt.path);
+  }
+
   // 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
@@ -1303,13 +2038,13 @@ while (i < STEPS.length) {
       // dashboard QA source check).
       try {
         var provRefresh = await agent(
-          "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"getprovenance\", args: {}. " +
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("get-provenance", {}) + "\n" +
           "If the response has no provenance (null), return JSON { \"refreshed\": false, \"reason\": \"no-record\" } and stop. " +
           "Otherwise run: basename $(readlink " + crewHome + "/current) — call this REL; " +
           "run: date -u +%Y-%m-%dT%H:%M:%SZ — call this TS. " +
-          "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"setprovenance\", args: " +
-          "{ \"source_commit\": \"<existing provenance.source_commit>\", \"crew_release\": \"<REL trimmed>\", \"published_at\": \"<TS trimmed>\", \"task_id\": \"" + taskId + "\" }. " +
-          "Return JSON { \"refreshed\": <true if the setprovenance response contains ok: true, false otherwise>, \"crew_release\": \"<REL trimmed>\", \"published_at\": \"<TS trimmed>\" } and nothing else.",
+          "Then run in shell:\n" + crewCmd("set-provenance", { source_commit: "<existing provenance.source_commit>", crew_release: "<REL trimmed>", published_at: "<TS trimmed>", task_id: taskId }) + "\n" +
+          "(substitute the real existing source_commit, REL, and TS for the placeholders). " +
+          "Return JSON { \"refreshed\": <true if the set-provenance stdout contains ok: true, false otherwise>, \"crew_release\": \"<REL trimmed>\", \"published_at\": \"<TS trimmed>\" } and nothing else.",
           { key: attemptKey("publish-provenance-refresh-" + taskId, reworkCount), label: "Refreshing dashboard provenance after crew release",
             schema: { type: "object", properties: { refreshed: { type: "boolean" }, reason: { type: "string" }, crew_release: { type: "string" }, published_at: { type: "string" } }, required: ["refreshed"] } }
         );
@@ -1330,43 +2065,51 @@ while (i < STEPS.length) {
     } // end: !npmPublishSkipped — a skipped publish has nothing to verify
   }
 
-  // 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.
+  // Publish content verification — parent-owned (docs/publish-verification.md).
+  // The old block read back the workflow's OWN provenance stamp and compared
+  // it to HEAD: that verifies the stamp, not the content. Canary run 8
+  // (2026-09-11) passed it with a hollow build — the stamp was honest, the
+  // artifact was stale, all eight phases green. The stamp now moves to the
+  // parent: trigger an independent artifact_inspect read-back of the changed
+  // regions here; the parent stamps provenance only after mechanically
+  // confirming the artifact's actual content matches the merged diff. QA's
+  // provenance check enforces the stamp — an unverified publish fails loudly
+  // there instead of passing silently here.
+  // Skip-aware (park 2026-09-11): an empty-diff Integrate takes no merge
+  // lock, and the deterministic publish path skips rebuild/stamp entirely —
+  // there is no new content to verify, so verification is vacuous.
+  // publishSkippedNoLock is workflow-computed state from the explicit
+  // lock-status read in STEP 0, not agent prose.
+  var publishVerifyInspect = { triggered: false, inspection_id: "", error: "" };
   if (step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG) {
-    // Skip-aware (park 2026-09-11): an empty-diff Integrate takes no merge
-    // lock, and the deterministic publish path skips rebuild/stamp entirely —
-    // there is no new provenance to compare against HEAD, so verification is
-    // vacuous. publishSkippedNoLock is workflow-computed state from the
-    // explicit lock-status read in STEP 0, not agent prose.
     if (publishSkippedNoLock) {
-      log("Publish skipped for task " + taskId + " (no merge lock held — empty-diff Integrate): artifact verification vacuous, nothing was shipped");
+      log("Publish skipped for task " + taskId + " (no merge lock held — empty-diff Integrate): content verification vacuous, nothing was shipped");
+    } else if (!publishBuildLanded) {
+      log("Publish build did not land for task " + taskId + " — no content to verify (the failure park above already fired)");
     } else {
     try {
-      var 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 inspectResult = await agent(
+        ARTIFACT_LOAD_PREAMBLE +
+        "Call artifact_inspect with slug \"" + PUBLISH_SLUG + "\", repair_authorized false, and verbatim_request exactly as follows:\n" +
+        "<<<READBACK_REQUEST\n" + buildPublishReadbackRequest(taskId, mergeCommitForPublish, mergeDiff, rebuildAgentId) + "\nREADBACK_REQUEST\n" +
+        "If artifact_inspect is still not available after the load, do NOT improvise — return { \"triggered\": false, \"inspection_id\": \"\", \"error\": \"artifact_tools missing after load\" } and nothing else.\n" +
+        "Return JSON { \"triggered\": <true if the inspection started, false otherwise>, \"inspection_id\": \"<the inspection id, or empty string>\", \"error\": \"<details or empty string>\" } and nothing else.",
+        { key: attemptKey("publish-verify-inspect-" + taskId, reworkCount), label: "Triggering publish content read-back",
+          schema: { type: "object", properties: { triggered: { type: "boolean" }, inspection_id: { type: "string" }, error: { type: "string" } }, required: ["triggered"] } }
       );
-      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.");
+      publishVerifyInspect.triggered = !!(inspectResult && inspectResult.triggered);
+      publishVerifyInspect.inspection_id = (inspectResult && inspectResult.inspection_id) || "";
+      publishVerifyInspect.error = (inspectResult && inspectResult.error) || "";
+      if (publishVerifyInspect.triggered) {
+        log("Publish content read-back inspection triggered for task " + taskId + ": " + publishVerifyInspect.inspection_id);
+      } else {
+        log("Publish content read-back inspect trigger failed for task " + taskId + ": " + (publishVerifyInspect.error || "not started") + " — the park below asks the parent to trigger it manually");
       }
-      log("Publish verified for task " + taskId + ": artifact provenance at " + provCommit);
-      publishVerified = true;
     } catch (e) {
-      return await parkTask("Publish verification failed: could not read artifact provenance (" + (e && e.message ? e.message : e) + "). Fail-closed.");
+      publishVerifyInspect.error = (e && e.message ? e.message : String(e)).slice(0, 200);
+      log("Publish content read-back inspect trigger threw for task " + taskId + ": " + publishVerifyInspect.error + " — the park below asks the parent to trigger it manually");
     }
-    } // end: !publishSkippedNoLock — a skipped publish has nothing to verify
+    } // end: !publishSkippedNoLock && publishBuildLanded — a skipped or failed publish has nothing to verify
   }
 
   // Session notes. Machine-readable marker lines are extracted from the full
@@ -1408,14 +2151,14 @@ while (i < STEPS.length) {
 
   await agent(
     "Update session and log 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\": \"" + status + "\", \"notes\": " + JSON.stringify(summary) + " }.\n" +
-    "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 + "\" }.",
+    "Run in shell and return the stdout verbatim:\n" + crewCmd("record-phase", {
+      task_id: taskId,
+      session: { id: activeSessionId, task_id: taskId, identity: step.identity, step: step.name, status: status, notes: summary },
+      event: { task_id: taskId, type: status, identity: step.identity, message: step.name + " " + status + " by " + step.identity }
+    }) + "\n",
     {
       key: "record-" + step.name + (reworkCount > 0 ? "-r" + reworkCount : "") + (mapGateBounceCount > 0 ? "-g" + mapGateBounceCount : ""),
-      label: "Recording " + step.name + " result",
-      schema: { type: "object" }
+      label: "Recording " + step.name + " result"
     }
   );
 
@@ -1441,17 +2184,33 @@ while (i < STEPS.length) {
     return { status: "failed", task_id: taskId, reason: "Publish failed: " + summary };
   }
 
+  // Publish verification park: the build landed and post-deploy finalized,
+  // but provenance is UNSTAMPED until the parent's independent read-back
+  // (docs/publish-verification.md) confirms the artifact's actual content
+  // matches the merged diff. The parent stamps provenance, then re-queues;
+  // the dispatcher resumes at QA, whose provenance check enforces the stamp
+  // mechanically. A failed Publish never reaches this park — it returned
+  // failed above and retries under the dispatcher's cap. The merge lock is
+  // already released (post-deploy), so the parked task holds no resources.
+  if (passed && step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG && !publishSkippedNoLock && publishBuildLanded) {
+    return await parkTask("publish: verification-requested " + mergeCommitForPublish +
+      " (build " + (rebuildAgentId || "agent_id unobserved") + ")" +
+      " — artifact build landed, post-deploy finalized, provenance NOT stamped. Parent: run docs/publish-verification.md" +
+      (publishVerifyInspect.triggered
+        ? " (content read-back inspection " + publishVerifyInspect.inspection_id + " already triggered)."
+        : " (read-back inspect trigger failed: " + (publishVerifyInspect.error || "not started") + " — parent: trigger artifact_inspect manually)."));
+  }
+
   i++;
 }
 
 await agent(
   "Mark this task as done.\n" +
-  "Call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"updatetask\", args: { \"id\": \"" + taskId + "\", \"state\": \"done\" }.\n" +
-  "Then call artifact_invoke_action on slug \"" + DASHBOARD_SLUG + "\", action \"logevent\", args:\n" +
-  "{ \"task_id\": \"" + taskId + "\", \"type\": \"completed\", \"message\": \"All chore workflow steps complete.\" }.",
-  { key: "task-done", label: "Completing task: " + taskTitle, schema: { type: "object" } }
+  "Run in shell and return the stdout verbatim:\n" + crewCmd("update-task", { id: taskId, state: "done" }) + "\n" +
+  "Then run in shell and return the stdout verbatim:\n" + crewCmd("log-event", { task_id: taskId, type: "completed", message: "All chore workflow steps complete." }),
+  { key: "task-done", label: "Completing task: " + taskTitle }
 );
 
 log("Chore workflow complete for task " + taskId);
-await agent("Clean up pinned lifecycle scripts: rm -rf " + RUN_LIB, { key: "cleanup-pins", label: "Cleaning pinned scripts", schema: { type: "object" } });
+await agent("Clean up pinned lifecycle scripts: rm -rf " + RUN_LIB, { key: "cleanup-pins", label: "Cleaning pinned scripts" });
 return { status: "ok", task_id: taskId, message: "Chore workflow complete for " + taskTitle };