muse-crew 0.17.2 → 0.17.3

package/lib/extract.js

@@ -0,0 +1,252 @@
+// lib/extract.js — deterministic report extractors for the worker-layer
+// phase modules (sandbox exit, Phase C Piece 2).
+//
+// Import-safe: pure functions, no I/O, no clock, no randomness, no
+// top-level await (require(esm)-safe).
+//
+// Generalized from lib/chore/extract.js (which stays live and untouched):
+// every function here is workflow-neutral. The four dead-in-chore helpers
+// (parseMergeRecord, decidePublishLockPath, decideIntegrateRetry,
+// hydrateReleaseDecision) are NOT carried — they are dead in chore and in
+// standard (defined but never called in workflows/standard.js).
+// extractContentFindings and classifyContentFinding are ported from
+// workflows/standard.js (QA content-attribution machinery).
+
+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.
+    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 extractLayer(workerText) {
+  // Reads Sage's layer: artifact|engine|docs marker line (bugfix Triage).
+  // Missing or malformed degrades to null (unknown) — callers degrade to
+  // "artifact" (today's single-strategy behavior), never park a task on a
+  // garbled line.
+  var t = workerText || "";
+  var r = /layer:\s*(artifact|engine|docs)\b/i.exec(t);
+  if (!r) return null;
+  return r[1].toLowerCase();
+}
+
+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) {
+  // releaseDecision is an explicit parameter (import-safe). Logic
+  // otherwise verbatim from the workflow sources.
+  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. 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.
+// 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;
+}
+
+// extractContentFindings — ported from workflows/standard.js (QA
+// content-attribution). The block is the LAST "CONTENT-FINDINGS:" line;
+// the JSON array follows on the same line. Fail closed (ok:false) when
+// missing or malformed — the caller blocks the phase for retry; unknown
+// attribution must never degrade to "no findings" (the prose grounds stay
+// preserved in the session notes).
+export function extractContentFindings(workerText) {
+  var text = workerText || "";
+  var regex = /^CONTENT-FINDINGS:\s*(\[.*\])\s*$/gim;
+  var matches = [];
+  var m;
+  while ((m = regex.exec(text)) !== null) {
+    matches.push(m[1]);
+  }
+  if (matches.length === 0) return { ok: false, reason: "no CONTENT-FINDINGS block" };
+  var findings;
+  try {
+    findings = JSON.parse(matches[matches.length - 1]);
+  } catch (e) {
+    return { ok: false, reason: "CONTENT-FINDINGS block is not valid JSON" };
+  }
+  if (!Array.isArray(findings)) return { ok: false, reason: "CONTENT-FINDINGS is not an array" };
+  for (var i = 0; i < findings.length; i++) {
+    var f = findings[i];
+    if (!f || typeof f !== "object" || typeof f.subject !== "string" || typeof f.observation !== "string") {
+      return { ok: false, reason: "finding " + i + " needs string subject and observation" };
+    }
+  }
+  return { ok: true, findings: findings };
+}
+
+// classifyContentFinding — ported from workflows/standard.js (QA
+// content-attribution). diffFiles: the task's publish-diff file set
+// (repo-relative paths). Pure set membership — no prose, no judgment.
+export function classifyContentFinding(finding, diffFiles) {
+  var subject = finding.subject;
+  if (subject === "live-data") {
+    return { attribution: "environment-attributable", reason: "live-data is never in a git publish diff — the crew has no live-DB write path (blocker 32)" };
+  }
+  if (diffFiles.indexOf(subject) !== -1) {
+    return { attribution: "task-change", reason: "subject is in the task's publish diff" };
+  }
+  return { attribution: "environment-attributable", reason: "subject is not in the task's publish diff" };
+}

package/lib/prompts/tool-check.js

