mandrel 2.31.0 → 2.32.0

package/.agents/schemas/lifecycle/README.md

@@ -1,18 +1,25 @@
 # Lifecycle event schemas
 
-JSON Schemas for the lifecycle event taxonomy consumed by the
-`/deliver` lifecycle bus
-(`lib/orchestration/lifecycle/bus.js`). The bus validates every
-emit payload against one of these schemas before invoking
-listeners; a schema mismatch fails the emit and propagates the
-throw.
+JSON Schemas for the two events a delivery run can append to its per-run
+lifecycle ledger. `appendLedgerEvent`
+(`lib/orchestration/lifecycle/emit-ledger-event.js`) validates every payload
+against one of these before the write; a schema mismatch throws and nothing is
+appended.
 
-Each event in the Tech Spec taxonomy has a `<event>.schema.json`
-file. The ledger record (`emitted | completed | failed` union)
-lives in `ledger-record.schema.json` and is consumed by
-`ledger-writer.js`.
+`ledger-record.schema.json` is the NDJSON record envelope
+(`emitted | completed | failed`), not an event. Only `emitted` has a writer —
+see the schema's own description for why the other two kinds remain.
 
-Schemas are intentionally permissive (`additionalProperties: true`)
-on inner objects whose shape is dictated by upstream tooling (e.g.
-`gh pr view` JSON, `checkOutcomes`). The required-key set is the
-contract.
+**A schema belongs here only while code emits its event.** Story #4545 applied
+that rule to the `epic.*` and `acceptance.reconcile.*` families; Story #5024
+applied it to the remaining fifteen when it retired the lifecycle bus that had
+been their only publish path. `tests/lifecycle/schema-registry.test.js` enforces
+it in both directions, so a schema file for an event nobody emits fails the
+suite rather than reading green.
+
+Schemas are intentionally permissive (`additionalProperties: true`) on inner
+objects whose shape is dictated by upstream tooling (e.g. `gh pr view` JSON).
+The required-key set is the contract.
+
+Full reference:
+[`docs/LIFECYCLE.md`](https://github.com/dsj1984/mandrel/blob/main/docs/LIFECYCLE.md).

package/.agents/schemas/lifecycle/ledger-record.schema.json

@@ -2,22 +2,41 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/dsj1984/mandrel/blob/main/.agents/schemas/lifecycle/ledger-record.schema.json",
   "title": "Lifecycle ledger record (emitted | completed | failed)",
-  "description": "Append-only NDJSON record shape for temp/run-<id>/lifecycle.ndjson. Three discriminated kinds; consumers (LedgerWriter, TraceLogger) discriminate on `kind`.",
+  "description": "Append-only NDJSON record shape for the per-run lifecycle ledger. Three discriminated kinds keyed on `kind`. Only `emitted` has a writer: Story #5024 retired the lifecycle bus, so the `completed` / `failed` kinds are a READ contract for ledgers archived from the bus era (`failed` requires a `listener`, which only a listener chain could supply). Reading a ledger never consults this schema; validation happens on the write path only.",
   "oneOf": [
-    { "$ref": "#/$defs/emitted" },
-    { "$ref": "#/$defs/completed" },
-    { "$ref": "#/$defs/failed" }
+    {
+      "$ref": "#/$defs/emitted"
+    },
+    {
+      "$ref": "#/$defs/completed"
+    },
+    {
+      "$ref": "#/$defs/failed"
+    }
   ],
   "$defs": {
     "emitted": {
       "type": "object",
       "required": ["kind", "seqId", "ts", "event", "payload"],
       "properties": {
-        "kind": { "const": "emitted" },
-        "seqId": { "type": "integer", "minimum": 1 },
-        "ts": { "type": "string", "format": "date-time" },
-        "event": { "type": "string", "minLength": 1 },
-        "payload": { "type": "object" }
+        "kind": {
+          "const": "emitted"
+        },
+        "seqId": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "ts": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "event": {
+          "type": "string",
+          "minLength": 1
+        },
+        "payload": {
+          "type": "object"
+        }
       },
       "additionalProperties": false
     },
@@ -25,11 +44,25 @@
       "type": "object",
       "required": ["kind", "seqId", "ts", "event"],
       "properties": {
-        "kind": { "const": "completed" },
-        "seqId": { "type": "integer", "minimum": 1 },
-        "ts": { "type": "string", "format": "date-time" },
-        "event": { "type": "string", "minLength": 1 },
-        "listener": { "type": "string", "minLength": 1 }
+        "kind": {
+          "const": "completed"
+        },
+        "seqId": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "ts": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "event": {
+          "type": "string",
+          "minLength": 1
+        },
+        "listener": {
+          "type": "string",
+          "minLength": 1
+        }
       },
       "additionalProperties": false
     },
@@ -37,18 +70,39 @@
       "type": "object",
       "required": ["kind", "seqId", "ts", "event", "listener", "error"],
       "properties": {
-        "kind": { "const": "failed" },
-        "seqId": { "type": "integer", "minimum": 1 },
-        "ts": { "type": "string", "format": "date-time" },
-        "event": { "type": "string", "minLength": 1 },
-        "listener": { "type": "string", "minLength": 1 },
+        "kind": {
+          "const": "failed"
+        },
+        "seqId": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "ts": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "event": {
+          "type": "string",
+          "minLength": 1
+        },
+        "listener": {
+          "type": "string",
+          "minLength": 1
+        },
         "error": {
           "type": "object",
           "required": ["name", "message"],
           "properties": {
-            "name": { "type": "string", "minLength": 1 },
-            "message": { "type": "string" },
-            "stack": { "type": "string" }
+            "name": {
+              "type": "string",
+              "minLength": 1
+            },
+            "message": {
+              "type": "string"
+            },
+            "stack": {
+              "type": "string"
+            }
           },
           "additionalProperties": false
         }

package/.agents/schemas/story-deliver-terminal.schema.json

@@ -73,10 +73,10 @@
     },
     "gates": {
       "type": "object",
-      "description": "Outcome of each close gate this invocation was responsible for. A gate the run skipped (--skip-validation, or a phase it never reached) reports \"skipped\" rather than being omitted, so a missing gate is never mistaken for a passing one.",
+      "description": "Outcome of each close gate this invocation was responsible for. A gate the run skipped (--skip-validation, or a phase it never reached) reports \"skipped\" rather than being omitted, so a missing gate is never mistaken for a passing one. \"overridden\" is distinct from both: the gate ran, it FAILED, and an operator authorized delivery anyway via --override-review-block with a recorded reason. Reporting that as \"passed\" would erase the one fact a reader of this envelope most needs, and reporting it as \"skipped\" would claim the gate never ran.",
       "additionalProperties": {
         "type": "string",
-        "enum": ["passed", "failed", "skipped"]
+        "enum": ["passed", "failed", "skipped", "overridden"]
       }
     },
     "tail": {

package/.agents/scripts/README.md

@@ -5,35 +5,13 @@ invoked indirectly by `npm run …`, slash-command workflows
 (`.agents/workflows/*.md`), or Husky / GitHub Actions hooks; you rarely
 need to call them by hand.
 
-This file is **not** an exhaustive index of the ~90 top-level entrypoints.
-It documents the **operator-facing scripts** that operators may want to
-run by hand and that are **not** wired into the standard quality / CI
-surface. For everything else, search `package.json` scripts and
-`.agents/workflows/` first.
-
-## Operator Scripts
-
-These scripts are kept in the distributed product but are intentionally
-not invoked by `npm test`, `npm run verify`, CI, or any Husky hook. They
-are optional operator tools; run them by hand when you need them.
-
-### `validate-docs-freshness.js`
-
-**Purpose.** Per-Epic documentation freshness gate. For each doc in
-`delivery.docsFreshness.paths` + `project.docsContextFiles`, asserts
-that the file was meaningfully updated during this Epic's lifecycle
-(commit message references `#<epicId>` or the file body does).
-
-**When to run.** Optional. Useful as a pre-merge spot check when an
-Epic should have produced documentation updates; the standard
-`/deliver` flow does **not** invoke this gate today.
-
-**Usage.**
-
-```bash
-node .agents/scripts/validate-docs-freshness.js --epic <id> \
-  [--base main] [--docs <comma-separated>] [--json]
-```
+This file is **not** an exhaustive index of the ~90 top-level entrypoints —
+it is the orientation pointer for the directory. Every script documents
+its own flags under `--help`, and each is reachable from a real caller:
+search `package.json` scripts, `.agents/workflows/`, and the Husky /
+GitHub Actions surfaces first. `check-knip-entries.js` derives that
+caller set mechanically, so a CLI no invoker names is dead, not
+operator-only.
 
 ## See Also
 

package/.agents/scripts/apply-quality-bootstrap.js

@@ -11,63 +11,56 @@
  * had no test so it silently drifted when the two helper signatures moved, and
  * it could not be invoked or dry-run independently.
  *
- * This script runs the two Epic #1386 quality-gate installs in order against
- * the consumer repo root:
+ * The script runs one install against the consumer repo root:
+ * `applyQualityBootstrap` — copies the code-quality-guardrails helper,
+ * installs the `.husky/pre-commit` quality:preview line, backfills the
+ * `quality:preview` / `quality:watch` npm scripts, seeds the
+ * `delivery.quality.{codingGuardrails,autoRefresh}` defaults, and prunes a
+ * committed pre-v2 `baselines/epic/` tree.
  *
- *   1. `applyQualityBootstrap` — copies the code-quality-guardrails helper,
- *      installs the `.husky/pre-commit` quality:preview line, backfills the
- *      `quality:preview` / `quality:watch` npm scripts, and seeds the
- *      `delivery.quality.{codingGuardrails,autoRefresh}` defaults.
- *   2. `migrateBaselinesLayout` — relocates per-Epic baseline snapshots into
- *      the `temp/epic/<id>/baselines/` namespace.
+ * Story #5007 retired the second step. `migrateBaselinesLayout` relocated
+ * per-Epic ratchet snapshots into `temp/epic/<id>/baselines/` on the contract
+ * that `/deliver` reaps that namespace on merge — a mechanism the Story-only
+ * v2 model deleted, so the migration moved dead data into a namespace no code
+ * path writes, reads, or reaps. Its one residual hygiene value (getting the
+ * committed `baselines/epic/` tree out of version control) survives as
+ * `pruneLegacyEpicBaselines`, the quality install's fifth step.
  *
- * Both helpers are idempotent by contract — a second run reports `no-change`
- * on every install path — so this wrapper is safe to re-run. It prints the
- * **same JSON result shape** the heredoc did: `{ quality, baselines }` to
- * stdout, so any tooling that parsed the old output keeps working.
+ * The helper is idempotent by contract — a second run reports `no-change` /
+ * `already-present` / `absent` on every install path — so this wrapper is safe
+ * to re-run. It prints `{ quality }` JSON to stdout.
  *
  * The effectful work is a thin pure function (`applyBootstrapAndMigration`)
- * that takes the two helpers and the project root, so the test suite can
- * drive it against a tmp directory without spawning a child process. The CLI
- * wrapper wires the real helpers and `process.cwd()`.
+ * that takes the helper and the project root, so the test suite can drive it
+ * against a tmp directory without spawning a child process. The CLI wrapper
+ * wires the real helper and `process.cwd()`.
  */
 
-import path from 'node:path';
-import { migrateBaselinesLayout } from './lib/bootstrap/baselines-layout-migration.js';
 import { applyQualityBootstrap } from './lib/bootstrap/quality-bootstrap.js';
 import { runAsCli } from './lib/cli-utils.js';
 
 /**
- * Run the quality-bootstrap install and the baselines-layout migration
- * against `projectRoot`, returning the combined `{ quality, baselines }`
- * envelope. Pure relative to its injected helpers: the default helpers touch
- * the filesystem under `projectRoot`, but tests can pass stubs to exercise
- * the composition in isolation.
+ * Run the quality-bootstrap install against `projectRoot`, returning the
+ * `{ quality }` envelope. Pure relative to its injected helper: the default
+ * helper touches the filesystem under `projectRoot`, but tests can pass a stub
+ * to exercise the composition in isolation.
  *
  * @param {object} options
  * @param {string} options.projectRoot Absolute consumer repo root.
  * @param {typeof applyQualityBootstrap} [options.applyQualityBootstrap]
- * @param {typeof migrateBaselinesLayout} [options.migrateBaselinesLayout]
- * @returns {{ quality: object, baselines: object }}
+ * @returns {{ quality: object }}
  */
 export function applyBootstrapAndMigration({
   projectRoot,
   applyQualityBootstrap: applyQuality = applyQualityBootstrap,
-  migrateBaselinesLayout: migrateBaselines = migrateBaselinesLayout,
 }) {
-  const quality = applyQuality({ projectRoot });
-  const baselines = migrateBaselines({
-    baselinesDir: path.join(projectRoot, 'baselines'),
-    repoRoot: projectRoot,
-  });
-  return { quality, baselines };
+  return { quality: applyQuality({ projectRoot }) };
 }
 
 async function main() {
   const projectRoot = process.cwd();
   const result = applyBootstrapAndMigration({ projectRoot });
-  // Mirror the retired heredoc's output: pretty-printed `{ quality, baselines }`
-  // to stdout. Use process.stdout.write (not console.log) per the no-console
+  // Use process.stdout.write (not console.log) per the no-console
   // enforcement boundary.
   process.stdout.write(`${JSON.stringify(result)}\n`);
   return 0;
@@ -79,7 +72,7 @@ runAsCli(import.meta.url, main, {
   usage: {
     invocation: 'node .agents/scripts/apply-quality-bootstrap.js',
     summary:
-      'Install the quality-gate surface into the consumer repo (guardrails helper, pre-commit line, npm scripts, config defaults) and migrate the baselines layout. Idempotent; prints { quality, baselines } JSON to stdout.',
+      'Install the quality-gate surface into the consumer repo (guardrails helper, pre-commit line, npm scripts, config defaults, legacy baselines/epic prune). Idempotent; prints { quality } JSON to stdout.',
     flags: [],
   },
 });

package/.agents/scripts/bootstrap.js

@@ -726,19 +726,25 @@ function githubSubMutationsSucceeded(gh) {
   return true;
 }
 
-/** Phase groups whose mutations actually landed, for the install ledger. */
-function resolveAppliedGroups(approvedGroups, report) {
-  const applied = new Set();
-  for (const group of approvedGroups ?? []) {
-    if (group === PHASE_GROUPS.GITHUB_ADMIN) {
-      const gh = report?.github;
-      if (gh && !gh.error && !gh.skipped && githubSubMutationsSucceeded(gh)) {
-        applied.add(group);
-      }
-      continue;
-    }
-    applied.add(group);
-  }
+/**
+ * Phase groups whose mutations actually landed, for the install ledger.
+ *
+ * Every project-side group runs on every install (Story #3690 replaced the
+ * consent-first phased-approval install with a plain summary+confirm loop),
+ * so the only variable is whether the irreversible GitHub-admin mutations
+ * landed. Story #5007 collapsed the set-threading this used to carry down to
+ * that one boolean.
+ *
+ * @param {object|undefined} report — the live execution report.
+ * @returns {Set<string>}
+ */
+function resolveAppliedGroups(report) {
+  const applied = new Set(Object.values(PHASE_GROUPS));
+  const gh = report?.github;
+  const githubApplied = Boolean(
+    gh && !gh.error && !gh.skipped && githubSubMutationsSucceeded(gh),
+  );
+  if (!githubApplied) applied.delete(PHASE_GROUPS.GITHUB_ADMIN);
   return applied;
 }
 
@@ -1210,23 +1216,22 @@ export async function provisionResources(state, deps = {}) {
 }
 
 /**
- * Step 6a — Project-side bootstrap. With phased approval removed, all
- * project-side phase groups are treated as approved.
+ * Step 6a — Project-side bootstrap. Every project-side phase runs; the
+ * install ledger decides afterwards which phase groups actually landed
+ * ({@link resolveAppliedGroups}).
  */
 export async function executeBootstrap(state) {
   Logger.info(
     `[Bootstrap] Starting project bootstrap at ${state.projectRoot} (owner=${state.answers.owner} repo=${state.answers.repo} base=${state.answers.baseBranch})`,
   );
-  const approvedGroups = new Set(Object.values(PHASE_GROUPS));
   const report = await applyProjectBootstrap({
     projectRoot: state.projectRoot,
     agentRoot: state.agentRoot,
     answers: state.answers,
-    approvedGroups,
     withQuality: state.withQuality === true,
     withIssueForms: state.withIssueForms === true,
   });
-  return { ok: true, payload: { report, approvedGroups } };
+  return { ok: true, payload: { report } };
 }
 
 /**
@@ -1293,22 +1298,19 @@ export async function executeGithubBootstrap(state) {
 
 /** Step 6c — Record the install ledger for a future uninstall. */
 export function recordLedger(state) {
-  const appliedGroups = resolveAppliedGroups(
-    state.approvedGroups,
-    state.report,
-  );
+  const appliedGroups = resolveAppliedGroups(state.report);
   const manifestCtx = {
     answers: state.answers,
     skipGithub: Boolean(state.flags['skip-github']),
     withQuality: state.withQuality === true,
   };
+  // The manifest always carries the unconditional ide-wiring / repo-config
+  // entries and `appliedGroups` always contains those groups, so the filter
+  // never empties. (Story #5007 removed the phased-approval gate that was the
+  // only way to reach an empty set.)
   const entries = buildMutationManifest(manifestCtx).filter((e) =>
     appliedGroups.has(e.phaseGroup),
   );
-  if (entries.length === 0) {
-    state.report.ledger = { written: false, reason: 'no-mutations-applied' };
-    return { ok: true, payload: {} };
-  }
   const record = buildLedgerRecord({
     entries,
     approvedGroups: appliedGroups,

package/.agents/scripts/check-baseline-drift.js

@@ -13,13 +13,23 @@
 // directory through the same scorer that writes the baseline, prints a per-row
 // before/after table for everything that moved beyond the gate's tolerance,
 // and exits non-zero when it finds any — so a consumer can wire it as a
-// scheduled CI job without wrapping it in verdict-parsing glue. Wiring it is
-// deliberately consumer-side work; nothing in this repo schedules it.
+// scheduled CI job without wrapping it in verdict-parsing glue. This repo
+// schedules the maintainability kind in `.github/workflows/baseline-drift.yml`;
+// a consumer materializing `.agents/` still owns its own schedule.
+//
+// `--require-scored` exists because the default skip-is-green contract below
+// is a fail-open trap for exactly that scheduled use. Measured on this repo:
+// `check-baseline-drift.js --gate crap` with no `coverage/coverage-final.json`
+// present prints "✅ No baseline drift detected" and exits 0 — a nightly job
+// wired that way reports green while having measured nothing. The flag turns
+// every skip into exit 2, so a job that asked for a kind and did not get it
+// reds instead.
 //
 // Exit codes:
 //   0 — no drift (or every kind skipped: disabled gate, no baseline, no scorer)
 //   1 — drift detected in at least one kind
-//   2 — the check itself could not run
+//   2 — the check itself could not run (including: a requested kind was
+//       skipped and `--require-scored` was passed)
 
 // Fail-fast if the framework's runtime deps are not installed — must be the
 // first import so the check runs before any third-party-importing sibling
@@ -42,6 +52,10 @@ diff-scoped gates structurally cannot see.
 Options:
   --gate <kind>       Restrict to one kind (repeatable). Default: ${DRIFT_KINDS.join(', ')}.
   --tolerance <n>     Override the per-gate absolute tolerance.
+  --require-scored    Treat a skipped kind (gate disabled, no baseline, no
+                      scorer, nothing scored) as a failure rather than a pass.
+                      Use this in scheduled jobs: without it a kind that could
+                      not be scored at all reports green.
   --json              Emit the machine-readable report instead of the table.
   -h, --help          Show this help.
 
@@ -55,16 +69,21 @@ commit the result with a \`baseline-refresh:\` tagged subject (non-empty body).`
  * cannot silently widen a scheduled job's scope.
  *
  * @param {string[]} argv
- * @returns {{ kinds: string[], tolerance: number|null, json: boolean }}
+ * @returns {{ kinds: string[], tolerance: number|null, json: boolean, requireScored: boolean }}
  */
 export function parseArgs(argv = []) {
   const kinds = [];
   let tolerance = null;
   let json = false;
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === '--gate' && argv[i + 1]) {
-      const kind = argv[i + 1];
+  // Lifted out of the loop rather than added to its else-if chain: the chain
+  // is the file's most complex method already, and a valueless boolean flag
+  // needs no positional handling to be recognised.
+  const requireScored = argv.includes('--require-scored');
+  const rest = argv.filter((a) => a !== '--require-scored');
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === '--gate' && rest[i + 1]) {
+      const kind = rest[i + 1];
       if (!DRIFT_KINDS.includes(kind)) {
         throw new Error(
           `[drift] unknown --gate "${kind}"; expected one of ${DRIFT_KINDS.join(', ')}`,
@@ -72,11 +91,11 @@ export function parseArgs(argv = []) {
       }
       kinds.push(kind);
       i += 1;
-    } else if (arg === '--tolerance' && argv[i + 1]) {
-      const value = Number(argv[i + 1]);
+    } else if (arg === '--tolerance' && rest[i + 1]) {
+      const value = Number(rest[i + 1]);
       if (!Number.isFinite(value)) {
         throw new Error(
-          `[drift] --tolerance must be a number (got ${argv[i + 1]})`,
+          `[drift] --tolerance must be a number (got ${rest[i + 1]})`,
         );
       }
       tolerance = value;
@@ -91,9 +110,44 @@ export function parseArgs(argv = []) {
     kinds: kinds.length > 0 ? kinds : [...DRIFT_KINDS],
     tolerance,
     json,
+    requireScored,
   };
 }
 
+/**
+ * Render the `--require-scored` verdict for a completed run.
+ *
+ * A skip is the detector's honest answer to "I could not score this kind" —
+ * `{ ok: true, skipped: '<reason>' }` — and the default contract maps that to
+ * a pass so an ad-hoc run does not red because coverage happened to be absent.
+ * Under `--require-scored` the same answer is a failure: the caller named the
+ * kinds it wanted measured, and a kind that was not measured is a gap, not a
+ * clean bill of health.
+ *
+ * Returns `null` when the flag is off or nothing was skipped, so the caller
+ * keeps the run's own 0/1 verdict untouched. Both "off" and "nothing skipped"
+ * are answered here rather than at the call site: the caller is the file's
+ * ratcheted entry point, and this is the branch's natural home anyway.
+ *
+ * @param {{ results?: Array<{ kind: string, skipped?: string }> }} run
+ * @param {boolean} requireScored  Whether `--require-scored` was passed.
+ * @returns {string|null} the operator-facing failure note, or null.
+ */
+function requireScoredFailure(run, requireScored) {
+  if (!requireScored) return null;
+  const skipped = (run?.results ?? []).filter((r) => r?.skipped);
+  if (skipped.length === 0) return null;
+  const detail = skipped.map((r) => `${r.kind} (${r.skipped})`).join(', ');
+  return (
+    `[drift] ❌ --require-scored: ${skipped.length} requested kind(s) were ` +
+    `not scored — ${detail}. The verdict above covers only the kinds that ` +
+    'DID score, which is why it can read clean. A scheduled run that cannot ' +
+    'measure a kind is not a clean run; fix the cause (a missing coverage ' +
+    'artifact, a missing baseline, a disabled gate) or drop the kind from ' +
+    'the invocation.'
+  );
+}
+
 /**
  * Run the drift check and render it. Returns the process exit code rather
  * than exiting, so the whole path is unit-testable.
@@ -112,10 +166,16 @@ export async function runCheckBaselineDrift({
     cwd,
     tolerance: args.tolerance,
   });
-  const output = args.json
+  const base = args.json
     ? JSON.stringify({ schemaVersion: '1', ...run }, null, 2)
     : formatDriftReport(run);
-  return { exitCode: run.ok ? 0 : 1, output };
+  // The note is appended rather than substituted: the drift table is still the
+  // useful half of the report for whichever kinds DID score. A note present at
+  // all means a requested kind went unmeasured, which is exit 2 regardless of
+  // what the measured kinds reported.
+  const unscored = requireScoredFailure(run, args.requireScored);
+  if (unscored) return { exitCode: 2, output: `${base}\n${unscored}` };
+  return { exitCode: run.ok ? 0 : 1, output: base };
 }
 
 /**