muse-crew 0.7.19 → 0.7.20

package/workflows/standard.js

@@ -451,13 +451,16 @@ function parseUnifiedDiff(diffText) {
 }
 
 
-// Publish read-back request (currently unavailable): the verbatim_request
-// the parent protocol (docs/publish-verification.md) would hand to an
-// independent read-back tool after the artifact build lands. artifact_inspect
-// was removed by the platform (2026-09-14); artifact.inspect is malfunction
-// diagnosis, not a substitute — so no agent-callable read-back tool exists
-// and this request cannot currently be issued. Pure function — no I/O, no
-// clock. The request carries the merged diff as the expected change and asks
+// Publish read-back request (agent path currently unavailable): the
+// verbatim_request the parent protocol (docs/publish-verification.md) would
+// hand to an independent read-back tool after the artifact build lands.
+// artifact_inspect was removed by the platform (2026-09-14);
+// artifact.inspect is malfunction diagnosis, not a substitute — so no
+// agent-callable read-back tool exists and this LLM-inspector request
+// cannot currently be issued. The primary sensor is now the deterministic
+// lib/readback-disk.js (reads the on-disk tree the artifact is served
+// from); this request builder is retained only as the manual fallback.
+// Pure function — no I/O, no clock. The request carries the merged diff as the expected change and asks
 // for an independent read of the artifact's actual source: for each file, the
 // exact current text of the changed regions plus a per-line present/absent
 // finding. Until a read-back path exists, the parent cannot independently
@@ -1299,9 +1302,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).
       // QA's provenance check enforces the stamp mechanically.
       var artifactPublish = null;
       var publishLockRefreshed = false;
@@ -1448,8 +1452,10 @@ while (i < STEPS.length) {
         // 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 every
-        // ledger line the workflow writes.
+        // 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
@@ -1460,10 +1466,13 @@ while (i < STEPS.length) {
         // 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" +
@@ -1473,9 +1482,10 @@ 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
@@ -1499,10 +1509,16 @@ while (i < STEPS.length) {
         // 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).
-        // Explicit negative evidence (missing) gets one bounded retry with a
-        // fresh key, then parks: without the tools the edit provably did NOT
-        // go through, so this is the one safe retry on the publish path.
+        // 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(
@@ -1514,12 +1530,29 @@ while (i < STEPS.length) {
                 label: "Checking artifact tool availability" + (toolcheckAttempt === 1 ? "" : " (retry)"),
                 schema: { type: "object", properties: { signal: { type: "string" } }, required: ["signal"] } }
             );
-            publishToolsOk = /ARTIFACT_TOOLS:\s*ok/.test(String((toolcheckResult && toolcheckResult.signal) || ""));
-            log("Publish artifact toolcheck for task " + taskId + " (attempt " + toolcheckAttempt + " of 2): " + (publishToolsOk ? "tools ok" : "tools missing"));
+            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) failed (" + (toolcheckErr && toolcheckErr.message ? toolcheckErr.message : toolcheckErr) + ") — counted as missing for this attempt");
+            log("Publish artifact toolcheck for task " + taskId + " (attempt " + toolcheckAttempt + " of 2) threw (" + (toolcheckErr && toolcheckErr.message ? toolcheckErr.message : toolcheckErr) + ") — inconclusive: a throw proves nothing about tool availability, never counted as missing");
           }
         }
