mandrel 2.122.0 → 2.123.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -183,7 +183,7 @@ Everything `/mandrel-deliver` and `single-story-close` consume: worktree isolati
183
183
  | `quality.gates.coverage.captureScope` | No | `"full"` \| `"affected"` | `"full"` | What coverage-capture runs. `full` (default) runs `captureScript`. `affected` runs the consumer-owned `test:coverage:affected` script with the base ref in `MANDREL_COVERAGE_BASE_REF`, merges its rows over the prior artifact and stamps it `affected`; baseline rows the scoped run did not measure are treated as unmeasured, never removed. Falls back to `full` with a warning when the script is absent. Meant for consumers whose CI already enforces coverage on the full suite. |
184
184
  | `quality.gates.coverage.timeoutMs` | No | `integer` | `600000` | Kill bound (ms) for one full-suite run — the coverage capture, the close-validation full-suite gate and the full-suite lock-wait budget all read it. The clock starts at spawn, never while queued on the host lock; a suite that signals `MANDREL_SUITE_READY_FILE` gets a fresh bound for its test phase, so worst-case wall is lock wait + 2 × timeoutMs. On expiry the run exits 124 so callers can tell a hang from a failure. |
185
185
  | `quality.gates.coverage.onOverBudget` | No | `"block"` \| `"defer-to-ci"` | `"block"` | What handoff and close do when the capture script — or the `test` command (`project.commands.test`, or `testChanged` on the skip branch and the delta re-credit) — exits 76: the consumer-declared signal that the selected slice is over this host's budget and no test ran. `block` (default) stops the handoff (`blocked`) and fails close, naming this key. `defer-to-ci` settles the coverage gate as deferred to CI: no artifact is written or stamped and no credit is recorded, the coverage-reading gates (CRAP preview, coverage and CRAP baselines) are skipped, and handoff and close proceed — the terminal envelope and the PR body say coverage was deferred. Set it only when the consumer's CI runs the deferred suite with a coverage floor. A timeout (124) is never deferred, under either value. |
186
- | `quality.gates.coverage.suiteOfRecord` | No | `"local"` \| `"ci"` | `"local"` | Where the coverage capture runs. `local` (default) changes nothing. `ci` — meant for a small host's `.agentrc.local.json` — makes CI the coverage and CRAP ratchet of record: handoff and close settle the coverage gate as deferred (reason `suite-of-record-ci`) without spawning the capture, the PR body carries the `Coverage-deferred:` key line, and confirm-merge waits for `ciRatchetCheck` to go green. When `project.commands.testChanged` is set, the handoff first runs it as a changed-tests guard. Requires `ciRatchetCheck`; without it handoff blocks and close fails. |
186
+ | `quality.gates.coverage.suiteOfRecord` | No | `"local"` \| `"ci"` | `"local"` | Where the coverage capture runs. `local` (default) changes nothing. `ci` — meant for a small host's `.agentrc.local.json` — makes CI the coverage and CRAP ratchet of record: handoff and close settle the suite gate (the capture, or `test` when it is the depositor) as deferred (reason `suite-of-record-ci`) without spawning it, the PR body carries the `Coverage-deferred:` key line, and confirm-merge waits for `ciRatchetCheck` to go green. When `project.commands.testChanged` is set, the handoff first runs it as a changed-tests guard. Requires `ciRatchetCheck`; without it handoff blocks and close fails. |
187
187
  | `quality.gates.coverage.ciRatchetCheck` | No | `string` \| `null` | `null` | Name of the consumer's CI check (check-run or status context) that runs `coverage-ratchet.js` on a deferred PR. Required by `suiteOfRecord: ci`; when set, confirm-merge holds `agent::done` on a PR carrying the `Coverage-deferred:` key line until this check is green on the PR head. Default `null`. |
188
188
  | `quality.gates.coverage.nonInputGlobs` | No | `array<string>` | `[]` | Repo-relative picomatch globs naming paths no test reads. A matching path is dropped from both sides of the coverage delta-refresh overlap check and from the re-measured set — a delta of only matching, baseline and coverage-directory paths restamps without a run — and from the overlap check of close's `test` delta re-credit (its incoming count and emptiness test are unchanged). It never changes the suite-input filter, the tree digest or stamp freshness. Default `[]`: nothing is built in, so Markdown counts as an input unless declared here. |
