muse-crew 0.7.18 → 0.7.20

package/docs/publish-verification.md

@@ -42,18 +42,25 @@ The rule: **the builder's applied report is never a verification signal, in
 either direction.** A matching report certifies nothing (it is derived from
 the carried diff — circular by construction, canary run 8). A mismatching or
 empty report blocks nothing (false-negative mode demonstrated by `23ca8f3f`).
-The workflow computes the report comparison as an observation only — it
-never parks on it. The parent ignores the applied report entirely when
-deciding whether to stamp: an `applied:[]` or mismatched report with a
-matching independent read-back stamps normally.
+The workflow dropped the report entirely on 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 its prose ("workflow agent output was not JSON"), parking a task whose
+edit may have gone through. The trigger is now awaited-but-unconsumed — no schema,
+no consumed return value — and there is no builder report to observe:
+`applied_report` is `missing-report` on ledger lines for issued triggers
+(pre-trigger parks and unattributed-unknown parks write null — no trigger
+was observed, so there is nothing to report). The
+parent ignores the (absent) report entirely when deciding whether to stamp.
 
 The contract is split on purpose:
 
-- **Workflow-owned:** carrying the merged diff to the builder, the
-  applied-report observation (logged, never a park), the build-completion
-  poll, post-deploy cleanup, recording the Publish session completed, and
-  parking with `publish: verification-requested <commit>` instead of
-  stamping. The workflow does NOT trigger the read-back inspection — an
+- **Workflow-owned:** carrying the merged diff to the builder, attributing
+  the edit itself (fire-and-forget trigger — no builder report — via
+  pre-trigger toolcheck, pre-trigger build-state baseline, and post-trigger
+  build-state diff), the build-completion poll, post-deploy cleanup,
+  recording the Publish session completed, and parking with `publish:
+  verification-requested <commit>` instead of stamping. The workflow does NOT trigger the read-back inspection — an
   async inspection triggered from inside a workflow run delivers its result
   to the root agent, never back into the run, so a workflow-side trigger is
   an orphan the verifier cannot consume. The parent triggers the one
@@ -313,24 +320,40 @@ For a task parked with `publish: verification-requested <commit>`:
   second scan sees the unexpired `publish: verification-claimed` note and
   skips. The lease expiry bounds the damage if a claimer dies.
 
