mandrel 2.59.0 → 2.61.0

package/.agents/scripts/lib/close-validation/projections/maintainability.js

@@ -1,18 +1,7 @@
 // .agents/scripts/lib/close-validation/projections/maintainability.js
 /**
- * maintainability.js — pre-merge MI ceiling projection helper.
- *
- * Extracted from close-validation.js (Story #1850) and refactored to use
- * the shared `validateProjectionInputs` predicate so the guard cascade
- * lives in exactly one place. Public contract is unchanged — the parent
- * `close-validation.js` re-exports this function and every existing call
- * site continues to import from there.
- *
- * The projection is advisory only: story-close logs it before the merge
- * runs so the operator sees, by name, the files that would breach their
- * per-file MI baseline post-merge and can ship a `baseline-refresh:`
- * commit atomically with the Story PR. The hard MI gate still runs at
- * pre-push time.
+ * Advisory pre-merge MI projection: names files that would breach their
+ * per-file baseline so a `baseline-refresh:` commit can ship with the PR.
  */
 
 import { getBaseline } from '../../baselines/maintainability-baseline-io.js';
@@ -22,16 +11,11 @@ import { gitSpawn as defaultGitSpawn } from '../../git-utils.js';
 import { calculateForSource } from '../../maintainability-engine.js';
 import { MISSING_ARG_REASONS, validateProjectionInputs } from './inputs.js';
 
-/**
- * Default tolerance shared with check-maintainability.js: small floating-
- * point variances must not register as a regression.
- */
+/** Absorbs floating-point noise. */
 export const DEFAULT_MI_TOLERANCE = 0.001;
 
 /**
- * Map the predicate's fine-grained `missing-*` reason to the historical
- * `missing-args` skipped-reason so the public contract of
- * `projectMaintainabilityRegressions` is preserved byte-for-byte.
+ * Collapse `missing-*` to the public `missing-args` reason.
  *
  * @param {string} reason
  * @returns {string}
@@ -41,10 +25,8 @@ function normaliseSkipReason(reason) {
 }
 
 /**
- * Refresh `origin/<baseBranch>` so the diff range resolves even when the
- * close script hasn't reached its own pull/rebase step yet. Routed through
- * the shared `(cwd, ref, windowMs)` cache so a story-init fetch in the same
- * wave satisfies the projection without re-hitting origin.
+ * Close may not have base-synced yet; the fetch cache makes this free when
+ * story-init already fetched.
  *
  * @param {string} cwd
  * @param {string} baseBranch
@@ -65,10 +47,6 @@ function refreshEpicRef(cwd, baseBranch, git) {
 }
 
 /**
- * Run `git diff --name-only` against the epic-branch fork point and parse
- * the changed-files list. Normalises Windows-style backslash paths to
- * forward slashes so the baseline lookup is platform-agnostic.
- *
  * @param {{ cwd: string, baseBranch: string, storyBranch: string, git: { gitSpawn: typeof defaultGitSpawn } }} opts
  * @returns {{ ok: true, files: string[] } | { ok: false, detail: string }}
  */