189
189
  | `quality.gates.coverage.captureHandlesConfigChanges` | No | `boolean` | `false` | Declares that the affected capture script, given `MANDREL_COVERAGE_BASE_REF`, widens its own selection when a coverage-determining config file (`package.json`, a lockfile, `tsconfig*.json`, a test-runner config) changes. When `true`, such a file in the coverage delta no longer refuses the delta refresh. Close's `test` delta re-credit refuses on a config file under either value. Default `false`. |
@@ -668,9 +668,11 @@ place.
668
668
  deferred, reason `over-budget`.
669
669
  - **`suiteOfRecord: "ci"`.** Set it in a small host's `.agentrc.local.json`.
670
670
  The handoff and close defer the capture before anything spawns, reason
671
- `suite-of-record-ci`: no full-suite lock is taken and `coverage-capture.js`
672
- never runs. It applies only when `coverage-capture` is the credited
673
- depositor; under the `test` depositor it changes nothing. It needs
671
+ `suite-of-record-ci`: no full-suite lock is taken and neither
672
+ `coverage-capture.js` nor `project.commands.test` runs. It applies to
673
+ either credited depositor: a Story with no changed file under
674
+ `crap.targetDirs`, or a host with no active capture, defers its `test`
675
+ run the same way, and close writes the same PR marker. It needs
674
676
  `ciRatchetCheck`. Without one the handoff settles `blocked`
675
677
  (`ci-ratchet-undeclared`) and close fails, both naming the two keys.
676
678
  - **The changed-tests guard.** Under `suiteOfRecord: "ci"`, when
@@ -758,7 +758,7 @@
758
758
  "suiteOfRecord": {
759
759
  "type": "string",
760
760
  "enum": ["local", "ci"],
761
- "description": "Where the coverage capture runs. `local` (default) changes nothing. `ci` — meant for a small host's `.agentrc.local.json` — makes CI the coverage and CRAP ratchet of record: handoff and close settle the coverage gate as deferred (reason `suite-of-record-ci`) without spawning the capture, the PR body carries the `Coverage-deferred:` key line, and confirm-merge waits for `ciRatchetCheck` to go green. When `project.commands.testChanged` is set, the handoff first runs it as a changed-tests guard. Requires `ciRatchetCheck`; without it handoff blocks and close fails.",
761
+ "description": "Where the coverage capture runs. `local` (default) changes nothing. `ci` — meant for a small host's `.agentrc.local.json` — makes CI the coverage and CRAP ratchet of record: handoff and close settle the suite gate (the capture, or `test` when it is the depositor) as deferred (reason `suite-of-record-ci`) without spawning it, the PR body carries the `Coverage-deferred:` key line, and confirm-merge waits for `ciRatchetCheck` to go green. When `project.commands.testChanged` is set, the handoff first runs it as a changed-tests guard. Requires `ciRatchetCheck`; without it handoff blocks and close fails.",
762
762
  "default": "local"
763
763
  },
