muse-crew 0.7.18 → 0.7.20

package/workflows/chore.js

@@ -499,48 +499,6 @@ function parseUnifiedDiff(diffText) {
   return files;
 }
 
-// Compare the artifact builder's reported applied-changes against the diff's
-// expected changes. Every added/removed line must match exactly per path,
-// and the file counts must match — the builder applies exactly the carried
-// change, nothing more, nothing less. Pure function — no I/O, no clock.
-// OBSERVATION INPUT ONLY (2026-09-12, task 23ca8f3f): the applied report
-// has a demonstrated false-negative mode (applied:[] for a diff the builder
-// had actually applied), and it is derived from the carried diff, so a match
-// certifies nothing either. A mismatch is logged as observation; it never
-// parks and never blocks the stamp. The verification is the independent
-// read-back (docs/publish-verification.md).
-function verifyAppliedChanges(expected, applied) {
-  if (!Array.isArray(applied)) {
-    return { ok: false, reason: "builder returned no applied-changes list" };
-  }
-  function sorted(a) { return (a || []).slice().sort(); }
-  function eq(a, b) {
-    a = sorted(a); b = sorted(b);
-    if (a.length !== b.length) return false;
-    for (var i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-    return true;
-  }
-  for (var i = 0; i < expected.length; i++) {
-    var exp = expected[i];
-    var got = null;
-    for (var j = 0; j < applied.length; j++) {
-      if (applied[j] && applied[j].path === exp.path) { got = applied[j]; break; }
-    }
-    if (!got) {
-      return { ok: false, reason: "builder did not report changing '" + exp.path + "'" };
-    }
-    if (!eq(exp.added, got.added)) {
-      return { ok: false, reason: "added lines for '" + exp.path + "' do not match the carried diff" };
-    }
-    if (!eq(exp.removed, got.removed)) {
-      return { ok: false, reason: "removed lines for '" + exp.path + "' do not match the carried diff" };
-    }
-  }
-  if (applied.length !== expected.length) {
-    return { ok: false, reason: "builder reported changing " + applied.length + " file(s), diff carries " + expected.length };
-  }
-  return { ok: true };
-}
 
 // Publish read-back request (currently unavailable): the verbatim_request
 // the parent protocol (docs/publish-verification.md) would hand to an
@@ -554,35 +512,12 @@ function verifyAppliedChanges(expected, applied) {
 // finding. Until a read-back path exists, the parent cannot independently
 // confirm content and verification parks at "publish: verification-requested"
 // (see docs/publish-verification.md). This preserves the circularity break
-// that hollowed canary run 8 (2026-09-11): verifyAppliedChanges compares the
-// builder's applied-report against the diff the report was derived from — a
-// fabricated report passes by construction. Independent read-back cannot be
+// that hollowed canary run 8 (2026-09-11): the old verifyAppliedChanges
+// compared the builder's applied-report against the diff the report was
+// derived from — a fabricated report passed by construction. The report
+// itself is gone now (2026-09-16 fire-and-forget trigger). Independent
+// read-back cannot be
 // fabricated from the diff; it must match the artifact's real content.
-// Pre-publish base observation (diagnostic, 2026-09-12): instruction fragment
-// for the builder's edit request, asking it to report the sha256 of each
-// touched file's CURRENT content BEFORE applying the diff. Pure function —
-// no I/O, no clock.
-//
-// Why: the builder applies the carried diff to its own source tree, whose
-// base state is unrecorded. The post-hoc read-back only checks the changed
-// regions AFTER the edit; it cannot tell us what base the diff landed on.
-// If the tree was dirty or drifted before the edit, the read-back still
-// passes (the diff's lines are present) while the artifact silently carries
-// uncommitted content — the production validateRepoPath incident
-// (2026-09-12), where the live artifact contained code absent from every git
-// ref. These pre-hashes, compared against the workflow-computed expected
-// base hashes (merge parent), reveal what the publish actually read.
-// Observation only — the workflow logs mismatches but never parks on them.
-function buildPreHashInstruction(files) {
-  var paths = files.map(function(f) { return f.path; }).join(", ");
-  return (
-    "- BEFORE applying anything, compute the sha256 hash of each file below as it CURRENTLY exists in your source tree (before your changes). Use the exact bytes of the current file content.\n" +
-    "- Report these hashes in the \"pre_hashes\" field of your return JSON, as { \"<path>\": \"<sha256 hex>\" }.\n" +
-    "- If a file does not exist in your tree, report its hash as the string \"MISSING\".\n" +
-    "- Do this BEFORE applying the diff — the hashes must reflect the pre-edit state.\n" +
-    "  Files: " + paths + "\n"
-  );
-}
 
 // Durable publish-attempt ledger (2026-09-12): every artifact publish
 // attempt is recorded append-only at $CREW_HOME/.publish-ledger/<slug>.jsonl
@@ -1412,9 +1347,10 @@ while (i < STEPS.length) {
       // 2026-09-11), so the stamp moved to the parent — after the build
       // lands, the workflow records the session completed and parks with
       // "publish: verification-requested". The parent owns verification
-      // (docs/publish-verification.md); the independent read-back step is
-      // currently unavailable (no agent-callable read-back tool exists —
-      // artifact_inspect was removed by the platform 2026-09-14).
+      // (docs/publish-verification.md); the primary sensor is the
+      // deterministic lib/readback-disk.js (the agent-callable read-back
+      // tool is unavailable — artifact_inspect was removed by the platform
+      // 2026-09-14 — so the LLM-inspector path is manual-fallback only).
       // Chore has no QA: the parent's verification is the final gate.
       var artifactPublish = null;
       var publishLockRefreshed = false;
@@ -1524,38 +1460,8 @@ while (i < STEPS.length) {
         if (expectedChanges.length === 0) {
           return await parkTask("Publish diff parsed to zero files for commit " + (mergeCommitForPublish || "unknown") + " — cannot verify application. Human attention needed.");
         }
-        // Pre-publish base observation (diagnostic, 2026-09-12): the builder
-        // applies the diff to its own source tree, whose base state is
-        // unrecorded. Compute the trustworthy expected base — the sha256 of
-        // each touched file at the merge parent commit — so the builder's
-        // self-reported pre-edit hashes (see buildPreHashInstruction) can be
-        // compared against it. Observation only: a mismatch is logged loudly
-        // but never parks. The observation tells us what the publish actually
-        // reads, so the subsequent fix can require the right base.
-        var expectedBaseHashes = {};
-        if (publishBase === EMPTY_TREE_SHA) {
-          // First publish: every file in the diff is new to the artifact.
-          expectedChanges.forEach(function (f) { expectedBaseHashes[f.path] = "NEW-FILE"; });
-          log("Publish expected base hashes for task " + taskId + ": empty tree (first publish) — all " + expectedChanges.length + " file(s) new");
-        } else try {
-          // Shell-quote helper (no regex-with-quote: the test parser does not
-          // understand regex literals containing quotes).
-          var sq = function(s) { return "'" + String(s).split("'").join("'\\''") + "'"; };
-          var baseHashResult = await agent(
-            "Run: cd " + REPO_PATH + " && parent=" + sq(publishBase) + " && for f in " + expectedChanges.map(function(f) { return sq(f.path); }).join(" ") + "; do printf '%s:' \"$f\"; git show \"$parent:$f\" 2>/dev/null | sha256sum | cut -d' ' -f1; done\n" +
-            "Return JSON { \"hashes\": \"<newline-separated <path>:<sha256> lines, empty hash means the file is new in this diff>\" } and nothing else.",
-            { key: attemptKey("publish-base-hashes-" + taskId, reworkCount), label: "Computing expected base content hashes",
-              schema: { type: "object", properties: { hashes: { type: "string" } }, required: ["hashes"] } }
-          );
-          (baseHashResult.hashes || "").split("\n").forEach(function(line) {
-            var m = /^([^:]+):([0-9a-f]*)$/.exec(line.trim());
-            if (m) expectedBaseHashes[m[1]] = m[2] || "NEW-FILE";
-          });
-          log("Publish expected base hashes for task " + taskId + " (stamped base " + publishBase.slice(0, 12) + "): " + JSON.stringify(expectedBaseHashes));
-        } catch (e) {
-          log("Publish expected base hash computation failed for task " + taskId + " (non-fatal, observation degraded): " + (e && e.message ? e.message : e));
-        }
         var rebuildPrompt =
+          ARTIFACT_LOAD_PREAMBLE +
           "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" +
@@ -1568,79 +1474,50 @@ while (i < STEPS.length) {
           "- For a deleted file (+++ /dev/null), delete it.\n" +
           "- If any hunk does not apply cleanly, STOP and report the failure — do not improvise or skip hunks.\n" +
           "- Do not make any other source changes.\n" +
-          "- After applying, rebuild and deploy.\n" +
-          "- Report, for each file you changed: its path, the exact lines you added, and the exact lines you removed.\n" +
-          buildPreHashInstruction(expectedChanges) + "'\n" +
-          ARTIFACT_LOAD_PREAMBLE +
-          "If artifact_edit is still not available after the load, do NOT improvise — return { \"edit_started\": false, \"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",
-                items: {
-                  type: "object",
-                  properties: {
-                    path: { type: "string" },
-                    added: { type: "array", items: { type: "string" } },
-                    removed: { type: "array", items: { type: "string" } }
-                  },
-                  required: ["path", "added", "removed"]
-                }
-              },
-              pre_hashes: {
-                type: "object",
-                description: "Diagnostic (2026-09-12): sha256 of each touched file's content BEFORE the builder applied the diff, as reported by the builder. Compared against the workflow-computed expected base hashes (merge parent) — observation only, never gating."
-              }
-            },
-            required: ["edit_started", "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
-        var rebuildEvidenceNote = null; // human-readable evidence line for the ledger when the edit is confirmed via fallback evidence (in-flight poll or durable audit dir) rather than the trigger's own report
+          "- 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 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";
         // The trigger key of the attempt that last ran, for the publish ledger.
         // Minted once here (not re-minted per use site) so the ledger always
         // records the exact key that was issued — and so a re-minted duplicate
         // can never drift from it.
         var rebuildAttemptKey = attemptKey("publish-artifact-rebuild-" + taskId, reworkCount);
-        // The artifact build's agent_id, captured from artifact_status when the
-        // trigger's outcome is ambiguous (structured-output failure). The
-        // agent_id is the artifact system's in-flight correlation ID (not durable post-completion)
-        // (research 2026-09-12): artifact.edit returns pending_init with NO
-        // agent_id, but artifact_status exposes build.agent_id immediately
-        // after acceptance, stable across polls. Recorded in the ledger so an
-        // ambiguous attempt correlates to the exact builder run; null when no
-        // build was ever observed.
+        // The artifact build's agent_id, attributed to this edit by the
+        // workflow-owned observation below. The agent_id is the artifact
+        // system's in-flight correlation ID (research 2026-09-12):
+        // artifact.edit returns pending_init with NO agent_id, but
+        // artifact_status exposes build.agent_id immediately after
+        // acceptance, stable across polls. Recorded in the ledger so an
+        // attempt correlates to the exact builder run; null when no build
+        // was ever observed.
         var rebuildAgentId = null;
-        // The builder's applied-report is an observation, not a gate
-        // (2026-09-12, task 23ca8f3f): computed once the trigger outcome is
-        // known, logged loudly, never a park.
-        var publishAppliedObservation = null; // "match" | "mismatch: <reason>" | "missing-report" — observation only, never a park
-        // Durable-evidence snapshot (2026-09-14): the structured-output
-        // fallback below only observes IN-FLIGHT builds. A build that
-        // finished before the poll leaves no in-flight trace — but the
-        // platform's audit harness leaves a durable one:
+        // The builder's applied report is gone (2026-09-16): it rode on the
+        // trigger's JSON closeout contract, which is removed below. The
+        // parent's independent read-back (docs/publish-verification.md) is
+        // the verification — this field stays "missing-report" on ledger
+        // lines for issued triggers; pre-trigger parks (toolcheck
+        // rejected/inconclusive) and unattributed-unknown parks write null
+        // (no trigger was observed, so there is nothing to report).
+        var publishAppliedObservation = "missing-report";
+        // Durable-evidence snapshot (2026-09-14): the observation below only
+        // detects IN-FLIGHT builds. A build that finished before the
+        // observation leaves no in-flight trace — but the platform's audit
+        // harness leaves a durable one:
         // ~/workspace/ts-spaces/<slug>/audits/<timestamp>-<id>/ per
         // completed build. Snapshot the listing BEFORE the trigger so the
         // fallback can diff before/after: a directory appearing during the
         // trigger window is positive evidence the edit went through and
         // the build completed. Best-effort and non-gating: if the snapshot
-        // fails, the durable check is skipped and the fallback behaves as
-        // before. No wall-clock in-script (deterministic replay) — the
+        // fails, auditBeforeOk stays false and BOTH fallback comparisons
+        // are disabled (2026-09-16, critic finding 4) — without a baseline,
+        // an empty before-list would make every historical audit dir look
+        // "new". No wall-clock in-script (deterministic replay) — the
         // comparison is a pure before/after set diff.
         var auditDirsBeforeTrigger = [];
+        var auditBeforeOk = false;
         try {
           var auditBefore = await agent(
             "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort snapshot, never a gate).\n" +
@@ -1650,242 +1527,342 @@ while (i < STEPS.length) {
               schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
           );
           auditDirsBeforeTrigger = String((auditBefore && auditBefore.dirs) || "").split("\n").map(function (s) { return s.trim(); }).filter(function (s) { return s.length > 0; });
+          auditBeforeOk = true;
           log("Publish audit-dir snapshot before trigger for task " + taskId + ": " + auditDirsBeforeTrigger.length + " entries");
         } catch (auditBeforeErr) {
-          log("Publish audit-dir snapshot before trigger failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditBeforeErr && auditBeforeErr.message ? auditBeforeErr.message : auditBeforeErr));
+          log("Publish audit-dir snapshot before trigger 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));
         }
+        // Fire-and-forget trigger + workflow-owned observation (2026-09-16,
+        // clean-room task e2a8d9f8): the trigger's JSON closeout contract
+        // traveled over the stochastic text channel, and the runtime's
+        // JSON-candidate heuristic misfired on it ("workflow agent output
+        // was not JSON: no JSON object or array found in final response"),
+        // parking a task whose edit may have gone through. The contract's
+        // content was already observation-only (the applied report never
+        // gated; the pre_hashes were diagnostic-only), so the contract is
+        // removed: the trigger carries NO schema and its return value is
+        // never consumed, which takes the extraction heuristic out of this
+        // call entirely. The workflow attributes the edit itself through
+        // the tiny schema'd reads below — no prose is parsed for the
+        // trigger outcome.
+        // (Probe, 2026-09-16: the workflow scope exposes only agent() —
+        // tool_search, artifact_edit and artifact_status are undefined
+        // there — so the workflow cannot call the artifact tools directly;
+        // observation still goes through minimal child calls with tiny
+        // schemas, never a broad JSON contract.)
+        //
+        // Pre-trigger toolcheck (tiny, schema'd): the artifact namespace is
+        // deferred for workflow children — the child self-loads it and emits
+        // one exact signal line, read mechanically (never English prose).
+        // Only a parsed ARTIFACT_TOOLS: missing signal is explicit negative
+        // evidence: it gets one bounded retry with a fresh key, then parks
+        // rejected — without the tools the edit provably did NOT go through,
+        // so this is the one safe retry on the publish path. A throw (or an
+        // unparseable signal) is INCONCLUSIVE transport noise, never
+        // evidence of missing tools (2026-09-16, critic finding 3): it is
+        // recorded, it retries once in case the flake clears, but it can
+        // never take the rejected path.
+        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"), reworkCount),
+                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"
+          }, reworkCount);
+          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"
+          }, reworkCount);
+          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.");
+        }
+        // Pre-trigger build-state baseline (tiny, schema'd): one read of
+        // artifact_status. The post-trigger observation diffs against this
+        // baseline — a build whose agent_id was absent from (or differs
+        // from) the baseline is attributed to our edit; a build already in
+        // flight at baseline predates the trigger and is never attributed
+        // to it. If the baseline read itself fails, receipt attribution is
+        // skipped and the durable audit-dir evidence below is the only
+        // positive signal.
+        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, reworkCount), 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");
+        }
+        // The trigger itself: the artifact_edit call is AWAITED (the workflow
+        // waits for it to complete) but its return value is intentionally
+        // UNCONSUMED — NO schema, so no schema validation can fail this
+        // call: a schema-less call resolves to the child's raw response as
+        // a plain string (probed live 2026-09-16 — never parsed, never
+        // throws on content). One caveat, also probed: the runtime still
+        // scans the response for a JSON candidate, and an unparseable
+        // {...}-looking substring in the child's prose throws ("response
+        // JSON candidate", probe P6). The prompt tells the child to end its
+        // turn with no prose at all, which keeps the common case clean —
+        // but the channel is stochastic, so any throw is possible and
+        // inconclusive: the edit may still have gone through, so the
+        // outcome stays unknown until the observation below confirms it —
+        // never inferred from the throw, and never blind-retried (a blind
+        // re-trigger duplicated the edit on 2026-09-12).
+        var rebuildTrigger = null;
         try {
-          rebuildTrigger = await agent(rebuildPrompt,
-            { key: rebuildAttemptKey, label: "Triggering artifact rebuild", schema: rebuildSchema });
-        } catch (rebuildErr) {
-          // Structured-output failure (canary run 9, 2026-09-11): the agent
-          // called artifact_edit (tool_call_count > 0) but returned prose
-          // instead of JSON. The side effect may have happened — the outcome
-          // is UNKNOWN, not "did not go through". The old code asked a child
-          // for derived booleans and retried on all-false; that check issued
-          // the DUPLICATE artifact_edit on 2026-09-12.
-          //
-          // Build-ID research (2026-09-12) corrected the model: artifact.edit
-          // returns pending_init with NO agent_id, but artifact_status exposes
-          // the build's agent_id (the artifact system's 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
-          // workflow script. An observed agent_id is positive evidence the
-          // edit went through; no build after a bounded poll is still
-          // inconclusive (unknown), never proof the edit failed. Mechanical
-          // rule: never blind-retry on unknown — record the attempt and park
-          // fail-closed; correlate via the ledger, never by re-issuing.
-          log("Publish rebuild trigger: structured-output failure (" + (rebuildErr && rebuildErr.message ? rebuildErr.message : rebuildErr) + ") — checking build state before deciding; outcome unknown until state confirms it");
-          var buildState = null;
-          var buildStateFailed = false;
+          var triggerResultLength = String(await agent(rebuildPrompt,
+            { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "").length;
+          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerResultLength + " chars; awaited but return intentionally unconsumed)");
+        } 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");
+        }
+        // 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, reworkCount), 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;
+        // Known limitation (failure-mode audit 2026-09-16): attribution
+        // is timing-based — any agent_id new relative to the baseline is
+        // treated as this edit's receipt. A stranger's build starting inside
+        // the trigger window is indistinguishable by timing and would be
+        // misattributed here. The consequence is bounded: the completion
+        // poll below tracks the recorded id, and the parent's mechanical
+        // content read-back (docs/publish-verification.md) certifies the
+        // exact commit's content — a wrong build's content fails closed as
+        // verification-failed, never stamped. Timing narrows the candidate;
+        // content decides.
+        var receiptAgentId = (!buildStateFailed && !baselineFailed && observedAgentId && observedAgentId !== baselineAgentId) ? observedAgentId : 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,
+            outcome: "submitted",
+            detail: "fire-and-forget trigger; build receipt captured by workflow-owned build-state observation (pre/post-trigger diff)"
+          }, reworkCount);
+        } else {
+          var newAuditDirs = [];
+          // 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.
+          // Defined here so both the immediate and post-poll audit
+          // fallbacks share it.
+          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-16, critic finding 2) When durable audit evidence
+          // confirms (or refutes) the build, there is no receipt agent_id
+          // to chain the completion poll to — skipReceiptPoll bypasses the
+          // poll below, which with a null receipt could only observe
+          // strangers or nothing.
+          var skipReceiptPoll = false;
+          // publishFailure is declared here (moved up from below) so the
+          // immediate audit fallback can record an explicit build failure
+          // without the later declaration resetting it.
+          var publishFailure = null;
           try {
-            buildState = await agent(
-              ARTIFACT_LOAD_PREAMBLE +
-              "Call artifact_status with slug \"" + PUBLISH_SLUG + "\".\n" +
-              "Poll up to 3 times, about 20 seconds apart, until the response shows a build (the \"build\" value is an object, not null). " +
-              "Return the raw \"build\" value verbatim as JSON — the build object exactly as returned, with its agent_id, operation, status, and any other fields untouched. " +
-              "Do not summarize, interpret, or derive booleans from it. " +
-              "If no build appears after 3 polls, return null. " +
-              "Return JSON { \"build\": <the raw build object or null> } and nothing else.",
-              { key: attemptKey("publish-artifact-buildcheck-" + taskId, reworkCount), label: "Reading artifact build state after trigger failure",
-                schema: { type: "object", properties: { build: { type: ["object", "null"] } }, required: ["build"] } }
+            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, reworkCount), label: "Re-listing audit dirs after trigger",
+                schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
             );