@@ -0,0 +1,18 @@
+// lib/prompts/tool-check.js — the tool-check preamble for creative
+// spawn prompts (sandbox exit, Phase C Piece 2).
+//
+// Generalized from lib/chore/prompts/tool-check.js (which stays live and
+// untouched): byte-identical across standard/bugfix/chore/docs.
+//
+// Import-safe: pure constant, no I/O. Verbatim from workflows/chore.js
+// (byte-identical across standard/bugfix/chore/docs — pinned by
+// tests/artifact-tools.test.js). The two signal lines are the ONLY
+// machine-read tool-availability evidence — the extractor never guesses
+// from English prose.
+
+export const TOOL_CHECK_PREAMBLE =
+  "TOOL CHECK (do this first, before any other work):\n" +
+  "1. Call tool_search.load_tool_namespace with paths [\"artifact\"].\n" +
+  "2. Write exactly one line: artifact_tools: ok - or artifact_tools: missing if the call failed or the tool does not exist.\n" +
+  "3. Run the shell command: echo tool-probe-ok - then write exactly one line: shell_transport: ok - or shell_transport: unavailable if you cannot run shell commands.\n" +
+  "Then do the assignment below.\n\n";

package/lib/prompts/trailers.js

@@ -0,0 +1,59 @@
+// lib/prompts/trailers.js — retry trailers for creative spawn prompts
+// (sandbox exit, Phase C Piece 2).
+//
+// Generalized from lib/chore/prompts/trailers.js (which stays live and
+// untouched): every function here is workflow-neutral.
+//
+// Import-safe: pure functions, no I/O, no clock, no randomness. Logic-
+// verbatim from workflows/chore.js with the exact source signatures:
+//   buildTransportRetryTrailer(stepName, repoPath, taskId, attempt, reason)
+//   classifyRetryTrailer(reason, failedReturn)
+//   versionRetryTrailer(reason, failedReturn)
+// buildTransportRetryTrailer is byte-identical across standard/bugfix/chore/docs
+// (pinned by tests/transport-retry.test.js); the classify/version trailers are
+// chore-local.
+//
+// Note: the classify/version trailers are retained for contract fidelity but
+// have no consumer in the worker layer — the mechanical gates they re-prompted
+// (classify-branch, version-check) now run via direct execFile, so there is no
+// agent ferry to re-prompt. Only buildTransportRetryTrailer is used, by the
+// work-agent transport-retry path.
+
+export function buildTransportRetryTrailer(stepName, repoPath, taskId, attempt, reason) {
+  // reason: "discarded" (the runtime threw the output away — the JSON-candidate
+  // scan found {...}-shaped fragments it could not parse), "empty" (the worker returned without throwing but produced
+  // nothing usable), "no-tools" (the worker's TOOL CHECK reported
+  // artifact_tools: missing), or "no-transport" (the worker's TOOL CHECK
+  // reported shell_transport: unavailable).
+  // The trailer tells the retry what to expect, not just to try again.
+  var why = reason === "empty"
+    ? "your previous attempt returned no usable output"
+    : reason === "no-tools"
+    ? "your previous attempt's TOOL CHECK reported artifact_tools: missing (this is a fresh launch, so run the TOOL CHECK's load step again before the work)"
+    : reason === "no-transport"
+    ? "your previous attempt's TOOL CHECK reported shell_transport: unavailable (this is a fresh launch, so run the TOOL CHECK's shell probe again before the work)"
+    : "your previous attempt's output was discarded by the transport because it contained {...}-shaped fragments the transport could not parse; write plain prose with no JSON-shaped fragments";
+  return "\n\nTRANSPORT RETRY (attempt " + attempt + " of 2): " + why + ". " +
+    "First check existing state (worktree/branch at " + repoPath + "/.worktrees/" + taskId + ", the task branch, dashboard sessions for this task) - " +
+    "if the " + stepName + " work is already complete, report on what was done rather than duplicating side effects. " +
+    "Then return your report in exactly the shape specified above.";
+}
+
+export function classifyRetryTrailer(reason, failedReturn) {
+  // Pass-2 simplification: the reason string already carries the truth
+  // (throw vs parse failure), so one neutral sentence replaces the
+  // throw/parse branch — the stringly-typed prefix contract between the
+  // call site and this function is deleted, not moved. Prompt accuracy,
+  // not prompt hardening.
+  return "\n\nCLASSIFY RETRY: the previous classifier attempt failed (" + reason + "). " +
+    "Return ONLY the two named fields: { \"stdout\": \"<the command's exact stdout>\", \"stderr\": \"<the command's exact stderr>\" }. " +
+    "Put each stream in its named field — do not add labels like \"stdout:\" in front of the content. " +
+    "Previous attempt detail (do not repeat this shape): " + String(failedReturn).slice(0, 200);
+}
+
+export function versionRetryTrailer(reason, failedReturn) {
+  return "\n\nVERSION-CHECK RETRY: the previous version-check attempt failed (" + reason + "). " +
+    "Return ONLY the named field: { \"stdout\": \"<the command's exact stdout>\" }. " +
+    "Put the command's stdout in the named field — do not add labels like \"stdout:\" in front of the content. " +
+    "Previous attempt detail (do not repeat this shape): " + String(failedReturn).slice(0, 200);
+}