764
764
  "ciRatchetCheck": {
@@ -136,6 +136,11 @@ function suiteOfRecordFlag(config) {
136
136
  return ci ? { suiteOfRecordCi: { ciRatchetCheck } } : {};
137
137
  }
138
138
 
139
+ /** A skip branch close scopes locally: under `suiteOfRecord: "ci"` CI owns it. */
140
+ function scopesSkipBranch(skipBranch, config) {
141
+ return skipBranch && !suiteOfRecord(config).ci;
142
+ }
143
+
139
144
  /** Shown when `suiteOfRecord: "ci"` has no ratchet check to hand the ratchet to. */
140
145
  export const CI_RATCHET_UNDECLARED_HINT =
141
146
  '`delivery.quality.gates.coverage.suiteOfRecord: "ci"` defers the coverage capture to CI, but `delivery.quality.gates.coverage.ciRatchetCheck` is unset, so nothing would ratchet coverage or CRAP. Name the CI check that runs `coverage-ratchet.js`, or set `suiteOfRecord` back to `"local"`.';
@@ -171,7 +176,9 @@ function isCoverageCaptureActive(config, scripts) {
171
176
  * close must keep exactly one working test gate. Its argv is
172
177
  * `project.commands.test` (default `npm test`); after a base move close's
173
178
  * phase may swap it for the delta re-credit (`test-delta.js`), which runs
174
- * `testChanged` keyed on `MANDREL_CHANGED_SINCE`.
179
+ * `testChanged` keyed on `MANDREL_CHANGED_SINCE`. Under
180
+ * `suiteOfRecord: "ci"` it carries the posture, so the runner defers it to
181
+ * CI before spawning, as it does the capture.
175
182
  *
176
183
  * @param {boolean} coverageCaptureRunsSuite
177
184
  * @param {object|undefined|null} config - Canonical resolved config.
@@ -181,7 +188,13 @@ function buildTestGateEntry(coverageCaptureRunsSuite, config, scope) {
181
188
  if (coverageCaptureRunsSuite) return [];
182
189
  // `fullSuiteLock` serializes this suite behind the host lock; when
183
190
  // coverage-capture runs instead, `runCapture` takes the lock itself.
184
- return [{ ...closeTestGate(config, scope), ...overBudgetFlag(config) }];
191
+ return [
192
+ {
193
+ ...closeTestGate(config, scope),
194
+ ...overBudgetFlag(config),
195
+ ...suiteOfRecordFlag(config),
196
+ },
197
+ ];
185
198
  }
186
199
 
187
200
  const CHECK_BASELINES_HINT =
@@ -605,7 +618,7 @@ export function buildDefaultGates({
605
618
  resolveBaseRefImpl,
606
619
  }).skipBranch;
607
620
  const testScope = closeTestScope({
608
- skipBranch: captureSkipPredicted,
621
+ skipBranch: scopesSkipBranch(captureSkipPredicted, config),
609
622
  config,
610
623
  cwd,
611
624
  baseBranch,
@@ -90,9 +90,14 @@ function keptRun(gate) {
90
90
  return gate?.evidenceNote ? 'the skip-branch scoped run' : 'the full suite';
91
91
  }
92
92
 
93
- /** The replaced gate's over-budget flag, carried onto the delta. */
94
- function overBudgetOf({ deferOnOverBudget }) {
95
- return deferOnOverBudget ? { deferOnOverBudget } : {};
93
+ /** The replaced gate's flags the delta keeps: over-budget, and CI ownership. */
94
+ const CARRIED_FLAGS = ['deferOnOverBudget', 'suiteOfRecordCi'];
95
+
96
+ /** The replaced gate's carried flags that are set. */
97
+ function carriedFlags(gate) {
98
+ return Object.fromEntries(
99
+ CARRIED_FLAGS.filter((key) => gate[key]).map((key) => [key, gate[key]]),
100
+ );
96
101
  }
97
102
 
98
103
  /**
@@ -150,6 +155,6 @@ export function applyTestDelta(
150
155
  since,
151
156
  incoming: incoming.length,
152
157
  });
153
- const swapped = { ...delta, ...overBudgetOf(gates[index]) };
158
+ const swapped = { ...delta, ...carriedFlags(gates[index]) };
154
159
  return gates.map((g, i) => (i === index ? swapped : g));
155
160
  }
@@ -100,7 +100,7 @@ export const COVERAGE_GATE = {
100
100
  type: 'string',
101
101
  enum: ['local', 'ci'],
102
102
  description:
103
- "Where the coverage capture runs. `local` (default) changes nothing. `ci` — meant for a small host's `.agentrc.local.json` — makes CI the coverage and CRAP ratchet of record: handoff and close settle the coverage gate as deferred (reason `suite-of-record-ci`) without spawning the capture, the PR body carries the `Coverage-deferred:` key line, and confirm-merge waits for `ciRatchetCheck` to go green. When `project.commands.testChanged` is set, the handoff first runs it as a changed-tests guard. Requires `ciRatchetCheck`; without it handoff blocks and close fails.",
103
+ "Where the coverage capture runs. `local` (default) changes nothing. `ci` — meant for a small host's `.agentrc.local.json` — makes CI the coverage and CRAP ratchet of record: handoff and close settle the suite gate (the capture, or `test` when it is the depositor) as deferred (reason `suite-of-record-ci`) without spawning it, the PR body carries the `Coverage-deferred:` key line, and confirm-merge waits for `ciRatchetCheck` to go green. When `project.commands.testChanged` is set, the handoff first runs it as a changed-tests guard. Requires `ciRatchetCheck`; without it handoff blocks and close fails.",
104
104
  default: COVERAGE_GATE_DEFAULTS.suiteOfRecord,
105
105
  },
106
106
  ciRatchetCheck: {
@@ -13,6 +13,7 @@ import {
13
13
  MissingCoverageArtifactError,
14
14
  } from './coverage-capture.js';
15
15
  import { isObject } from './json-utils.js';
16
+ import { isScorableSourceFile } from './source-extensions.js';
16
17
 
17
18
  const COVERAGE_FINAL_PATH = COVERAGE_CAPTURE_DEFAULTS.coveragePath;
18
19
  const COVERAGE_BASELINE_PATH = 'baselines/coverage.json';
@@ -342,9 +343,12 @@ export async function resolveCoverageRefreshScope({
342
343
  if (fullScope) return { fullScope: true };
343
344
  return diffScopeRef ? { baseRef: diffScopeRef } : {};
344
345
  }
346
+ // Only a scorable source can carry a row; a docs-only diff scopes nothing.
345
347
  const diff = fullScope
346
348
  ? null
347
- : await deriveDiffFiles(diffScopeRef ?? 'origin/main');
349
+ : (await deriveDiffFiles(diffScopeRef ?? 'origin/main')).filter(
350
+ isScorableSourceFile,
351
+ );
348
352
  return {
349
353
  scopeFiles: narrowScopeToMeasured(diff, listMeasured(cwd), inCoverageScope),
350
354
  requireRowsForScopeFiles: true,
@@ -1,7 +1,7 @@
1
1
  /**
2
2
  * handoff-suite-of-record.js — the credited-run step under
3
3
  * `coverage.suiteOfRecord: "ci"`, decided from config before any lock or spawn
4
- * but the changed-tests guard.
4
+ * but the changed-tests guard, whichever depositor was resolved.
5
5
  */
6
6
 
7
7
  import { suiteOfRecord } from '../close-validation/gates.js';
@@ -14,6 +14,14 @@ import { changedTestsGuard } from './handoff-changed-tests.js';
14
14
  const UNDECLARED_DETAIL =
15
15
  'delivery.quality.gates.coverage.suiteOfRecord is "ci" but delivery.quality.gates.coverage.ciRatchetCheck is unset — name the CI check that runs coverage-ratchet.js, or set suiteOfRecord to "local"';
16
16
 
17
+ /** Why this depositor holds the credited run, named in the deferred detail. */
18
+ function depositorReason(ctx) {
19
+ if (ctx.depositor === 'coverage-capture') return 'coverage-capture';
20
+ return ctx.skipBranch
21
+ ? 'test (no changed file under crap.targetDirs)'
22
+ : 'test (no active coverage capture)';
23
+ }
24
+
17
25
  /**
18
26
  * The deferred step, once the changed-tests guard did not stop the run.
19
27
  *
@@ -25,25 +33,25 @@ function deferred(ctx, name, ciRatchetCheck, checked) {
25
33
  return {
26
34
  name,
27
35
  outcome: 'deferred',
28
- detail: `coverage deferred to CI (suiteOfRecord: ci, ratchet check "${ciRatchetCheck}") — no capture spawned and no credit was deposited${checked.note}`,
36
+ detail: `coverage deferred to CI (suiteOfRecord: ci, ratchet check "${ciRatchetCheck}", depositor ${depositorReason(ctx)}) — no suite spawned and no credit was deposited${checked.note}`,
29
37
  depositor: ctx.depositor,
30
38
  ...checked.extra,
31
39
  };
32
40
  }
33
41
 
34
42
  /**
35
- * The capture depositor's step under the `ci` posture: deferred to CI, or
36
- * `blocked` when no `ciRatchetCheck` would take the ratchet. `null` when the
37
- * posture is off or the depositor is `test`.
43
+ * The credited-run step under the `ci` posture, for either depositor:
44
+ * deferred to CI, or `blocked` when no `ciRatchetCheck` would take the
45
+ * ratchet. `null` when the posture is off.
38
46
  *
39
- * @param {{ config: object, depositor: string, head: string, state: object }} ctx
47
+ * @param {{ config: object, depositor: string, skipBranch?: boolean, head: string, state: object }} ctx
40
48
  * @param {string} name
41
49
  * @param {{ run: Function, signal: AbortSignal }} guard runs `testChanged`.
42
50
  * @returns {Promise<object|null>}
43
51
  */
44
52
  export async function settleSuiteOfRecord(ctx, name, guard) {
45
53
  const { ci, ciRatchetCheck } = suiteOfRecord(ctx.config);
46
- if (!ci || ctx.depositor !== 'coverage-capture') return null;
54
+ if (!ci) return null;
47
55
  const extra = { depositor: ctx.depositor };
48
56
  if (!ciRatchetCheck) {
49
57
  return {
@@ -187,12 +187,21 @@ function ejectingRunOf(runs) {
187
187
  }
188
188
 
189
189
  /** First rule wins: inherited (capped), own, unknown. */
190
- function classifyEjection({ ejecting, parentRuns, entries }) {
190
+ function classifyEjection({ conclusion, parentRuns, entries }) {
191
191
  const inherited =
192
- ejecting.conclusion === 'cancelled' ||
192
+ conclusion === 'cancelled' ||
193
193
  parentRuns.some((r) => RED_RUN.has(r.conclusion));
194
194
  if (inherited) return entries > MAX_INHERITED_REARMS ? 'own' : 'inherited';
195
- return ejecting.conclusion === 'failure' ? 'own' : 'unknown';
195
+ return conclusion === 'failure' ? 'own' : 'unknown';
196
+ }
197
+
198
+ /** A cancelled run with a job that failed on its own was a fail-fast cancel. */
199
+ async function settledConclusion(get, ejecting) {
200
+ if (ejecting.conclusion !== 'cancelled') {
201
+ return { conclusion: ejecting.conclusion, jobs: null };
202
+ }
203
+ const jobs = await readFailedJobs(get, ejecting.id);
204
+ return { conclusion: jobs?.length ? 'failure' : 'cancelled', jobs };
196
205
  }
197
206
 
198
207
  /**
@@ -239,8 +248,9 @@ export async function readQueueEjection({
239
248
  const parentRuns = (
240
249
  (await get(`${QUEUE_RUNS}&head_sha=${parentSha}`))?.workflow_runs ?? []
241
250
  ).filter((r) => r.head_sha === parentSha);
251
+ const settled = await settledConclusion(get, ejecting);
242
252
  const verdict = classifyEjection({
243
- ejecting,
253
+ conclusion: settled.conclusion,
244
254
  parentRuns,
245
255
  entries: new Set(runs.map((r) => r.head_sha)).size,
246
256
  });
@@ -251,24 +261,40 @@ export async function readQueueEjection({
251
261
  conclusion: ejecting.conclusion,
252
262
  };
253
263
  const failedJobs =
254
- verdict === 'own' ? await readFailedJobs(get, ejecting.id) : [];
264
+ verdict === 'own'
265
+ ? await failedJobsOf(get, ejecting.id, settled.jobs)
266
+ : [];
255
267
  return { verdict, labels, run, failedJobs };
256
268
  } catch (err) {
257
269
  return { verdict: 'unknown', labels, detail: describeGhFailure(err) };
258
270
  }
259
271
  }
260
272
 
261
- /** Failed job names of a run; `[]` when unreadable. */
273
+ const OWN_FAILURE = new Set(['failure', 'timed_out']);
274
+
275
+ /** A run cancel rewrites a running job to `cancelled`; its failed step keeps `failure`. */
276
+ function failedOnItsOwn(job) {
277
+ if (OWN_FAILURE.has(job.conclusion)) return true;
278
+ return (
279
+ job.conclusion === 'cancelled' &&
280
+ (job.steps ?? []).some((s) => s.conclusion === 'failure')
281
+ );
282
+ }
283
+
284
+ /** Failed job names, reusing a read already made; `[]` when unreadable. */
285
+ async function failedJobsOf(get, runId, jobs) {
286
+ return jobs ?? (await readFailedJobs(get, runId)) ?? [];
287
+ }
288
+
289
+ /** Names of a run's jobs that failed on their own; `null` when unreadable. */
262
290
  async function readFailedJobs(get, runId) {
263
291
  try {
264
292
  const body = await get(
265
293
  `repos/{owner}/{repo}/actions/runs/${runId}/jobs?filter=latest&per_page=100`,
266
294
  );
267
- return (body?.jobs ?? [])
268
- .filter((j) => j.conclusion === 'failure')
269
- .map((j) => j.name);
295
+ return (body?.jobs ?? []).filter(failedOnItsOwn).map((j) => j.name);
270
296
  } catch {
271
- return [];
297
+ return null;
272
298
  }
273
299
  }
274
300
 
@@ -115,7 +115,7 @@ driver or `host-resources` (exit 77): it flips `agent::blocked` and posts
115
115
  per-host `.agentrc.local.json` sets `delivery.execution.preflightConcurrency`
116
116
  above 1 (default 1): close's independent gates then run in admitted
117
117
  lanes beside the base lane — [`deliver-reference.md`](deliver-reference.md) § Preflight.
118
- 3. **One depositor**, by the one predicate close registers `coverage-capture`
118
+ 3. **One depositor** (`suiteOfRecord: ci`: CI's), by one predicate close registers `coverage-capture`
119
119
  on — coverage or CRAP gate on **and** a `captureScript`:
120
120
  - **Capture-active** →
121
121
  `node <main-repo>/.agents/scripts/coverage-capture.js --cwd <workCwd>`,
@@ -518,6 +518,10 @@ Digest § 5 states the rule and both invocations; this is what surrounds them.
518
518
  `testChanged` or an unreadable merge-base falls back to the full
519
519
  `project.commands.test`, logging which reason applied. An exit 76 from any
520
520
  `test` form settles by `coverage.onOverBudget`, as the capture's does.
521
+ Under `coverage.suiteOfRecord: "ci"` none of this runs: the `test`
522
+ depositor is deferred to CI like the capture (no lock, no credit, the
523
+ `Coverage-deferred:` marker), after the changed-tests guard when
524
+ `testChanged` is set.
521
525
  - **Runner shapes.** A bare `npm test` earns the `test` credit **only** where
522
526
  the project's test script routes through mandrel's own runner, which prints
523
527
  the outcome. On any other runner it deposits nothing and prints nothing, so
@@ -714,8 +718,9 @@ line naming host contention — neither is reported as failing tests. A
714
718
  coverage-capture exiting `76` (the consumer's capture script declared its
715
719
  slice over this host's budget, so nothing ran) follows
716
720
  `delivery.quality.gates.coverage.onOverBudget`, and under
717
- `coverage.suiteOfRecord: "ci"` the capture is deferred before anything
718
- spawns (no lock, no credit). A deferral reports the gate `deferred`, the
721
+ `coverage.suiteOfRecord: "ci"` the credited suite — the capture or the
722
+ `test` depositor — is deferred before anything spawns (no lock, no
723
+ credit). A deferral reports the gate `deferred`, the
719
724
  coverage-reading gates `skipped` (`coverage-deferred-ci`), settles the
720
725
  handoff `ready` with a `coverage` field, and puts a `Coverage-deferred:
721
726
  <reason>` key line in the PR body. CI's `ciRatchetCheck` job then runs
package/docs/CHANGELOG.md CHANGED
@@ -15,6 +15,14 @@ All notable changes to this project will be documented in this file.
15
15
  -->
16
16
  <!-- markdownlint-disable-file MD004 MD012 MD037 -->
17
17
 
18
+ ## [2.123.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.122.0...mandrel-v2.123.0) (2026-11-17)
19
+
20
+
21
+ ### Fixed
22
+
23
+ * merge wait reads a fail-fast-cancelled queue run as an own ejection ([#6086](https://github.com/dsj1984/mandrel/issues/6086)) ([#6088](https://github.com/dsj1984/mandrel/issues/6088)) ([4f94261](https://github.com/dsj1984/mandrel/commit/4f94261818494b76208e6828fca0fd74d319e5eb))
24
+ * under suiteOfRecord ci, the test depositor defers to CI too, so a Story with no change under the CRAP target dirs runs no full local suite ([#6087](https://github.com/dsj1984/mandrel/issues/6087)) ([#6090](https://github.com/dsj1984/mandrel/issues/6090)) ([7a184a9](https://github.com/dsj1984/mandrel/commit/7a184a92bd535ae54a3d7760ae6076a5a9f200b4))
25
+
18
26
  ## [2.122.0](https://github.com/dsj1984/mandrel/compare/mandrel-v2.121.0...mandrel-v2.122.0) (2026-11-13)
19
27
 
20
28
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "mandrel",
3
- "version": "2.122.0",
3
+ "version": "2.123.0",
4
4
  "description": "Claude Code-first opinionated workflow framework: instructions, skills, rules, and SDLC workflows that govern AI coding assistants.",
5
5
  "files": [
6
6
  ".agents/",