-          } catch (buildCheckErr) {
-            buildStateFailed = true;
-            log("Publish rebuild trigger: build-state check itself failed (" + (buildCheckErr && buildCheckErr.message ? buildCheckErr.message : buildCheckErr) + ") — treating the outcome as unknown");
+            var 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));
           }
-          var acceptedAgentId = (buildState && buildState.build && typeof buildState.build.agent_id === "string" && buildState.build.agent_id) || null;
-          if (!buildStateFailed && acceptedAgentId) {
-            // The edit went through — the agent just failed to return JSON.
-            // The build's agent_id is positive evidence: it appears in
-            // artifact_status immediately after our accepted edit (pending_init
-            // acceptance is followed by a visible build with a stable agent_id,
-            // per the 2026-09-12 research). No applied report to smoke-check;
-            // the parent's independent read-back (docs/publish-verification.md)
-            // is the real verification, not the circular applied-report. The
-            // agent_id is recorded in the ledger so this attempt correlates to
-            // the exact builder run, not just commit + attempt key.
-            log("Publish rebuild trigger: artifact_status shows build " + acceptedAgentId + " for slug " + PUBLISH_SLUG + " — the edit went through despite the structured-output failure. Skipping applied-report smoke-check; parent read-back is the verification.");
-            rebuildTrigger = { edit_started: true, error: "", applied: null };
-            rebuildReportMissing = true;
-            rebuildAgentId = acceptedAgentId;
-            rebuildEvidenceNote = "edit confirmed via build-state poll after structured-output failure (build " + acceptedAgentId + "); builder applied-report missing";
-          } else {
-            // Durable completion check (2026-09-14): the in-flight poll
-            // above only sees RUNNING builds. Attempt 7 (2026-09-14) proved
-            // the gap: the trigger child applied the edit, the build ran
-            // and completed — the platform's audit harness captured it
-            // mid-window — then the child failed to return JSON. The
-            // fallback poll saw no in-flight build, so a successful publish
-            // parked as "unknown". Diff the audit-dir listing against the
-            // pre-trigger snapshot: a timestamped directory that appeared
-            // during the trigger window is positive evidence the edit went
-            // through and the build completed. This never re-issues the
-            // edit and never stamps provenance — it only routes to the
-            // parent's independent content read-back, which remains the
-            // real verification.
-            var newAuditDirs = [];
+          if (newAuditDirs.length > 0) {
+            rebuildTrigger = { edit_started: true };
+            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-16, critic finding 2) 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: ok=true confirms completion and routes
+            // directly to parent verification (the poll is skipped);
+            // ok=false is explicit failure; unreadable is unknown.
+            var immediateReportOk = null;
             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, reworkCount), label: "Re-listing audit dirs after trigger failure",