-## Unknown-outcome recovery (2026-09-14, Gate 1 Journey 3 attempt 7)
+## Unknown-outcome recovery (2026-09-14, Gate 1 Journey 3 attempt 7; fire-and-forget 2026-09-16)
 
 Attempt 7 parked at Publish with outcome `unknown`: the rebuild trigger's
 child failed structured closeout and the in-flight-only build-state poll
 could not see the completed build — even though the build HAD run (a fresh
-platform audit directory existed). Two mechanisms close this gap.
-
-**1. Workflow-side durable evidence.** Before the rebuild trigger, the
+platform audit directory existed). 2026-09-16 (clean-room task `e2a8d9f8`)
+showed the failure is worse than a catchable throw: the runtime's
+JSON-candidate heuristic rejects the trigger call itself ("workflow agent
+output was not JSON") whenever the child returns prose, whether or not the
+edit went through. The trigger is therefore fire-and-forget — no schema, no
+consumed return value — and the workflow always attributes the edit itself.
+Two mechanisms close the gap.
+
+**1. Pre-trigger toolcheck + baseline.** Before the trigger, a tiny schema'd
+child proves the artifact tool namespace is available (one bounded retry on
+explicit negative evidence — the only safe retry on the publish path:
+without the tools the edit provably did not go through) and captures a
+pre-trigger build-state baseline. After the trigger, the workflow diffs the
+post-trigger build state against the baseline: a build whose `agent_id` is
+new relative to the baseline is this edit's receipt. The baseline build's
+`agent_id` is never substituted — a build already in flight at baseline
+predates the trigger and is never attributed to this edit.
+
+**2. Workflow-side durable evidence.** Before the rebuild trigger, the
 workflow snapshots the artifact's audit-directory listing
-(`~/workspace/ts-spaces/<slug>/audits/` — best-effort, never a gate). On a
-structured-output failure with no in-flight build observed, it re-lists and
-diffs: a timestamped directory that appeared during the trigger window is
-positive evidence the edit went through and the build completed. The
-fallback never re-issues the edit, never stamps provenance, and only routes
-to the parent's independent content read-back. No new directory still parks
-`unknown` fail-closed. The ledger distinguishes the two confirmations: `edit
-confirmed via durable audit evidence …` vs `edit confirmed via build-state
-poll …`.
+(`~/workspace/ts-spaces/<slug>/audits/` — best-effort, never a gate). When
+no in-flight receipt was observed, it re-lists and diffs: a timestamped
+directory that appeared during the trigger window is positive evidence the
+edit went through and the build completed. The fallback never re-issues the
+edit, never stamps provenance, and only routes to the parent's independent
+content read-back. No new directory still parks `unknown` fail-closed. The
+ledger's `detail` line distinguishes the two confirmations: `… edit
+confirmed via durable audit evidence (new audit dir …)` vs `… build receipt
+captured by workflow-owned build-state observation (pre/post-trigger diff)`.
 
 The fallback's known limitation: audit directories are not attributed to
 tasks, so two concurrent publishes to the same artifact could cross-read.

package/lib/AGENTS.md

@@ -14,7 +14,7 @@ Shell scripts for the crew's infrastructure. Called by workflow scripts, cron, a
 - `test-publish-skip.sh` — regression tests for the no-lock graceful publish skip (park 2026-09-11): `lock-status` returns exact `UNLOCKED`/`LOCKED by <holder> since <ts> (pid <pid>)`; a fake empty-diff integrate takes the MERGED_EMPTY branch and never takes the lock; the shipped step-5 block from publish-npm.sh (extracted by anchor) skips gracefully on UNLOCKED (no park, no `PUBLISH_COMPLETE`), follows the refresh path when a lock is held, and fails closed on a `lock-status` query failure; the gate sits inside the ALREADY_PUBLISHED=0 branch and mutation steps are gated on NO_LOCK_HELD=0
 - `publish-npm.sh` — deterministic npm publish: lock refresh, release install, version write/commit, pack, registry publish, verify, push, post-deploy. Takes TARGET_VERSION as input; idempotent on retry/resume.
 - `compose-evidence.py` — deterministic visual-evidence compositor (Pillow): pairs identical PNG stems from baseline/ and postchange/ dirs, emits `<stem>-sidebyside.png` and amplified-difference `<stem>-overlay.png` into composites/, prints `PAIR`/`SKIP` manifests. Byte-deterministic; nonzero exit on errors.
-- `compose-evidence-caption.js` — deterministic QA-evidence caption composer (2026-09-14): given `--crew-home`, `--task-id`, and the resolved `--audit-dir` name, extracts the task title/description, the latest `visual_verdict:` note, the `publish: verified` commit (or the global provenance record when it belongs to this task), and the merge commit's subject line from the project repo — and prints the out-of-context transition Eric asked for (problem → solution → evidence handoff) to stdout. The caller appends the desktop/mobile attachment lines after this caption. Honest labels: "provenance not yet stamped" when no commit is known, "no QA verdict recorded" when none exists, and the visual-protocol-unavailable note when the task's own run recorded `baseline: none`. Exits non-zero on missing input.
+- `compose-evidence-caption.js` — deterministic QA-evidence caption composer (2026-09-14): given `--crew-home`, `--task-id`, and the resolved `--audit-dir` name, extracts the task title/description, the QA verdict, the `publish: verified` commit (or the global provenance record when it belongs to this task), and the merge commit's subject line from the project repo — and prints the out-of-context transition Eric asked for (problem → solution → evidence handoff) to stdout. The caller appends the desktop/mobile attachment lines after this caption. Verdict source (2026-09-16): Hazel's `task-evidence/<taskId>/postchange/verdict.json` is authoritative, then the last line of the append-only `verdicts.jsonl` ledger, then the newest legacy `visual_verdict:` note (the parent visual-verdict protocol was retired 2026-09-15). Honest labels: "provenance not yet stamped" when no commit is known, "no QA verdict recorded" when none exists, and the visual-protocol-unavailable note only when no verdict evidence exists at all and the newest `baseline:` note is `baseline: none` (a `baseline: none` note means no baseline captures to compare against — it never overrules a real QA verdict). "Latest" is by event timestamp, sorted explicitly. Exits non-zero on missing input.
 - `edit-image.py` — deterministic pixel-level evidence editing (2026-09-15, Pillow): `crop --region x,y,w,h` (pixel-exact, rejects out-of-bounds), `zoom --factor <f> [--center x,y]` (nearest-neighbor, returns to source frame size), `label --text <caption>` (caption bar), `nup --cols <n> --in <a.png> --in <b.png> [--labels "a|b"]` (side-by-side grid). Byte-deterministic PNG output; no network, no time, no randomness. Derivatives supplement raw frames — the source frame stays archived.
 - `render-html.js` — deterministic HTML evidence composition (2026-09-15, headless Chromium): renders a local HTML layout to PNG (fixed viewport width, device scale 1, full-page screenshot). Hermetic: remote HTTP(S) assets are blocked and fail the render loudly; relative image paths resolve against the HTML file; local/system fonts only. Exit 3 reports NOT POSSIBLE when Chromium is unavailable. The composition layer above edit-image.py's pixel layer.
 - `see-act.js` — single-step browser driver for experiential QA (2026-09-14): one browser action per invocation (`aria`, `shot`, `click`, `scroll`, `type`), one JSON line on stdout, exit 0/2/3 (3 = NOT POSSIBLE: missing playwright-core or Chromium). Spawns its own loopback forward proxy on an ephemeral port (Chromium blocks direct loopback). The QA work agent closes the OODA loop: run a step, read the screenshot/aria, decide the next. Determinism: no wall-clock reads, no randomness. `SEE_ACT_ARCHIVE_DIR=<phase-dir>` (2026-09-14): every screenshot is archived automatically as `001-shot-desktop.png`, `002-click-mobile.png`, ... (counter in `<dir>/.seq`); `--out` becomes optional; JSON carries `screenshot` + `archived`; explicit `--out` + archive copies into the archive; unusable dir is NOT POSSIBLE exit 3.
@@ -22,3 +22,6 @@ Shell scripts for the crew's infrastructure. Called by workflow scripts, cron, a
 - `write-ooda-verdict.js` — deterministic writer for the OODA terminal verdict (2026-09-14, append-only ledger 2026-09-15): `node write-ooda-verdict.js --dir <phase-dir> --attempt <id> --verdict <PASS|FAIL|NOT_POSSIBLE> --summary <text> --expected <text> --actual <text> --missing <json-array> [--reason <text>]` writes `<phase-dir>/verdict.json` (the latest verdict) and appends one JSON line to `<phase-dir>/verdicts.jsonl` — the append-only ledger: every attempt's verdict is preserved with a mechanical `seq`, never overwritten; corrupt or non-contiguous ledgers fail loudly. `--reason` is REQUIRED and must be non-empty for `FAIL` and `NOT_POSSIBLE` — a reason-less negative verdict fails with exit 2 before anything is written (2026-09-15). Exit 2 on bad input. See `docs/ooda-report.md`.
 - `read-ooda-verdict.js` — deterministic cross-checker for the OODA terminal verdict (2026-09-15): `node read-ooda-verdict.js --dir <phase-dir> --expect <PASS|FAIL>` reads `<dir>/verdict.json`, prints one JSON line to stdout, exits 0 with `{ok:true, verdict, reason, summary, expected, actual, attempt}` when the record agrees with the prose expectation and a FAIL carries a non-empty reason, or exits 2 with `{ok:false, code}` — `missing|corrupt|contradiction|no_reason`. No wall-clock reads, no randomness. The bugfix QA closeout runs it against the prose `VERDICT:` line before any rework routing: a failed cross-check records the phase as failed for retry, never routes to rework.
 - `serve-artifact.js` — local server for a built TS space for experiential QA (2026-09-14): serves `<space-dir>/client/dist` statically and dispatches POST `*/actions` to the compiled server actions with a locally-built Ctx. Prints `READY port=<n>` then serves until killed. Read-only w.r.t. the space directory. Fidelity: the served client and action handlers are the artifact's own built code; the Ctx is locally built (privileged handlers run from the space's own `server/dist/privileged.js` when present; blobs are stored in a per-run temp dir and served back at `/__blobs/<key>`); environment is inherited from the caller. It is not the hosted runtime — tasks that cannot be judged under it must report `NOT POSSIBLE: <reason>`.
+- `readback-disk.js` — deterministic publish content sensor (2026-09-16): reads the on-disk tree the artifact is built/served from and emits the machine-readable findings block (`FILE:`/`ADDED:`/`REMOVED:`/`END_FILE`) that `verify-publish.js` judges. The primary sensor — the LLM-inspector path (`build-readback-request.js`) is manual-fallback only since `artifact_inspect` was removed by the platform 2026-09-14.
+- `build-readback-request.js` — builds the LLM-inspector read-back `verbatim_request` from the merge commit's diff (2026-09-14): carries the merged diff as the expected change and asks for an independent read of the artifact's actual source. Retained as the manual fallback; the deterministic `readback-disk.js` is the primary sensor.
+- `verify-publish.js` — mechanical publish verification judge (2026-09-14/16): certifies the read-back findings block against `git diff` (strict `FILE:`/`ADDED:`/`REMOVED:`/`END_FILE` parsing, every added line PRESENT / every removed line ABSENT, HEAD==commit supersession check) and only then stamps provenance. Binary files, mode-only changes, and fully-colliding added hunks fail closed as `unverifiable-content` (2026-09-16, critic findings 1/5) — they can never vacuously stamp. Content-mismatch, unreadable-result, superseded, and stamp failures exit 1 with `publish: verification-failed` and no stamp. Collision exemption (2026-09-15): a removed line occurring in the old tree strictly more times than the diff removes is exempt from ABSENT (zero discriminating power); computed from `git show <base>:<path>`, never the working tree.

package/lib/compose-evidence-caption.js

@@ -18,6 +18,7 @@
 // Prints the caption to stdout. Exits non-zero on any missing input.
 
 const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
 const path = require("node:path");
 
 function usage(msg) {
@@ -83,19 +84,51 @@ try {
   usage("cannot read task events: " + (e.message || e));
 }
 const notes = events.filter((e) => e.type === "note");
+// Newest-first by timestamp. The API orders DESC, but the sort is explicit:
+// array order is not a contract this script should depend on, and the old
+// [...notes].reverse().find() pattern silently returned the OLDEST match.
+const byNewest = (a, b) => {
+  const ta = a.timestamp || "", tb = b.timestamp || "";
+  return tb < ta ? -1 : tb > ta ? 1 : 0;
+};
+const notesNewest = [...notes].sort(byNewest);
 
-// QA verdict: the workflow's own exact-prefix contract — the latest note
-// whose message starts exactly "visual_verdict: PASS" / "visual_verdict: FAIL".
-const verdictNote = [...notes].reverse()
-  .find((e) => /^visual_verdict:\s*(PASS|FAIL)/.test(e.message || ""));
-const verdict = verdictNote
-  ? verdictNote.message.replace(/^visual_verdict:\s*/, "").trim()
-  : null;
+// QA verdict: Hazel owns the verdict — <phase-dir>/verdict.json is
+// authoritative (2026-09-15: the parent visual-verdict protocol was retired,
+// so the workflows no longer emit `visual_verdict:` notes; the old note
+// contract is legacy fallback only). Prefer verdict.json, then the last line
+// of the append-only verdicts.jsonl ledger, then the newest legacy note.
+let verdict = null; // { status, summary }
+const qaDir = path.join(crewHome, "task-evidence", taskId, "postchange");
+function readVerdictFile(p) {
+  try {
+    const v = JSON.parse(fs.readFileSync(p, "utf8"));
+    if (v && v.verdict) return { status: String(v.verdict), summary: v.summary || "" };
+  } catch { /* fall through */ }
+  return null;
+}
+verdict = readVerdictFile(path.join(qaDir, "verdict.json"));
+if (!verdict) {
+  // Append-only ledger: the last line is the latest attempt's verdict.
+  try {
+    const lines = fs.readFileSync(path.join(qaDir, "verdicts.jsonl"), "utf8").trim().split("\n");
+    const last = JSON.parse(lines[lines.length - 1]);
+    if (last && last.verdict) verdict = { status: String(last.verdict), summary: last.summary || "" };
+  } catch { /* fall through to the legacy note contract */ }
+}
+if (!verdict) {
+  const verdictNote = notesNewest
+    .find((e) => /^visual_verdict:\s*(PASS|FAIL)/.test(e.message || ""));
+  if (verdictNote) {
+    const m = /^visual_verdict:\s*(PASS|FAIL)\s*[—–-]?\s*([\s\S]*)$/.exec(verdictNote.message || "");
+    verdict = { status: m[1], summary: (m[2] || "").trim() };
+  }
+}
 
-// Provenance: this task's own `publish: verified` event first; the global
-// provenance record only when it belongs to this task.
+// Provenance: this task's own newest `publish: verified` event first; the
+// global provenance record only when it belongs to this task.
 let commit = null;
-const verifiedNote = [...notes].reverse()
+const verifiedNote = notesNewest
   .find((e) => (e.message || "").includes("publish: verified"));
 if (verifiedNote) {
   const m = /\b([0-9a-f]{40})\b/.exec(verifiedNote.message);
@@ -122,9 +155,19 @@ if (commit) {
 if (!solution) solution = task.title;
 
 const problem = trimWords(task.description || task.title, 280);
-// The task's own run record is authoritative for the honest label: a
-// `baseline: none` note means QA ran without the visual protocol.
-const visualUnavailable = notes.some((e) => /baseline:\s*none/i.test(e.message || ""));
+// The "visual protocol unavailable" honest label answers "did QA get to
+// look?" — and the only honest signal for that is the ABSENCE of any QA
+// verdict evidence. A `baseline: none` note means the Capture phase had no
+// baseline screenshots to compare against; it does NOT mean QA couldn't
+// inspect. Room #5 (2026-09-16) logged `baseline: none (visual protocol
+// unavailable)` as its newest baseline note, yet Hazel still ran the full
+// experiential see-act loop and stamped PASS in verdict.json — the old
+// .some() check mislabeled that run. So: any verdict evidence (file,
+// ledger, legacy note) suppresses the label; without it, the newest
+// `baseline: none` note earns it.
+const newestBaselineNote = notesNewest.find((e) => /^baseline:\s*/i.test(e.message || ""));
+const visualUnavailable = !verdict && !!newestBaselineNote &&
+  /^baseline:\s*none/i.test(newestBaselineNote.message || "");
 
 const lines = [];
 lines.push("These screenshots are dropping in out of context — quick transition.");
@@ -134,7 +177,7 @@ lines.push("Problem: " + problem);
 lines.push("Shipped: " + trimWords(solution, 160) +
   (commit ? " (commit `" + commit.slice(0, 12) + "`, parent-verified)" : " (provenance not yet stamped)"));
 lines.push("Evidence: desktop + mobile captures below, taken by the platform audit harness after deploy (`" + auditDir + "`)." +
-  (verdict ? " QA verdict: " + trimWords(verdict, 200) + "." : " No QA verdict recorded."));
+  (verdict ? " QA verdict: " + verdict.status + (verdict.summary ? " — " + trimWords(verdict.summary, 200) : "") + "." : " No QA verdict recorded."));
 if (visualUnavailable) {
   lines.push("Note: the visual protocol is unavailable — these are the post-deploy capture plus QA's mechanical checks, not a QA visual inspection.");
 }

package/lib/verify-publish.js

@@ -2,17 +2,22 @@
 // verify-publish.js — deterministic parent publish verifier.
 //
 // The parent never eyeballs an inspection report. This script takes the
-// async read-back inspection's result JSON and MECHANICALLY decides the
-// verdict: it parses the inspector's machine-readable findings block,
-// compares every added/removed diff line against the reported
-// present/absent verdicts (with a mechanically computed collision
-// exemption for removed lines that also occur in untouched code),
-// checks supersession via git, and only then stamps provenance, logs
-// the terminal event, and re-queues the task.
+// read-back inspection's result JSON and MECHANICALLY decides the verdict:
+// it parses the machine-readable findings block, compares every
+// added/removed diff line against the reported present/absent verdicts
+// (with mechanically computed collision exemptions for lines that also
+// occur in untouched code and therefore have zero discriminating power),
+// checks supersession via git, and only then stamps provenance, logs the
+// terminal event, and re-queues the task.
 //
-// The LLM is the sensor (it reads the artifact source); this code is the
-// judge. Unparseable findings, content mismatches, supersession, and stamp
-// failures all fail CLOSED with a terminal parent verdict — never a stamp.
+// The sensor is the deterministic lib/readback-disk.js (it reads the
+// on-disk tree the artifact is built/served from); this code is the judge.
+// The LLM inspector driven by lib/build-readback-request.js is retained
+// only as the manual fallback for environments without disk access.
+// Unparseable findings, content mismatches, unverifiable changes (binary
+// files, mode-only changes, renames, fully-colliding hunks), supersession,
+// and stamp failures all fail CLOSED with a terminal parent verdict —
+// never a stamp.
 //
 // Usage:
 //   node verify-publish.js --crew-home <path> --task-id <uuid>
@@ -177,13 +182,15 @@ try {
 } catch (e) {
   terminal("read-back-unavailable", `git diff failed: ${e.message}`);
 }
-const expected = new Map(); // path -> { added: [], removed: [] }
+const expected = new Map(); // path -> { added: [], removed: [], isBinary: bool }
 let curFile = null;
 for (const line of diff.split("\n")) {
   if (line.startsWith("diff --git")) {
     const m = line.match(/^diff --git a\/(.+) b\/(.+)$/);
     curFile = m ? m[2] : "unknown";
-    expected.set(curFile, { added: [], removed: [] });
+    expected.set(curFile, { added: [], removed: [], isBinary: false });
+  } else if (curFile && line.startsWith("Binary files ")) {
+    expected.get(curFile).isBinary = true;
   } else if (curFile && line.startsWith("+") && !line.startsWith("+++")) {
     expected.get(curFile).added.push(line.slice(1));
   } else if (curFile && line.startsWith("-") && !line.startsWith("---")) {
@@ -257,11 +264,42 @@ let exempted = 0;
 for (const [path, exp] of expected) {
   const found = findings.get(path);
   if (!found) terminal("content-mismatch", `no findings for changed file ${path}`);
+  // (2026-09-16, critic finding 1) Binary files, mode-only changes, and
+  // renames produce zero added/removed lines: the loops below would
+  // iterate over empty arrays and the stamp would issue with "all added
+  // lines PRESENT, all removed lines ABSENT" — vacuously true, content
+  // never read. The line-based judge cannot verify these changes, so they
+  // fail closed as unverifiable (never stamped); a human verifies.
+  if (exp.added.length === 0 && exp.removed.length === 0) {
+    terminal("unverifiable-content",
+      `${exp.isBinary ? "binary file" : "no content lines (mode-only change or rename)"} ${path}: ` +
+      "the diff carries no added/removed lines for this file, so the line-based read-back checked nothing — " +
+      "provenance NOT stamped; human verification needed");
+  }
+  // (2026-09-16, critic finding 5) Added-line collisions: an added line
+  // that already occurs verbatim in the old tree is reported PRESENT
+  // whether or not the new hunk actually landed — zero discriminating
+  // power (the sensor is membership-only, not count-sensitive). Exempt
+  // such lines from the pass criteria, symmetric to the removed-side
+  // exemption below — and require at least one discriminating added line
+  // per file, or the added-side check is vacuous (finding 1's class).
+  let discriminatingAdded = 0;
   for (const line of exp.added) {
     const v = found.added.get(line);
     if (v === undefined) terminal("unreadable-result", `no ADDED finding for line in ${path}: ${line.slice(0, 60)}`);
+    if (oldCount(path, line) > 0) {
+      exempted += 1; // colliding pre-existing line: zero signal, cannot fail a good publish
+      continue;
+    }
+    discriminatingAdded += 1;
     if (v !== "PRESENT") terminal("content-mismatch", `added line ABSENT in ${path}: ${line.slice(0, 80)}`);
   }
+  if (exp.added.length > 0 && discriminatingAdded === 0) {
+    terminal("unverifiable-content",
+      `all ${exp.added.length} added line(s) in ${path} already occur in the old tree: ` +
+      "their PRESENT findings cannot tell \"hunk landed\" from \"hunk dropped\" — " +
+      "provenance NOT stamped; human verification needed");
+  }
   // The diff may remove the same line more than once; the old tree must
   // account for every removal before a line counts as a collision.
   const removedBudget = new Map();
@@ -316,7 +354,7 @@ if (!p || p.source_commit !== commit || p.task_id !== taskId || p.crew_release !
 // --- 8. Terminal verified event + re-queue -----------------------------------
 const verifiedMsg =
   `publish: verified ${commit} (${inspectionId}) — read-back: all added lines PRESENT, all removed lines ABSENT` +
-  (exempted > 0 ? ` (${exempted} colliding removed line${exempted === 1 ? "" : "s"} exempted)` : "") +
+  (exempted > 0 ? ` (${exempted} colliding line${exempted === 1 ? "" : "s"} exempted as non-discriminating)` : "") +
   `; ${buildNote}; no supersession (HEAD=${commit}).`;
 api("log-event", { task_id: taskId, type: "note", message: verifiedMsg.slice(0, 1000) });
 api("update-task", { id: taskId, state: "in_progress" });

package/package.json

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