package/lib/prompts/verdict-reask.js

@@ -0,0 +1,31 @@
+// lib/prompts/verdict-reask.js — the verdict re-ask prompt builder
+// (sandbox exit, Phase C Piece 2).
+//
+// Generalized from lib/chore/prompts/verdict-reask.js (which stays live and
+// untouched): a pure function of declared params, workflow-neutral.
+//
+// A pure function of declared params (P1). Logic-verbatim from
+// workflows/chore.js buildVerdictReaskPrompt: the re-ask is a fresh content
+// judgment — it must NOT copy any VERDICT line from the report, it decides
+// from the content. Bounded to 2 attempts by the spawn bridge
+// (MAX_ATTEMPTS), 180s each.
+
+export function buildVerdictReaskPrompt(params) {
+  var p = params || {};
+  var stepName = p.step_name;
+  var workerText = p.worker_text;
+  if (typeof stepName !== "string" || stepName.length === 0) {
+    throw new Error("buildVerdictReaskPrompt: missing required param 'step_name'");
+  }
+  if (typeof workerText !== "string") {
+    throw new Error("buildVerdictReaskPrompt: missing required param 'worker_text'");
+  }
+  return (
+    "Mechanical transcription task. Read the work report below and emit its verdict.\n\n" +
+    "WORK REPORT (verbatim):\n" + workerText + "\n\n" +
+    "Decide from the report's own content whether the " + stepName + " step clearly describes successful completion: " +
+    "if it does, the verdict is PASS; otherwise — failure, error, unfinished work, or unclear — the verdict is FAIL. " +
+    "Do NOT copy any VERDICT line from the report — decide from the content.\n\n" +
+    "The result must be exactly one line and nothing else: VERDICT: PASS or VERDICT: FAIL."
+  );
+}

package/lib/prompts/verdict-reask.schema.json

@@ -0,0 +1 @@
+{"_note":"Extractor contract for the verdict-reask spawn kind — the exact line grammar lib/chore/extract.js requires. This is NOT JSON Schema; 'schema' here means the machine-read report contract the agent's prose must satisfy.","contract":{"bounds":"2 attempts max, 180s each (MAX_ATTEMPTS['verdict-reask']); attempts are separate ledger rows kind='verdict-reask'. Terminal reask failures count toward the per-task transport budget.","verdict":{"function":"extractVerdict","grammar":"Exactly one line and nothing else: 'VERDICT: PASS' or 'VERDICT: FAIL'. Read with extractVerdict (same grammar as work-agent); anything else → missing (null) and the re-ask attempt is spent."}},"extractor_module":"../extract.js","kind":"verdict-reask","prompt_builder":"./verdict-reask.js"}

package/lib/prompts/work-agent.js