-                  schema: { type: "object", properties: { dirs: { type: "string" } }, required: ["dirs"] } }
+              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, reworkCount), label: "Reading build report for audit-confirmed build",
+                  schema: { type: "object", properties: { raw: { type: "string" } }, required: ["raw"] } }
               );
-              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.
-              newAuditDirs = 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 failure failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterErr && auditAfterErr.message ? auditAfterErr.message : auditAfterErr));
+              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;
             }
-            if (newAuditDirs.length > 0) {
-              log("Publish rebuild trigger: new audit dir(s) during the trigger window (" + newAuditDirs.join(", ") + ") — the edit went through and the build completed despite the structured-output failure. Skipping applied-report smoke-check; parent read-back is the verification.");
-              rebuildTrigger = { edit_started: true, error: "", applied: null };
-              rebuildReportMissing = true;
-              rebuildAgentId = null;
-              rebuildEvidenceNote = "edit confirmed via durable audit evidence after structured-output failure (new audit dir " + newAuditDirs[0] + "); builder applied-report missing";
+            if (immediateReportOk === true) {
+              publishBuildLanded = true;
+              artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
+              skipReceiptPoll = true;
+              log("Publish build landed for task " + taskId + " via immediate durable audit evidence (audit dir " + newestImmediateDir + ", report ok=true) — receipt poll skipped (no receipt to chain to), routing directly to parent verification");
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: null,
+                applied_report: publishAppliedObservation,
+                outcome: "submitted",
+                detail: "durable audit evidence shows a build completed during the attempt window (audit dir " + newestImmediateDir + ", report ok=true); receipt poll skipped (no receipt agent_id), routed to parent verification"
+              }, reworkCount);
+            } else if (immediateReportOk === false) {
+              skipReceiptPoll = true;
+              publishFailure = "Artifact build FAILED for slug " + PUBLISH_SLUG + " (audit dir " + newestImmediateDir + ", report ok=false — immediate audit evidence, no receipt observed). Explicit negative evidence: a build ran and failed. The publish did not land — provenance was not stamped. Fail-closed.";
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: null,
+                applied_report: publishAppliedObservation,
+                outcome: "failed",
+                detail: "a build ran and failed: audit dir " + newestImmediateDir + " report ok=false (immediate audit evidence, no receipt)"
+              }, reworkCount);
             } else {
-            // No build observed — but that proves nothing (a fast-completing
-            // build can finish between polls, or the check itself failed). The
-            // outcome is UNKNOWN. No retry: re-issuing the edit here duplicated
-            // it on 2026-09-12. Record the attempt durably and park fail-closed;
+              await recordPublishLedger({
+                commit: mergeCommitForPublish,
+                attempt: rebuildAttemptKey,
+                agent_id: null,
+                applied_report: null,
+                outcome: "unknown",
+                detail: "new audit dir " + newestImmediateDir + " appeared during the trigger window but its build report is unreadable/missing; no receipt agent_id to poll — outcome unknown, fail-closed with no blind retry"
+              }, reworkCount);
+              return await parkTask("Publish outcome unknown for task " + taskId + ": a new audit dir (" + newestImmediateDir + ") appeared during the trigger window but its build report is unreadable, and no in-flight receipt was observed to poll. The edit may have completed. Correlate the accepted edit via the publish ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl — do NOT reissue the edit blindly: if the trigger was accepted, a retry duplicates it (2026-09-12). Verify independently whether the build completed (audit dir + report, or the parent's content read-back) before deciding the next step. Fail-closed.");
+            }
+          } else {
+            // No attributable build and no durable evidence — but that
+            // proves nothing (a fast-completing build can finish between
+            // polls, or the checks themselves failed). The outcome is
+            // UNKNOWN. No retry: re-issuing the edit here duplicated it on
+            // 2026-09-12. Record the attempt durably and park fail-closed;
             // correlate via the ledger, never by guessing from a blind poll.
-            log("Publish rebuild trigger: no build observed after structured-output failure — outcome UNKNOWN. Recording the attempt and parking fail-closed; no blind retry.");
+            log("Publish rebuild trigger for task " + taskId + ": no attributable build observed and no new audit dir — outcome UNKNOWN. Recording the attempt and parking fail-closed; no blind retry.");
             await recordPublishLedger({
               commit: mergeCommitForPublish,
               attempt: rebuildAttemptKey,
               agent_id: null,
               applied_report: null,
               outcome: "unknown",
-              detail: "structured-output failure on rebuild trigger; build-state poll saw no build (or the check itself failed); edit may have been accepted as pending_init"
+              detail: "fire-and-forget trigger; post-trigger build-state poll saw no attributable build (or the check failed) and the audit-dir diff found no new dir; the edit may have been accepted as pending_init"
             }, reworkCount);
-            return await parkTask("Publish outcome unknown: the rebuild trigger's child did not return JSON, and the follow-up build-state poll could not observe a build for slug " + PUBLISH_SLUG + ". The edit may have been accepted as pending_init, so no retry was issued — a blind retry duplicated the edit on 2026-09-12. The attempt is recorded in the publish ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl (commit " + String(mergeCommitForPublish || "unknown").slice(0, 12) + "). Correlate the accepted edit via the ledger and the builder's eventual completion before re-driving Publish. Fail-closed.");
-            }
+            return await parkTask("Publish outcome unknown for task " + taskId + ": the rebuild trigger was issued fire-and-forget (no schema, so no validation failure mode; a candidate-parse throw stays possible and is inconclusive), and the follow-up observation could not attribute a build to the edit for slug " + PUBLISH_SLUG + " — no in-flight build with a new agent_id appeared in the poll window and no new audit dir landed. The edit may have been accepted as pending_init, so no retry was issued: a blind retry duplicated the edit on 2026-09-12. The attempt is recorded in the publish ledger at " + crewHome + "/.publish-ledger/" + PUBLISH_SLUG + ".jsonl (commit " + String(mergeCommitForPublish || "unknown").slice(0, 12) + "). Correlate the accepted edit via the ledger and the builder's eventual completion — do NOT reissue the edit blindly. Verify independently whether the build completed before deciding the next step. Fail-closed.");
           }
         }