@@ -86,10 +64,7 @@ function diffChangedFiles({ cwd, baseBranch, storyBranch, git }) {
 }
 
 /**
- * Score a single changed file and return a regression record when the
- * projected MI breaches `baselineScore - tolerance`. Returns `null` when
- * the file is non-JS, absent from baseline, deleted on the story branch,
- * or within tolerance.
+ * `null` when deleted on the story branch or within tolerance.
  *
  * @param {{
  *   cwd: string,
@@ -124,8 +99,6 @@ function scoreFile({
 }
 
 /**
- * Walk the changed-files list and collect regression records.
- *
  * @param {{
  *   cwd: string,
  *   storyBranch: string,
@@ -166,27 +139,9 @@ function collectRegressions({
 }
 
 /**
- * Project the post-merge maintainability scores for every file changed on
- * the Story branch relative to the Epic branch, and return the subset whose
- * projected score breaches the per-file baseline ceiling.
- *
- * Advisory only — the result is rendered as a log line by story-close
- * before the merge runs. The hard MI gate still runs at pre-push time via
- * the husky hook. The point of this projection is to surface the breach
- * **before** the merge so the operator can ship a `baseline-refresh:`
- * commit atomically with the Story PR rather than as a follow-on after the
- * push.
- *
- * The "post-merge body" of each file is approximated by the file content
- * at the tip of the Story branch — a `--no-ff` merge into the Epic branch
- * does not modify file contents, so this is exact when the merge applies
- * cleanly and a close-enough projection when it auto-resolves minor
- * conflicts.
- *
- * The helper never throws and never has side effects beyond running `git`
- * subcommands via the injected interface. Any failure path resolves to
- * `{ ok: true, regressions: [], skipped: '<reason>' }` so the caller
- * treats the advisory as best-effort.
+ * Scores each changed file's content at the Story branch tip (exact for a
+ * clean merge). Never throws; failures resolve to
+ * `{ ok: true, regressions: [], skipped }`.
  *
  * @param {{
  *   cwd: string,
@@ -261,9 +216,7 @@ export function projectMaintainabilityRegressions({
 }
 
 /**
- * Render the pre-merge MI advisory as a human-readable multi-line log
- * block. Returns `null` when there are no regressions to surface so
- * callers can `if` past the log call without a string-empty check.
+ * `null` when there is nothing to surface.
  *
  * @param {ReturnType<typeof projectMaintainabilityRegressions>} result
  * @returns {string | null}

package/.agents/scripts/lib/close-validation/runner.js

@@ -1,13 +1,10 @@
 /**
- * close-validation/runner.js — The `runCloseValidation` orchestrator.
- *
- * Runs typecheck, lint, test, format check, and maintainability/coverage/
- * CRAP regression checks before the story merge so drift is caught in the
- * worktree rather than at pre-push time on the Epic branch. All gates
- * inherit stdio so the operator sees the raw output; the returned summary
- * surfaces actionable hints on failure.
+ * Runs the close gates (typecheck, lint, test, format, baselines) in the
+ * Story worktree before merge; the summary carries failure hints.
  */
 
