muse-crew 0.17.1 → 0.17.3

package/lib/chore/CONTRACT.md

@@ -0,0 +1,181 @@
+# Chore phase contracts (sandbox exit, Piece 2)
+
+Each phase module under `lib/chore/phases/` is a pure-ish function of its
+declared inputs. This document is the contract: inputs, outputs, state
+read/written, the typed handoff to the next phase, and the explicit
+transitions. No shared mutable scratch exists between phases except through
+these declared channels.
+
+The driver (`lib/chore-run.js`, Piece 3) invokes `runPhase(ctx)` and acts on the
+returned result object. `ctx = { env, state }`:
+
+- `env` — derived once per run by `deriveRunEnv()` in `phase-lib.js`: task
+  identity, repo/crew paths, pinned lifecycle script paths, publish target,
+  surface classification. Read-only.
+- `state` — per-run driver state: `activeSessionId` (the claimed session id;
+  null until the first claim), `reworkCount` (integer, 0 on first pass),
+  `isFirstClaimVisit` (true only on the run's first phase visit),
+  `nextPhaseRouted` (the dispatcher's routed next phase, if any),
+  `experiential` (seeded by Triage's ADVANCE result), `memo` (phase scratch,
+  namespaced per phase). The driver owns it; phases read it and only mutate
+  `memo` and the driver's own `experiential`/`activeSessionId` transitions.
+
+Result types (all phases):
+
+| type | meaning |
+|---|---|
+| `ADVANCE` | phase done; driver proceeds to `next` (a phase name) or ends the run (`next: null`) |
+| `REWIND` | go back to an earlier phase (`next`), carrying `reason` |
+| `PARK` / `PARK_FAILED` | task parked with `reason`; driver stops |
+| `FAILED` | phase failed operationally; dispatcher retries under its consecutive-failure cap |
+| `STAND_DOWN` | lost the first-claim race; driver stops quietly |
+| `NEED_SPAWN` | the creative boundary needs a spawn; driver posts it and re-invokes later |
+| `STANDBY` | a requested spawn is still running; driver waits |
+
+Every phase begins with `ensureClaimed(env, state, PHASE)`: on the first
+visit of the run it claims the task (state→in_progress, atomic claimtask);
+a lost race returns `STAND_DOWN`. Every phase claims its own session
+(source parity — one session per phase): the driver nulls
+`state.activeSessionId` on each ADVANCE/REWIND, so the next phase goes
+through `claimStep` for a fresh per-phase session, never a second
+first-claim. When the driver resumes mid-run, the derived running session
+is reused for its own phase.
+
+Creative phases (Triage, Map, Build, Review, Integrate, Publish) cross the
+work boundary through `runWorkBoundary`, which never spawns itself: it reads
+terminal spawn-ledger rows via `getSpawnRow`, or returns `NEED_SPAWN` with a
+`workRequest` the driver posts. Capture is fully mechanical (no spawn).
+
+`recordPhase` writes the session row + event row in one transaction
+(`record-phase` composite). Session `status` vocabulary: `completed`,
+`failed`, `rejected`, `in_progress`. Event `type` mirrors the session
+status.
+
+## Triage (Sage) — `triage.js`
+
+- **Inputs:** task title/description, repo path, surface description, UX
+  doctrine path, event preamble.
+- **State read:** claim context.
+- **Work:** one work-agent (Sage) validates the task; report must end with
+  the machine-read `experiential: yes|no` line.
+- **State written:** completed session + event (notes = summarized report).
+  Not a verdict step: usable output = pass.
+- **Handoff:** `experiential` (`"yes"`/`"no"`/null) — read by Capture and
+  Map from the durable Triage session notes (re-derived, never passed in
+  memory).
+- **Transitions:** `ADVANCE → Capture` always (a rejected Triage still
+  advances; the rejection is recorded).
+
+## Capture (Hazel) — `capture.js`
+
+- **Inputs:** experiential status (from Triage session notes), surface
+  classification, baseline notes (`baselineStatus`), visual-protocol
+  availability flag.
+- **State read:** prior `baseline:` notes (exact-prefix scan).
+- **Work:** fully mechanical. Skips when not experiential or not an
+  artifact surface. Otherwise: baseline already recorded → carry-forward
+  note; 2 requests exhausted → `baseline: none`; else request baseline
+  (attempt N) and park for the parent protocol.
+- **State written:** `baseline:` notes (`requested`, `none`, or the
+  carry-forward form), completed session + event.
+- **Handoff:** the `baseline:` notes themselves (Map's gate reads them).
+- **Transitions:** `ADVANCE → Map` on every path except the park path
+  (`PARK` with the baseline-request reason).
+
+## Map (Mara) — `map.js`
+
+- **Inputs:** experiential/baseline gate, task context, prior events,
+  mapper inputs.
+- **State read:** Triage session notes (experiential), `baseline:` notes.
+- **Work:** baseline gate first — an experiential artifact task with no
+  baseline evidence bounces to Capture (session `failed`, never a task
+  failure). Then one work-agent (Mara) writes the builder spec; the
+  baseline-gate paragraph is included when the gate applied.
+- **State written:** completed/failed session + event (notes = the mapper
+  specification — the durable cross-run handoff Build reads).
+- **Handoff:** the Map session notes (the spec); Build re-derives them via
+  `latestSessionNotes`.
+- **Transitions:** `REWIND → Capture` (Map gate bounce); `ADVANCE → Build`.
+
+## Build (Wren) — `build.js`
+
+- **Inputs:** mapper spec + rejection notes (from durable session notes),
+  worktree hints, task branch, publish-type npm paragraph, surface UX
+  paragraphs.
+- **State read:** Map session notes (spec), prior rejection notes, claim
+  context.
+- **Work:** one work-agent (Wren) prepares the worktree (STEP 1), starts
+  the heartbeat loop, implements the spec (STEP 2). Verdict step:
+  `VERDICT: PASS|FAIL` extracted deterministically; missing verdict →
+  bounded verdict-reask.
+- **State written:** completed/failed session + event (notes = summarized
+  report, incl. the machine-read `release:`/`version_bump:` and
+  `repo_diff:` marker lines).
+- **Handoff:** the Build session notes (report + markers); Review reads the
+  report, Publish re-derives the release decision.
+- **Transitions:** `ADVANCE → Review` on pass; `FAILED` (dispatcher retry)
+  on terminal work-agent failure.
+
+## Review (Cass) — `review.js`
+
+- **Inputs:** mapper spec, branch classification (direct `inspect` parse),
+  npm `version` touch check (bounded instrument retries), Build report,
+  release decision, worktree hint.
+- **State read:** Build session notes, git branch state (mechanical).
+- **Work:** direct branch classification first (no Cass on empty/touched
+  branches — synthetic mechanical FAIL). Cold Cass review otherwise:
+  structured verdict extracted deterministically; rejection carries a
+  bounded rework budget and rewinds to Build with rejection notes.
+- **State written:** completed (`VERDICT: PASS`), `rejected` (structured
+  verdict payload in the `verdicts` table, first-write-wins), or `failed`
+  session + event.
+- **Handoff:** rejection notes (Build re-reads them); the accepted report.
+- **Transitions:** `ADVANCE → Integrate` on pass; `REWIND → Build`
+  (rework, bounded); `FAILED` on mechanical/instrument failure.
+
+## Integrate (Wren) — `integrate.js`
+
+- **Inputs:** task branch, merge-lock holder identity, lifecycle
+  `integrate` command, mechanical `verify-merge` check.
+- **State read:** lock status, prior merge records, claim context.
+- **Work:** one work-agent (Wren) runs the lifecycle `integrate`
+  instruction (conflict-resolution protocol, detached-HEAD rules); the
+  workflow then runs mechanical `verify-merge <taskId>` requiring a
+  `VERIFIED:` line. `MERGED_EMPTY` (no commits ahead) is a clean skip —
+  no lock is taken.
+- **State written:** completed/failed session + event; merge record via the
+  lifecycle script.
+- **Handoff:** the merge on the integration target; Publish reads the lock
+  state (`UNLOCKED` ⇒ empty-diff skip).
+- **Transitions:** `ADVANCE → Publish` on verified merge (incl.
+  `MERGED_EMPTY`); `FAILED` on verification failure.
+
+## Publish (Wren) — `publish.js`
+
+- **Inputs:** publish target (`npm`/`artifact`/`vercel`/empty), pinned
+  lifecycle scripts, merge-lock state, registry version, artifact
+  provenance, publish diff.
+- **State read:** Build session notes (release decision), provenance,
+  lock status, registry.
+- **Ordering (source-preserved):** pin guard + one re-pin → target
+  validation → npm precomputation (registry base + deterministic bump) →
+  claim → instructions branch.
+- **Work — npm:** the work agent runs exactly one command (the pinned
+  publish script); the workflow verifies the registry version and
+  refreshes provenance mechanically. `release: no` and empty target skip
+  deterministically before the claim.
+- **Work — artifact:** fully mechanical before the work agent — verified
+  re-entry guard, lock-status/refresh, artifact target preflight,
+  provenance base, checksummed diff with binary/rename/line-budget guards,
+  intent-ledger anchor → parks at publish intent for the tick worker. The
+  work agent only reports on the mechanical outcome (verified / skipped /
+  normal framing).
+- **Work — vercel:** not implemented → `VERDICT: FAIL`, no invented
+  behavior.
+- **State written:** completed/failed session + event; publish ledger
+  entries (`recordPublishLedger`). P4 preserved: early artifact ledger
+  entries carry `commit: null` (the `var mergeCommitForPublish`
+  declaration hoists below them — do not move it).
+- **Handoff:** terminal — the run ends (`ADVANCE` with `next: null`).
+- **Transitions:** `ADVANCE → null` (done); `PARK` on any fail-closed
+  condition; `FAILED` on work-agent failure.

package/lib/chore/DISPOSITION.md

@@ -0,0 +1,98 @@
+# Chore 44-site disposition inventory (sandbox exit, Piece 2)
+
+Independent review (2026-09-26) found 44 `agent()` call sites in
+`workflows/chore.js`: **42 couriers** (deterministic — become `execFile` /
+Node in the worker layer), **1 work-agent** (creative), **1 verdict-reask**
+(creative). Chore fits completely; Standard QA and Bugfix Reproduce/QA
+remain deferred Piece 4.
+
+Disposition vocabulary: `execFile` · `spawn-bridge` · `deferred-piece-4` ·
+`deleted`. Unknown → fail closed.
+
+## Creative (spawn-bridge)
+
+| # | site | disposition |
+|---|---|---|
+| 1 | L2004 — the phase work-agent (`workPromptBase`) | `spawn-bridge` → `work-agent` kind via `runWorkBoundary`/`workRequest` |
+| 2 | L247 — verdict re-ask (`buildVerdictReaskPrompt`) | `spawn-bridge` → `verdict-reask` kind via `runWorkBoundary` |
+
+## Deterministic couriers → execFile
+
+All 42 become direct `execFile`/Node calls in the worker layer (argv only,
+no shell). Grouped by phase:
+
+**Run scaffolding / telemetry**
+| site | command |
+|---|---|
+| L72 | `record-run-start` (crew-api) |
+| L95 | `record-run-events-batch` (crew-api) |
+| L114 | `record-run-end` (crew-api) |
+| L282 | `pinLifecycle` — mkdir/cp/chmod/ls of pinned scripts |
+| L1022 | pin verification — `ls -1 RUN_LIB` |
+| L2397 | cleanup pins — `rm -rf RUN_LIB` |
+
+**Claim protocol**
+| site | command |
+|---|---|
+| L1114 | first claim — `update-task` (state→in_progress + workflow) |
+| L1148 | session claim — `claim-task` |
+
+**Phase tracking**
+| site | command |
+|---|---|
+| L1181 | `record-phase` |
+| L1201 | `log-event` (baseline carry-forward) |
+| L1219 | `log-event` (baseline: none) |
+| L1233 | `log-event` (baseline: requested) |
+| L1242 | `log-event` (baseline: none, protocol unavailable) |
+| L1270 | `record-phase` (Map gate bounce) |
+| L2053 | `record-phase` (work failure) |
+| L2092 | `record-phase` (verdict failure) |
+| L2134 | `record-phase` (worktree confinement failure) |
+| L2323 | `record-phase` (phase closeout) |
+| L2388 | `update-task` (done) + `log-event` (completed) |
+| L918 | `park-task` |
+| L998 | `record-phase` (abort stale run) |
+
+**Preflight / probes**
+| site | command |
+|---|---|
+| L715 | experiential check — `get-state` → Triage notes |
+| L751 | baseline notes — `get-events` |
+| L826 | baseline seed — `get-events` |
+| L983 | project check — `get-state` |
+| L902 | `terminal-cleanup` (lifecycle) |
+
+**Review instruments** (bounded, schema-shaped)
+| site | command |
+|---|---|
+| L1383 | `classify-branch` — lifecycle `inspect` → JSON |
+| L1454 | `version-check` — lifecycle `version-check` → JSON |
+
+**Publish** (all deterministic pre/post work)
+| site | command |
+|---|---|
+| L1045 | `post-deploy` (npm skip path) |
+| L1070 | `post-deploy` (empty-target skip path) |
+| L1085 | `npm view muse-crew version` (registry base) |
+| L1606 | verified re-entry guard — `get-provenance` + `git rev-parse HEAD` |
+| L1634 | `lock-status` (lifecycle) |
+| L1702 | artifact preflight — `test -d` |
+| L1739 | `get-provenance` (publish base) |
+| L1755 | `compute-publish-diff.js` (checksummed diff) |
+| L1872 | `post-deploy` (artifact path) |
+| L1895 | `post-deploy` (cleanup after failure) |
+| L2177 | `verify-merge` (lifecycle) |
+| L2219 | `npm view muse-crew version` (registry verification) |
+| L2232 | provenance refresh — `get-provenance` + `set-provenance` |
+| L631 | publish-attempt ledger append (mkdir + printf) |
+
+## Deferred (Piece 4)
+
+Standard QA and Bugfix Reproduce/QA — not in Chore. No Chore site is
+deferred.
+
+## Deleted
+
+None in Piece 2. The publish-verification content-verdict machine was
+already retired (0.14.6); no Chore `agent()` site references it.

package/lib/chore/extract.js

@@ -0,0 +1,204 @@
+// lib/chore/extract.js — deterministic report extractors for the worker-layer
+// chore port (sandbox exit, Piece 2, 2026-09-26).
+//
+// Import-safe: pure functions, no I/O, no clock, no randomness, no
+// top-level await (require(esm)-safe). Moved logic-verbatim from
+// workflows/chore.js; the one function that closed over module state
+// (releaseDecisionText) now takes that state as an explicit parameter.
+// The four dead-in-chore helpers (parseMergeRecord, decidePublishLockPath,
+// decideIntegrateRetry, hydrateReleaseDecision) are NOT carried — they are
+// dead in chore and standard. captureTargets is NOT carried — write-only
+// in every reviewed workflow.
+
+export function extractVerdict(workerText) {
+  // The verdict is the LAST VERDICT: PASS/FAIL in the report (contract: end
+  // your report with the verdict). This ignores literal VERDICT strings echoed
+  // from the worker's instructions (which contain quoted examples). Fail
+  // closed if: no verdict found, the last verdict is not in the trailing 100
+  // chars (verdict must be at the end), or conflicting verdicts appear in the
+  // trailing 200 chars. Word boundary prevents "PASSING" matching as PASS.
+  var text = workerText || "";
+  var regex = /VERDICT:\s*(PASS|FAIL)\b/gi;
+  var matches = [];
+  var m;
+  while ((m = regex.exec(text)) !== null) {
+    matches.push({ value: /FAIL/i.test(m[0]) ? "FAIL" : "PASS", index: m.index });
+  }
+  if (matches.length === 0) return { ok: false, count: 0 };
+  var last = matches[matches.length - 1];
+  if (last.index < text.length - 100) return { ok: false, count: matches.length };
+  var trailing = matches.filter(function (x) { return x.index >= text.length - 200; });
+  var uniq = trailing.map(function (x) { return x.value; }).filter(function (v, i, a) { return a.indexOf(v) === i; });
+  if (uniq.length !== 1) return { ok: false, count: matches.length };
+  return { ok: true, passed: last.value === "PASS" };
+}
+
+export function extractMarkerLines(workerText) {
+  var lines = (workerText || "").split("\n");
+  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:|layer:|capture_targets:|terminal_targets:|worktree:)/i.test(line)) {
+      markers.push(line);
+    }
+  }
+  return markers.join("\n");
+}
+
+export function parseToolSignals(text) {
+  var t = String(text || "");
+  var out = { artifactTools: "unknown", shellTransport: "unknown" };
+  var am = t.match(/^artifact_tools:\s*(ok|missing)\s*$/m);
+  if (am) out.artifactTools = am[1];
+  var sm = t.match(/^shell_transport:\s*(ok|unavailable)\s*$/m);
+  if (sm) out.shellTransport = sm[1];
+  return out;
+}
+
+export function parseClassifyFerry(bsResult) {
+  var bsStdout = (bsResult && typeof bsResult.stdout === "string") ? bsResult.stdout : null;
+  var bsStderr = (bsResult && typeof bsResult.stderr === "string") ? bsResult.stderr : null;
+  if (bsStdout === null || bsStderr === null) {
+    return { state: null, diagField: null, diagText: "",
+      failReason: "classifier return fields missing or non-string (stdout and stderr must both be strings)" };
+  }
+  // State channel: stdout ONLY. A BRANCH_STATE match on stderr is never
+  // trusted — workers merge streams constantly, and trusting a channel
+  // swap as truth is the wrong shape. Search, never anchor (blocker 11):
+  // the ferry labels output ("stdout: BRANCH_STATE: has-work"). Collect
+  // ALL matches and dedupe normalized values: exactly one distinct value
+  // is truth; zero or two-or-more is UNKNOWN — alternation order never
+  // adjudicates.
+  var bsRe = /\bBRANCH_STATE:\s*(has-work|already-merged:[0-9a-f]{40}|empty-no-work)(?![\w-])/gi;
+  var bsSeen = {};
+  var bsM;
+  while ((bsM = bsRe.exec(bsStdout)) !== null) {
+    bsSeen[bsM[1].toLowerCase()] = true;
+  }
+  var bsStates = Object.keys(bsSeen);
+  if (bsStates.length !== 1) {
+    return { state: null, diagField: null, diagText: "",
+      failReason: bsStates.length === 0
+        ? "no BRANCH_STATE match in the stdout field"
+        : "ambiguous BRANCH_STATE values in stdout (" + bsStates.length + " distinct)" };
+  }
+  var bsState = bsStates[0];
+  // DIAG pin: search both fields, stderr first. Keep the DIAG: prefix — a
+  // prose mention without it must not satisfy the pin.
+  var bsDiagRe = /DIAG:\s*classify-branch\s+records=\d+\s+resolvable=\d+/;
+  var bsDiagField = bsDiagRe.test(bsStderr) ? "stderr" : (bsDiagRe.test(bsStdout) ? "stdout" : null);
+  var bsDiagText = "";
+  if (bsDiagField !== null) {
+    bsDiagText = bsDiagRe.exec(bsDiagField === "stderr" ? bsStderr : bsStdout)[0];
+  }
+  if (bsState.indexOf("already-merged:") === 0 && bsDiagField === null) {
+    // already-merged's sha flows into Cass's `git diff <sha>^1 <sha>` — a
+    // hallucinated-but-well-formed sha is a false-PASS vector. The script
+    // emits exactly one DIAG on every path that emits a BRANCH_STATE, so a
+    // missing pin means stderr wasn't faithfully ferried: UNKNOWN.
+    // Residual risk, named (blocker-42 fib 4): a worker could fabricate
+    // BOTH fields wholesale — the pin is a tripwire, not proof of
+    // execution. The workflow has no exec channel for a deterministic
+    // cross-check; if the platform ever offers one, verify the sha
+    // against the task's durable merge records directly.
+    return { state: null, diagField: null, diagText: "",
+      failReason: "already-merged without the DIAG pin — stderr not faithfully ferried" };
+  }
+  return { state: bsState, diagField: bsDiagField, diagText: bsDiagText, failReason: "" };
+}
+
+export function parseVersionFerry(vtResult) {
+  var vtStdout = (vtResult && typeof vtResult.stdout === "string") ? vtResult.stdout : null;
+  if (vtStdout === null) {
+    return { versionState: null,
+      failReason: "version-check return field missing or non-string (stdout must be a string)" };
+  }
+  // Search, never anchor (blocker 11): the ferry labels output
+  // ("stdout: VERSION_CLEAN"). Collect ALL matches and dedupe normalized
+  // values: exactly one distinct value is truth; zero or two-or-more is
+  // UNKNOWN — alternation order never adjudicates.
+  var vtRe = /\bVERSION_(TOUCHED|CLEAN)(?![\w-])/gi;
+  var vtSeen = {};
+  var vtM;
+  while ((vtM = vtRe.exec(vtStdout)) !== null) {
+    vtSeen[vtM[1].toUpperCase()] = true;
+  }
+  var vtStates = Object.keys(vtSeen);
+  if (vtStates.length !== 1) {
+    return { versionState: null,
+      failReason: vtStates.length === 0
+        ? "no VERSION_(TOUCHED|CLEAN) match in the stdout field"
+        : "ambiguous VERSION values in stdout (" + vtStates.length + " distinct)" };
+  }
+  return { versionState: vtStates[0] === "CLEAN" ? "clean" : "touched", failReason: "" };
+}
+
+export function extractReleaseDecision(workerText) {
+  var t = workerText || "";
+  var r = /release:\s*(yes|no)\b/i.exec(t);
+  if (!r) return null;
+  var b = /version_bump:\s*(patch|minor|major)\b/i.exec(t);
+  var rel = r[1].toLowerCase();
+  if (rel === "yes" && !b) return null;
+  return { release: rel, version_bump: b ? b[1].toLowerCase() : null };
+}
+
+export function extractWorktree(workerText) {
+  var lines = (workerText || "").split("\n");
+  var found = null;
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    var m = /^worktree:\s*(\S.*)$/i.exec(line);
+    if (m) found = m[1].trim();
+  }
+  if (!found) return { ok: false };
+  // Normalize trailing slashes: ".../<task_id>/" and ".../<task_id>"
+  // name the same directory. Compare locations, not spellings — a
+  // builder that emits the trailing slash still worked in the right
+  // place. (Canary 2026-09-11: an exact comparison rejected a correct
+  // declaration over one trailing slash.)
+  return { ok: true, path: found.replace(/\/+$/, "") };
+}
+
+export function extractExperiential(workerText) {
+  // Reads Sage's experiential: yes|no marker line. Missing or malformed
+  // fails closed to null — the flag is opt-in; null is treated as
+  // non-experiential (never silently parks a task on a garbled line).
+  var t = workerText || "";
+  var r = /experiential:\s*(yes|no)\b/i.exec(t);
+  if (!r) return null;
+  return r[1].toLowerCase() === "yes";
+}
+
+export function bumpVersion(base, scope) {
+  var p = String(base).trim().split(".").map(function (x) { return parseInt(x, 10) || 0; });
+  if (scope === "major") return (p[0] + 1) + ".0.0";
+  if (scope === "minor") return p[0] + "." + (p[1] + 1) + ".0";
+  return p[0] + "." + p[1] + "." + (p[2] + 1); // patch (default)
+}
+
+export function releaseDecisionText(releaseDecision) {
+  // In workflows/chore.js this closed over the module-level
+  // `releaseDecision`; here it is an explicit parameter (import-safe).
+  // Logic otherwise verbatim.
+  if (!releaseDecision) return "no machine-readable release decision from the Build report";
+  return "release: " + releaseDecision.release + (releaseDecision.version_bump ? ", version_bump: " + releaseDecision.version_bump : " (no version_bump line)");
+}
+
+// extractRepoDiffNone — the Build report's plain `repo_diff: none` (no repo
+// change) claim. Inline in workflows/chore.js
+// (`/repo_diff:\s*none/im.test(workerText || "")`); named here per the
+// phase-module contract. Pure, no I/O.
+export function extractRepoDiffNone(workerText) {
+  return /repo_diff:\s*none/im.test(workerText || "");
+}
+
+// extractPublishSkipped — the PUBLISH_SKIPPED=<reason> marker the npm publish
+// script emits and the Publish agent pastes verbatim into its report. Inline
+// in workflows/chore.js
+// (`/^PUBLISH_SKIPPED=(no-lock-held|no-npm-publish)$/m.exec(workerText || "")`);
+// named here per the phase-module contract. Returns the reason string or null.
+export function extractPublishSkipped(workerText) {
+  var m = /^PUBLISH_SKIPPED=(no-lock-held|no-npm-publish)$/m.exec(workerText || "");
+  return m ? m[1] : null;
+}