muse-crew 0.7.7 → 0.7.9

package/docs/guide.md

@@ -99,6 +99,30 @@ After init completes, it returns a summary:
 
 Re-running init against an existing setup returns `"unchanged"` (or `"updated"` with the converged field names) for each cron, with no other mutations.
 
+### Uninstall
+
+Uninstalling a crew removes its scheduler crons and deletes the crew home — one flow, never a manual two-step. Launch it as a workflow through the agent's workflow tools:
+
+```
+workflow_launch with:
+  scriptPath: "<install-path>/workflows/crew-uninstall.js"
+  args: {
+    crewHome: "~/workspace/.my-crew",
+    confirm: true
+  }
+```
+
+`crewHome` is required; `confirm` must be exactly `true` or the run blocks. `force` (default `false`) overrides the live-work check described below.
+
+The run has four phases:
+
+1. **Gates** — the crew home must be inside the workspace (uninstall refuses to delete anything outside it), and `confirm: true` must be present. Either missing blocks the run before anything is touched.
+2. **Safety** — if any task is `in_progress`, the run blocks unless `force: true`. Uninstalling under live workflows would strand them.
+3. **Crons** — removes the crew's scheduler jobs, and only those: the exact ids from `$CREW_HOME/.cron-registry.json` (written by init; covers id overrides), plus discovery of `crew-poll-*` jobs whose body contains the crew home path (covers installs from before the registry existed). Anything not on that union is never touched — shared crons are safe by construction, and a missing home still gets its orphaned crons removed.
+4. **Home** — best-effort `git worktree prune` on the crew's project repos, then deletes the crew home directory and verifies it is gone.
+
+Dashboard artifacts are left untouched — uninstall removes the crew instance (its crons and its home), never the user's artifacts.
+
 ## Connecting an existing project
 
 Projects are registered through the API, not through init. Init sets up the infrastructure and registers the task service as the first project; you register additional projects separately.

package/docs/publish-verification.md