+import { getQuality } from '../config/quality.js';
+import { FULL_SUITE_LOCK_EXPIRY_ENV } from '../full-suite-lock.js';
 import { gitSpawn } from '../git-utils.js';
 import {
   recordPass as defaultRecordPass,
@@ -27,10 +24,7 @@ import { defaultGetHeadSha } from './projections/head-sha.js';
 /** @typedef {import('./gates.js').Gate} Gate */
 
 function applyChangedFileScope({ gate, spawnCwd, log }) {
-  // Story #5278 — a skip the gate list already decided (the coverage-capture
-  // gate whose incremental skip is known to fire). Honoured before anything
-  // else so the gate is recorded as `skipped` with its real reason rather
-  // than spawned to discover the same thing minutes later.
+  // A skip decided when the gate list was built wins over everything.
   if (gate.skip) {
     log(`[close-validation] ⏭ ${gate.name} skipped (${gate.skip.reason})`);
     return {
@@ -48,11 +42,7 @@ function applyChangedFileScope({ gate, spawnCwd, log }) {
     cwd: spawnCwd,
     baseRef: gate.changedFileScope.baseRef,
   });
-  // Filter to the formatter-eligible subset before deciding to skip. A
-  // non-empty diff that contains zero formatter-eligible files (e.g. a
-  // docs-only Story) must take the skip path, not invoke biome with only
-  // ineligible paths — biome reports "No files were processed" and exits 1
-  // in that case (Story #3410).
+  // Biome exits 1 ("No files were processed") on only-ineligible paths.
   const eligibleFiles = changedFiles.filter(isFormatterEligible);
   if (eligibleFiles.length === 0) {
     log(
@@ -67,12 +57,8 @@ function applyChangedFileScope({ gate, spawnCwd, log }) {
   log(
     `[close-validation] ↳ ${gate.name} scoped to ${eligibleFiles.length} formatter-eligible changed file(s) from ${gate.changedFileScope.baseRef}...HEAD`,
   );
-  // The extension filter cannot see biome's own config-ignore axis
-  // (`files.includes` allowlist / `files.ignore` / `overrides`). When every
-  // eligible-by-extension path is also config-ignored, the scoped biome
-  // invocation exits 1 with "No files were processed" — a false negative for
-  // the gate (Story #4292). Flag the scoped run so the runner downgrades that
-  // specific exit to a clean skip instead of a formatting failure.
+  // The extension filter cannot see biome's config ignores; if every path is
+  // config-ignored biome exits 1 "No files were processed" — downgrade that.
   return {
     gate,
     cmd: gate.cmd,
@@ -83,38 +69,12 @@ function applyChangedFileScope({ gate, spawnCwd, log }) {
 }
 
 /**
- * Run every gate sequentially. Stops collecting after the first failure but
- * still returns a summary so the caller decides how to surface the result.
- *
- * Worktree locality (Story #1120): when `worktreePath` is supplied, every
- * gate runner is spawned with `cwd: worktreePath` so the gate sees the
- * Story branch's post-rebase tree. Evidence reads/writes still key against
- * `cwd` (the main checkout) because the temp tree lives under the main
- * `.git/`. Failure messages name the worktree path.
- *
- * Evidence-aware: when `storyId` is provided alongside `standalone: true`,
- * and `useEvidence !== false`, each gate consults
- * `validation-evidence.shouldSkip()` against current HEAD + the gate's
- * command-config hash. A matching record skips the gate; a successful run
- * is recorded so the next caller in the local hot path can skip in turn.
- *
- * Standalone keyspace (Story #4250): `standalone: true` routes the evidence
- * file to the storyId-anchored
- * `<tempRoot>/standalone/stories/story-<id>/validation-evidence.json`
- * keyspace. v2.0.0 removed the Epic tier and its Epic-keyed keyspace.
- *
- * `onGateStart` is invoked immediately before each gate's runner spawn, so a
- * caller can record per-gate wall-clock telemetry. Errors thrown from the
- * hook propagate.
- *
- * Projection advisories (Story #4776): when `baseBranch` and `storyBranch`
- * are both supplied and every gate passed, the maintainability and CRAP
- * pre-merge projections run through `projections/advisories.js` and log
- * their advisories to the same `log` sink the gates use. They are advisory
- * by construction — the returned `ok` is decided entirely by the gates, so
- * a projected breach never fails a close. They are skipped after a gate
- * failure, where the operator needs the failing gate's evidence, not a
- * baseline-refresh nudge.
+ * Independent gates run in parallel (first failure aborts the rest), then
+ * serial gates in order, stopping at the first failure. Gates spawn in
+ * `worktreePath`; evidence is keyed to `cwd` (main checkout). With
+ * `storyId` + `standalone`, a matching evidence record skips a gate and a
+ * pass is recorded. Projection advisories run only after every gate passes
+ * and never affect `ok`. `onGateStart` errors propagate.
  *
  * @param {{
  *   cwd: string,
@@ -135,7 +95,9 @@ function applyChangedFileScope({ gate, spawnCwd, log }) {
  *   getTreeFingerprint?: (cwd: string) => string|null,
  *   recordPass?: typeof defaultRecordPass,
  *   shouldSkip?: typeof defaultShouldSkip,
- * }} opts
+ *   deferOnLockExpiry?: boolean,
+ * }} opts `deferOnLockExpiry`: an expired full-suite lock wait spawns
+ *   nothing (here or in any gate child) and reports `LOCK_WAIT_EXPIRED_EXIT_CODE`.
  * @returns {{ ok: boolean, failed: Array<{ gate: Gate, status: number, cwd: string }>, skipped: Array<{ gate: Gate, reason: string }> }}
  */
 export async function runCloseValidation({
@@ -158,32 +120,20 @@ export async function runCloseValidation({
     defaultTreeFingerprint(resolvedCwd, gitSpawn),
   recordPass = defaultRecordPass,
   shouldSkip = defaultShouldSkip,
+  deferOnLockExpiry = false,
 } = {}) {
   const failed = [];
+  const lockOpts = fullSuiteLockOptions({ config, deferOnLockExpiry });
   const skipped = [];
-  // Evidence is active when a Story id is present AND there is a keyspace to
-  // anchor on (`standalone: true` — Story #4250's storyId-anchored
-  // keyspace, now the only one).
   const evidenceActive = useEvidence && storyId != null && standalone;
   const evidenceStoreOpts = { cwd, standalone };
-  // Evidence keys against the main checkout's HEAD because the evidence
-  // file lives under the main `.git/`. Gate spawn, in contrast,
-  // runs in the worktree when one is supplied — that's the whole point of
-  // Story #1120.
   const spawnCwd = worktreePath ?? cwd;
   const headSha = evidenceActive ? getHeadSha(spawnCwd) : null;
-  // Story #5278 — one tree fingerprint for the whole run, not one per gate.
-  // Every gate here reads the same working tree, so an identical tree means
-  // identical inputs for all of them; a per-gate scope would be narrower but
-  // would have to model each gate's read set, and being wrong about that
-  // grants a skip the gate did not earn. A gate that carries its own
+  // One whole-tree fingerprint for every gate: a per-gate read set that is
+  // modelled wrong would grant a skip the gate did not earn. A gate's own
   // `inputFingerprint` still wins.
   const treeSha = evidenceActive ? getTreeFingerprint(spawnCwd) : null;
 
-  // Helper closures so the parallel and serial passes share evidence
-  // bookkeeping bit-for-bit.
-
-  /** Returns a `{ skip: true }` verdict when evidence makes the gate redundant. */
   const evidenceVerdict = (gate, configHash) => {
     if (!(evidenceActive && headSha)) return { skip: false };
     const verdict = shouldSkip(
@@ -230,13 +180,7 @@ export async function runCloseValidation({
   };
 
   /**
-   * Run a single gate. When `gate.run` is a function the gate executes
-   * **in process** (Story #1973 / Task #1984 — per-kind baseline gates
-   * removed their `child_process.spawn(node check-<kind>.js)` arm and
-   * call `compare(head, base)` directly). The `run` callable receives
-   * the same `(cmd, args, opts)` argv shape as `runner` so it slots into
-   * the existing contract without churn at the runner boundary.
-   * Otherwise the supplied `runner` is used (default: spawn).
+   * A `gate.run` function executes in process with the `runner` signature.
    *
    * @returns {Promise<{ status: number }>}
    */
@@ -251,13 +195,9 @@ export async function runCloseValidation({
       gateName: gate.name,
       log,
       signal,
-      ...(gate.env ? { env: gate.env } : {}),
-      // Story #5278 — only the full-suite gate can end up *waiting* on the
-      // host lock, and only it is expensive enough for the wait to change the
-      // answer: whoever we queued behind may have deposited this gate's
-      // evidence while we sat there. Re-asking the same question the runner
-      // asked before the wait is the whole mechanism; a `{ status: 0 }`
-      // stands in for the spawn.
+      ...lockOpts.forGate(gate),
+      // Whoever held the full-suite lock may have deposited this gate's
+      // evidence meanwhile; re-check after the wait instead of spawning.
       ...(gate.fullSuiteLock && configHash
         ? {
             skipIfSatisfied: () =>
@@ -266,10 +206,7 @@ export async function runCloseValidation({
                 : undefined,
           }
         : {}),
-      // Story #5173 — forwarded unconditionally (never a conditional spread
-      // like the two below): `defaultGateRunner` already treats a falsy value
-      // as "no lock", so a branch here would only add a decision point to the
-      // hottest function in this file.
+      // Unconditional: the runner treats falsy as "no lock".
       fullSuiteLock: gate.fullSuiteLock,
       ...(gate.tolerateNoFilesProcessed
         ? { tolerateNoFilesProcessed: true }
@@ -280,11 +217,8 @@ export async function runCloseValidation({
 
   const { independent, serial } = partitionGates(gates);
 
-  // ── Phase 1: independent gates in parallel ──────────────────────────
-  // First non-zero exit pins `firstFailure` and aborts every in-flight
-  // sibling via SIGTERM. Other gates' results are still awaited (so we
-  // never leak children) but their non-zero status is intentionally
-  // dropped: only one error surfaces.
+  // Phase 1. The first failure aborts siblings; they are still awaited (no
+  // leaked children) but only one error surfaces.
   const ac = new AbortController();
   let firstIndepFailure = null;
 
@@ -363,7 +297,6 @@ export async function runCloseValidation({
     return { ok: false, failed, skipped };
   }
 
-  // ── Phase 2: serial gates in declared order ─────────────────────────
   await runSerialGates(serial, {
     spawnCwd,
     log,
@@ -376,10 +309,6 @@ export async function runCloseValidation({
     dispatchGate,
   });
 
-  // ── Phase 3: advisory projections ───────────────────────────────────
-  // Story #4776 — the projection layer's live call site. Deliberately
-  // outside the `ok` computation: a projected breach informs, it never
-  // fails a close.
   if (failed.length === 0) {
     await runAdvisoryProjections({
       runProjections,
@@ -395,13 +324,31 @@ export async function runCloseValidation({
 }
 
 /**
- * Phase 2 helper — run the serial gates in declared order, stopping at the
- * first failure. Extracted from `runCloseValidation` (Story #4926); the
- * evidence bookkeeping stays bit-identical to the parallel pass because both
- * call the same injected `evidenceVerdict` / `recordIfActive` closures.
+ * The `fullSuiteLock` gate shares coverage capture's timeout so a hung suite
+ * fails instead of holding the host lock. Under `deferOnLockExpiry` every
+ * gate child inherits the defer opt-in via env.
  *
- * Mutates the caller's `failed` / `skipped` accumulators — the same arrays
- * Phase 1 already wrote into, so the returned verdict stays one list.
+ * @param {{ config: object|null, deferOnLockExpiry: boolean }} args
+ * @returns {{ forGate: (gate: object) => object }}
+ */
+function fullSuiteLockOptions({ config, deferOnLockExpiry }) {
+  const timeoutMs = getQuality(config).coverage?.timeoutMs;
+  const deferEnv = deferOnLockExpiry
+    ? { [FULL_SUITE_LOCK_EXPIRY_ENV]: 'defer' }
+    : null;
+  return {
+    forGate(gate) {
+      const env = deferEnv ? { ...gate.env, ...deferEnv } : gate.env;
+      return {
+        ...(env ? { env } : {}),
+        ...(gate.fullSuiteLock ? { timeoutMs, deferOnLockExpiry } : {}),
+      };
+    },
+  };
+}
+
+/**
+ * Mutates the caller's `failed` / `skipped` accumulators.
  *
  * @param {Array<object>} serial
  * @param {object} deps
@@ -484,11 +431,7 @@ async function runSerialGates(
 }
 
 /**
- * Phase 3 helper — run the advisory projections, absorbing every failure.
- *
- * No-ops without a branch pair to diff (resume / legacy callers), and can
- * never influence the close verdict: the caller has already decided `ok`
- * before this runs, and a throw here is logged, not propagated.
+ * No-op without a branch pair; a throw is logged, never propagated.
  *
  * @param {{
  *   runProjections: typeof defaultRunProjections,

package/.agents/scripts/lib/command-header.js

@@ -1,24 +1,8 @@
-// .agents/scripts/lib/command-header.js
-/**
- * Pure helper for projecting workflow `.md` files into slash commands:
- * injects the AUTO-GENERATED provenance header without disturbing YAML
- * frontmatter placement.
- *
- * Kept as its own module (rather than inline in `sync-claude-commands.js`,
- * which runs its sync at import time via top-level await) so it can be unit
- * tested directly.
- */
+/** Helpers for projecting workflow `.md` files into slash commands. */
 
 /**
- * Inject `header` into a workflow's `content`. When the source begins with a
- * YAML frontmatter block, the header is inserted **after** the closing `---`
- * so the frontmatter stays on line 1; sources without frontmatter keep the
- * header prepended verbatim.
- *
- * Claude Code only parses a command's frontmatter (its `description`) when the
- * `---` block is the very first thing in the file. Prepending the HTML comment
- * above it made `claude plugin validate` report "No frontmatter block found"
- * for every command and silently dropped all descriptions.
+ * Insert `header` after any YAML frontmatter: Claude Code only parses
+ * frontmatter that starts on line 1.
  *
  * @param {string} content - Raw workflow `.md` content.
  * @param {string} header - Provenance header to inject (typically ends `\n\n`).
@@ -33,15 +17,9 @@ export function applyHeader(content, header) {
 }
 
 /**
- * True when a workflow opts out of slash-command projection via a
- * `command: false` key in its YAML frontmatter (#4482). Used for dual-use
- * lens files (e.g. `audit-security.md`) that stay in
- * the payload as `/mandrel-deliver` audit-suite prompts but must NOT surface as
- * standalone slash commands because the host ships a native equivalent.
- *
- * Both `sync-claude-commands.js` (projection + orphan-reap) and the
- * `commands-in-sync` doctor check (parity expectation) consult this flag so
- * an excluded workflow never reads as "not synced".
+ * `command: false` in frontmatter opts a workflow out of slash-command
+ * projection (e.g. a lens the host ships natively). The sync and the doctor
+ * parity check both honour it.
  *
  * @param {string} content - Raw workflow `.md` content.
  * @returns {boolean}

package/.agents/scripts/lib/config/acceptance-eval.js

@@ -1,39 +1,17 @@
 /**
- * Acceptance self-eval accessor (Story #3819, Story #5313).
- *
- * Resolves `.agentrc.json → delivery.acceptanceEval` into the canonical
- * shape the per-Story acceptance self-eval loop consumes. The loop scores
- * the caller-injected change set against each inline `acceptance[]` item,
- * redrafts the unmet items, and re-evaluates — capped at `maxRounds`
- * redraft rounds, then escalates to `agent::blocked` when criteria remain
- * unmet.
- *
- * Story #5313 dropped the hard ceiling (`ACCEPTANCE_EVAL_MAX_ROUNDS_CEILING`)
- * and the floor-of-one clamp: `maxRounds` is any non-negative integer, and
- * `0` means the verdict is scored **once** with no redraft round. The
- * scoring pass itself is always on — there is intentionally no `enabled`
- * flag (hard cutover per `rules/git-conventions.md`); only the redraft
- * budget is tunable.
+ * `delivery.acceptanceEval`: redraft rounds before `agent::blocked`. `0`
+ * scores once with no redraft; the scoring pass itself cannot be disabled.
  */
 
 /**
- * Default redraft-round budget applied when `.agentrc.json` omits
- * `delivery.acceptanceEval.maxRounds`. Frozen so downstream callers cannot
- * mutate the resolver's defaults across processes.
- *
- * Keep in lockstep with the schema mirror in
- * `agentrc.schema.json → $defs.acceptanceEval` and the AJV schema in
- * `config-settings-schema-delivery.js → ACCEPTANCE_EVAL_SCHEMA`.
+ * Keep in lockstep with `agentrc.schema.json` and
+ * `config-settings-schema-delivery.js#ACCEPTANCE_EVAL_SCHEMA`.
  */
 export const ACCEPTANCE_EVAL_DEFAULTS = Object.freeze({
   maxRounds: 2,
 });
 
 /**
- * Normalize a candidate round count: a non-negative integer is taken as-is
- * (including `0`); anything else — negative, non-integer, non-finite,
- * missing — falls back to the documented default.
- *
  * @param {unknown} value
  * @param {number} fallback
  * @returns {number}
@@ -45,10 +23,6 @@ function normalizeRounds(value, fallback) {
 }
 
 /**
- * Read the merged acceptance-eval block. Returns the canonical shape:
- *
- *   { maxRounds: number }  // non-negative integer; 0 = scored once
- *
  * @param {object | null | undefined} config
  * @returns {{ maxRounds: number }}
  */

package/.agents/scripts/lib/config/baselines.js

@@ -1,15 +1,9 @@
 /**
- * `delivery.quality.baselines` accessor (Epic #1720 Story #1737 — per-gate
- * baselines). Every gate now carries its own `baselinePath` under
- * `delivery.quality.gates.<tier>.baselinePath`. This module preserves the
- * historical `{ lint, crap, maintainability }` envelope so existing call
- * sites that read `getBaselines(config).lint.path` keep working.
- * `refreshCommand` is no longer carried per-baseline — it stays in the
- * envelope as `null` for shape stability.
+ * Flat `{ crap, maintainability }` view over each gate's `baselinePath`;
+ * `refreshCommand` is always `null`, kept for shape stability.
  */
 
 export const BASELINES_DEFAULTS = Object.freeze({
-  lint: Object.freeze({ path: 'baselines/lint.json', refreshCommand: null }),
   crap: Object.freeze({ path: 'baselines/crap.json', refreshCommand: null }),
   maintainability: Object.freeze({
     path: 'baselines/maintainability.json',
@@ -18,12 +12,8 @@ export const BASELINES_DEFAULTS = Object.freeze({
 });
 
 /**
- * Read the per-gate baseline paths and surface them under the historical
- * flat envelope. Accepts the full resolved config — the canonical
- * `delivery.quality.gates` path is the single supported shape.
- *
  * @param {object | null | undefined} config
- * @returns {{ lint: { path: string, refreshCommand: null }, crap: { path: string, refreshCommand: null }, maintainability: { path: string, refreshCommand: null } }}
+ * @returns {{ crap: { path: string, refreshCommand: null }, maintainability: { path: string, refreshCommand: null } }}
  */
 export function getBaselines(config) {
   const gates = config?.delivery?.quality?.gates ?? {};
@@ -33,7 +23,6 @@ export function getBaselines(config) {
     return { path, refreshCommand: null };
   };
   return {
-    lint: merge('lint'),
     crap: merge('crap'),
     maintainability: merge('maintainability'),
   };

package/.agents/scripts/lib/config/ci.js

@@ -1,27 +1,9 @@
 /**
- * `delivery.ci` accessor + framework defaults — Story #4356 (Epic #4355).
- *
- * Surviving knobs: `watch` tunes the merge/CI watch poll loop; `autoMerge`
- * (default `"trust-ci"`) selects the merge posture — `"trust-ci"` merges once
- * required checks pass, `"strict"` additionally requires a clean review gate.
- *
- * Story #5096 added `blockOnAdvisoryFailure` (default `true`) and
- * `advisoryAllowlist` (default `[]`). GitHub native auto-merge waits on
- * REQUIRED contexts only, so a red ADVISORY gate would otherwise be merged
- * straight past; these knobs own mandrel's side of that decision. Set
- * `blockOnAdvisoryFailure: false` to restore the pre-#5096 behaviour verbatim,
- * or list a job name in `advisoryAllowlist` to exempt just that one.
- *
- * Story #5266 added `rerunAdvisory`, **default `0`**. It is the number of
- * times close may re-run a failed advisory workflow run before blocking on it.
- * Zero is the deliberate default and not a placeholder: a rerun spends the
- * consumer's CI minutes and mutates GitHub state, and close must never do
- * either unasked. Raise it (or pass `--rerun-advisory <n>`) on a repository
- * whose advisory scans time out transiently.
- *
- * Retired (no production readers on v2 Story-only delivery): `earlyPr`
- * (Epic early-PR warmup) and `requireChecks` (AutomergePredicate escape hatch
- * whose listener was never landed).
+ * `delivery.ci`. `autoMerge: 'strict'` also requires a clean review gate.
+ * Native auto-merge waits on required checks only, so
+ * `blockOnAdvisoryFailure` stops a red advisory gate being merged past
+ * (`advisoryAllowlist` exempts named jobs). `rerunAdvisory` defaults to 0
+ * deliberately: a rerun spends CI minutes and mutates GitHub state.
  */
 
 export const CI_DELIVERY_DEFAULTS = Object.freeze({
@@ -31,29 +13,19 @@ export const CI_DELIVERY_DEFAULTS = Object.freeze({
   rerunAdvisory: 0,
 });
 
-/**
- * Per-knob validators for the scalar `delivery.ci` settings. A value that
- * fails its own test is not an instruction to guess — it degrades to the
- * framework default beside it in {@link CI_DELIVERY_DEFAULTS}, which is why
- * the two objects are keyed alike and read as a pair.
- */
+/** An invalid value degrades to the same-keyed default. */
 const CI_KNOB_VALIDATORS = Object.freeze({
   autoMerge: (value) => value === 'trust-ci' || value === 'strict',
   blockOnAdvisoryFailure: (value) => typeof value === 'boolean',
-  // Story #5266 — a negative or non-integer allowance spends nothing.
   rerunAdvisory: (value) => Number.isInteger(value) && value >= 0,
 });
 
 /**
- * Read the merged `delivery.ci` block, applying framework defaults for any
- * field the operator omitted. Accepts the full resolved config, the bare
- * delivery bag, or the bare ci bag. The `watch` sub-block is passed through
- * as-is (undefined when unset) so consumers apply their own poll-loop
- * defaults; only the scalar knobs carry framework defaults here.
+ * Accepts the full config, the `delivery` bag, or the `ci` bag.
  *
  * @param {object | null | undefined} config
  * @returns {{ autoMerge: 'trust-ci' | 'strict', blockOnAdvisoryFailure: boolean,
- *   advisoryAllowlist: string[], rerunAdvisory: number, watch: object | undefined }}
+ *   advisoryAllowlist: string[], rerunAdvisory: number }}
  */
 export function getCiDelivery(config) {
   const ci = config?.delivery?.ci ?? config?.ci ?? config ?? {};
@@ -68,7 +40,5 @@ export function getCiDelivery(config) {
           (entry) => typeof entry === 'string' && entry,
         )
       : [...CI_DELIVERY_DEFAULTS.advisoryAllowlist],
-    watch:
-      ci.watch && typeof ci.watch === 'object' ? { ...ci.watch } : undefined,
   };
 }

package/.agents/scripts/lib/config/commands.js

@@ -1,10 +1,3 @@
-/**
- * `project.commands` accessor (Epic #1720 Story #1739 — top-level reshape).
- *
- * The command keys are `test`, `typecheck`, `lint`, `formatCheck`,
- * `formatWrite`.
- */
-
 export const COMMANDS_DEFAULTS = Object.freeze({
   test: 'npm test',
   typecheck: null,
@@ -14,19 +7,12 @@ export const COMMANDS_DEFAULTS = Object.freeze({
 });
 
 /**
- * Read the grouped `project.commands` block, applying framework defaults
- * for any field the operator omitted. Accepts the full resolved config or
- * a bare `{ project }` bag.
- *
  * @param {object | null | undefined} config
  * @returns {{ test: string, typecheck: string|null, lint: string|null, formatCheck: string, formatWrite: string }}
  */
 export function getCommands(config) {
   const commands = config?.project?.commands ?? {};
-  // `??` is uniform across every key: the two nullable ones (`typecheck`,
-  // `lint`) default to `null` themselves, so coalescing an explicit `null`
-  // onto the default returns that same `null` — the per-key `=== undefined`
-  // ladder this replaces drew a distinction that had no observable effect.
+  // `??` is safe for the nullable keys: their default is `null` too.
   return Object.fromEntries(
     Object.keys(COMMANDS_DEFAULTS).map((key) => [
       key,