-        if (!rebuildReportMissing && !rebuildTrigger.edit_started && rebuildTrigger.error === "artifact_tools missing after load") {
-          log("Publish rebuild trigger: artifact_tools missing after load — one bounded retry with a fresh key");
-          rebuildTrigger = await agent(rebuildPrompt,
-            { key: attemptKey("publish-artifact-rebuild-" + taskId + "-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
         // at the park site above). A later run or human matches commit hash +
         // attempt key against the builder's eventual completion.
-        if (rebuildTrigger && rebuildTrigger.edit_started) {
-          // Applied-report observation (2026-09-12, task 23ca8f3f): the
-          // builder's applied-report is logged as observation only — it
-          // never parks. The report is derived from the carried diff, so a
-          // "match" certifies nothing (canary run 8); and it has a
-          // demonstrated false-negative mode (applied:[] for a diff the
-          // builder had actually applied). The independent read-back below
-          // plus the parent protocol (docs/publish-verification.md) are the
-          // verification — this block always proceeds to them.
-          publishAppliedObservation = rebuildReportMissing
-            ? "missing-report"
-            : (function () { var c = verifyAppliedChanges(expectedChanges, rebuildTrigger.applied); return c.ok ? "match" : "mismatch: " + c.reason; })();
-          log("Publish applied-report observation for task " + taskId + ": " + publishAppliedObservation + " — observation only, never a park: the applied report is derived from the carried diff and proved unreliable in the false-negative direction (task 23ca8f3f, 2026-09-12: applied:[] for a diff the builder had applied). The independent read-back below plus the parent protocol are the verification.");
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            agent_id: rebuildAgentId,
-            applied_report: publishAppliedObservation,
-            outcome: "submitted",
-            detail: rebuildReportMissing
-              ? (rebuildEvidenceNote || "edit confirmed via build-state poll after structured-output failure (build " + (rebuildAgentId || "agent_id unknown") + "); builder applied-report missing")
-              : "edit accepted; builder applied-report received"
-          }, reworkCount);
-        } else if (rebuildTrigger) {
-          await recordPublishLedger({
-            commit: mergeCommitForPublish,
-            attempt: rebuildAttemptKey,
-            applied_report: null,
-            outcome: "rejected",
-            detail: "edit not accepted: " + (rebuildTrigger.error || "no error detail")
-          }, reworkCount);
-        }
-        var publishFailure = null;
-        if (rebuildTrigger.edit_started) {
-          // STEP 1b (observation only): publishAppliedObservation was
-          // computed and logged above, inside the ledger block — the
-          // builder's applied-report never parks and never blocks the stamp.
-          // Task 23ca8f3f (2026-09-12) proved its false-negative mode:
-          // applied:[] for a diff the builder had actually applied, which
-          // parked a successful publish as unverified. A "match" certifies
-          // nothing either — the report is derived from the carried diff
-          // (canary run 8). The flow proceeds to the build poll and the
-          // independent read-back trigger regardless of what the report
-          // claimed; real verification is the parent's read-back
-          // (docs/publish-verification.md) before the provenance stamp.
-          // Pre-publish base observation (diagnostic, 2026-09-12): compare
-          // the builder's self-reported pre-edit hashes against the
-          // workflow-computed expected base (merge parent). This tells us
-          // what base state the publish actually read. OBSERVATION ONLY —
-          // a mismatch is logged loudly but never parks and never blocks
-          // the stamp. If the tree was dirty or drifted, the evidence is
-          // here; the fix (requiring the right base) comes after we see it.
-          try {
-            var preHashes = (rebuildTrigger && rebuildTrigger.pre_hashes) || {};
-            var baseLines = expectedChanges.map(function(f) {
-              var expected = expectedBaseHashes[f.path];
-              var actual = preHashes[f.path];
-              var expShort = (expected || "UNKNOWN").slice(0, 12);
-              var actShort = String(actual || "NOT-REPORTED").slice(0, 12);
-              var match = (expected !== undefined && actual !== undefined) ? (expected === actual) : "unknown";
-              return "  " + f.path + ": expected_base=" + expShort + " builder_pre=" + actShort + " match=" + match;
-            });
-            var anyMismatch = expectedChanges.some(function(f) {
-              return expectedBaseHashes[f.path] !== undefined && preHashes[f.path] !== undefined && expectedBaseHashes[f.path] !== preHashes[f.path];
-            });
-            log("Publish pre-tree base observation for task " + taskId + (anyMismatch ? " — BASE MISMATCH DETECTED (tree was not at the expected merge-parent state when the diff was applied):" : " — base matches expected merge-parent state:") + "\n" + baseLines.join("\n"));
-          } catch (e) {
-            log("Publish pre-tree base observation failed for task " + taskId + " (non-fatal): " + (e && e.message ? e.message : e));
-          }
+        // (2026-09-16) The trigger is fire-and-forget: the observation above
+        // already recorded the ledger's submitted line on both positive paths
+        // and parked on unknown — there is no applied report to observe and
+        // no rejection signal to record.
+        // (publishFailure is declared with the immediate audit fallback
+        // above so an explicit build failure there survives to here.)
+        if (rebuildTrigger.edit_started && !skipReceiptPoll) {
+          // (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
@@ -1973,15 +1950,18 @@ while (i < STEPS.length) {
           if (buildPoll.build_done && pollSawOurBuild) {
             // STEP 1c (mechanical): NO provenance stamp here. Canary run 8
             // (2026-09-11) proved the stamp cannot certify content: the
-            // builder's applied-report is derived from the carried diff, so
-            // verifyAppliedChanges above is circular — a fabricated report
-            // passes by construction, and every phase went green on a hollow
+            // builder's applied-report was derived from the carried diff, so
+            // the old report check was circular — a fabricated report
+            // passed by construction, and every phase went green on a hollow
             // build. The stamp moves to the parent (docs/publish-verification.md);
-            // the independent read-back step is currently unavailable (no
-            // agent-callable read-back tool exists — artifact_inspect was
-            // removed by the platform 2026-09-14), so the parent cannot
-            // confirm content and the task parks for verification.
+            // the deterministic lib/readback-disk.js is the primary sensor
+            // (the agent-callable read-back tool is unavailable —
+            // artifact_inspect was removed by the platform 2026-09-14 — so
+            // the LLM-inspector path is manual-fallback only), and the task
+            // parks for parent verification.
             // Chore has no QA: the parent's verification is the final gate.
+            // An unverified publish fails loudly in QA instead of passing
+            // silently here.
             publishBuildLanded = true;
             artifactPublish = { source_commit: mergeCommitForPublish, pending_parent_verification: true };
             log("Publish build landed for task " + taskId + " — provenance stamp deferred to parent content verification");
@@ -2021,26 +2001,17 @@ while (i < STEPS.length) {
                   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; });
-              newAuditDirsAfterPoll = auditDirsAfterPollList.filter(function (d) {
+              // 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));
             }
-            // 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.
-            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;
-            };
+            // 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) {
@@ -2099,7 +2070,9 @@ while (i < STEPS.length) {
             }
           }
         } else {
-          publishFailure = "Artifact rebuild trigger failed: " + (rebuildTrigger.error || "artifact_edit not accepted") + ". The publish did not land.";
+          // Unreachable: the observation above either attributes the edit
+          // (edit_started) or parks. Defensive only — never a silent pass.
+          publishFailure = "Artifact rebuild trigger failed: the edit was not attributed to any observed build. The publish is unattributed (not proven landed, not proven failed) — provenance was not stamped. Fail-closed.";
         }
         } // end: publishSkippedNoLock — no rebuild, no stamp, nothing to ship
         // STEP 2 (mechanical, always — skip path included): post-deploy