muse-crew 0.14.4 → 0.14.6

package/workflows/bugfix.js

@@ -237,14 +237,6 @@ var TOOL_CHECK_PREAMBLE =
   "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), "empty" (agent() returned without throwing but produced
@@ -392,10 +384,10 @@ function hydrateReleaseDecision(rec) {
 }
 
 // See docs/decisions/publish-path.md#publish-attempt-ledger: every trigger outcome is recorded in the durable ledger.
-// keyTag (optional): same-outcome ledger writes in one pass need distinct
-// agent-call keys — the runtime replays cached calls by key, so a shared key
-// silently drops the second write (2026-09-19, submitted-on-issuance).
-async function recordPublishLedger(entry, rework, keyTag) {
+// (2026-09-20, one-party worker-owned publish) No keyTag: every ledger
+// write in a Publish pass is followed by a return, so no pass can write two
+// same-outcome entries — the runtime replay key can never collide in-pass.
+async function recordPublishLedger(entry, rework) {
   try {
     var ledgerDir = crewHome + "/.publish-ledger";
     var line = JSON.stringify({
@@ -413,6 +405,20 @@ async function recordPublishLedger(entry, rework, keyTag) {
       // D1 (2026-09-19): issued_at = upper bound on the trigger-issuance
       // instant (null when no trigger); ts = ledger-write instant.
       issued_at: entry.issued_at || null,
+      // (2026-09-20, one-party worker-owned publish) issuer = which party
+      // wrote the entry ("workflow" for the intent entry, "tick-worker" for
+      // the worker's own issuance); diff_path/diff_sha256 locate the
+      // checksummed diff the worker issues. The workflow never writes an
+      // issuance ("submitted") entry — it did not issue.
+      issuer: entry.issuer || null,
+      diff_path: entry.diff_path || null,
+      diff_sha256: entry.diff_sha256 || null,
+      base: entry.base || null,
+      // (0.14.6) Numeric publication attempt + the attempt's deterministic
+      // version. Attempt 1 is staged here by the workflow; attempts 2-3 are
+      // staged by scan-ack-pending's re-issue path with fresh versions.
+      publish_attempt: entry.publish_attempt || null,
+      version: entry.version || null,
     });
     var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
     var res = await agent(
@@ -420,13 +426,19 @@ async function recordPublishLedger(entry, rework, keyTag) {
       "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 + (keyTag ? "-" + keyTag : ""), rework),
+      { key: attemptKey("publish-ledger-" + taskId + "-" + entry.outcome, rework),
         label: "Recording publish attempt in ledger",
         schema: { type: "object", properties: { result: { type: "string" } }, required: ["result"] } }
     );
-    log("Noted publish outcome '" + entry.outcome + "' for task " + taskId + " in ledger");
+    // (2026-09-20 REVIEW) The intent entry is the machine's anchor — the
+    // caller gates on this return. LEDGER_OK in the agent's verbatim output
+    // is the only mechanical proof the line landed.
+    var ok = res && typeof res.result === "string" && res.result.indexOf("LEDGER_OK") !== -1;
+    log("Noted publish outcome '" + entry.outcome + "' for task " + taskId + " in ledger" + (ok ? "" : " (WRITE UNCONFIRMED)"));
+    return ok;
   } catch (e) {
     log("Publish ledger: write failed for task " + taskId + " (non-fatal, observability only): " + (e && e.message ? e.message : e));
+    return false;
   }
 }
 
@@ -452,11 +464,6 @@ function extractAlreadyMerged(workerText) {
   return m ? { sha: m[1].toLowerCase() } : { sha: null };
 }
 
-// See docs/decisions/publish-path.md#refusal-signal: the refusal signal must be the ENTIRE trimmed turn output.
-function extractRefusal(workerText) {
-  var m = /^ARTIFACT_EDIT_REFUSED:\s*(.+?)\s*$/.exec(String(workerText || "").trim());
-  return m ? m[1].slice(0, 300) : null;
-}
 
 // See docs/decisions/qa-reproduce.md#worktree-confinement: the Build agent must declare its worktree.
 function extractWorktree(workerText) {
@@ -1319,10 +1326,41 @@ while (i < STEPS.length) {
         "VERDICT: PASS\n\n";
         } else if (PUBLISH_TYPE === "artifact") {
       // See docs/decisions/publish-path.md#deterministic-artifact-publish: the work agent never publishes; the parent runs the deterministic publish script.
-      var artifactPublish = null;
+      // Blocker 22 (one-party publish, room #24): verified re-entry guard.
+      // The workflow parks at publish intent; the tick worker issues
+      // artifact_edit, verifies by read-back, stamps provenance, and
+      // re-queues. The dispatcher resumes this task at the Publish step
+      // (the parked session's own step — the failed→retry path). If the
+      // stamped provenance names THIS task and its source_commit is the
+      // repo's current HEAD, the merge commit was already published and
+      // verified by the parent: issuance is skipped entirely (the
+      // empty-diff park below must NOT fire on this branch) and the
+      // Publish work agent runs with the verified framing instead. A guard
+      // failure never claims verification — it proceeds down the normal path.
+      var publishAlreadyVerified = false;
+      try {
+        var reentryCheck = await agent(
+          "Run in shell and return the stdout verbatim:\n" + crewCmd("get-provenance", { project_id: LAUNCH_PROJECT_ID }) + "\n" +
+          "Then run in shell and return the stdout verbatim: cd " + REPO_PATH + " && git rev-parse HEAD\n" +
+          "Return JSON { \"source_commit\": \"<provenance.source_commit, empty string when null>\", \"stamp_task_id\": \"<provenance.task_id, empty string when null>\", \"head\": \"<the rev-parse output, trimmed>\" } and nothing else.",
+          { key: attemptKey("publish-reentry-guard-" + taskId, totalReworkCount), label: "Checking for a verified publish re-entry",
+            schema: { type: "object", properties: { source_commit: { type: "string" }, stamp_task_id: { type: "string" }, head: { type: "string" } }, required: ["source_commit", "stamp_task_id", "head"] } }
+        );
+        var reentrySC = String((reentryCheck && reentryCheck.source_commit) || "").trim();
+        var reentryTID = String((reentryCheck && reentryCheck.stamp_task_id) || "").trim();
+        var reentryHEAD = String((reentryCheck && reentryCheck.head) || "").trim();
+        if (reentrySC && reentryHEAD && reentrySC === reentryHEAD && reentryTID === taskId) {
+          publishAlreadyVerified = true;
+          log("Publish verified re-entry for task " + taskId + ": provenance stamps " + reentrySC + " == HEAD for this task — the parent already published and verified it; issuance skipped");
+        }
+      } catch (reentryErr) {
+        log("Publish re-entry guard threw for task " + taskId + " (" + (reentryErr && reentryErr.message ? reentryErr.message : reentryErr) + ") — proceeding with the normal publish path; a guard failure never claims verification");
+      }
+      // publishAlreadyVerified is consumed by the intent-tail edit (next
+      // chunk): on the verified branch the workflow skips to the Publish
+      // work agent with the verified framing and proceeds to QA.
       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)
@@ -1346,7 +1384,11 @@ while (i < STEPS.length) {
           publishLockRefreshed = true;
         }
         // See docs/decisions/publish-path.md#step1-builder-source: the builder's source tree is NOT the crew's repo; verify report before stamping.
-        if (!publishSkippedNoLock) {
+        // (2026-09-20, one-party worker-owned publish) A verified re-entry
+        // skips the whole issuance tail: the edit already went out, was
+        // verified by the parent read-back, and was stamped. The empty-diff
+        // park must not fire on this branch.
+        if (!publishSkippedNoLock && !publishAlreadyVerified) {
         // 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
@@ -1446,7 +1488,7 @@ while (i < STEPS.length) {
         var publishDiffFile = crewHome + "/.publish-diffs/" + taskId + (totalReworkCount > 0 ? "-r" + totalReworkCount : "") + ".diff";
         var diffResult = await agent(
           "Run exactly one command and nothing else:\n" +
-          "node " + COMPUTE_DIFF + " --repo-path \"" + REPO_PATH + "\" --base " + publishBase + " --out \"" + publishDiffFile + "\"\n" +
+          "node " + COMPUTE_DIFF + " --repo-path \"" + REPO_PATH + "\" --base " + publishBase + " --task-id \"" + taskId + "\" --attempt 1 --out \"" + publishDiffFile + "\"\n" +
           "The script prints one small JSON object to stdout. Return the stdout verbatim as { \"output\": \"<verbatim stdout>\" } and nothing else. Do not interpret it.",
           { key: attemptKey("publish-artifact-diff-" + taskId, totalReworkCount), label: "Computing publish diff from stamped base",
             schema: { type: "object", properties: { output: { type: "string" } }, required: ["output"] } }
@@ -1469,6 +1511,18 @@ while (i < STEPS.length) {
         var mergeCommitForPublish = String(diffSummary.commit || "").trim();
         var mergeCommitShortForPublish = String(mergeCommitForPublish).substring(0, 7) || "unknown";
         var publishDiffSha256 = String(diffSummary.sha256 || "");
+        // (0.14.6) The per-attempt publish version, synthesized into the
+        // staged diff as .crew-publish-version-<task_id> (per-task receipt —
+        // two same-project tasks can publish concurrently) by the
+        // deterministic script.
+        // The workflow never invents it: the script derives it from
+        // task+commit+attempt, and the intent scan re-derives it before
+        // claiming. A missing/malformed version parks — never publish blind.
+        var publishVersion = String(diffSummary.version || "");
+        // Mirrors isPublishVersion() in lib/crew-api.js: <40-hex commit>:<attempt>.
+        if (!/^[0-9a-f]{40}:[1-9][0-9]*$/.test(publishVersion)) {
+          return await parkTask("Publish diff for commit " + (mergeCommitForPublish || "unknown") + " carries no usable publish version — cannot stage a verifiable intent. Human attention needed.");
+        }
         if (!diffSummary.bytes) {
           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.");
         }
@@ -1490,685 +1544,59 @@ while (i < STEPS.length) {
         if (!diffSummary.file_count) {
           return await parkTask("Publish diff parsed to zero files for commit " + (mergeCommitForPublish || "unknown") + " — cannot verify application. Human attention needed.");
         }
-        // The trigger agent reads the diff from the checksummed file — the
+        // The tick worker reads the diff from the checksummed file — the
         // workflow never holds diff bytes (room #14, 2026-09-17). The file
-        // is small by construction: the 200-line budget above gates the
-        // trigger. The sha256 check is the agent's only verification step;
-        // a mismatch stops the trigger before any artifact_edit call.
-        var rebuildPrompt =
-          ARTIFACT_LOAD_PREAMBLE +
-          "The change to apply is the unified diff in the file \"" + publishDiffFile + "\" (sha256 " + publishDiffSha256 + ").\n" +
-          "1. Verify the file: run sha256sum on it. If the printed hash is not exactly " + publishDiffSha256 + ", STOP and end your turn — do not call artifact_edit.\n" +
-          "2. Read the file's full content.\n" +
-          "3. Call artifact_edit with slug \"" + PUBLISH_SLUG + "\" and verbatim_request:\n" +
-          "'Apply the following change to your source tree, then rebuild and deploy.\n" +
-          "\n" +
-          "UNIFIED DIFF (relative to your source tree):\n" +
-          "```diff\n<the full content of the verified file, pasted verbatim>\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" +
-          "Edit-request contract (read carefully):\n" +
-          "- Call artifact_edit exactly once with the slug and verbatim_request above. Never retry the edit yourself: if the edit is not accepted, do NOT call artifact_edit again — end your turn.\n" +
-          "- If artifact_edit explicitly refuses the edit (the call is rejected — e.g. the artifact does not exist), do NOT call artifact_edit again: end your turn with exactly one line and nothing else: ARTIFACT_EDIT_REFUSED: <the refusal text, one line>.\n" +
-          "- If artifact_edit is not available after the load, do NOT improvise — end your turn.\n" +
-          "- You do NOT call setprovenance, artifact_inspect, or post-deploy yourself.\n" +
-          "No report is needed: do not return JSON, do not summarize what you did, do not echo the diff. End your turn after the artifact_edit call.\n";
-        // See docs/decisions/publish-path.md#agent-id-attribution: the artifact build's agent_id is attributed to the edit call.
-        var rebuildAgentId = null;
-        // See docs/decisions/publish-path.md#applied-report-gone: the builder's applied report is gone; the workflow verifies differently.
-        var publishAppliedObservation = "missing-report";
-        // See docs/decisions/publish-path.md#durable-evidence-snapshot: snapshot the audit-dir listing BEFORE the trigger; fallback diffs before/after.
-        var auditDirsBeforeTrigger = [];
-        var auditBeforeOk = false;
-        // Pre-trigger baselines (design §1.9): the audit-dir listing and the
-        // manifest snapshot. The verified-path freshness check compares the
-        // post-trigger manifest against the baseline (built_at advance +
-        // content_sha256 change). Best-effort, never gates — a missing
-        // manifest baseline fails the verified path closed.
-        var preTriggerManifest = null;
-        try {
-          var auditBefore = await agent(
-            "Capture pre-trigger baselines for slug \"" + PUBLISH_SLUG + "\" (best-effort snapshots, never gates).\n" +
-            "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null; echo ---MANIFEST---; cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/.space-build/manifest.json 2>/dev/null\n" +
-            "Return JSON { \"dirs\": \"<newline-separated names, empty string when missing>\", \"manifest\": \"<the manifest's full text, or empty string when missing/unreadable>\" } and nothing else.",
-            { key: attemptKey("publish-baseline-before-" + taskId, totalReworkCount), label: "Snapshotting baselines before rebuild trigger",
-              schema: { type: "object", properties: { dirs: { type: "string" }, manifest: { type: "string" } }, required: ["dirs", "manifest"] } }
-          );
-          auditDirsBeforeTrigger = String((auditBefore && auditBefore.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
-          var manifestText = String((auditBefore && auditBefore.manifest) || "").trim();
-          if (manifestText) {
-            var manifestJson = JSON.parse(manifestText);
-            preTriggerManifest = {
-              built_at: typeof manifestJson.built_at === "string" ? manifestJson.built_at : null,
-              content_sha256: typeof manifestJson.content_sha256 === "string" ? manifestJson.content_sha256 : null,
-            };
-          }
-          // Arm only after both baselines parse.
-          auditBeforeOk = true;
-          log("Publish pre-trigger baselines for task " + taskId + ": " + auditDirsBeforeTrigger.length + " audit dirs, manifest " + (preTriggerManifest ? "built_at=" + preTriggerManifest.built_at : "none"));
-        } catch (auditBeforeErr) {
-          log("Publish pre-trigger baselines failed for task " + taskId + " (non-fatal): audit fallback DISABLED for this attempt — without a baseline, historical dirs would look new: " + (auditBeforeErr && auditBeforeErr.message ? auditBeforeErr.message : auditBeforeErr));
-        }
-
-        // See docs/decisions/publish-path.md#fire-and-forget-trigger: the trigger child returns immediately; the workflow owns observation and verdict.
-        var publishToolsOk = false;
-        var publishToolsMissing = false;
-        for (var toolcheckAttempt = 1; toolcheckAttempt <= 2 && !publishToolsOk; toolcheckAttempt++) {
-          try {
-            var toolcheckResult = await agent(
-              "Check whether the artifact tool namespace is available.\n" +
-              "Call tool_search.load_tool_namespace with paths [\"artifact\"].\n" +
-              "Then emit exactly one line and nothing else: ARTIFACT_TOOLS: <ok if the load succeeded and artifact_edit and artifact_status are now functions, missing otherwise>.\n" +
-              "Return JSON { \"signal\": \"<the exact ARTIFACT_TOOLS line>\" } and nothing else.",
-              { key: attemptKey("publish-artifact-toolcheck-" + taskId + (toolcheckAttempt === 1 ? "" : "-retry2"), totalReworkCount),
-                label: "Checking artifact tool availability" + (toolcheckAttempt === 1 ? "" : " (retry)"),
-                schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] } }
-            );
-            var toolSignal = String((toolcheckResult && toolcheckResult.signal) || "");
-            if (/ARTIFACT_TOOLS:\s*ok/.test(toolSignal)) {
-              publishToolsOk = true;
-            } else if (/ARTIFACT_TOOLS:\s*missing/.test(toolSignal)) {
-              publishToolsMissing = true;
-            }
-            log("Publish artifact toolcheck for task " + taskId + " (attempt " + toolcheckAttempt + " of 2): " +
-              (publishToolsOk ? "tools ok" : publishToolsMissing ? "tools missing (explicit parsed signal)" : "inconclusive (no ARTIFACT_TOOLS signal parsed)"));
-          } catch (toolcheckErr) {
-            log("Publish artifact toolcheck for task " + taskId + " (attempt " + toolcheckAttempt + " of 2) threw (" + (toolcheckErr && toolcheckErr.message ? toolcheckErr.message : toolcheckErr) + ") — inconclusive: a throw proves nothing about tool availability, never counted as missing");
-          }
-        }
-        if (!publishToolsOk && !publishToolsMissing) {
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            agent_id: null,
-            applied_report: null,
-            outcome: "unknown",
-            detail: "artifact toolcheck inconclusive after two attempts (throws or unparseable signals — never an explicit ARTIFACT_TOOLS: missing): tool availability unproven, so the trigger was NOT issued; unknown parks fail closed with no blind retry"
-          }, totalReworkCount);
-          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact toolcheck was inconclusive after two attempts (no explicit ARTIFACT_TOOLS signal parsed — a throw is transport noise, not evidence). Tool availability is unproven, so no edit was issued and nothing was retried blindly. Human attention needed.");
-        }
-        if (!publishToolsOk) {
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            agent_id: null,
-            applied_report: null,
-            outcome: "rejected",
-            detail: "artifact tool namespace explicitly missing (parsed ARTIFACT_TOOLS: missing signal, one bounded retry spent): the edit provably did not go through — no trigger issued, no blind retry"
-          }, totalReworkCount);
-          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact tool namespace was explicitly missing (parsed signal — the edit provably did not go through, so no trigger was issued and nothing was retried blindly). Human attention needed.");
-        }
-        // See docs/decisions/publish-path.md#pretrigger-baseline: a tiny schema'd baseline is captured before the trigger.
-        var baselineAgentId = null;
-        var baselineFailed = false;
-        try {
-          var publishBaseline = await agent(
-            ARTIFACT_LOAD_PREAMBLE +
-            "Call artifact_status with slug \"" + PUBLISH_SLUG + "\" once.\n" +
-            "Return JSON { \"build\": <the raw \"build\" value exactly as returned, or null when there is none> } and nothing else.",
-            { key: attemptKey("publish-artifact-baseline-" + taskId, totalReworkCount), label: "Reading pre-trigger build state",
-              schema: { type: "object", properties: { build: { type: ["object", "null"] } }, required: ["build"] } }
-          );
-          baselineAgentId = (publishBaseline && publishBaseline.build && typeof publishBaseline.build.agent_id === "string" && publishBaseline.build.agent_id) || null;
-          log("Publish pre-trigger baseline for task " + taskId + ": " + (baselineAgentId ? "build " + baselineAgentId + " already in flight (predates the trigger — never attributed to this edit)" : "no build in flight"));
-        } catch (baselineErr) {
-          baselineFailed = true;
-          log("Publish pre-trigger baseline read failed for task " + taskId + " (" + (baselineErr && baselineErr.message ? baselineErr.message : baselineErr) + ") — receipt attribution skipped; durable audit-dir evidence is the only positive signal");
-        }
-        // See docs/decisions/publish-path.md#trigger-await: the artifact_edit call is awaited.
-        var rebuildTrigger = null, triggerThrew = false;
-        try {
-          var triggerText = String(await agent(rebuildPrompt,
-            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "");
-          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerText.length + " chars; awaited; scanned only for the explicit refusal signal)");
-          // See docs/decisions/publish-path.md#explicit-refusal-16: the child must explicitly refuse artifact work.
-          var refusalText = extractRefusal(triggerText);
-          if (refusalText) {
-            await recordPublishLedger({
-              commit: mergeCommitForPublish,
-              attempt: rebuildAttemptKey,
-              agent_id: null,
-              applied_report: null,
-              outcome: "rejected",
-              detail: "artifact_edit explicitly refused the edit (parsed ARTIFACT_EDIT_REFUSED signal): " + refusalText + " — conclusive negative: the edit provably did not go through, no observation polling, no blind retry"
-            }, totalReworkCount);
-            return await parkTask("Publish cannot proceed for task " + taskId + ": artifact_edit explicitly refused the edit (" + refusalText + "). This is conclusive (rejected, not unknown): the edit did not go through. Repair or provision the artifact target, then re-run Publish. Human attention needed.");
-          }
-        } catch (triggerErr) {
-          log("Publish rebuild trigger for task " + taskId + " threw (" + (triggerErr && triggerErr.message ? triggerErr.message : triggerErr) + ") — outcome unknown until observation confirms it; the edit may have gone through");
-          triggerThrew = true;
-        }
-        // D1 (2026-09-19; F-A1 upper-bound 2026-09-20): issued_at is an UPPER
-        // bound on issuance — captured AFTER the trigger-agent call returns,
-        // ferried from one shell date call (workflows have no clock) and
-        // validated mechanically; null when unobserved (fallback: ts).
-        // See docs/decisions/publish-path.md#d1-issuance-time.
-        var triggerIssuedAt = null;
-        try {
-          var issuedAtFerry = await agent(
-            "Run: date -u +%Y-%m-%dT%H:%M:%SZ\n" +
-            "Return JSON { \"ts\": \"<the date output, verbatim>\" } and nothing else.",
-            { key: attemptKey("publish-issued-at-" + taskId, totalReworkCount), label: "Capturing post-trigger instant (upper bound on issuance)",
-              schema: { type: "object", properties: { ts: { type: "string" } }, required: ["ts"] } }
-          );
-          var issuedAtRaw = String((issuedAtFerry && issuedAtFerry.ts) || "").trim();
-          if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(issuedAtRaw)) triggerIssuedAt = issuedAtRaw;
-        } catch (issuedAtErr) { /* issued_at stays null: the verifier falls back to ts */ }
-        if (!triggerIssuedAt) log("Publish issuance instant unobserved for task " + taskId + " — issued_at null; the freshness gate falls back to ledger-write ts");
-        // (2026-09-19, room #22) Submitted-on-issuance: see docs/decisions/publish-path.md#submitted-on-issuance.
-        await recordPublishLedger({
+        // is small by construction: the 200-line budget above gates it. The
+        // worker verifies the sha256 from the intent entry before issuing;
+        // a mismatch stops issuance. (2026-09-20, one-party worker-owned
+        // publish: the workflow no longer issues the edit itself.)
+        // (2026-09-20, one-party worker-owned publish) The workflow exits
+        // Publish at intent. Everything above — preflight, provenance base,
+        // checksummed diff — is read-only. (2026-09-20 REVIEW: the
+        // pre-trigger baselines, artifact toolcheck, and pre-trigger build
+        // state agent steps were deleted — their outputs fed only the
+        // retired content-verdict/receipt-attribution machinery, and the
+        // toolcheck ran in a workflow child that cannot reach artifact_edit.
+        // Issuance belongs to the session-carrying tick worker, which
+        // handles tool-unavailability as inconclusive per the tick protocol.)
+        // Publish at intent. Everything above — preflight, provenance base,
+        // checksummed diff, toolcheck, pre-trigger baselines — is read-only.
+        // Issuance belongs to the session-carrying tick worker
+        // (scan-publish-intent's intent bucket), the only caller class that
+        // can reach artifact_edit. This entry is issuer-written BY THE
+        // WORKFLOW and names the intent: outcome "publish-intent", never
+        // "submitted" — the workflow issued nothing. The worker claims it
+        // via the park note below.
+        // (2026-09-20 REVIEW) The intent ledger entry is the anchor the
+        // whole machine depends on. If the ferry drops it, the task would
+        // park with publish-requested and no anchor — unclaimable forever.
+        // Fail loudly instead of parking an orphan intent.
+        var intentAnchored = await recordPublishLedger({
           commit: mergeCommitForPublish,
           attempt: rebuildAttemptKey,
+          // (0.14.6) Attempt 1, staged here. The version is the attempt's
+          // deterministic receipt string, synthesized into the staged diff;
+          // the ack scan re-derives it from task+commit+attempt before the
+          // tick worker may issue the edit.
+          publish_attempt: 1,
+          version: publishVersion,
           agent_id: null,
-          applied_report: publishAppliedObservation,
-          manifest_before: preTriggerManifest,
-          outcome: "submitted",
-          issued_at: triggerIssuedAt,
-          detail: "trigger issuance: rebuild-trigger agent invoked; receipt/observation pending. Invocation only - not evidence of artifact_edit or build acceptance." + (triggerThrew ? "; trigger-threw" : "; trigger-returned")
-        }, totalReworkCount, "issuance");
-        // Post-trigger observation (primary, not fallback): the workflow
-        // attributes the edit itself. First the in-flight build state — a
-        // build whose agent_id is new relative to the pre-trigger baseline
-        // is this edit's receipt. Then the durable audit-dir diff — a
-        // timestamped directory appearing during the trigger window proves
-        // the edit went through and the build completed even when no
-        // in-flight build was ever observed (the 2026-09-14 attempt-7 gap).
-        // Absence of both signals proves nothing: the outcome is UNKNOWN,
-        // never "did not go through". No blind retry — record the attempt
-        // and park fail-closed; correlate via the ledger, never by
-        // re-issuing.
-        log("Publish rebuild trigger issued for task " + taskId + " — observing build state to attribute the edit");
-        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, totalReworkCount), label: "Reading artifact build state after trigger",
-              schema: { type: "object", properties: { build: { type: ["object", "null"] } }, required: ["build"] } }
-          );
-        } catch (buildCheckErr) {
-          buildStateFailed = true;
-          log("Publish post-trigger build-state check failed for task " + taskId + " (" + (buildCheckErr && buildCheckErr.message ? buildCheckErr.message : buildCheckErr) + ") — this signal is unknown, not negative");
-        }
-        var observedAgentId = (buildState && buildState.build && typeof buildState.build.agent_id === "string" && buildState.build.agent_id) || null;
-        // See docs/decisions/publish-path.md#attribution-limitation: attribution is timing-based; content verification bounds the risk.
-        var receiptAgentId = (!buildStateFailed && !baselineFailed && observedAgentId && observedAgentId !== baselineAgentId) ? observedAgentId : null;
-        // auditReportOk: pure tri-state read of a report.json body —
-        // true (build ok), false (build failed), null (missing or
-        // unreadable — not evidence either way). The child returns the
-        // raw body verbatim; interpretation lives here, never in prose.
-        // Hoisted to Publish-step scope (before the receipt branch) so both
-        // the immediate and post-poll audit fallbacks share it on every path —
-        // the receipt path skips the else below, which must not leave these
-        // undefined.
-        var auditReportOk = function (raw) {
-          if (typeof raw !== "string") return null;
-          var trimmed = raw.trim();
-          if (trimmed === "" || trimmed === "MISSING") return null;
-          var parsed;
-          try { parsed = JSON.parse(trimmed); } catch (e) { return null; }
-          if (parsed && typeof parsed.ok === "boolean") return parsed.ok;
-          return null;
-        };
-        // (2026-09-18, H2 verdict-first) Publish-verdict vocabulary. The
-        // verdict is one of "landed" | "unknown". Decided once,
-        // before the receipt poll, and dispatched on — never re-derived.
-        // Pure and self-contained: unit-tested by
-        // tests/publish-verdict-first.test.js.
-        // See docs/decisions/publish-path.md#h2-verdict-dispatch.
-        var decidePublishVerdict = function (opts) {
-          var immediateReport = (opts && "immediateReport" in opts) ? opts.immediateReport : null;
-          var newDirCount = (opts && typeof opts.newDirCount === "number") ? opts.newDirCount : 0;
-          if (newDirCount === 1 && immediateReport === true) return { verdict: "landed", unattributableReason: null };
-          if (newDirCount === 1 && immediateReport === false) return { verdict: "unknown", unattributableReason: "audit-report-ok-false" };
-          if (newDirCount === 1) return { verdict: "unknown", unattributableReason: "audit-report-unreadable-or-missing" };
-          if (newDirCount === 0) return { verdict: "unknown", unattributableReason: "no-new-audit-dir-in-window" };
-          return { verdict: "unknown", unattributableReason: "audit-dir-ambiguity", ambiguousDirCount: newDirCount };
-        };
-        // (2026-09-18, H2 message contract, design §1.5) The human line is
-        // the output of a mechanical field→template mapping: the trigger
-        // commit short-sha, one plain clause per unattributable reason, the
-        // no-republish warning, the ledger path with (outcome: unknown), and
-        // the unknown-recovery clause. The appendix carries every machine
-        // field. Pure and self-contained: unit-tested by
-        // tests/publish-verdict-first.test.js.
-        var composeUnattributedParkReason = function (fields) {
-          var f = fields || {};
-          var task = f.taskId || taskId;
-          var reason = f.unattributableReason || "unknown-outcome";
-          var shortSha = String(f.commitShortSha || "").substring(0, 7) || "unknown";
-          var reasonClauses = {
-            "no-new-audit-dir-in-window": "no build could be tied to this attempt",
-            "audit-report-unreadable-or-missing": "the build's report is unreadable",
-            "audit-dir-ambiguity": "more than one build appeared in the check window",
-            "stranger-build-observed-during-poll": "a different build was running during the check",
-            "status-read-errors-during-poll": "status reads kept failing"
-          };
-          var clause = reasonClauses[reason] || "no build could be tied to this attempt";
-          return "Publish outcome unknown for task " + task +
-            ": the trigger was sent for commit " + shortSha + " but the outcome could not be confirmed — " + clause + ". " +
-            "Do NOT republish: if the trigger was accepted, a retry duplicates the build (2026-09-12). " +
-            "The attempt is in the ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl (outcome: unknown) " +
-            "and the crew's unknown-recovery will re-examine it. " +
-            "Appendix: unattributable_reason=" + reason +
-            "; poll_end_state=" + (f.pollEndState || "not-polled") +
-            "; saw_our_build=" + (f.sawOurBuild ? "true" : "false") +
-            "; new_audit_dirs=" + (f.newAuditDirCount == null ? 0 : f.newAuditDirCount) +
-            "; poll_chunks_failed=" + (f.chunkFailures == null ? 0 : f.chunkFailures) +
-            "; poll_status_errors=" + (f.pollStatusErrors == null ? 0 : f.pollStatusErrors) + ".";
-        };
-        // publishFailure is declared here (per-Publish-pass scope) so the
-        // post-poll explicit build failure survives to the final routing
-        // below; publishUnknownFields carries the structured unknown fields
-        // for the single composed fail-closed park. Both re-initialize on
-        // every pass — a rework re-entry never leaks a stale verdict.
-        var publishFailure = null;
-        var publishUnknownFields = null;
-        if (receiptAgentId) {
-          // The edit went through — a build with a new agent_id appeared
-          // after the trigger. The parent's independent read-back
-          // (docs/publish-verification.md) is the verification, not any
-          // builder report.
-          rebuildTrigger = { edit_started: true };
-          rebuildAgentId = receiptAgentId;
-          log("Publish rebuild trigger for task " + taskId + ": artifact_status shows build " + receiptAgentId + " for slug " + PUBLISH_SLUG + " (new relative to the pre-trigger baseline) — the edit went through.");
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            agent_id: rebuildAgentId,
-            applied_report: publishAppliedObservation,
-            manifest_before: preTriggerManifest,
-            outcome: "submitted",
-            issued_at: triggerIssuedAt,
-            detail: "fire-and-forget trigger; build receipt captured by workflow-owned build-state observation (pre/post-trigger diff); observation, not re-issuance"
-          }, totalReworkCount, "receipt");
-        } else {
-          var newAuditDirs = [];
-          try {
-            var auditAfter = await agent(
-              "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
-              "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
-              "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
-              { key: attemptKey("publish-audit-after-" + taskId, totalReworkCount), label: "Re-listing audit dirs after trigger",
-                schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
-            );
-            var auditDirsAfterTrigger = String((auditAfter && auditAfter.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
-            // Only timestamped build dirs count — the "latest" symlink
-            // and anything else are not builds. Gated on auditBeforeOk:
-            // without a baseline every historical dir would look new.
-            newAuditDirs = auditBeforeOk ? auditDirsAfterTrigger.filter(function (d) {
-              return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
-            }) : [];
-          } catch (auditAfterErr) {
-            log("Publish audit-dir re-list after trigger failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterErr && auditAfterErr.message ? auditAfterErr.message : auditAfterErr));
-          }
-          if (newAuditDirs.length > 0) {
-            rebuildAgentId = null;
-            newAuditDirs.sort();
-            var newestImmediateDir = newAuditDirs[newAuditDirs.length - 1];
-            log("Publish rebuild trigger for task " + taskId + ": new audit dir(s) during the trigger window (" + newAuditDirs.join(", ") + ") — the edit went through and a build completed; no in-flight receipt was observed.");
-            // (2026-09-18, H2 verdict-first) Durable audit evidence exists,
-            // but there is no receipt agent_id to chain the completion poll
-            // to — polling with a null receipt can only observe strangers
-            // (any running build differs from "null") or nothing, burning
-            // 10.5 minutes to park unknown. Read the build report now instead
-            // of polling, then decide the verdict ONCE via
-            // decidePublishVerdict: exactly one new dir with ok=true lands
-            // (attribution by window, not identity — never poll blind);
-            // ok=false is UNKNOWN with the failure evidence preserved in the
-            // ledger detail (the evidence is explicit, the attribution is
-            // not); unreadable / zero / ambiguous dirs are UNKNOWN.
-            // Verdict-first: landed bypasses the poll below, unknown falls
-            // through to post-deploy. STEP 2 runs on every path.
-            // See docs/decisions/publish-path.md#h2-verdict-dispatch.
-            var immediateReportOk = null;
-            // (N1) Read the report only when exactly one new dir exists:
-            // ambiguity (>1) forces UNKNOWN regardless — don't shell out to
-            // read a report that will be discarded.
-            if (newAuditDirs.length === 1) {
-              try {
-                var immediateOkRead = await agent(
-                  "Read the artifact build report for slug \"" + PUBLISH_SLUG + "\".\n" +
-                  "Run: cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/" + newestImmediateDir + "/report.json 2>/dev/null || echo MISSING\n" +
-                  "Return JSON { \"raw\": \"<verbatim file contents, or the literal string MISSING when the file does not exist>\" } and nothing else.",
-                  { key: attemptKey("publish-audit-ok-immediate-" + taskId, totalReworkCount), label: "Reading build report for audit-confirmed build",
-                    schema: { type: "object", properties: { raw: { type: "string" } }, required: ["raw"] } }
-                );
-                immediateReportOk = auditReportOk(immediateOkRead && immediateOkRead.raw);
-              } catch (immediateOkErr) {
-                log("Publish build-report read for audit-confirmed dir failed for task " + taskId + " (treated as unknown): " + (immediateOkErr && immediateOkErr.message ? immediateOkErr.message : immediateOkErr));
-                immediateReportOk = null;
-              }
-            }
-            var immediateVerdict = decidePublishVerdict({ editStarted: true, immediateReport: immediateReportOk, newDirCount: newAuditDirs.length });
-            if (immediateVerdict.verdict === "landed") {
-              publishBuildLanded = true;
-              artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
-              await recordPublishLedger({
-                commit: mergeCommitForPublish,
-                attempt: rebuildAttemptKey,
-                agent_id: null,
-                applied_report: publishAppliedObservation,
-                manifest_before: preTriggerManifest,
-            outcome: "build-observed",
-                detail: "durable audit evidence shows a build completed during the attempt window (no receipt agent_id — attribution by window, not identity; receipt poll bypassed (verdict decided), routed to parent verification)"
-              }, totalReworkCount);
-              log("Publish verdict LANDED for task " + taskId + ": a completed build was observed during the attempt window — receipt poll bypassed (verdict decided, no receipt to chain to), routing directly to parent verification.");
-            } else {
-              // Verdict UNKNOWN on the immediate path. ok=false is explicit
-              // failure evidence but not an attributable failure — the ledger
-              // records unknown with the evidence preserved in the detail,
-              // and the flow continues to post-deploy (never parks early).
-              publishUnknownFields = {
-                taskId: taskId,
-                unattributableReason: immediateVerdict.unattributableReason,
-                pollEndState: "not-polled",
-                sawOurBuild: false,
-                newAuditDirCount: newAuditDirs.length,
-                chunkFailures: 0,
-                pollStatusErrors: 0
-              };
-              var immediateDetail = "durable audit-dir fallback could not prove a completed build for this attempt (unattributable_reason=" + immediateVerdict.unattributableReason + ", no receipt agent_id)";
-              if (immediateReportOk === false) {
-                immediateDetail += "; explicit failure evidence preserved: report ok=false for audit dir " + newestImmediateDir;
-              }
-              if (immediateVerdict.unattributableReason === "audit-dir-ambiguity") {
-                immediateDetail += "; audit-dir ambiguity: " + newAuditDirs.length + " new dirs in window";
-              }
-              await recordPublishLedger({
-                commit: mergeCommitForPublish,
-                attempt: rebuildAttemptKey,
-                agent_id: null,
-                applied_report: publishAppliedObservation,
-                outcome: "unknown",
-                detail: immediateDetail
-              }, totalReworkCount);
-              log("Publish verdict UNKNOWN for task " + taskId + ": " + immediateDetail + " — continuing to post-deploy; never polling blind and never parking early.");
-            }
-          } else {
-            // See docs/decisions/publish-path.md#no-attributable-build: no attributable build and no durable evidence means no publish.
-            publishUnknownFields = {
-              taskId: taskId,
-              unattributableReason: decidePublishVerdict({ editStarted: true, immediateReport: null, newDirCount: 0 }).unattributableReason,
-              pollEndState: "not-polled",
-              sawOurBuild: false,
-              newAuditDirCount: 0,
-              chunkFailures: 0,
-              pollStatusErrors: 0
-            };
-            await recordPublishLedger({
-              commit: mergeCommitForPublish,
-              attempt: rebuildAttemptKey,
-              agent_id: null,
-              applied_report: publishAppliedObservation,
-              outcome: "unknown",
-              detail: "no new audit dir appeared in the trigger window and no receipt agent_id was observed — the edit was issued fire-and-forget, so completion is unproven; never poll blind on a null receipt"
-            }, totalReworkCount);
-            log("Publish verdict UNKNOWN for task " + taskId + ": no new audit dir in window and no receipt — continuing to post-deploy; never polling blind and never parking early.");
-          }
+          applied_report: null,
+          outcome: "publish-intent",
+          issuer: "workflow",
+          diff_path: publishDiffFile,
+          diff_sha256: publishDiffSha256,
+          // (2026-09-20, critic-0145 F-A4) The base the diff was computed
+          // against: scan-publish-intent's intent branch compares it with
+          // current stamped provenance and re-queues the task when it went
+          // stale — never issues the stale diff.
+          base: publishBase,
+          detail: "publish intent: preflight and checksummed diff are complete; issuance is owned by the session-carrying tick worker. The workflow performed no artifact_edit and wrote no issuance."
+        }, totalReworkCount);
+        if (!intentAnchored) {
+          throw new Error("publish-intent ledger anchor write unconfirmed for task " + taskId + " — refusing to park an unclaimable intent; the Publish phase fails loudly instead");
         }
-        // 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.
-        // (2026-09-18, H2 verdict-first) The verdict was decided exactly
-        // once above; dispatch on it. landed bypasses the receipt poll
-        // (the audit evidence already proved completion); an explicit
-        // publishFailure is preserved verbatim through post-deploy.
-        // Otherwise the verdict is open — but the poll below is only
-        // legitimate against a real receipt: the null-safe assertion records
-        // UNKNOWN and continues to STEP 2 instead of polling blind.
-        // See docs/decisions/publish-path.md#h2-verdict-dispatch.
-        if (publishBuildLanded) {
-          log("Publish verdict already LANDED for task " + taskId + " — bypassing receipt poll.");
-        } else if (publishFailure) {
-          // design §1.2 pre-poll branch — currently unassigned; kept for the converged dispatch shape.
-          log("Publish verdict already FAILED for task " + taskId + " — preserved verbatim through post-deploy.");
-        } else if (!rebuildTrigger || !rebuildTrigger.edit_started) {
-          // Loud defensive assertion (replaces the old lying "Unreachable"
-          // else): with no receipt state the poll would observe strangers or
-          // nothing — record UNKNOWN and continue to STEP 2. Never park
-          // early here; never poll blind.
-          if (!publishUnknownFields) {
-            publishUnknownFields = {
-              taskId: taskId,
-              unattributableReason: "no-receipt-state",
-              pollEndState: "not-polled",
-              sawOurBuild: false,
-              newAuditDirCount: 0,
-              chunkFailures: 0,
-              pollStatusErrors: 0
-            };
-            await recordPublishLedger({
-              commit: mergeCommitForPublish,
-              attempt: rebuildAttemptKey,
-              agent_id: null,
-              applied_report: publishAppliedObservation,
-              outcome: "unknown",
-              detail: "no receipt state was recorded for this attempt — never polling blind; continuing to post-deploy"
-            }, totalReworkCount);
-          }
-          log("Publish verdict UNKNOWN for task " + taskId + ": no receipt state recorded — never polling blind, continuing to post-deploy.");
-        } else {
-          // (2026-09-16) There is no builder report: the fire-and-forget
-          // trigger carries no JSON contract, so there is nothing to
-          // compare and no pre-hash diagnostic. The builder's old
-          // self-report was circular by construction (canary run 8) with a
-          // demonstrated false-negative mode (task 23ca8f3f, 2026-09-12:
-          // applied:[] for a diff the builder had applied). The flow
-          // proceeds to the build poll regardless; real verification is the
-          // parent's independent read-back (docs/publish-verification.md)
-          // before the provenance stamp.
-          // 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
-          // poll runs in three chunks (7 checks x 30s ~= 3.5 min each) with a
-          // holder-only lease refresh between chunks. If a refresh fails, the
-          // lock was lost: stop the run and park the task — never continue to
-          // a provenance stamp or version assignment without holding the lock.
-          var buildPoll = null;
-          // STEP 1b poll-signal accumulators (2026-09-15, task aadeccc3):
-          // the durable audit-dir fallback below needs the poll's own
-          // observations, not just its final verdict — whether our build was
-          // ever seen, whether a stranger's build was ever in flight, and
-          // what the last check observed. OR-ed across all three chunks so
-          // a signal seen in any chunk survives the chunk boundary.
-          var pollSawOurBuild = false;
-          var pollSawStranger = false;
-          var lastObservedAgentId = null;
-          // Poll-chunk failure record (2026-09-16, task 1febe8eb): chunk
-          // agent calls that threw instead of returning a verdict —
-          // recorded for the post-poll diagnosis, never terminal alone.
-          var chunkFailures = [];
-          // Poll status-read error count (2026-09-16): a failed
-          // artifact_status read (rate limiting / TOO_MANY_REQUESTS /
-          // 429, network error, or any non-build response) is
-          // inconclusive — it is NOT evidence of absence and must never
-          // be folded into the no-build-observed signal. Counted for
-          // the post-poll diagnosis only; never terminal alone.
-          var pollStatusErrors = 0;
-          for (var chunk = 1; chunk <= 3; chunk++) {
-            if (chunk > 1) {
-              var refreshPoll = await agent(
-                "Refresh the merge lock for task " + taskId + ".\n" +
-                "Run: " + LIFECYCLE_ENV + " refresh-lock " + taskId + "\n" +
-                "If the output contains REFRESHED, return JSON { \"held\": true } and nothing else. Otherwise return JSON { \"held\": false, \"output\": \"<verbatim output>\" } and nothing else.",
-                { key: attemptKey("publish-lock-refresh-poll-" + taskId + "-c" + chunk, totalReworkCount), label: "Refreshing merge lock during build poll",
-                  schema: { type: "object", properties: { held: { type: "boolean" }, output: { type: "string" } }, required: ["held"] },
-                  timeoutMs: 60000 }
-              );
-              if (!refreshPoll || refreshPoll.held !== true) {
-                return await parkTask("Merge-lock lease lost during the artifact build poll (refresh before chunk " + chunk + " of 3 failed: " + ((refreshPoll && refreshPoll.output) || "no output") + "). Fail-closed: stopping before any provenance stamp or version assignment.");
-              }
-            }
-            // Chunk 1 keeps the original stable key; later chunks use -c<N>
-            // suffixed keys. All are attemptKey-scoped so rework passes stay
-            // disjoint (replay-key contract).
-            var pollKey = (chunk === 1)
-              ? attemptKey("publish-artifact-poll-" + taskId, totalReworkCount)
-              : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, totalReworkCount);
-            try {
-              buildPoll = await agent(
-                "First call tool_search.load_tool_namespace with paths [\"artifact\"]. Then poll artifact_status for slug \"" + PUBLISH_SLUG + "\" \u2014 for OUR build only, the one whose agent_id is \"" + rebuildAgentId + "\" (the receipt captured when the edit was accepted; the agent_id is the artifact system's in-flight build correlation ID, stable across polls while the build runs). Check every 30 seconds, up to 7 checks (3.5 minutes max). On each check, read the raw build object:\n" +
-                "If an artifact_status call itself FAILS (rate limiting / TOO_MANY_REQUESTS / 429, network error, or any response that is not a build object): that check is inconclusive \u2014 do NOT record it as \"no build\". Stop polling immediately and return with status_error: true. A failed read is not evidence of absence and must never be folded into the no-build-observed signal.\n" +
-                "On every check, record whether you have positively OBSERVED our build: a running build whose agent_id equals \"" + rebuildAgentId + "\", or a completed-build record whose agent_id equals \"" + rebuildAgentId + "\" (if the tool surfaces one \u2014 match it mechanically, never assume).\n" +
-                "- If no build is running (build is null) and you have NOT observed our build: our build's completion is UNPROVEN. Absence of a running build is not evidence our build ran. Do NOT report done.\n" +
-                "- If no build is running (build is null) and you previously observed our build running: our build finished. Stop and report done.\n" +
-                "- If the running build's agent_id equals \"" + rebuildAgentId + "\": still ours \u2014 keep waiting.\n" +
-                "- If the running build's agent_id is present but DIFFERENT: that is a stranger's build. Do NOT attribute its completion to our attempt and do NOT wait on it \u2014 keep checking within budget; if the budget expires without observing our build, report done=false. Record it in saw_stranger regardless of what else you observe.\n" +
-                "Return JSON { \"build_done\": <true ONLY when you positively observed our build and it is no longer running, false otherwise>, \"saw_our_build\": <true if you observed our build at any check, false if never>, \"saw_stranger\": true if at ANY check a running build had an agent_id different from ours (\"" + rebuildAgentId + "\"), false otherwise, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\", \"status_error\": <true ONLY when a status read failed as described above, false or omitted otherwise> } and nothing else.",
-                { key: pollKey, label: "Waiting for artifact build to complete (chunk " + chunk + " of 3)",
-                  schema: { type: "object", properties: { build_done: { type: "boolean" }, saw_our_build: { type: "boolean" }, saw_stranger: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] }, status_error: { type: "boolean" } }, required: ["build_done"] },
-                  timeoutMs: 270000 }
-              );
-            } catch (chunkErr) {
-              // See docs/decisions/publish-path.md#hung-chunk: a hung or failed chunk is inconclusive, never terminal.
-              chunkFailures.push("chunk " + chunk + ": " + (chunkErr && chunkErr.message ? chunkErr.message : chunkErr));
-              log("Artifact build poll chunk " + chunk + " of 3 failed (" + (chunkErr && chunkErr.message ? chunkErr.message : chunkErr) + ") \u2014 continuing to the next chunk; build completion still unproven.");
-            }
-            if (buildPoll) {
-              pollSawOurBuild = pollSawOurBuild || (buildPoll.saw_our_build === true);
-              pollSawStranger = pollSawStranger || (buildPoll.saw_stranger === true);
-              lastObservedAgentId = buildPoll.observed_agent_id || null;
-              if (buildPoll.status_error === true) { pollStatusErrors++; log("Artifact build poll chunk " + chunk + " of 3 hit a status-read error \u2014 recorded as inconclusive, continuing to the next chunk; a failed read is not evidence of absence."); }
-              if (buildPoll.build_done) { break; }
-            }
-          }
-          if (!buildPoll || !buildPoll.build_done) {
-            buildPoll = { build_done: false, status: (buildPoll && buildPoll.status) || "build still running after the 10.5-minute bounded poll" };
-          }
-          if (buildPoll.build_done && pollSawOurBuild) {
-            // See docs/decisions/publish-path.md#step-1c-no-stamp: no provenance stamp in STEP 1c.
-            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 {
-            // STEP 1b durable audit-dir fallback (2026-09-15, task aadeccc3):
-            // the poll observes only in-flight builds; a build that finished
-            // inside the window leaves a durable audit dir. Diff the audit
-            // listing against the pre-trigger snapshot: a new timestamped dir
-            // is evidence a build completed. Attribution is by window, not by build identity: any
-            // observed stranger blocks it. Never re-issues, never stamps;
-            // ok=true routes to the parent's read-back (the verification).
-            //
-            // The poll end-state is read from the poll's own observations,
-            // not from build_done alone: a build in flight at the last check
-            // means the budget was shorter than the latency (or the build is
-            // stuck) — NOT that no build ever started; nothing observed at
-            // any check is the never-started signal.
-            var pollEndState = lastObservedAgentId ? "build-still-running-at-poll-end"
-              : (pollSawOurBuild ? "our-build-observed-then-unconfirmed" : "no-build-observed-in-window");
-            var strangerObserved = pollSawStranger;
-            var newAuditDirsAfterPoll = [];
-            try {
-              var auditAfterPoll = await agent(
-                "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
-                "Run: ls -1 ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/ 2>/dev/null\n" +
-                "Return JSON { \"dirs\": \"<newline-separated names, empty string when the audits directory does not exist or is empty>\" } and nothing else.",
-                { key: attemptKey("publish-audit-after-poll-" + taskId, totalReworkCount), label: "Re-listing audit dirs after build poll",
-                  schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
-              );
-              var auditDirsAfterPollList = String((auditAfterPoll && auditAfterPoll.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
-              // Gated on auditBeforeOk (critic finding 4): without a baseline
-              // every historical dir would look new.
-              newAuditDirsAfterPoll = auditBeforeOk ? auditDirsAfterPollList.filter(function (d) {
-                return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
-              }) : [];
-              log("Publish audit-dir re-list after build poll for task " + taskId + ": " + newAuditDirsAfterPoll.length + " new timestamped dir(s)");
-            } catch (auditAfterPollErr) {
-              log("Publish audit-dir re-list after build poll failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterPollErr && auditAfterPollErr.message ? auditAfterPollErr.message : auditAfterPollErr));
-            }
-            // The shared auditReportOk (defined with the immediate fallback
-            // above) interprets the raw body here too.
-            var auditOkAfterPoll = null;
-            var newestAuditDirAfterPoll = null;
-            if (newAuditDirsAfterPoll.length > 0 && !strangerObserved) {
-              newAuditDirsAfterPoll.sort();
-              newestAuditDirAfterPoll = newAuditDirsAfterPoll[newAuditDirsAfterPoll.length - 1];
-              try {
-                var auditOkRead = await agent(
-                  "Read the build report for artifact slug \"" + PUBLISH_SLUG + "\", audit dir \"" + newestAuditDirAfterPoll + "\" (verbatim read, never interpreted, never a gate).\n" +
-                  "Run: cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/" + newestAuditDirAfterPoll + "/report.json 2>/dev/null || echo MISSING\n" +
-                  "Return JSON { \"raw\": \"<verbatim file contents, or the literal string MISSING when the file does not exist>\" } and nothing else.",
-                  { key: attemptKey("publish-audit-ok-after-poll-" + taskId, totalReworkCount), label: "Reading build report after build poll",
-                    schema: { type: "object", properties: { raw: { type: "string" } }, required: ["raw"] } }
-                );
-                auditOkAfterPoll = auditReportOk(auditOkRead && auditOkRead.raw);
-              } catch (auditOkReadErr) {
-                log("Publish build-report read after build poll failed for task " + taskId + " (non-fatal, treated as unknown): " + (auditOkReadErr && auditOkReadErr.message ? auditOkReadErr.message : auditOkReadErr));
-                auditOkAfterPoll = null;
-              }
-            }
-            if (auditOkAfterPoll === true) {
-              publishBuildLanded = true;
-              artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
-              log("Publish build landed for task " + taskId + " via durable audit evidence — provenance stamp deferred to parent content verification");
-              await recordPublishLedger({
-                commit: mergeCommitForPublish,
-                attempt: rebuildAttemptKey,
-                agent_id: rebuildAgentId,
-                applied_report: publishAppliedObservation,
-                manifest_before: preTriggerManifest,
-            outcome: "build-observed",
-                detail: "durable audit evidence shows a build completed during the attempt window (audit dir " + newestAuditDirAfterPoll + ", report ok=true); routed to parent verification"
-              }, totalReworkCount);
-            } else if (auditOkAfterPoll === false) {
-              // Explicit negative evidence under the stranger guard: a build
-              // ran and failed during the poll window with no stranger in
-              // flight. This is an attributable failure — preserved verbatim
-              // through post-deploy. Message contract unchanged.
-              publishFailure = "Artifact build FAILED for slug " + PUBLISH_SLUG + " (audit dir " + newestAuditDirAfterPoll + ", report ok=false). Explicit negative evidence: a build ran and failed (attribution by window, not by build identity — no stranger build was observed in flight during the poll). The publish did not land — provenance was not stamped — your change was NOT published. Build log: ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/" + newestAuditDirAfterPoll + "/. This explicit failure is not auto-retried. Appendix: attribution=window; report=ok=false; provenance=unstamped.";
-              await recordPublishLedger({
-                commit: mergeCommitForPublish,
-                attempt: rebuildAttemptKey,
-                agent_id: rebuildAgentId,
-                applied_report: publishAppliedObservation,
-                outcome: "failed",
-                detail: "a build ran and failed (attribution by window, not by build identity): audit dir " + newestAuditDirAfterPoll + " report ok=false; no stranger build observed in flight during the poll"
-              }, totalReworkCount);
-            } else {
-              var unattributableReason = strangerObserved ? "stranger-build-observed-during-poll"
-                : ((pollStatusErrors > 0 && !pollSawOurBuild) ? "status-read-errors-during-poll"
-                : (pollEndState === "build-still-running-at-poll-end" ? "build-still-running-at-poll-end"
-                : (newAuditDirsAfterPoll.length === 0 ? "no-new-audit-dir-in-window" : "audit-report-unreadable-or-missing")));
-              // Verdict UNKNOWN (poll path): the build cannot be attributed
-              // to this attempt. The fields feed the single composed
-              // fail-closed park reason after post-deploy — never a
-              // fabricated verdict, never a silent pass.
-              publishUnknownFields = {
-                taskId: taskId,
-                unattributableReason: unattributableReason,
-                pollEndState: pollEndState,
-                sawOurBuild: pollSawOurBuild,
-                newAuditDirCount: newAuditDirsAfterPoll.length,
-                chunkFailures: chunkFailures.length,
-                pollStatusErrors: pollStatusErrors
-              };
-              await recordPublishLedger({
-                commit: mergeCommitForPublish,
-                attempt: rebuildAttemptKey,
-                agent_id: rebuildAgentId,
-                applied_report: publishAppliedObservation,
-                outcome: "unknown",
-                detail: "durable audit-dir fallback could not attribute a completed build to this attempt (unattributable_reason=" + unattributableReason + ", poll_end_state=" + pollEndState + ")"
-              }, totalReworkCount);
-            }
-          }
-        }
-
+        return await parkTask("publish: publish-requested " + mergeCommitForPublish + " attempt=1 — Publish intent recorded for task " + taskId + ": the merged change is staged as a checksummed diff (" + publishDiffFile + ", sha256 " + publishDiffSha256 + ") carrying the per-attempt publish version for the crew's publish worker to issue. The worker issues the edit directly and the acknowledgement scan owns the task from there; no action needed.");
         } // end: publishSkippedNoLock — no rebuild, no stamp, nothing to ship
         // STEP 2 (mechanical, always — skip path included): post-deploy
         // commits builder leftovers if any, removes the worktree, and releases
@@ -2181,34 +1609,17 @@ while (i < STEPS.length) {
           { key: attemptKey("publish-postdeploy-" + taskId, totalReworkCount), label: "Finalizing publish (post-deploy)",
             schema: { type: "object", properties: { deployed: { type: "boolean" }, output: { type: "string" } }, required: ["deployed"] } }
         );
-        if (publishSkippedNoLock) {
+        // (2026-09-20, one-party worker-owned publish) Verified re-entry:
+        // the intent park's terminal-cleanup already released the lock and
+        // reclaimed the worktree. Post-deploy above is best-effort hygiene
+        // on this branch — never a gate, never a park.
+        if (publishAlreadyVerified) {
+          log("Publish verified re-entry for task " + taskId + " — post-deploy ran forgivingly; continuing to the verified work-agent framing");
+        } else if (publishSkippedNoLock) {
           if (!postDeploy.deployed) {
             return await parkTask("Post-deploy failed after a skipped publish: " + (postDeploy.output || "no output") + ". Nothing was published; worktree cleanup and lock state unknown — human attention needed.");
           }
           log("Publish skipped cleanly for task " + taskId + " (no lock held) — post-deploy step finished");
-        } else {
-          if (publishFailure) {
-            return await parkTask(publishFailure + (postDeploy.deployed
-              ? " Post-deploy step finished (cleanup status unknown)."
-              : " Post-deploy also failed (" + (postDeploy.output || "no output") + ") — worktree and lock state unknown."));
-          }
-          if (!publishBuildLanded) {
-            // Verdict UNKNOWN (single fail-closed park — post-deploy always
-            // runs first; no early parks anywhere above). Machine contract:
-            // "unattributable_reason=" and "poll_end_state=" are always
-            // present; attribution is by window, not identity.
-            // (2026-09-18, H2 message contract) Thread the commit short-sha
-            // through the unknown fields so the human line names the trigger
-            // commit (design §1.5: "the trigger was sent for commit <short-sha>").
-            if (publishUnknownFields) publishUnknownFields.commitShortSha = mergeCommitShortForPublish;
-            return await parkTask(composeUnattributedParkReason(publishUnknownFields) + (postDeploy.deployed
-              ? " Post-deploy step finished (cleanup status unknown)."
-              : " Post-deploy also failed (" + (postDeploy.output || "no output") + ") — worktree and lock state unknown."));
-          }
-          if (!postDeploy.deployed) {
-            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 + ": build at " + artifactPublish.source_commit + ", provenance PENDING parent content verification");
         }
       } catch (pubErr) {
         // Best-effort cleanup: if the lock was refreshed, try to release it
@@ -2229,7 +1640,16 @@ while (i < STEPS.length) {
       // The work agent no longer performs the publish — it reports on the
       // mechanical outcome above. It must not rebuild or re-stamp: a second
       // artifact_edit would trigger a duplicate build.
-      if (publishSkippedNoLock) {
+      // (2026-09-20, one-party worker-owned publish) On a verified re-entry
+      // the publish was issued by the crew worker, verified by the parent
+      // read-back, and stamped — the work agent reports that, VERDICT: PASS.
+      if (publishAlreadyVerified) {
+        instructions = "Publish was already completed and verified for this task — do NOT call artifact_edit, artifact_status, setprovenance, or post-deploy yourself; doing so would disturb the finalized state.\n\n" +
+          "The crew's publish worker issued the artifact edit for the merged commit, the parent's independent content read-back confirmed the artifact contains the merged change, and provenance was stamped (docs/publish-verification.md). This Publish pass is a verified re-entry after the stamp: there is nothing to issue and nothing to re-verify.\n\n" +
+          "For the change summary, run: cd " + REPO_PATH + " && git log -1 --stat\n\n" +
+          "Write plain prose describing what was published, then on its own line: VERDICT: PASS\n" +
+          "The VERDICT line must be the last line of your report.";
+      } else if (publishSkippedNoLock) {
         instructions = "Publish was skipped deterministically by the workflow before your step — do NOT call artifact_edit, artifact_status, setprovenance, or post-deploy yourself; doing so would disturb the finalized state.\n\n" +
           "Integrate reported MERGED_EMPTY (the task branch had no commits ahead of the integration target), so no merge lock was taken and there is nothing to ship. Post-deploy step finished per its return — do NOT run post-deploy yourself.\n\n" +
           "Write plain prose describing the skip, then on its own line: VERDICT: PASS\n" +
@@ -2837,10 +2257,10 @@ while (i < STEPS.length) {
     } // end: !npmPublishSkipped — a skipped publish has nothing to verify
   }
 
-  // Parent-owned verification (docs/publish-verification.md): the parent's
-  // scan builds the request via lib/build-readback-request.js and ferries
-  // the inspection; a skipped or failed publish has nothing to verify.
-  // See docs/decisions/publish-path.md#parent-owned-verification for history.
+  // Version acknowledgement (docs/publish-verification.md): the tick worker
+  // issues the edit directly and the ack scan owns the task from there —
+  // the exact per-attempt version on the artifact's disk is the sole positive
+  // completion criterion. A skipped or failed publish has nothing to ack.
   let summary;
   var workerMarkers = extractMarkerLines(workerText);
   if (step.name === "Publish" && PUBLISH_TYPE === "npm" && publishTarget && (publishVerified || npmPublishSkipped)) {
@@ -2957,20 +2377,6 @@ while (i < STEPS.length) {
     return { status: "failed", task_id: taskId, reason: "Publish failed: " + summary };
   }
 
-  // See docs/decisions/publish-path.md#verification-park: the build landed but provenance is unstamped until parent verification.
-  if (passed && step.name === "Publish" && PUBLISH_TYPE === "artifact" && PUBLISH_SLUG && !publishSkippedNoLock && publishBuildLanded) {
-    // Success contract (2026-09-18, H2): the parent asked for exactly
-    // one build for this publish. The build landed — do NOT republish: a
-    // duplicate build would re-publish the same change. content_check=pending
-    // means parent read-back is pending; this
-    // park is NOT proof the content is correct.
-    return await parkTask("publish: verification-requested " + mergeCommitForPublish +
-      " attempt=" + rebuildAttemptKey +
-      " Do NOT republish: a duplicate build would re-publish the same change. " +
-      "Artifact build landed, post-deploy finalized, provenance not stamped — the crew has not yet independently confirmed the live artifact contains exactly the change; waiting on the manual read-back in docs/publish-verification.md. " +
-      "Appendix: build=" + (rebuildAgentId || "agent_id unobserved") + "; provenance=unstamped; content_check=pending.");
-  }
-
   i++;
 }