mandrel 1.58.0 → 1.60.0

package/.agents/scripts/lib/orchestration/epic-runner/phases/build-wave-dag.js

@@ -2,13 +2,9 @@
  * Build the wave DAG from the Epic's open child Stories.
  *
  * `getSubTickets` returns the **direct** children of a parent ticket via
- * native sub-issues + checklist links + body reverse-lookup (despite an
- * older docstring claiming "every descendant"). The v5 canonical Epic
- * hierarchy is Epic → Feature → Story → Task, so Stories live as
- * **grandchildren** of the Epic. We therefore walk one level deeper from
- * each `type::feature` direct child to collect the real Story set, and
- * union with any direct-child Stories (some Epics still carry Stories
- * directly while migrating).
+ * native sub-issues + checklist links + body reverse-lookup. The
+ * canonical 2-tier hierarchy is Epic → Story, so the Epic's direct
+ * `type::story` children are the complete Story set.
  *
  * We additionally filter out closed Stories — `getSubTickets`'s reverse-
  * reference search can surface closed-as-obsolete tickets whose body
@@ -19,14 +15,14 @@
  * Throws if no open Stories are found.
  */
 
-import { parseBlockedBy } from '../../../dependency-parser.js';
 import { computeWaves } from '../../../Graph.js';
 import { TYPE_LABELS } from '../../../label-constants.js';