+        if (!publishToolsOk && !publishToolsMissing) {
+          await recordPublishLedger({
+            commit: mergeCommitForPublish,
+            attempt: rebuildAttemptKey,
+            agent_id: null,
+            applied_report: null,
+            outcome: "unknown",
+            detail: "artifact toolcheck inconclusive after two attempts (throws or unparseable signals — never an explicit ARTIFACT_TOOLS: missing): tool availability unproven, so the trigger was NOT issued; unknown parks fail closed with no blind retry"
+          }, totalReworkCount);
+          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact toolcheck was inconclusive after two attempts (no explicit ARTIFACT_TOOLS signal parsed — a throw is transport noise, not evidence). Tool availability is unproven, so no edit was issued and nothing was retried blindly. Human attention needed.");
+        }
         if (!publishToolsOk) {
           await recordPublishLedger({
             commit: mergeCommitForPublish,
@@ -1527,9 +1560,9 @@ while (i < STEPS.length) {
             agent_id: null,
             applied_report: null,
             outcome: "rejected",
-            detail: "artifact tool namespace missing in two toolcheck attempts (explicit negative evidence): the edit provably did not go through — no trigger issued, no blind retry"
+            detail: "artifact tool namespace explicitly missing (parsed ARTIFACT_TOOLS: missing signal, one bounded retry spent): the edit provably did not go through — no trigger issued, no blind retry"
           }, totalReworkCount);
-          return await parkTask("Publish cannot proceed for task " + taskId + ": the artifact tool namespace was missing in two toolcheck attempts (explicit negative evidence — the edit provably did not go through, so no trigger was issued and nothing was retried blindly). Human attention needed.");
+          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
@@ -1555,19 +1588,26 @@ while (i < STEPS.length) {
           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: fire-and-forget transport for the
-        // artifact_edit call. NO schema — the return value is not consumed,
-        // so the runtime's JSON-candidate heuristic never runs on this
-        // call. A transport 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).
+        // 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 {
           var triggerResultLength = String(await agent(rebuildPrompt,
             { key: rebuildAttemptKey, label: "Triggering artifact rebuild" }) || "").length;
-          log("Publish rebuild trigger for task " + taskId + " returned (" + triggerResultLength + " chars, fire-and-forget: not consumed)");
+          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");
         }
@@ -1602,6 +1642,16 @@ while (i < STEPS.length) {
           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
@@ -1621,6 +1671,31 @@ while (i < STEPS.length) {
           }, totalReworkCount);
         } 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 {
             var auditAfter = await agent(
               "List the artifact audit directories for slug \"" + PUBLISH_SLUG + "\" (best-effort, never a gate).\n" +
@@ -1631,25 +1706,77 @@ while (i < STEPS.length) {
             );
             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) {
+            // and anything else are not builds. Gated on auditBeforeOk:
+            // without a baseline every historical dir would look new.
+            newAuditDirs = auditBeforeOk ? auditDirsAfterTrigger.filter(function (d) {
               return auditDirsBeforeTrigger.indexOf(d) === -1 && /^20\d\d-\d\d-\d\dT\d\d-\d\d-\d\dZ-/.test(d);
-            });
+            }) : [];
           } catch (auditAfterErr) {
             log("Publish audit-dir re-list after trigger failed for task " + taskId + " (non-fatal, durable-evidence check degraded): " + (auditAfterErr && auditAfterErr.message ? auditAfterErr.message : auditAfterErr));
           }
           if (newAuditDirs.length > 0) {
             rebuildTrigger = { edit_started: true };
             rebuildAgentId = null;
-            log("Publish rebuild trigger for task " + taskId + ": new audit dir(s) during the trigger window (" + newAuditDirs.join(", ") + ") — the edit went through and the build completed; no in-flight receipt was observed.");
-            await recordPublishLedger({
-              commit: mergeCommitForPublish,
-              attempt: rebuildAttemptKey,
-              agent_id: null,
-              applied_report: publishAppliedObservation,
-              outcome: "submitted",
-              detail: "fire-and-forget trigger; edit confirmed via durable audit evidence (new audit dir " + newAuditDirs[0] + "); no in-flight receipt observed"
-            }, totalReworkCount);
+            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 immediateOkRead = await agent(
+                "Read the artifact build report for slug \"" + PUBLISH_SLUG + "\".\n" +
+                "Run: cat ~/workspace/ts-spaces/" + PUBLISH_SLUG + "/audits/" + newestImmediateDir + "/report.json 2>/dev/null || echo MISSING\n" +
+                "Return JSON { \"raw\": \"<verbatim file contents, or the literal string MISSING when the file does not exist>\" } and nothing else.",
+                { key: attemptKey("publish-audit-ok-immediate-" + taskId, totalReworkCount), label: "Reading build report for audit-confirmed build",
+                  schema: { type: "object", properties: { raw: { type: "string" } }, required: ["raw"] } }
+              );
+              immediateReportOk = auditReportOk(immediateOkRead && immediateOkRead.raw);
+            } catch (immediateOkErr) {
+              log("Publish build-report read for audit-confirmed dir failed for task " + taskId + " (treated as unknown): " + (immediateOkErr && immediateOkErr.message ? immediateOkErr.message : immediateOkErr));
+              immediateReportOk = null;
+            }
+            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"
+              }, totalReworkCount);
+            } 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)"
+              }, totalReworkCount);
+            } else {
+              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"
+              }, totalReworkCount);
+              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
@@ -1666,7 +1793,7 @@ while (i < STEPS.length) {
               outcome: "unknown",
               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"
             }, totalReworkCount);
-            return await parkTask("Publish outcome unknown for task " + taskId + ": the rebuild trigger was issued fire-and-forget (no JSON closeout for the runtime heuristic to misfire on), 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 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.");
           }
         }
 
@@ -1679,8 +1806,9 @@ while (i < STEPS.length) {
         // 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.
-        var publishFailure = null;
-        if (rebuildTrigger.edit_started) {
+        // (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
@@ -1781,10 +1909,11 @@ while (i < STEPS.length) {
             // 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.
             // QA's provenance check enforces the stamp mechanically.
             // An unverified publish fails loudly in QA instead of passing
             // silently here.
@@ -1827,26 +1956,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) {
@@ -1907,7 +2027,7 @@ while (i < STEPS.length) {
         } else {
           // 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 did not land.";
+          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