muse-crew 0.7.19 → 0.8.0

package/workflows/standard.js

@@ -57,7 +57,10 @@ if (!inputs.crewHome) throw new Error("crewHome is required — pass the crew ho
 const crewHome = inputs.crewHome;
 // Crew API: the workflow calls the crew-owned CLI, not the dashboard.
 // The CLI implements the API.md contract against $CREW_HOME/crew-state.db.
-const CREW_API = crewHome + "/current/lib/crew-api.js";
+const CREW_API_SRC = crewHome + "/current/lib/crew-api.js";
+// Pinned at pinLifecycle: after the pin, CREW_API points into RUN_LIB so a
+// mid-flight release swap cannot change the CLI under a running workflow.
+let CREW_API = CREW_API_SRC;
 // Build a shell command invoking the CLI. Args are JSON-encoded and
 // single-quote-wrapped for safe shell passing. The agent runs this and
 // returns the stdout verbatim (the CLI emits JSON on stdout).
@@ -83,9 +86,12 @@ const LIFECYCLE = RUN_LIB + "/worktree-lifecycle.sh";
 const MERGE_LOCK = RUN_LIB + "/merge-lock.sh";
 const PUBLISH_NPM_SRC = crewHome + "/lib/publish-npm.sh";
 const PUBLISH_NPM = RUN_LIB + "/publish-npm.sh";
-// The three basenames the pin step must materialize — asserted mechanically
+const CREW_API_PINNED = RUN_LIB + "/crew-api.js";
+const SCHEMA_SQL_SRC = crewHome + "/lib/schema.sql";
+const SCHEMA_SQL_PINNED = RUN_LIB + "/schema.sql";
+// The five basenames the pin step must materialize — asserted mechanically
 // by workflow code from the verbatim listing, never from agent prose.
-const PIN_BASENAMES = [LIFECYCLE, MERGE_LOCK, PUBLISH_NPM].map(function (p) { return p.split("/").pop(); });
+const PIN_BASENAMES = [LIFECYCLE, MERGE_LOCK, PUBLISH_NPM, CREW_API_PINNED, SCHEMA_SQL_PINNED].map(function (p) { return p.split("/").pop(); });
 
 // Project config — passed by dispatcher, falls back to dashboard defaults
 const projectConfig = inputs.project_config || {};
@@ -231,7 +237,7 @@ function attemptKey(base, reworkCount) {
   return base + (reworkCount > 0 ? "-r" + reworkCount : "");
 }
 // pinLifecycle(key) — snapshot the lifecycle scripts into RUN_LIB and return
-// the verbatim `ls -1` listing so WORKFLOW CODE asserts the four pinned
+// the verbatim `ls -1` listing so WORKFLOW CODE asserts the five pinned
 // basenames; the agent cannot self-certify. (The pin step was the one place
 // the workflows trusted agent prose: task 24be1cd6 walked to Publish on an
 // empty pin dir.) Byte-identical across standard/bugfix/chore — pinned by
@@ -239,7 +245,7 @@ function attemptKey(base, reworkCount) {
 function pinLifecycle(key) {
   return agent(
     "Snapshot lifecycle scripts for version pinning.\n" +
-    "Run: mkdir -p " + RUN_LIB + " && cp " + LIFECYCLE_SRC + " " + LIFECYCLE + " && cp " + MERGE_LOCK_SRC + " " + MERGE_LOCK + " && cp " + PUBLISH_NPM_SRC + " " + PUBLISH_NPM + " && chmod +x " + LIFECYCLE + " " + MERGE_LOCK + " " + PUBLISH_NPM + " && ls -1 " + RUN_LIB + "\n" +
+    "Run: mkdir -p " + RUN_LIB + " && cp " + LIFECYCLE_SRC + " " + LIFECYCLE + " && cp " + MERGE_LOCK_SRC + " " + MERGE_LOCK + " && cp " + PUBLISH_NPM_SRC + " " + PUBLISH_NPM + " && cp " + CREW_API_SRC + " " + CREW_API_PINNED + " && cp " + SCHEMA_SQL_SRC + " " + SCHEMA_SQL_PINNED + " && chmod +x " + LIFECYCLE + " " + MERGE_LOCK + " " + PUBLISH_NPM + " && ls -1 " + RUN_LIB + "\n" +
     "Return the verbatim output of the ls -1 command as { \"listing\": \"<verbatim output>\" } and nothing else.",
     { key: key, label: "Pinning lifecycle scripts",
       schema: { type: "object", properties: { listing: { type: "string" } }, required: ["listing"] } }
@@ -451,13 +457,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
@@ -531,7 +540,7 @@ function extractMarkerLines(workerText) {
   var markers = [];
   for (var i = 0; i < lines.length; i++) {
     var line = lines[i].trim();
-    if (/^(repo_diff:|release:|version_bump:|VERDICT:|TARGET_VERSION=|published:|experiential:|capture_targets:|worktree:)/i.test(line)) {
+    if (/^(repo_diff:|release:|version_bump:|VERDICT:|TARGET_VERSION=|published:|experiential:|layer:|capture_targets:|worktree:)/i.test(line)) {
       markers.push(line);
     }
   }
@@ -802,7 +811,7 @@ let i = startStepIndex;
 // ── Pin lifecycle scripts ────────────────────────────────────────────
 // Copy lifecycle scripts into a per-task temp dir so this run is immune
 // to upgrades that land while it's in flight. Verified mechanically:
-// workflow code asserts the four basenames from the verbatim listing —
+// workflow code asserts the five basenames from the verbatim listing —
 // the agent cannot self-certify. Any miss parks the task before Triage.
 const initialPins = parsePinListing(await pinLifecycle("pin-lifecycle"));
 const missingInitialPins = PIN_BASENAMES.filter(function (b) { return initialPins.indexOf(b) === -1; });
@@ -810,6 +819,10 @@ if (missingInitialPins.length > 0) {
   return await parkTask("Lifecycle pin incomplete before Triage — missing " + missingInitialPins.join(", ") + " in " + RUN_LIB + ".");
 }
 log("Lifecycle scripts pinned to " + RUN_LIB);
+// From here on, every crew-api.js invocation uses the pinned copy: immune
+// to a release swap landing mid-flight.
+CREW_API = CREW_API_PINNED;
+log("Crew API pinned to " + CREW_API);
 
 // Merge-lock holder identity (bug 2fc8f52f): the opaque task+run identity
 // minted at this run's first claim (never a PID — short-lived agent PIDs
@@ -1112,7 +1125,9 @@ while (i < STEPS.length) {
   var mapBaselineRefs = "";
   var mapBaselineNone = false;
   if (step.name === "Map") {
-    if ((await resolveExperiential()) === "yes") {
+    // Must match Capture's run condition (experiential + artifact publish):
+    // when Capture skips, no baseline notes exist, so the gate must not apply.
+    if ((await resolveExperiential()) === "yes" && PUBLISH_TYPE === "artifact") {
       var gateStatus = await baselineStatus();
       if (!gateStatus.baseline_found) {
         log("Map gate: no baseline evidence for experiential task " + taskId + " — bouncing to Capture");
@@ -1280,6 +1295,10 @@ while (i < STEPS.length) {
         "TARGET_VERSION=" + publishTarget.target + " computed as " + publishTarget.base + " + " + publishTarget.scope + " → " + publishTarget.target + "\n" +
         "skipped: no-lock-held (empty-diff Integrate — nothing merged, nothing to ship)\n" +
         "VERDICT: PASS\n\n" +
+        "If the script's output contains PUBLISH_SKIPPED=no-npm-publish, the publish was skipped gracefully: npm publish is not configured on this machine (helper or credential absent) — the merge stands, the version was not cut, nothing was shipped. Paste the marker block verbatim into your report, then end your report with exactly these three lines, in this order — lowercase, no trailing period, do not rephrase:\n" +
+        "TARGET_VERSION=" + publishTarget.target + " computed as " + publishTarget.base + " + " + publishTarget.scope + " → " + publishTarget.target + "\n" +
+        "skipped: no-npm-publish (npm publish not configured — helper or credential missing; nothing versioned or published)\n" +
+        "VERDICT: PASS\n\n" +
         "If it exits zero, paste the script's COMPLETE marker block verbatim into your report, then end your report with exactly these three lines, in this order — lowercase, no trailing period, do not rephrase:\n" +
         "TARGET_VERSION=" + publishTarget.target + " computed as " + publishTarget.base + " + " + publishTarget.scope + " → " + publishTarget.target + "\n" +
         "published: muse-crew@" + publishTarget.target + "\n" +
@@ -1299,9 +1318,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;
@@ -1373,9 +1393,17 @@ while (i < STEPS.length) {
         } else if (!/^[0-9a-f]{40}$/.test(publishBase)) {
           return await parkTask("Publish base '" + publishBase + "' is not a valid commit SHA — cannot compute the publish diff. Human attention needed.");
         }
+        // The empty tree is not a commit: git merge-base --is-ancestor fails on it.
+        // The workflow knows publishBase == EMPTY_TREE_SHA (set above), so it
+        // hardcodes ANCESTOR=yes for a first publish instead of asking the agent
+        // to execute the conditional (clean-room 2026-09-16: the agent ran
+        // merge-base on the empty tree directly and parked).
+        var ancestorShell = (publishBase === EMPTY_TREE_SHA)
+          ? "ANCESTOR=yes && "
+          : "git merge-base --is-ancestor \"$BASE\" \"$HEAD\" && ANCESTOR=yes || ANCESTOR=no && ";
         var diffResult = await agent(
           "Run: cd " + REPO_PATH + " && BASE='" + publishBase + "' && HEAD=$(git rev-parse HEAD) && " +
-          "if [ \"$BASE\" = '" + EMPTY_TREE_SHA + "' ]; then ANCESTOR=yes; else git merge-base --is-ancestor \"$BASE\" \"$HEAD\" && ANCESTOR=yes || ANCESTOR=no; fi && " +
+          ancestorShell + 
           "echo '---COMMIT---' && echo \"$HEAD\" && echo '---BASE---' && echo \"$BASE\" && echo '---ANCESTOR---' && echo \"$ANCESTOR\" && " +
           "if [ \"$ANCESTOR\" = yes ]; then echo '---DIFF---' && git diff \"$BASE\" \"$HEAD\" && echo '---NAMES---' && git diff-tree --no-commit-id --name-only -r \"$BASE\" \"$HEAD\"; fi\n" +
           "Return JSON { \"commit\": \"<HEAD trimmed>\", \"base\": \"<BASE trimmed>\", \"ancestor\": \"<yes|no>\", \"diff\": \"<raw unified diff, may be multi-line>\", \"files\": \"<newline-separated paths>\" } and nothing else.",
@@ -1448,8 +1476,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 +1490,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 +1506,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 +1533,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 +1554,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 +1584,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 +1612,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 +1666,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 +1695,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 +1730,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 +1817,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 +1830,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 +1933,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 +1980,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 +2051,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
@@ -2406,16 +2550,24 @@ while (i < STEPS.length) {
   // Skip-aware (park 2026-09-11): when the deterministic publish script found
   // no merge lock held (empty-diff Integrate), it skips the publish path
   // gracefully and emits the machine-readable PUBLISH_SKIPPED=no-lock-held
-  // marker. Verification is then vacuous — nothing was shipped, and the
+  // marker. The preflight (bugfix 2026-09-17) emits
+  // PUBLISH_SKIPPED=no-npm-publish when npm publish is not configured on
+  // this machine (helper or credential absent) — also before any mutation.
+  // Verification is then vacuous — nothing was shipped, and the
   // registry must NOT have moved. The marker is script-emitted explicit state
   // (pasted verbatim per the Publish agent instructions), not agent prose; a
   // report without the marker still runs the full verification fail-closed.
   var publishVerified = false;
   var npmPublishSkipped = false;
   if (step.name === "Publish" && PUBLISH_TYPE === "npm" && publishTarget) {
-    if (/^PUBLISH_SKIPPED=no-lock-held$/m.test(workerText || "")) {
+    var publishSkipMatch = /^PUBLISH_SKIPPED=(no-lock-held|no-npm-publish)$/m.exec(workerText || "");
+    if (publishSkipMatch) {
       npmPublishSkipped = true;
-      log("Publish skipped for task " + taskId + " (no merge lock held — empty-diff Integrate): publish verification vacuous, nothing was shipped");
+      if (publishSkipMatch[1] === "no-npm-publish") {
+        log("Publish skipped for task " + taskId + " (no-npm-publish — npm publish not configured): publish verification vacuous, nothing was shipped");
+      } else {
+        log("Publish skipped for task " + taskId + " (no merge lock held — empty-diff Integrate): publish verification vacuous, nothing was shipped");
+      }
     }
     if (!npmPublishSkipped) {
     try {