@@ -72,7 +72,7 @@ The parked message is stored as `Parked: publish: verification-requested
 `publish: verification-requested`. The `<commit>` is the merged commit whose
 content must be verified. The `(build …)` suffix carries the
 `build.agent_id` the workflow observed for this publish attempt (the
-artifact system's durable build identifier — the parent uses it for the
+artifact system's in-flight build correlation ID — the parent uses it for the
 build-ID correlation in step 4b); `agent_id unobserved` means the edit was
 accepted but the workflow never correlated it to a builder run. The merge
 lock is already released (post-deploy ran before the park), so the parked

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muse-crew",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "Opinionated orchestration for Muse — workflows, identities, and tooling for autonomous software development.",
   "license": "UNLICENSED",
   "private": false,

package/seed/cron-body-template.md

@@ -21,7 +21,7 @@ You are the dispatch trigger for Muse Crew. Run the authoritative dispatcher wor
 
 1. **Load tools:** Call tool_search_load_tool_namespace with paths ["workflow_launch"].
 
-2. **Load the workflow registry:** Read the file "{crewHome}/workflows/registry.json" with the read tool and parse it as JSON. If the file does not exist (the live release predates the registry), proceed without it — omit the `registry` arg and the dispatcher will load the registry the slow way and log a warning.
+2. **Load the workflow registry:** Read the file "{crewHome}/workflows/registry.json" with the read tool and parse it as JSON. If the file does not exist (the live release predates the registry), proceed without it — omit the `registry` arg and the dispatcher will load the registry the slow way and log a warning. If the read FAILS on a file that exists (transient read error — observed 2026-09-13; the file itself was healthy and later ticks read it fine), retry the read once; if it still fails, write the error text into your run summary (observability — never silently swallow a failed read) and proceed without the registry the same way.
 
 3. **Run the dispatcher:** Call workflow_launch with scriptPath "{crewHome}/workflows/crew-dispatch.js" and args {"crewHome": "{crewHome}", "registry": <parsed registry JSON, or omit the key when the file was missing>}.
 

package/workflows/bugfix.js

@@ -486,8 +486,8 @@ function verifyAppliedChanges(expected, applied) {
 // 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
+  // workflow observed for the publish attempt (the artifact system's in-flight
+  // build correlation ID — not a durable post-completion identifier). The read-back request carries it so the parent can
   // prove the read-back inspected the live build of THIS attempt — not a
   // different build's output. Null/empty means the edit was accepted but
   // never correlated to a builder run. Pure function of inputs — no I/O,
@@ -1521,12 +1521,22 @@ while (i < STEPS.length) {
           "- 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.";
+          "If artifact_edit is still not available after the load, do NOT improvise — return { \"edit_started\": false, \"build_agent_id\": null, \"error\": \"artifact_tools missing after load\", \"applied\": [] }.\n" +
+          "RECEIPT CAPTURE (receipt-chained publish, 2026-09-13): the edit is only half the contract — you must also capture the platform build's receipt, the in-flight correlation ID the follow-up poll chains to.\n" +
+          "- The artifact namespace is already loaded (see below). BEFORE calling artifact_edit, call artifact_status with slug \"" + PUBLISH_SLUG + "\" and note the running build's agent_id (or null when no build is running). This is the pre-edit baseline.\n" +
+          "- Call artifact_edit as instructed above.\n" +
+          "- IMMEDIATELY after artifact_edit returns, call artifact_status again. If a build is running whose agent_id DIFFERS from the pre-edit baseline (or the baseline was null), that build is this edit's — its agent_id is the receipt.\n" +
+          "- If the post-edit status shows the SAME agent_id as the baseline, or no build at all, wait about 15 seconds and check artifact_status again, up to 4 more times. If a build with a NEW agent_id appears, that is the receipt.\n" +
+          "- If no new build appears, the receipt is null: the build may be pending_init-invisible, may have finished before the capture, or may be queued behind the earlier build. Return null — do NOT guess, and do NOT substitute the baseline build's agent_id.\n" +
+          "Make no other calls. Return JSON { \"edit_started\": <true if the edit was accepted, false otherwise>, \"build_agent_id\": <the receipt agent_id string, or null when no build could be attributed to this edit>, \"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" },
+              build_agent_id: {
+                type: ["string", "null"],
+                description: "Receipt-chained publish (2026-09-13): the platform build's in-flight correlation ID (build.agent_id from artifact_status) captured immediately after the edit was accepted — the receipt the follow-up poll chains to. Null when no build could be attributed to this edit. Required: an accepted edit with a null receipt parks fail-closed as unknown."
+              },
               error: { type: "string" },
               applied: {
                 type: "array",
@@ -1545,7 +1555,7 @@ while (i < STEPS.length) {
                 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"] };
+            required: ["edit_started", "build_agent_id", "applied"] };
         var rebuildTrigger = null;
         var rebuildReportMissing = false; // true if the edit went through but the agent returned no applied report (structured-output failure) — the smoke-check is skipped; the parent's independent read-back is the verification
         // The trigger key of the attempt that last ran, for the publish ledger.
@@ -1579,8 +1589,9 @@ while (i < STEPS.length) {
           //
           // 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.
+          // the build's agent_id (the artifact system's in-flight build
+          // correlation ID, stable across polls while the build runs)
+          // 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
@@ -1647,6 +1658,42 @@ while (i < STEPS.length) {
             { key: attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", totalReworkCount), label: "Triggering artifact rebuild (retry)", schema: rebuildSchema });
           rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", totalReworkCount);
         }
+        // Receipt chaining (2026-09-13): adopt the trigger's build receipt,
+        // or park on an uncorrelated acceptance. The trigger's closeout schema
+        // requires build_agent_id — the platform build's in-flight correlation
+        // ID captured immediately after the edit was accepted.
+        // An accepted edit (edit_started=true) with a null receipt is UNKNOWN,
+        // not "did not go through": the build may be pending_init-invisible,
+        // may have finished before the capture window, or may be queued behind
+        // a still-running earlier build. No re-trigger is issued on unknown —
+        // a blind re-trigger duplicated the edit on 2026-09-12, and the platform
+        // offers no idempotency proof that would make re-issue safe.
+        // (Retry-semantics reconciliation, 2026-09-13: the "no receipt → safe
+        // re-trigger" sketch assumed the edit command idempotently publishes
+        // what's on git; the duplicate-edit incident disproves the assumption,
+        // and the standing rule retries only on explicit negative evidence.
+        // Re-trigger stays exactly where it was: the edit_started=false
+        // explicit-rejection path above.) Record the attempt and park
+        // fail-closed; correlate via the ledger and the parent's content
+        // read-back before re-driving Publish.
+        if (rebuildTrigger && rebuildTrigger.edit_started && !rebuildReportMissing) {
+          var triggerAgentId = (typeof rebuildTrigger.build_agent_id === "string" && rebuildTrigger.build_agent_id.length > 0) ? rebuildTrigger.build_agent_id : null;
+          if (!triggerAgentId) {
+            var uncorrelatedObservation = (function () { var c = verifyAppliedChanges(expectedChanges, rebuildTrigger.applied); return c.ok ? "match" : "mismatch: " + c.reason; })();
+            log("Publish receipt missing for task " + taskId + ": the trigger reported edit_started=true but captured no build receipt (build_agent_id null) — no build attributable to this edit. Parking fail-closed without re-triggering.");
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: uncorrelatedObservation,
+              outcome: "unknown",
+              detail: "edit accepted (edit_started=true) but the trigger captured no build receipt in its capture window: no build attributable to this edit (pending_init-invisible, finished before capture, or queued behind an earlier build). No re-trigger issued — a blind re-trigger on an unknown outcome duplicated the edit on 2026-09-12 and the platform offers no idempotency proof."
+            }, totalReworkCount);
+            return await parkTask("Publish outcome unknown: the rebuild trigger reported the edit was accepted but captured no build receipt (build_agent_id null) — no build could be attributed to this edit in the capture window. The edit may be pending_init-invisible, already finished, or queued behind an earlier build, so no re-trigger 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 via the ledger and re-drive Publish only after the parent's content read-back resolves what actually landed. Fail-closed.");
+          }
+          rebuildAgentId = triggerAgentId;
+          log("Publish receipt chained for task " + taskId + ": build " + triggerAgentId + " — the follow-up poll waits on this build only.");
+        }
         // 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
@@ -1750,10 +1797,13 @@ while (i < STEPS.length) {
               ? attemptKey("publish-artifact-poll-" + taskId, totalReworkCount)
               : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, totalReworkCount);
             buildPoll = await agent(
-              "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.",
+              "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 no build is running (build is null): 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: our build is gone (it finished before this one started). Do NOT wait on the stranger's build and do NOT attribute its completion to our attempt \u2014 stop and report done.\n" +
+              "Return JSON { \"build_done\": <true if our build is no longer running within budget, false on timeout>, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } 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"] },
+                schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
                 timeoutMs: 270000 }
             );
             if (buildPoll && buildPoll.build_done) { break; }

package/workflows/chore.js

@@ -543,8 +543,8 @@ function verifyAppliedChanges(expected, applied) {
 // 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
+  // workflow observed for the publish attempt (the artifact system's in-flight
+  // build correlation ID — not a durable post-completion identifier). The read-back request carries it so the parent can
   // prove the read-back inspected the live build of THIS attempt — not a
   // different build's output. Null/empty means the edit was accepted but
   // never correlated to a builder run. Pure function of inputs — no I/O,
@@ -1510,12 +1510,22 @@ while (i < STEPS.length) {
           "- 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.";
+          "If artifact_edit is still not available after the load, do NOT improvise — return { \"edit_started\": false, \"build_agent_id\": null, \"error\": \"artifact_tools missing after load\", \"applied\": [] }.\n" +
+          "RECEIPT CAPTURE (receipt-chained publish, 2026-09-13): the edit is only half the contract — you must also capture the platform build's receipt, the in-flight correlation ID the follow-up poll chains to.\n" +
+          "- The artifact namespace is already loaded (see below). BEFORE calling artifact_edit, call artifact_status with slug \"" + PUBLISH_SLUG + "\" and note the running build's agent_id (or null when no build is running). This is the pre-edit baseline.\n" +
+          "- Call artifact_edit as instructed above.\n" +
+          "- IMMEDIATELY after artifact_edit returns, call artifact_status again. If a build is running whose agent_id DIFFERS from the pre-edit baseline (or the baseline was null), that build is this edit's — its agent_id is the receipt.\n" +
+          "- If the post-edit status shows the SAME agent_id as the baseline, or no build at all, wait about 15 seconds and check artifact_status again, up to 4 more times. If a build with a NEW agent_id appears, that is the receipt.\n" +
+          "- If no new build appears, the receipt is null: the build may be pending_init-invisible, may have finished before the capture, or may be queued behind the earlier build. Return null — do NOT guess, and do NOT substitute the baseline build's agent_id.\n" +
+          "Make no other calls. Return JSON { \"edit_started\": <true if the edit was accepted, false otherwise>, \"build_agent_id\": <the receipt agent_id string, or null when no build could be attributed to this edit>, \"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" },
+              build_agent_id: {
+                type: ["string", "null"],
+                description: "Receipt-chained publish (2026-09-13): the platform build's in-flight correlation ID (build.agent_id from artifact_status) captured immediately after the edit was accepted — the receipt the follow-up poll chains to. Null when no build could be attributed to this edit. Required: an accepted edit with a null receipt parks fail-closed as unknown."
+              },
               error: { type: "string" },
               applied: {
                 type: "array",
@@ -1534,7 +1544,7 @@ while (i < STEPS.length) {
                 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"] };
+            required: ["edit_started", "build_agent_id", "applied"] };
         var rebuildTrigger = null;
         var rebuildReportMissing = false; // true if the edit went through but the agent returned no applied report (structured-output failure) — the smoke-check is skipped; the parent's independent read-back is the verification
         // The trigger key of the attempt that last ran, for the publish ledger.
@@ -1568,8 +1578,9 @@ while (i < STEPS.length) {
           //
           // 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.
+          // the build's agent_id (the artifact system's in-flight build
+          // correlation ID, stable across polls while the build runs)
+          // 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
@@ -1636,6 +1647,42 @@ while (i < STEPS.length) {
             { key: attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", reworkCount), label: "Triggering artifact rebuild (retry)", schema: rebuildSchema });
           rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", reworkCount);
         }
+        // Receipt chaining (2026-09-13): adopt the trigger's build receipt,
+        // or park on an uncorrelated acceptance. The trigger's closeout schema
+        // requires build_agent_id — the platform build's in-flight correlation
+        // ID captured immediately after the edit was accepted.
+        // An accepted edit (edit_started=true) with a null receipt is UNKNOWN,
+        // not "did not go through": the build may be pending_init-invisible,
+        // may have finished before the capture window, or may be queued behind
+        // a still-running earlier build. No re-trigger is issued on unknown —
+        // a blind re-trigger duplicated the edit on 2026-09-12, and the platform
+        // offers no idempotency proof that would make re-issue safe.
+        // (Retry-semantics reconciliation, 2026-09-13: the "no receipt → safe
+        // re-trigger" sketch assumed the edit command idempotently publishes
+        // what's on git; the duplicate-edit incident disproves the assumption,
+        // and the standing rule retries only on explicit negative evidence.
+        // Re-trigger stays exactly where it was: the edit_started=false
+        // explicit-rejection path above.) Record the attempt and park
+        // fail-closed; correlate via the ledger and the parent's content
+        // read-back before re-driving Publish.
+        if (rebuildTrigger && rebuildTrigger.edit_started && !rebuildReportMissing) {
+          var triggerAgentId = (typeof rebuildTrigger.build_agent_id === "string" && rebuildTrigger.build_agent_id.length > 0) ? rebuildTrigger.build_agent_id : null;
+          if (!triggerAgentId) {
+            var uncorrelatedObservation = (function () { var c = verifyAppliedChanges(expectedChanges, rebuildTrigger.applied); return c.ok ? "match" : "mismatch: " + c.reason; })();
+            log("Publish receipt missing for task " + taskId + ": the trigger reported edit_started=true but captured no build receipt (build_agent_id null) — no build attributable to this edit. Parking fail-closed without re-triggering.");
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: uncorrelatedObservation,
+              outcome: "unknown",
+              detail: "edit accepted (edit_started=true) but the trigger captured no build receipt in its capture window: no build attributable to this edit (pending_init-invisible, finished before capture, or queued behind an earlier build). No re-trigger issued — a blind re-trigger on an unknown outcome duplicated the edit on 2026-09-12 and the platform offers no idempotency proof."
+            }, reworkCount);
+            return await parkTask("Publish outcome unknown: the rebuild trigger reported the edit was accepted but captured no build receipt (build_agent_id null) — no build could be attributed to this edit in the capture window. The edit may be pending_init-invisible, already finished, or queued behind an earlier build, so no re-trigger 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 via the ledger and re-drive Publish only after the parent's content read-back resolves what actually landed. Fail-closed.");
+          }
+          rebuildAgentId = triggerAgentId;
+          log("Publish receipt chained for task " + taskId + ": build " + triggerAgentId + " — the follow-up poll waits on this build only.");
+        }
         // 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
@@ -1739,10 +1786,13 @@ while (i < STEPS.length) {
               ? attemptKey("publish-artifact-poll-" + taskId, reworkCount)
               : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, reworkCount);
             buildPoll = await agent(
-              "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.",
+              "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 no build is running (build is null): 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: our build is gone (it finished before this one started). Do NOT wait on the stranger's build and do NOT attribute its completion to our attempt \u2014 stop and report done.\n" +
+              "Return JSON { \"build_done\": <true if our build is no longer running within budget, false on timeout>, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } 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"] },
+                schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
                 timeoutMs: 270000 }
             );
             if (buildPoll && buildPoll.build_done) { break; }

package/workflows/crew-dispatch.js

@@ -248,6 +248,34 @@ function unwrapBoardResult(boardResult) {
       }
     }
   }
+  // The read-board agent may return the whole board stdout in a
+  // {"status":"ok","result":"<board JSON string>"} envelope — the
+  // get-dispatch-state stdout placed in .result as a string instead of a
+  // parsed object (17:00 PDT tick, 2026-09-13). Parse it deterministically
+  // in JS: a string that parses to an array is the ready_tasks array
+  // itself; a string that parses to an object is the whole board stdout,
+  // so re-run the unwrap on it. Unparseable or scalar strings fall through
+  // to the fail-closed throw below.
+  if (boardData && typeof boardData === 'object' && typeof boardData.result === 'string' && !Array.isArray(boardData.ready_tasks)) {
+    var parsedResult = null, resultParsed = false;
+    try {
+      parsedResult = JSON.parse(boardData.result);
+      resultParsed = true;
+    } catch (e) {
+      // Unparseable — fall through to fail-closed below.
+    }
+    if (resultParsed) {
+      if (Array.isArray(parsedResult)) {
+        boardData.ready_tasks = parsedResult;
+      } else if (parsedResult && typeof parsedResult === 'object') {
+        // Recursion happens outside the try: a fail-closed throw from the
+        // inner unwrap must propagate with its own precise message, not be
+        // swallowed into the generic throw below.
+        return unwrapBoardResult(parsedResult);
+      }
+      // Scalar — fall through to fail-closed below.
+    }
+  }
   // The read-board agent may hand back the envelope with ready_tasks as a
   // JSON string — {"ready_tasks": "<json string>"} — the get-dispatch-state
   // stdout placed in the envelope instead of parsed (14:24 PDT tick,
@@ -272,7 +300,7 @@ function unwrapBoardResult(boardResult) {
   if (!boardData || typeof boardData !== 'object' || !Array.isArray(boardData.ready_tasks)) {
     throw new Error(
       "unwrapBoardResult: unknown board envelope — expected ready_tasks at top level, " +
-      "in .data, in .result, in .result.data, or as a JSON string of a ready_tasks array " +
+      "in .data, in .result (object or JSON string), in .result.data, or as a JSON string of a ready_tasks array " +
       "or of a whole board object. Got keys: " +
       (boardData && typeof boardData === 'object' ? Object.keys(boardData).join(",") : typeof boardData)
     );

package/workflows/crew-init.js

@@ -363,9 +363,18 @@ try {
     "      Call cron_update with only the fields that differ. If nothing differs,\n" +
     "      do not call cron_update. Record action 'updated' with the updated field\n" +
     "      names, or 'unchanged' with no updated fields.\n" +
-    "3. Return { passed: true, summary: { crons: [...] } } with one entry per\n" +
-    "   manifest entry, in manifest order: { id, action: 'created' | 'updated' |\n" +
-    "   'unchanged', updated_fields: [...] }.",
+    "3. Write the cron registry at " + crewHome + "/.cron-registry.json — the exact\n" +
+    "   record a later uninstall uses to find these jobs. Build this JSON (one entry\n" +
+    "   per manifest entry, in manifest order, using the live ids from step 2):\n" +
+    "   {\"version\":1,\"instanceId\":\"" + instanceId + "\",\"owner\":\"" + cronOwner + "\",\n" +
+    "    \"crons\":[{\"id\":<live id>,\"manifestId\":<entry.id>}, ...]}\n" +
+    "   Write it with printf '%s' and a single-quoted heredoc so the shell\n" +
+    "   interpolates nothing, then read it back to confirm it parses.\n" +
+    "4. Return { passed: true, summary: { crons: [...], registry: {...} } } with one\n" +
+    "   crons entry per manifest entry, in manifest order:\n" +
+    "   { id, action: 'created' | 'updated' | 'unchanged', updated_fields: [...] },\n" +
+    "   and registry: { path: \"" + crewHome + "/.cron-registry.json\",\n" +
+    "   ids: [<live id>, ...] } echoing the ids written to disk.",
     {
       key: "crons-1",
       label: "Create and converge cron jobs",
@@ -387,9 +396,17 @@ try {
                   },
                   required: ["id", "action", "updated_fields"]
                 }
+              },
+              registry: {
+                type: "object",
+                properties: {
+                  path: { type: "string" },
+                  ids: { type: "array", items: { type: "string" } }
+                },
+                required: ["path", "ids"]
               }
             },
-            required: ["crons"]
+            required: ["crons", "registry"]
           }
         },
         required: ["passed", "summary"]
@@ -399,10 +416,12 @@ try {
 } catch (e) {
   return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Cron setup failed", message: String(e.message || e) } };
 }
-if (!cronsResult.passed || !cronsResult.summary || !Array.isArray(cronsResult.summary.crons)) {
-  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Cron manifest invalid", message: "seed/crons.json failed validation or produced no crons list" } };
+if (!cronsResult.passed || !cronsResult.summary || !Array.isArray(cronsResult.summary.crons) ||
+    !cronsResult.summary.registry || !Array.isArray(cronsResult.summary.registry.ids)) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Cron manifest invalid", message: "seed/crons.json failed validation, produced no crons list, or wrote no cron registry" } };
 }
-log("Crons: " + cronsResult.summary.crons.map(function (c) { return c.id + "=" + c.action; }).join(", "));
+log("Crons: " + cronsResult.summary.crons.map(function (c) { return c.id + "=" + c.action; }).join(", ") +
+    "; registry: " + cronsResult.summary.registry.path + " (" + cronsResult.summary.registry.ids.join(", ") + ")");
 
 
 // ── Summary ───────────────────────────────────────────────────────────
@@ -416,5 +435,6 @@ return {
   releaseHash: releaseResult.hash,
   scaffold: { created: scaffoldCreated, skipped: scaffoldSkipped },
   project: projectResult.action,
-  crons: cronsResult.summary.crons
+  crons: cronsResult.summary.crons,
+  registry: cronsResult.summary.registry
 };

package/workflows/crew-uninstall.js

@@ -0,0 +1,264 @@
+export const meta = {
+  name: "crew-uninstall",
+  description: "Uninstall a Muse Crew instance: remove its scheduler cron jobs, then delete the crew home directory. Destructive and irreversible — requires confirm: true, and refuses to run while any task is in_progress unless force: true. Only the crew's own crons are removed (exact registry plus body-match discovery); shared crons are never touched. Dashboard artifacts are left alone.",
+  phases: [
+    { name: "gates", title: "Containment gate and explicit confirmation" },
+    { name: "safety", title: "Refuse while work is live (unless forced)" },
+    { name: "crons", title: "Remove the crew's scheduler crons" },
+    { name: "home", title: "Delete the crew home directory" }
+  ]
+};
+
+// ── Arguments ──────────────────────────────────────────────────────────
+const inputs = args ?? {};
+const crewHome = inputs.crewHome;
+const confirm = inputs.confirm;
+const force = inputs.force;
+
+if (!crewHome) throw new Error("crewHome is required — e.g. ~/workspace/.crew");
+
+// ── Pure decision helpers ──────────────────────────────────────────────
+// The agent is a sensor, not a judge: it reports raw facts (HOME, expanded
+// paths, existence, in-progress counts) and the verdicts below are computed
+// here, deterministically. (Prompt hardening is a smell — this is the
+// mechanical version.)
+function expandTilde(p, home) {
+  if (p === "~") return home;
+  if (p.indexOf("~/") === 0) return home + p.slice(1);
+  return p;
+}
+function uninstallGateDecide(facts) {
+  // facts: { home, crewHomeExpanded }
+  // Uninstall deletes a directory tree — it must never run against a home
+  // outside the workspace. Same prefix rule as crew-init's Gate 0.
+  var workspace = facts.home + "/workspace";
+  var launchable = facts.crewHomeExpanded.indexOf(workspace + "/") === 0;
+  return { workspace: workspace, launchable: launchable };
+}
+function confirmDecide(c) {
+  // Strict: only the boolean true counts. "true", 1, and undefined do not.
+  if (c === true) return { ok: true, message: "" };
+  return {
+    ok: false,
+    message: "crew-uninstall is destructive and irreversible: it removes the crew's scheduler cron jobs and deletes the crew home directory. Re-run with confirm: true to proceed."
+  };
+}
+function safetyDecide(inProgressCount, f) {
+  // Live work strands if its home disappears mid-run. Refuse unless forced.
+  if (inProgressCount > 0 && f !== true) {
+    return {
+      ok: false,
+      message: inProgressCount + " task(s) are in_progress. Uninstalling now would strand their workflows. Re-run with force: true to uninstall anyway, or finish/park the work first."
+    };
+  }
+  return { ok: true, message: "" };
+}
+
+// ── Gates: containment + confirmation ──────────────────────────────────
+phase("gates");
+var gateFacts;
+try {
+  gateFacts = await agent(
+    "Report filesystem facts for a crew uninstall. Do not judge — just report.\n\n" +
+    "Requested crewHome: " + crewHome + "\n\n" +
+    "Steps (run in shell):\n" +
+    "1. home=$(echo $HOME)\n" +
+    "2. Expand a leading ~/ in the requested crewHome against $HOME (leave other paths untouched).\n" +
+    "3. Report whether the expanded path exists: test -e \"<expanded>\"; echo EXISTS:$?\n" +
+    "4. Return JSON { home, crewHomeExpanded, homeExists } where homeExists is true\n" +
+    "   when the path exists.",
+    {
+      key: "uninstall-gates",
+      label: "Validate uninstall target",
+      schema: {
+        type: "object",
+        properties: {
+          home: { type: "string" },
+          crewHomeExpanded: { type: "string" },
+          homeExists: { type: "boolean" }
+        },
+        required: ["home", "crewHomeExpanded", "homeExists"]
+      }
+    }
+  );
+} catch (e) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Uninstall validation failed", message: String(e.message || e) } };
+}
+var gateResult = uninstallGateDecide(gateFacts);
+if (!gateResult.launchable) {
+  return {
+    __hatchWorkflowControl: "blocked",
+    result: {
+      blocked_reason: "crewHome is not workspace-contained",
+      message: "crewHome must be inside the workspace (" + gateResult.workspace + "). Requested: " + gateFacts.crewHomeExpanded + ". Uninstall refuses to delete anything outside the workspace."
+    }
+  };
+}
+var crewHomeExpanded = gateFacts.crewHomeExpanded;
+var confirmation = confirmDecide(confirm);
+if (!confirmation.ok) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Uninstall not confirmed", message: confirmation.message } };
+}
+log("Uninstall confirmed for " + crewHomeExpanded + (gateFacts.homeExists ? "" : " (crew home already gone — removing orphaned crons only)"));
+
+// ── Safety: refuse while work is live (unless forced) ───────────────────
+phase("safety");
+var safetyFacts = { homeExists: gateFacts.homeExists, inProgress: 0 };
+if (gateFacts.homeExists) {
+  try {
+    safetyFacts = await agent(
+      "Report whether this crew has live work. Do not judge — just report.\n\n" +
+      "crewHome: " + crewHomeExpanded + "\n\n" +
+      "Steps (run in shell):\n" +
+      "1. If \"" + crewHomeExpanded + "/crew-state.db\" exists, run:\n" +
+      "   sqlite3 \"" + crewHomeExpanded + "/crew-state.db\" \"SELECT COUNT(*) FROM tasks WHERE state='in_progress';\"\n" +
+      "   Report the number. When the database is missing, the count is 0.\n" +
+      "2. Return JSON { homeExists: true, inProgress: <number> }.",
+      {
+        key: "uninstall-safety",
+        label: "Check for live work",
+        schema: {
+          type: "object",
+          properties: {
+            homeExists: { type: "boolean" },
+            inProgress: { type: "number" }
+          },
+          required: ["homeExists", "inProgress"]
+        }
+      }
+    );
+  } catch (e) {
+    return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Safety check failed", message: String(e.message || e) } };
+  }
+}
+var safety = safetyDecide(safetyFacts.inProgress, force);
+if (!safety.ok) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Live work in progress", message: safety.message } };
+}
+log("Safety: " + safetyFacts.inProgress + " in_progress task(s)" + (force === true ? " (forced)" : ""));
+
+// ── Remove the crew's scheduler crons ──────────────────────────────────
+// Two sources, unioned: the exact registry written by crew-init (covers id
+// overrides), and discovery (covers installs from before the registry
+// existed, and a registry that was never written). A job is only removed
+// when it is on that union — never by guesswork.
+phase("crons");
+var cronsResult;
+try {
+  cronsResult = await agent(
+    "Remove this crew instance's scheduler cron jobs — and nothing else.\n\n" +
+    "crewHome: " + crewHomeExpanded + "\n\n" +
+    "Steps:\n" +
+    "1. Registry: if \"" + crewHomeExpanded + "/.cron-registry.json\" exists, read it\n" +
+    "   and take its crons[].id list as registry candidates.\n" +
+    "2. Discovery: call cron_list. For every job whose id starts with 'crew-poll-',\n" +
+    "   call cron_view and keep it as a discovery candidate when the job body\n" +
+    "   contains the crewHome string '" + crewHomeExpanded + "' (the poll body template\n" +
+    "   embeds the crew home path). The bare id 'crew-poll' with no instance suffix\n" +
+    "   is never a live crew job — never remove it.\n" +
+    "3. Removal list = registry candidates ∪ discovery candidates, deduped.\n" +
+    "   SAFETY: remove only jobs on this list. When in doubt about any job, fail\n" +
+    "   closed (passed: false) instead of guessing.\n" +
+    "4. For each id on the removal list: call cron_remove. A job that is already\n" +
+    "   gone records action 'already_gone'.\n" +
+    "5. Call cron_list again and confirm none of the removed ids remain. If any\n" +
+    "   remain, return passed: false.\n" +
+    "6. Return { passed: true, summary: { removed: [...] } } with one entry per\n" +
+    "   removal-list id: { id, source: 'registry' | 'discovery',\n" +
+    "   action: 'removed' | 'already_gone' }. An empty removal list is a pass\n" +
+    "   with removed: [].",
+    {
+      key: "uninstall-crons",
+      label: "Remove the crew's crons",
+      schema: {
+        type: "object",
+        properties: {
+          passed: { type: "boolean" },
+          summary: {
+            type: "object",
+            properties: {
+              removed: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: { type: "string" },
+                    source: { type: "string", enum: ["registry", "discovery"] },
+                    action: { type: "string", enum: ["removed", "already_gone"] }
+                  },
+                  required: ["id", "source", "action"]
+                }
+              }
+            },
+            required: ["removed"]
+          }
+        },
+        required: ["passed", "summary"]
+      }
+    }
+  );
+} catch (e) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Cron removal failed", message: String(e.message || e) } };
+}
+if (!cronsResult.passed || !cronsResult.summary || !Array.isArray(cronsResult.summary.removed)) {
+  return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Cron removal failed", message: "The cron-removal agent did not pass. No further teardown was attempted; the crew home is untouched." } };
+}
+var removedDesc = cronsResult.summary.removed.map(function (r) { return r.id + "=" + r.action; }).join(", ");
+log("Crons: " + (removedDesc || "(none belonged to this crew)"));
+
+// ── Delete the crew home directory ─────────────────────────────────────
+phase("home");
+var homeRemoved = false;
+if (gateFacts.homeExists) {
+  var homeResult;
+  try {
+    homeResult = await agent(
+      "Delete the crew home directory.\n\n" +
+      "crewHome: " + crewHomeExpanded + "\n\n" +
+      "Steps:\n" +
+      "1. Best-effort worktree hygiene (failures do not block): if\n" +
+      "   \"" + crewHomeExpanded + "/crew-state.db\" exists, list the repo_path values\n" +
+      "   from its projects table and run 'git worktree prune' in each. Ignore errors.\n" +
+      "2. Run: rm -rf \"" + crewHomeExpanded + "\"\n" +
+      "3. Verify: test ! -e \"" + crewHomeExpanded + "\" — fail closed (passed: false)\n" +
+      "   if the path still exists.\n" +
+      "4. Return { passed: true, summary: { removed: true } }.",
+      {
+        key: "uninstall-home",
+        label: "Delete the crew home",
+        schema: {
+          type: "object",
+          properties: {
+            passed: { type: "boolean" },
+            summary: {
+              type: "object",
+              properties: {
+                removed: { type: "boolean" }
+              },
+              required: ["removed"]
+            }
+          },
+          required: ["passed", "summary"]
+        }
+      }
+    );
+  } catch (e) {
+    return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Crew home removal failed", message: String(e.message || e) } };
+  }
+  if (!homeResult.passed || !homeResult.summary || homeResult.summary.removed !== true) {
+    return { __hatchWorkflowControl: "blocked", result: { blocked_reason: "Crew home removal failed", message: "The crew home could not be deleted. Its crons were already removed; delete " + crewHomeExpanded + " manually." } };
+  }
+  homeRemoved = true;
+  log("Crew home deleted: " + crewHomeExpanded);
+} else {
+  log("Crew home already gone — nothing to delete.");
+}
+
+// ── Summary ────────────────────────────────────────────────────────────
+return {
+  message: "Muse Crew uninstalled.",
+  crewHome: crewHomeExpanded,
+  removed_crons: cronsResult.summary.removed,
+  crew_home_removed: homeRemoved,
+  note: "Dashboard artifacts were left untouched — uninstall removes the crew instance (its crons and its home), never the user's artifacts."
+};

package/workflows/standard.js

@@ -486,8 +486,8 @@ function verifyAppliedChanges(expected, applied) {
 // 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
+  // workflow observed for the publish attempt (the artifact system's in-flight
+  // build correlation ID — not a durable post-completion identifier). The read-back request carries it so the parent can
   // prove the read-back inspected the live build of THIS attempt — not a
   // different build's output. Null/empty means the edit was accepted but
   // never correlated to a builder run. Pure function of inputs — no I/O,
@@ -1493,12 +1493,22 @@ while (i < STEPS.length) {
           "- 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.";
+          "If artifact_edit is still not available after the load, do NOT improvise — return { \"edit_started\": false, \"build_agent_id\": null, \"error\": \"artifact_tools missing after load\", \"applied\": [] }.\n" +
+          "RECEIPT CAPTURE (receipt-chained publish, 2026-09-13): the edit is only half the contract — you must also capture the platform build's receipt, the in-flight correlation ID the follow-up poll chains to.\n" +
+          "- The artifact namespace is already loaded (see below). BEFORE calling artifact_edit, call artifact_status with slug \"" + PUBLISH_SLUG + "\" and note the running build's agent_id (or null when no build is running). This is the pre-edit baseline.\n" +
+          "- Call artifact_edit as instructed above.\n" +
+          "- IMMEDIATELY after artifact_edit returns, call artifact_status again. If a build is running whose agent_id DIFFERS from the pre-edit baseline (or the baseline was null), that build is this edit's — its agent_id is the receipt.\n" +
+          "- If the post-edit status shows the SAME agent_id as the baseline, or no build at all, wait about 15 seconds and check artifact_status again, up to 4 more times. If a build with a NEW agent_id appears, that is the receipt.\n" +
+          "- If no new build appears, the receipt is null: the build may be pending_init-invisible, may have finished before the capture, or may be queued behind the earlier build. Return null — do NOT guess, and do NOT substitute the baseline build's agent_id.\n" +
+          "Make no other calls. Return JSON { \"edit_started\": <true if the edit was accepted, false otherwise>, \"build_agent_id\": <the receipt agent_id string, or null when no build could be attributed to this edit>, \"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" },
+              build_agent_id: {
+                type: ["string", "null"],
+                description: "Receipt-chained publish (2026-09-13): the platform build's in-flight correlation ID (build.agent_id from artifact_status) captured immediately after the edit was accepted — the receipt the follow-up poll chains to. Null when no build could be attributed to this edit. Required: an accepted edit with a null receipt parks fail-closed as unknown."
+              },
               error: { type: "string" },
               applied: {
                 type: "array",
@@ -1517,7 +1527,7 @@ while (i < STEPS.length) {
                 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"] };
+            required: ["edit_started", "build_agent_id", "applied"] };
         var rebuildTrigger = null;
         var rebuildReportMissing = false; // true if the edit went through but the agent returned no applied report (structured-output failure) — the smoke-check is skipped; the parent's independent read-back is the verification
         // The trigger key of the attempt that last ran, for the publish ledger.
@@ -1551,8 +1561,9 @@ while (i < STEPS.length) {
           //
           // 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.
+          // the build's agent_id (the artifact system's in-flight build
+          // correlation ID, stable across polls while the build runs)
+          // 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
@@ -1619,6 +1630,42 @@ while (i < STEPS.length) {
             { key: attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", totalReworkCount), label: "Triggering artifact rebuild (retry)", schema: rebuildSchema });
           rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId + "-retry2", totalReworkCount);
         }
+        // Receipt chaining (2026-09-13): adopt the trigger's build receipt,
+        // or park on an uncorrelated acceptance. The trigger's closeout schema
+        // requires build_agent_id — the platform build's in-flight correlation
+        // ID captured immediately after the edit was accepted.
+        // An accepted edit (edit_started=true) with a null receipt is UNKNOWN,
+        // not "did not go through": the build may be pending_init-invisible,
+        // may have finished before the capture window, or may be queued behind
+        // a still-running earlier build. No re-trigger is issued on unknown —
+        // a blind re-trigger duplicated the edit on 2026-09-12, and the platform
+        // offers no idempotency proof that would make re-issue safe.
+        // (Retry-semantics reconciliation, 2026-09-13: the "no receipt → safe
+        // re-trigger" sketch assumed the edit command idempotently publishes
+        // what's on git; the duplicate-edit incident disproves the assumption,
+        // and the standing rule retries only on explicit negative evidence.
+        // Re-trigger stays exactly where it was: the edit_started=false
+        // explicit-rejection path above.) Record the attempt and park
+        // fail-closed; correlate via the ledger and the parent's content
+        // read-back before re-driving Publish.
+        if (rebuildTrigger && rebuildTrigger.edit_started && !rebuildReportMissing) {
+          var triggerAgentId = (typeof rebuildTrigger.build_agent_id === "string" && rebuildTrigger.build_agent_id.length > 0) ? rebuildTrigger.build_agent_id : null;
+          if (!triggerAgentId) {
+            var uncorrelatedObservation = (function () { var c = verifyAppliedChanges(expectedChanges, rebuildTrigger.applied); return c.ok ? "match" : "mismatch: " + c.reason; })();
+            log("Publish receipt missing for task " + taskId + ": the trigger reported edit_started=true but captured no build receipt (build_agent_id null) — no build attributable to this edit. Parking fail-closed without re-triggering.");
+            await recordPublishLedger({
+              commit: mergeCommitForPublish,
+              attempt: rebuildAttemptKey,
+              agent_id: null,
+              applied_report: uncorrelatedObservation,
+              outcome: "unknown",
+              detail: "edit accepted (edit_started=true) but the trigger captured no build receipt in its capture window: no build attributable to this edit (pending_init-invisible, finished before capture, or queued behind an earlier build). No re-trigger issued — a blind re-trigger on an unknown outcome duplicated the edit on 2026-09-12 and the platform offers no idempotency proof."
+            }, totalReworkCount);
+            return await parkTask("Publish outcome unknown: the rebuild trigger reported the edit was accepted but captured no build receipt (build_agent_id null) — no build could be attributed to this edit in the capture window. The edit may be pending_init-invisible, already finished, or queued behind an earlier build, so no re-trigger 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 via the ledger and re-drive Publish only after the parent's content read-back resolves what actually landed. Fail-closed.");
+          }
+          rebuildAgentId = triggerAgentId;
+          log("Publish receipt chained for task " + taskId + ": build " + triggerAgentId + " — the follow-up poll waits on this build only.");
+        }
         // 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
@@ -1722,10 +1769,13 @@ while (i < STEPS.length) {
               ? attemptKey("publish-artifact-poll-" + taskId, totalReworkCount)
               : attemptKey("publish-artifact-poll-" + taskId + "-c" + chunk, totalReworkCount);
             buildPoll = await agent(
-              "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.",
+              "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 no build is running (build is null): 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: our build is gone (it finished before this one started). Do NOT wait on the stranger's build and do NOT attribute its completion to our attempt \u2014 stop and report done.\n" +
+              "Return JSON { \"build_done\": <true if our build is no longer running within budget, false on timeout>, \"status\": \"<final status or timeout note>\", \"observed_agent_id\": \"<the agent_id seen on the last check, or null when no build was running>\" } 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"] },
+                schema: { type: "object", properties: { build_done: { type: "boolean" }, status: { type: "string" }, observed_agent_id: { type: ["string", "null"] } }, required: ["build_done"] },
                 timeoutMs: 270000 }
             );
             if (buildPoll && buildPoll.build_done) { break; }

package/workflows/tests/read-board-parse.test.mjs

@@ -125,6 +125,40 @@ ok("string and object returns converge identically (deep equal)", () => {
   assert.deepStrictEqual(fromString, fromObject);
 });
 
+// ── result-as-string envelope (2026-09-13 17:00 PDT tick) ───────────
+// The read-board agent returned {"status":"ok","result":"<board JSON>"} —
+// the whole board stdout as a string in .result. unwrapBoardResult must
+// converge it the same way it converges every other envelope.
+ok("envelope string {status, result: board-JSON-string} converges", () => {
+  const boardData = converge(JSON.stringify({ status: "ok", result: JSON.stringify(BOARD) }));
+  assert.deepStrictEqual(boardData.ready_tasks, TASKS);
+  assert.deepStrictEqual(boardData.projects, PROJECTS);
+});
+
+ok("envelope object {status, result: board-JSON-string} converges", () => {
+  const boardData = converge({ status: "ok", result: JSON.stringify(BOARD) });
+  assert.deepStrictEqual(boardData.ready_tasks, TASKS);
+  assert.deepStrictEqual(boardData.projects, PROJECTS);
+});
+
+ok("envelope {status, result: tasks-array-JSON-string} converges", () => {
+  const boardData = converge({ status: "ok", result: JSON.stringify(TASKS) });
+  assert.deepStrictEqual(boardData.ready_tasks, TASKS);
+});
+
+ok("doubly-nested envelope {status, result: \"{result:{ready_tasks}}\"} converges", () => {
+  const inner = JSON.stringify({ result: { ready_tasks: TASKS } });
+  const boardData = converge(JSON.stringify({ status: "ok", result: inner }));
+  assert.deepStrictEqual(boardData.ready_tasks, TASKS);
+});
+
+throwsClosed("envelope {status, result: unparseable-string} throws", () =>
+  converge(JSON.stringify({ status: "ok", result: "{not json" })));
+throwsClosed("envelope {status, result: scalar-string} throws", () =>
+  converge(JSON.stringify({ status: "ok", result: "42" })));
+throwsClosed("envelope {status, result: JSON-without-ready_tasks} throws", () =>
+  converge(JSON.stringify({ status: "ok", result: JSON.stringify({ foo: 1 }) })));
+
 // ── Fail-closed: never a silent empty task set ──────────────────────
 throwsClosed("invalid JSON string throws", () => converge("{not json"));
 throwsClosed("truncated JSON throws", () => converge('{"ready_tasks": ['));