@@ -0,0 +1,56 @@
+// lib/prompts/work-agent.js — the work-agent prompt builder for the
+// worker-layer phase modules (sandbox exit, Phase C Piece 2).
+//
+// Generalized from lib/chore/prompts/work-agent.js (which stays live and
+// untouched): the frame is workflow-neutral; per-step instructions arrive
+// as a param (built by the phase modules).
+//
+// A pure function of declared params (P1, 2026-09-26): prompts are NOT
+// verbatim-lifted (only 1 of 44 chore prompts was liftable). The frame below
+// reproduces the workPromptBase assembly from workflows/chore.js exactly;
+// the per-step instructions arrive as a param (built by the phase modules),
+// as do the conditional trailers.
+
+import { TOOL_CHECK_PREAMBLE } from "./tool-check.js";
+
+function requiredString(params, name) {
+  var v = params[name];
+  if (typeof v !== "string" || v.length === 0) {
+    throw new Error("buildWorkPrompt: missing required param '" + name + "'");
+  }
+  return v;
+}
+
+export function buildWorkPrompt(params) {
+  var p = params || {};
+  var identity = requiredString(p, "identity");
+  var orchPath = requiredString(p, "orch_path");
+  var taskId = requiredString(p, "task_id");
+  var stepName = requiredString(p, "step_name");
+  var instructions = requiredString(p, "instructions");
+  // Source equivalence (workflows/chore.js): task_title and task_description
+  // flow through `inputs.task_title || ""` — empty values are valid and must
+  // NOT be rejected. Only identity/orch_path/task_id/step_name/instructions
+  // are required.
+  var taskTitle = p.task_title || "";
+  var taskDescription = p.task_description || "";
+  var crewApi = typeof p.crew_api === "string" ? p.crew_api : "";
+  // Source equivalence: the "Crew API:" line is emitted for every step
+  // EXCEPT Review (Cass must not call the Crew API directly — the frame is
+  // `(step.name !== "Review" ? "Crew API: " + CREW_API + "\n" : "")`). The
+  // phase module passes the pinned crew-api path, or "" for Review.
+  var eventPreamble = typeof p.event_preamble === "string" ? p.event_preamble : "";
+  var retryTrailer = typeof p.transport_retry_trailer === "string" ? p.transport_retry_trailer : "";
+  var includeToolCheck = p.include_tool_check !== false;
+
+  return (
+    (includeToolCheck ? TOOL_CHECK_PREAMBLE : "") +
+    "Read the identity file at " + orchPath + "/identities/" + identity + ".md using the read tool, and embody that character fully.\n\n" +
+    "## Your Assignment\n\n" +
+    "Task: " + taskTitle + "\nTask ID: " + taskId + "\nDescription: " + taskDescription + "\nStep: " + stepName + "\n" +
+    (crewApi ? "Crew API: " + crewApi + "\n" : "") +
+    "\n## Instructions\n\n" + eventPreamble + instructions + "\n\nCONSTRAINT: Do NOT call logevent or upsertagentsession — the workflow handles all phase tracking after your step completes.\n\nStay in character. Do the work thoroughly.\n\n" +
+    "Your report is plain prose describing what you did and found. For verdict steps, end the report with exactly one line: VERDICT: PASS or VERDICT: FAIL." +
+    retryTrailer
+  );
+}

package/lib/prompts/work-agent.schema.json

@@ -0,0 +1 @@
+{"_note":"Extractor contract for the work-agent spawn kind — the exact line grammars lib/chore/extract.js requires. This is NOT JSON Schema; 'schema' here means the machine-read report contract the agent's prose must satisfy.","contract":{"bump_version":{"function":"bumpVersion","grammar":"Deterministic semver bump (patch default); computed by the workflow, never by the agent."},"experiential":{"function":"extractExperiential","grammar":"'experiential: yes|no' → boolean; missing or malformed → null (opt-in flag, never parks on a garbled line)."},"marker_lines":{"function":"extractMarkerLines","grammar":"Known prefixes (repo_diff:, release:, version_bump:, VERDICT:, TARGET_VERSION=, published:, experiential:, layer:, capture_targets:, terminal_targets:, worktree:); identical lines deduped. Long reports cannot amputate them — they are re-appended after the summary slice."},"release_decision":{"function":"extractReleaseDecision","grammar":"'release: yes|no' → {release, version_bump}; missing release line → null; 'yes' without version_bump → null (fail closed)."},"repo_diff_none":{"function":"extractRepoDiffNone","grammar":"/repo_diff:\\s*none/im — the builder declared no repo change."},"tool_signals":{"function":"parseToolSignals","grammar":"Lines 'artifact_tools: ok|missing' and 'shell_transport: ok|unavailable' (anchored, first match each). Missing lines → 'unknown', never null."},"verdict":{"function":"extractVerdict","grammar":"The LAST 'VERDICT: PASS|FAIL' in the report; must be in the trailing 100 chars; conflicting verdicts in the trailing 200 chars fail closed. Returns {ok, passed} or {ok:false, count}. Word boundary prevents 'PASSING' matching."},"worktree":{"function":"extractWorktree","grammar":"Line 'worktree: <path>' (last wins); trailing slashes normalized. Missing → {ok:false}."}},"extractor_module":"../extract.js","kind":"work-agent","prompt_builder":"./work-agent.js"}