+import { buildStoryAdjacency } from '../../../story-adjacency.js';
 import { WaveScheduler } from '../wave-scheduler.js';
 
 /**
- * Walk Epic → Feature → Story (one descent past the Epic's direct
- * children) and return the open `type::story` tickets, deduped by id.
+ * Collect the Epic's direct `type::story` children and return the open
+ * ones, deduped by id.
  *
  * Exported so `snapshot.js#discoverStoryIds` and `epic-deliver-preflight`
  * can share the same enumeration contract — the snapshot.end payload,
@@ -34,20 +30,9 @@ import { WaveScheduler } from '../wave-scheduler.js';
  */
 export async function discoverOpenStories({ epicId, provider }) {
   const descendants = (await provider.getSubTickets(epicId)) ?? [];
-  const features = descendants.filter((t) =>
-    (t.labels ?? []).includes(TYPE_LABELS.FEATURE),
-  );
-  const grandchildren = (
-    await Promise.all(
-      features.map(async (f) => {
-        const id = f.id ?? f.number;
-        return id == null ? [] : ((await provider.getSubTickets(id)) ?? []);
-      }),
-    )
-  ).flat();
   const seen = new Set();
   const stories = [];
-  for (const t of [...descendants, ...grandchildren]) {
+  for (const t of descendants) {
     const labels = t.labels ?? [];
     if (!labels.includes(TYPE_LABELS.STORY)) continue;
     const rawState = t.state ?? 'open';
@@ -116,30 +101,17 @@ function normalizeWavesForEmit(waves) {
  * Convert an ordered list of story tickets into the adjacency/taskMap shape
  * that `Graph.computeWaves()` expects.
  *
- * Dependency source order (must match manifest-builder.js so dispatch manifest
- * and runtime wave scheduling never disagree):
- *   1. Canonical: `blocked by #NNN` / `depends on #NNN` parsed from the story
- *      ticket body via `parseBlockedBy` (same parser the dispatcher uses).
- *   2. Fallback: explicit `dependencies` array on the provider-returned story
- *      object (present in fixture / test payloads; optional in live GitHub
- *      payloads).
- * Only edges to other stories in this Epic are retained — foreign IDs are
- * dropped so the DAG stays closed over the scheduled set.
+ * The adjacency comes from the shared story-level builder
+ * (`lib/story-adjacency.js#buildStoryAdjacency`), which owns the
+ * dependency-source ordering contract (body `blocked by` references via
+ * `parseBlockedBy`, then explicit `dependencies[]`) and drops foreign
+ * edges so the DAG stays closed over the scheduled set.
  */
 function buildStoryDag(stories) {
-  const adjacency = new Map();
+  const adjacency = buildStoryAdjacency(stories);
   const taskMap = new Map();
-  const storyIds = new Set(stories.map((s) => Number(s.id ?? s.number)));
   for (const s of stories) {
     const id = Number(s.id ?? s.number);
-    const fromBody = parseBlockedBy(s.body ?? '');
-    const fromField = Array.isArray(s.dependencies)
-      ? s.dependencies.map(Number)
-      : [];
-    const merged = [...new Set([...fromBody, ...fromField])]
-      .map(Number)
-      .filter((dep) => dep !== id && storyIds.has(dep));
-    adjacency.set(id, merged);
     taskMap.set(id, { ...s, id });
   }
   return { adjacency, taskMap };

package/.agents/scripts/lib/orchestration/epic-runner/phases/snapshot.js

@@ -2,7 +2,7 @@
  * Epic snapshot phase — fetch Epic ticket and enforce the acceptance-spec
  * start gate.
  *
- * Auto-close is now the default for `/epic-deliver` (the human PR-merge is
+ * Auto-close is now the default for `/deliver` (the human PR-merge is
  * the gate); no per-Epic label snapshot is required.
  *
  * Acceptance-spec start gate (relaxed): an Epic may be delivered when
@@ -11,9 +11,9 @@
  * `context::acceptance-spec` ticket is linked to the Epic. The ticket's
  * GitHub state (open / closed) is **not** checked — presence is
  * sufficient, matching the PRD and Tech Spec contract. The reviewer's
- * OK during /epic-plan Phase 7 is the approval signal, not a manual
+ * OK during /plan Phase 7 is the approval signal, not a manual
  * ticket-close action. This still refuses to launch Epics that skipped
- * the /epic-plan Phase 7 acceptance-spec authoring step (or didn't
+ * the /plan Phase 7 acceptance-spec authoring step (or didn't
  * waive), surfacing the gap at delivery time rather than letting Story
  * dispatch race ahead without a spec at all.
  */
@@ -66,8 +66,8 @@ export async function runSnapshotPhase(ctx, collaborators, state) {
 /**
  * Enumerate the Story IDs owned by an Epic. Delegates to
  * `discoverOpenStories` so the snapshot.end payload and the wave DAG
- * input set never disagree — both now walk Epic → Feature → Story and
- * exclude closed reverse-referenced tickets.
+ * input set never disagree — both enumerate the Epic's direct Story
+ * children and exclude closed reverse-referenced tickets.
  *
  * Returns a sorted array of positive integers (sort order makes the
  * ledger record deterministic across runs and platform iteration
@@ -82,7 +82,7 @@ async function discoverStoryIds({ epicId, provider }) {
 }
 
 /**
- * Refuse to launch /epic-deliver when the acceptance-spec precondition has
+ * Refuse to launch /deliver when the acceptance-spec precondition has
  * not been satisfied. Throws a clear `Error` (per
  * orchestration-error-handling rule) so the `runAsCli` boundary maps it to
  * `process.exit(1)` with the operator-visible message intact.
@@ -104,7 +104,7 @@ function assertAcceptanceSpecGate({ epic, epicId }) {
   if (!acceptanceSpecId) {
     throw new Error(
       `[epic-deliver] Epic #${epicId} cannot launch: no context::acceptance-spec is linked and the acceptance::n-a waiver label is absent. ` +
-        'Run /epic-plan Phase 7 to author an acceptance-spec, or apply the acceptance::n-a label to the Epic to opt out.',
+        'Run /plan Phase 7 to author an acceptance-spec, or apply the acceptance::n-a label to the Epic to opt out.',
     );
   }
 }

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/composition.js

@@ -24,7 +24,7 @@ import { EPIC_RUN_PROGRESS_TYPE, STATE_EMOJI } from './signals.js';
  * (`…`) when the string was longer. Returns the empty string for any
  * falsy input so table cells never render `undefined`/`null`.
  */
-export function truncate(s, n) {
+function truncate(s, n) {
   if (!s) return '';
   return s.length > n ? `${s.slice(0, n - 1)}…` : s;
 }
@@ -240,7 +240,7 @@ export async function renderProgressBody({
 /**
  * Render and upsert the rolled-up `epic-run-progress` comment on the Epic.
  *
- * Called by `/epic-deliver` Step 2b (`epic-execute-record-wave.js`) after
+ * Called by `/deliver` Step 2b (`epic-execute-record-wave.js`) after
  * each wave completes. The caller folds `state.waves[]` from the
  * `epic-run-state` checkpoint into the per-wave rows and persists the
  * unified rollup as a fenced-JSON payload on the Epic ticket via
@@ -272,7 +272,6 @@ export async function renderProgressBody({
  *     wave: number,
  *     concurrencyCap?: number,
  *     stories?: Array<{ id: number, title?: string, state?: string,
- *                       tasksDone?: number, tasksTotal?: number,
  *                       blockerCommentId?: string }>,
  *   }>,
  *   currentWave: number,

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/signals.js

@@ -29,7 +29,7 @@ export const PHASE_TIMINGS_TYPE = 'phase-timings';
 
 /**
  * Structured-comment kind for the per-Story run-progress snapshot that
- * `/story-deliver` upserts on every Task transition. Read by
+ * `/deliver` upserts on every Task transition. Read by
  * ProgressReporter so the Epic-level table reflects sub-agent state in
  * near-real time instead of label-derived classifications.
  */
@@ -91,7 +91,7 @@ export function phaseToState(phase) {
 }
 
 /**
- * Parse a `story-run-progress` structured comment posted by `/story-deliver`.
+ * Parse a `story-run-progress` structured comment posted by `/deliver`.
  * Returns `null` for any malformed body — the caller falls back to the
  * ticket-label state derivation in that case.
  *
@@ -100,7 +100,6 @@ export function phaseToState(phase) {
  *     storyId: number,
  *     branch?: string,
  *     phase: 'init'|'implementing'|'closing'|'blocked'|'done',
- *     tasks?: [{ id, title?, state, commitSha? }],
  *     title?: string,
  *     updatedAt?: string,
  *   }
@@ -109,16 +108,11 @@ export function parseStoryRunProgressComment(comment) {
   const payload = parseFencedJsonComment(comment);
   if (!payload || typeof payload !== 'object') return null;
   const phase = typeof payload.phase === 'string' ? payload.phase : undefined;
-  const tasks = Array.isArray(payload.tasks) ? payload.tasks : [];
-  const tasksTotal = tasks.length;
-  const tasksDone = tasks.filter((t) => t && t.state === 'done').length;
   return {
     storyId: Number(payload.storyId),
     title: typeof payload.title === 'string' ? payload.title : '',
     phase,
     state: phaseToState(phase),
-    tasksDone,
-    tasksTotal,
   };
 }
 

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/transport.js

@@ -1,6 +1,6 @@
 /**
  * progress-reporter/transport.js — outbound I/O for the
- * `/epic-deliver` progress narrative.
+ * `/deliver` progress narrative.
  *
  * Extracted from the parent `progress-reporter.js` so the
  * GitHub-comment posting surface (in `composition.js`) and the
@@ -16,7 +16,7 @@
  *
  * The webhook events emitted from this module are:
  *
- *   - `epic-started`  — fired once at /epic-deliver kickoff
+ *   - `epic-started`  — fired once at /deliver kickoff
  *   - `epic-progress` — fired at wave boundaries / blocker transitions
  *   - `epic-blocked`  — wave aggregated to blocked/failed outside halt path
  *   - `epic-unblocked` — operator flipped back to executing
@@ -118,7 +118,7 @@ export async function emitEpicProgress({
 }
 
 /**
- * Fire a curated `epic-started` webhook event at /epic-deliver kickoff.
+ * Fire a curated `epic-started` webhook event at /deliver kickoff.
  * The Slack consumer anchors the rest of the epic narrative to this fire.
  * Failures are swallowed.
  */
@@ -157,7 +157,7 @@ export async function emitEpicStarted({
 /**
  * Fire a curated `epic-blocked` webhook event when a wave aggregates to
  * `blocked` or `failed` outside the `BlockerHandler.halt` code path (the
- * /epic-deliver host-LLM loop has no handler instance — it calls this
+ * /deliver host-LLM loop has no handler instance — it calls this
  * helper directly from `epic-execute-record-wave.js`). The payload shape
  * matches the inline emit in `BlockerHandler.halt` so downstream consumers
  * see one canonical envelope regardless of which entry point fired.

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/component-drift.js

@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { resolveComponents } from '../../../baselines/components.js';
+import { componentOrder } from './_bullet-format.js';
+
+/**
+ * Shared component-regression walk for the progress-signal drift detectors
+ * (Story #3984). `crap-drift.js` and `maintainability-drift.js` previously
+ * duplicated this baseline-rollup → per-component compare → bullet-list
+ * shape verbatim; the only divergence was the breach comparator (CRAP is
+ * "lower is better", maintainability is "higher is better") and the bullet
+ * text. Both detectors now parameterize this walk.
+ *
+ * Pure — the caller loads the baseline via `lib/baselines/reader.js#load(...)`
+ * and passes the resulting `{ rollup }` plus the gate config block.
+ *
+ * Only components whose rollup breaches the configured floor surface — a
+ * breach in a component-scoped floor does NOT report against `*` unless
+ * `*` itself breaches. This keeps the rollout narrowly targeted: when an
+ * operator wires up a per-component floor for `api`, regressing `api`
+ * names `api` — not `*`.
+ *
+ * @param {{
+ *   rollup?: Record<string, Record<string, number>>,
+ *   gateConfig?: { floors?: Record<string, Record<string, number>> } & object,
+ * }} params
+ * @param {{
+ *   isBreach: (value: number, floor: number) => boolean,
+ *   formatBullet: (name: string, axis: string, value: number, floor: number) => string,
+ * }} spec
+ * @returns {string[]}
+ */
+export function walkComponentRegressions(params = {}, spec) {
+  const rollup = params.rollup ?? {};
+  const gateConfig = params.gateConfig ?? {};
+  const floors = gateConfig.floors ?? {};
+  const components = resolveComponents(gateConfig);
+  const names = new Set([
+    ...Object.keys(components),
+    ...Object.keys(floors),
+    ...Object.keys(rollup),
+  ]);
+  const bullets = [];
+  for (const name of [...names].sort(componentOrder)) {
+    const aggregate = rollup[name];
+    if (!aggregate || typeof aggregate !== 'object') continue;
+    const floor = floors[name] ?? floors['*'];
+    if (!floor || typeof floor !== 'object') continue;
+    for (const axis of Object.keys(floor).sort()) {
+      const target = floor[axis];
+      const value = aggregate[axis];
+      if (typeof target !== 'number' || !Number.isFinite(target)) continue;
+      if (typeof value !== 'number' || !Number.isFinite(value)) continue;
+      if (!spec.isBreach(value, target)) continue;
+      bullets.push(spec.formatBullet(name, axis, value, target));
+    }
+  }
+  return bullets;
+}
+
+/**
+ * Shared wave-start snapshot persistence for the drift detectors. Both
+ * detectors persist a `{ capturedAt, ...metadata, scores }` JSON document
+ * under `<cwd>/<baselineDir>/<filename>` so a resumed epic run can re-read
+ * the wave-start anchor rather than lose it, and both treat persistence as
+ * best-effort (the in-memory baseline still works when a write fails).
+ *
+ * @param {{
+ *   fs: { readFileSync?: Function, writeFileSync?: Function, mkdirSync?: Function },
+ *   baselinePath: string,
+ *   metadata?: Record<string, unknown>,
+ * }} opts
+ */
+export function createSnapshotStore({ fs, baselinePath, metadata = {} }) {
+  return {
+    persist(scores) {
+      if (!fs.writeFileSync) return;
+      try {
+        fs.mkdirSync?.(path.dirname(baselinePath), { recursive: true });
+        fs.writeFileSync(
+          baselinePath,
+          JSON.stringify(
+            { capturedAt: new Date().toISOString(), ...metadata, scores },
+            null,
+            2,
+          ),
+        );
+      } catch {
+        // persistence is best-effort; the in-memory baseline still works
+      }
+    },
+
+    load() {
+      if (!fs.readFileSync) return null;
+      try {
+        const raw = fs.readFileSync(baselinePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed?.scores ?? null;
+      } catch {
+        return null;
+      }
+    },
+  };
+}

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/crap-drift.js

@@ -1,9 +1,12 @@
 import nodeFs from 'node:fs';
 import path from 'node:path';
-import { resolveComponents } from '../../../baselines/components.js';
 import { loadCoverage as defaultLoadCoverage } from '../../../coverage-utils.js';
 import { calculateCrapForSource } from '../../../crap-engine.js';
-import { componentOrder, formatNumber } from './_bullet-format.js';
+import { formatNumber } from './_bullet-format.js';
+import {
+  createSnapshotStore,
+  walkComponentRegressions,
+} from './component-drift.js';
 
 const DEFAULT_THRESHOLD = 5.0;
 const DEFAULT_CEILING = 30;
@@ -43,11 +46,10 @@ export function coverageKeyMatches(key, suffix) {
  *
  *   🧨 crap: <component> <axis> <value> > floor <floor>
  *
- * Only components whose rollup exceeds the configured floor surface — a
- * breach in a component-scoped floor does NOT report against `*` unless
- * `*` itself breaches. This keeps the rollout narrowly targeted: when an
- * operator wires up a per-component floor for `api`, regressing `api`
- * names `api` — not `*`.
+ * CRAP is a "lower is better" gate — every axis breach reports when
+ * `value > floor`. Component-scoped breaches do NOT trigger a `*` bullet
+ * unless `*` itself breaches. The walk itself is the shared
+ * `component-drift.js` helper (Story #3984).
  *
  * @param {{
  *   rollup?: Record<string, Record<string, number>>,
@@ -56,34 +58,11 @@ export function coverageKeyMatches(key, suffix) {
  * @returns {string[]}
  */
 export function detectComponentRegressions(params = {}) {
-  const rollup = params.rollup ?? {};
-  const gateConfig = params.gateConfig ?? {};
-  const floors = gateConfig.floors ?? {};
-  const components = resolveComponents(gateConfig);
-  const names = new Set([
-    ...Object.keys(components),
-    ...Object.keys(floors),
-    ...Object.keys(rollup),
-  ]);
-  const bullets = [];
-  // CRAP is a "lower is better" gate — every axis under crap is ≤ floor.
-  for (const name of [...names].sort(componentOrder)) {
-    const aggregate = rollup[name];
-    if (!aggregate || typeof aggregate !== 'object') continue;
-    const floor = floors[name] ?? floors['*'];
-    if (!floor || typeof floor !== 'object') continue;
-    for (const axis of Object.keys(floor).sort()) {
-      const cap = floor[axis];
-      const value = aggregate[axis];
-      if (typeof cap !== 'number' || !Number.isFinite(cap)) continue;
-      if (typeof value !== 'number' || !Number.isFinite(value)) continue;
-      if (value <= cap) continue;
-      bullets.push(
-        `🧨 crap: ${name} ${axis} ${formatNumber(value)} > floor ${formatNumber(cap)}`,
-      );
-    }
-  }
-  return bullets;
+  return walkComponentRegressions(params, {
+    isBreach: (value, cap) => value > cap,
+    formatBullet: (name, axis, value, cap) =>
+      `🧨 crap: ${name} ${axis} ${formatNumber(value)} > floor ${formatNumber(cap)}`,
+  });
 }
 
 /**
@@ -141,6 +120,11 @@ export function createCrapDriftDetector(opts = {}) {
   const baselineDir = opts.baselineDir ?? '.agents/state';
   const baselinePath = path.join(cwd, baselineDir, BASELINE_FILENAME);
   const logger = opts.logger ?? null;
+  const store = createSnapshotStore({
+    fs,
+    baselinePath,
+    metadata: { ceiling, threshold },
+  });
 
   let baseline = null;
 
@@ -220,39 +204,13 @@ export function createCrapDriftDetector(opts = {}) {
         }
       }
       baseline = snapshot;
-      if (fs.writeFileSync) {
-        try {
-          fs.mkdirSync?.(path.dirname(baselinePath), { recursive: true });
-          fs.writeFileSync(
-            baselinePath,
-            JSON.stringify(
-              {
-                capturedAt: new Date().toISOString(),
-                ceiling,
-                threshold,
-                scores: snapshot,
-              },
-              null,
-              2,
-            ),
-          );
-        } catch {
-          // persistence is best-effort; the in-memory baseline still works
-        }
-      }
+      store.persist(snapshot);
       return snapshot;
     },
 
     loadBaseline() {
-      if (!fs.readFileSync) return null;
-      try {
-        const raw = fs.readFileSync(baselinePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        baseline = parsed?.scores ?? null;
-        return baseline;
-      } catch {
-        return null;
-      }
+      baseline = store.load();
+      return baseline;
     },
 
     async detect() {

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/maintainability-drift.js

@@ -1,9 +1,12 @@
 import nodeFs from 'node:fs';
 import path from 'node:path';
 
-import { resolveComponents } from '../../../baselines/components.js';
 import { calculateForSource } from '../../../maintainability-engine.js';
-import { componentOrder, formatNumber } from './_bullet-format.js';
+import { formatNumber } from './_bullet-format.js';
+import {
+  createSnapshotStore,
+  walkComponentRegressions,
+} from './component-drift.js';
 
 const DEFAULT_THRESHOLD = 2.0;
 // Distinct from the canonical ratchet baseline at `baselines/maintainability.json`
@@ -12,6 +15,35 @@ const DEFAULT_THRESHOLD = 2.0;
 // grep for the canonical baseline no longer hits the snapshot.
 const BASELINE_FILENAME = 'wave-mi-snapshot.json';
 
+/**
+ * Detect per-component maintainability regressions from a baseline rollup
+ * against the gate's configured floors. Pure — the caller loads the
+ * baseline via `lib/baselines/reader.js#load('maintainability')` and passes
+ * the resulting `{ rollup }` plus the gate config block.
+ *
+ * Bullet shape (Task #1919, Epic #1786):
+ *
+ *   📉 maintainability: <component> <axis> <value> < floor <floor>
+ *
+ * Maintainability is "higher is better" — every axis breach reports when
+ * `value < floor`. Component-scoped breaches do NOT trigger a `*` bullet
+ * unless `*` itself breaches. The walk itself is the shared
+ * `component-drift.js` helper (Story #3984).
+ *
+ * @param {{
+ *   rollup?: Record<string, Record<string, number>>,
+ *   gateConfig?: { floors?: Record<string, Record<string, number>> } & object,
+ * }} params
+ * @returns {string[]}
+ */
+export function detectComponentRegressions(params = {}) {
+  return walkComponentRegressions(params, {
+    isBreach: (value, target) => value < target,
+    formatBullet: (name, axis, value, target) =>
+      `📉 maintainability: ${name} ${axis} ${formatNumber(value)} < floor ${formatNumber(target)}`,
+  });
+}
+
 /**
  * Detects per-file maintainability drop versus a wave-start baseline.
  *
@@ -40,56 +72,6 @@ const BASELINE_FILENAME = 'wave-mi-snapshot.json';
  *   baselineDir?: string,           // directory (under cwd) to persist snapshot
  * }} [opts]
  */
-/**
- * Detect per-component maintainability regressions from a baseline rollup
- * against the gate's configured floors. Pure — the caller loads the
- * baseline via `lib/baselines/reader.js#load('maintainability')` and passes
- * the resulting `{ rollup }` plus the gate config block.
- *
- * Bullet shape (Task #1919, Epic #1786):
- *
- *   📉 maintainability: <component> <axis> <value> < floor <floor>
- *
- * Maintainability is "higher is better" — every axis breach reports when
- * `value < floor`. Component-scoped breaches do NOT trigger a `*` bullet
- * unless `*` itself breaches.
- *
- * @param {{
- *   rollup?: Record<string, Record<string, number>>,
- *   gateConfig?: { floors?: Record<string, Record<string, number>> } & object,
- * }} params
- * @returns {string[]}
- */
-export function detectComponentRegressions(params = {}) {
-  const rollup = params.rollup ?? {};
-  const gateConfig = params.gateConfig ?? {};
-  const floors = gateConfig.floors ?? {};
-  const components = resolveComponents(gateConfig);
-  const names = new Set([
-    ...Object.keys(components),
-    ...Object.keys(floors),
-    ...Object.keys(rollup),
-  ]);
-  const bullets = [];
-  for (const name of [...names].sort(componentOrder)) {
-    const aggregate = rollup[name];
-    if (!aggregate || typeof aggregate !== 'object') continue;
-    const floor = floors[name] ?? floors['*'];
-    if (!floor || typeof floor !== 'object') continue;
-    for (const axis of Object.keys(floor).sort()) {
-      const target = floor[axis];
-      const value = aggregate[axis];
-      if (typeof target !== 'number' || !Number.isFinite(target)) continue;
-      if (typeof value !== 'number' || !Number.isFinite(value)) continue;
-      if (value >= target) continue;
-      bullets.push(
-        `📉 maintainability: ${name} ${axis} ${formatNumber(value)} < floor ${formatNumber(target)}`,
-      );
-    }
-  }
-  return bullets;
-}
-
 export function createMaintainabilityDriftDetector(opts = {}) {
   const fs = opts.fs ?? nodeFs;
   const cwd = opts.cwd ?? process.cwd();
@@ -100,6 +82,7 @@ export function createMaintainabilityDriftDetector(opts = {}) {
     : DEFAULT_THRESHOLD;
   const baselineDir = opts.baselineDir ?? '.agents/state';
   const baselinePath = path.join(cwd, baselineDir, BASELINE_FILENAME);
+  const store = createSnapshotStore({ fs, baselinePath });
 
   let baseline = null;
 
@@ -126,34 +109,13 @@ export function createMaintainabilityDriftDetector(opts = {}) {
         if (s != null) snapshot[f] = s;
       }
       baseline = snapshot;
-      if (fs.writeFileSync) {
-        try {
-          fs.mkdirSync?.(path.dirname(baselinePath), { recursive: true });
-          fs.writeFileSync(
-            baselinePath,
-            JSON.stringify(
-              { capturedAt: new Date().toISOString(), scores: snapshot },
-              null,
-              2,
-            ),
-          );
-        } catch {
-          // persistence is best-effort; the in-memory baseline still works
-        }
-      }
+      store.persist(snapshot);
       return snapshot;
     },
 
     loadBaseline() {
-      if (!fs.readFileSync) return null;
-      try {
-        const raw = fs.readFileSync(baselinePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        baseline = parsed?.scores ?? null;
-        return baseline;
-      } catch {
-        return null;
-      }
+      baseline = store.load();
+      return baseline;
     },
 
     async detect() {

package/.agents/scripts/lib/orchestration/epic-runner/story-launcher.js

@@ -5,10 +5,10 @@
  * After Story #908, in-session Agent-tool fan-out replaces the subprocess
  * spawn pipeline. The launcher's primary responsibility is `planWave(stories)`:
  * given a wave's Story tickets it returns a stable list of
- * `{ storyId, worktree }` entries. The `/epic-deliver` skill consumes that
+ * `{ storyId, worktree }` entries. The `/deliver` skill consumes that
  * list (one wave at a time) to format one assistant turn containing N
  * parallel `Agent` tool calls (subagent_type `general-purpose`), each of
- * which drives `/story-deliver <storyId>` for one Story.
+ * which drives `/deliver <storyId>` for one Story.
  *
  * `launchWave(stories)` is a convenience for callers that already hold a
  * concrete dispatch adapter (tests, future programmatic harnesses). It calls
@@ -46,7 +46,7 @@ export class StoryLauncher {
 
   /**
    * Produce the dispatch plan for a wave. Pure: no side effects, no IO. The
-   * caller (the `/epic-deliver` skill's wave loop, or `launchWave` below)
+   * caller (the `/deliver` skill's wave loop, or `launchWave` below)
    * decides what to do with the plan.
    *
    * @param {Array<number|{id?:number,storyId?:number,number?:number}>} stories
@@ -78,7 +78,7 @@ export class StoryLauncher {
   async launchWave(stories, signal) {
     if (typeof this.dispatch !== 'function') {
       throw new TypeError(
-        'StoryLauncher.launchWave requires a dispatch adapter (in-session Agent-tool fan-out is the responsibility of the /epic-deliver skill).',
+        'StoryLauncher.launchWave requires a dispatch adapter (in-session Agent-tool fan-out is the responsibility of the /deliver skill).',
       );
     }
     const plan = this.planWave(stories);