mandrel 1.58.0 → 1.60.0

package/.agents/scripts/lib/coverage-capture.js

@@ -11,6 +11,7 @@
  * `isCoverageFresh` and decide whether to delegate to `runCapture`.
  */
 import { spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -65,10 +66,130 @@ export function newestSourceMtime(cwd, targetDirs, io = {}) {
 }
 
 /**
- * Decide whether the existing coverage artifact is "fresh" — present and at
- * least as new as the newest source file under `targetDirs`. Missing files,
- * missing target dirs, or any IO error resolve to `false` so the caller
- * captures rather than trusting stale data.
+ * Resolve the capture-stamp path that sits next to the coverage artifact.
+ * The stamp persists the content digest of the CRAP-target sources at the
+ * moment coverage was last captured, so freshness can be decided by content
+ * rather than mtime (mtime churns on branch switches / checkouts even when
+ * content is unchanged).
+ *
+ * @param {string} cwd Absolute repo root.
+ * @param {string} coveragePath Repo-relative coverage artifact path.
+ * @returns {string} Absolute stamp path (`<coverage-dir>/.capture-stamp.json`).
+ */
+export function captureStampPath(cwd, coveragePath) {
+  return path.join(
+    path.dirname(path.resolve(cwd, coveragePath)),
+    '.capture-stamp.json',
+  );
+}
+
+const SOURCE_EXT_RE = /\.(?:js|mjs)$/;
+
+/**
+ * Compute a stable content digest of the `.js`/`.mjs` sources under
+ * `targetDirs`: the `git ls-files -s` listing (mode + blob SHA + path) of
+ * tracked content, plus the on-disk bytes of any dirty working-tree files.
+ * Checkout/branch churn leaves blob SHAs untouched, so the digest only moves
+ * when content actually changes.
+ *
+ * Returns `null` when the digest cannot be computed (git unavailable, not a
+ * repo, empty target list) so callers can fall back to the mtime heuristic.
+ *
+ * @param {string} cwd Absolute repo root.
+ * @param {string[]} targetDirs Repo-relative directories to digest.
+ * @param {{ spawnSync?: typeof spawnSync, readFileSync?: typeof fs.readFileSync }} [io]
+ * @returns {string | null} Hex SHA-256 digest, or null when unavailable.
+ */
+export function computeContentDigest(cwd, targetDirs, io = {}) {
+  const spawn = io.spawnSync ?? spawnSync;
+  const readFileSync = io.readFileSync ?? fs.readFileSync;
+  const dirs = (targetDirs ?? []).filter(
+    (d) => typeof d === 'string' && d.length > 0,
+  );
+  if (dirs.length === 0) return null;
+
+  const git = (...args) => {
+    const res = spawn('git', args, { cwd, encoding: 'utf8' });
+    if (res?.error || res?.status !== 0) {
+      throw res?.error ?? new Error(res?.stderr || `git ${args[0]} failed`);
+    }
+    return res.stdout ?? '';
+  };
+
+  try {
+    const hash = crypto.createHash('sha256');
+    const tracked = git('ls-files', '-s', '--', ...dirs)
+      .split('\n')
+      .filter((line) => SOURCE_EXT_RE.test(line.trimEnd()));
+    hash.update(tracked.join('\n'));
+
+    // Dirty working-tree files are not represented by their index blob SHA,
+    // so fold in their on-disk bytes (or absence) explicitly.
+    const dirty = git('status', '--porcelain', '--', ...dirs)
+      .split('\n')
+      .filter((line) => line.length > 3);
+    for (const line of dirty) {
+      let file = line.slice(3).trim();
+      if (file.includes(' -> ')) file = file.split(' -> ').pop();
+      file = file.replace(/^"|"$/g, '');
+      if (!SOURCE_EXT_RE.test(file)) continue;
+      hash.update(`\0${file}\0`);
+      try {
+        hash.update(readFileSync(path.resolve(cwd, file)));
+      } catch {
+        hash.update('<absent>');
+      }
+    }
+    return hash.digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist the capture stamp next to the coverage artifact. Best-effort: a
+ * write failure returns `false` rather than throwing — the worst case is a
+ * fall back to the mtime heuristic on the next freshness check.
+ *
+ * @param {{
+ *   cwd: string,
+ *   coveragePath: string,
+ *   digest: string,
+ *   writeFileSync?: typeof fs.writeFileSync,
+ * }} opts
+ * @returns {boolean} True when the stamp was written.
+ */
+export function writeCaptureStamp({
+  cwd,
+  coveragePath,
+  digest,
+  writeFileSync = fs.writeFileSync,
+}) {
+  if (typeof digest !== 'string' || digest.length === 0) return false;
+  try {
+    writeFileSync(
+      captureStampPath(cwd, coveragePath),
+      `${JSON.stringify({ digest, capturedAt: new Date().toISOString() }, null, 2)}\n`,
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Decide whether the existing coverage artifact is "fresh".
+ *
+ * Primary test (content-aware, Story #3982): when a capture stamp exists
+ * next to the artifact, compare its persisted digest against the current
+ * content digest of `targetDirs`. Equal digests → fresh; different → stale.
+ * Branch switches and checkouts that bump mtimes without changing content
+ * no longer invalidate coverage.
+ *
+ * Fallback (stamp absent / unreadable / digest unavailable): the original
+ * mtime heuristic — artifact at least as new as the newest source file
+ * under `targetDirs`. Missing files, missing target dirs, or any IO error
+ * resolve to `false` so the caller captures rather than trusting stale data.
  *
  * @param {{
  *   coveragePath: string,
@@ -77,6 +198,8 @@ export function newestSourceMtime(cwd, targetDirs, io = {}) {
  *   statSync?: typeof fs.statSync,
  *   readdirSync?: typeof fs.readdirSync,
  *   existsSync?: typeof fs.existsSync,
+ *   readFileSync?: typeof fs.readFileSync,
+ *   computeDigest?: typeof computeContentDigest,
  * }} opts
  * @returns {{ fresh: boolean, reason: 'missing' | 'stale' | 'fresh' | 'no-sources' }}
  */
@@ -87,10 +210,30 @@ export function isCoverageFresh({
   statSync = fs.statSync,
   readdirSync = fs.readdirSync,
   existsSync = fs.existsSync,
+  readFileSync = fs.readFileSync,
+  computeDigest = computeContentDigest,
 }) {
   const absCoverage = path.resolve(cwd, coveragePath);
   if (!existsSync(absCoverage)) return { fresh: false, reason: 'missing' };
 
+  const stampPath = captureStampPath(cwd, coveragePath);
+  if (existsSync(stampPath)) {
+    let stamp = null;
+    try {
+      stamp = JSON.parse(readFileSync(stampPath, 'utf8'));
+    } catch {
+      // Corrupt/unreadable stamp → fall through to the mtime heuristic.
+    }
+    if (typeof stamp?.digest === 'string' && stamp.digest.length > 0) {
+      const current = computeDigest(cwd, targetDirs);
+      if (typeof current === 'string' && current.length > 0) {
+        return current === stamp.digest
+          ? { fresh: true, reason: 'fresh' }
+          : { fresh: false, reason: 'stale' };
+      }
+    }
+  }
+
   let coverageMtime;
   try {
     coverageMtime = statSync(absCoverage).mtimeMs;

package/.agents/scripts/lib/cpu-pool.js

@@ -54,6 +54,20 @@ import { Worker } from 'node:worker_threads';
 /** Default factory: spawn a real `worker_threads.Worker`. */
 const defaultWorkerFactory = (script, options) => new Worker(script, options);
 
+/**
+ * Pool-vs-serial cutover for `runOnPool` callers.
+ *
+ * Below this batch size the pool's worker spawn overhead dominates, so
+ * callers fall back to in-process serial scoring. Tuned against the test
+ * suite's tmpdir fixtures (n=2 stays serial; the full repo n≈200–470
+ * takes the pool path). Single-sourced here so the maintainability
+ * baseline scan (`maintainability-utils.js`), the CRAP scanner
+ * (`crap-utils.js`), and the native review provider
+ * (`review-providers/native.js`) cannot silently desynchronize on a
+ * retune.
+ */
+export const POOL_SERIAL_THRESHOLD = 8;
+
 /**
  * @template TItem, TResult
  * @param {string|URL} workerScript - File URL or path to the worker entry.

package/.agents/scripts/lib/crap-utils.js

@@ -6,22 +6,17 @@ import {
   coverageForMethodInEntry,
   findCoverageEntry,
 } from './coverage-utils.js';
-import { runOnPool } from './cpu-pool.js';
+import { POOL_SERIAL_THRESHOLD, runOnPool } from './cpu-pool.js';
 import { crapFormula } from './crap-engine.js';
 import { Logger } from './Logger.js';
-import {
-  resolveTsTranspilerVersion,
-  scanDirectory,
-  transpileIfNeeded,
-} from './maintainability-utils.js';
+import { scanDirectory } from './maintainability-utils.js';
+import { resolveTsTranspilerVersion, transpileIfNeeded } from './transpile.js';
 
 const CRAP_WORKER_URL = new URL('./workers/crap-worker.js', import.meta.url);
 
-// Below this batch size the pool's spawn overhead dominates — fall
-// back to in-process serial scoring. The full repo (~200+ files)
-// always takes the pool path; tests with handful-of-files fixtures
-// stay serial and remain byte-identical to the pre-pool output.
-const SERIAL_THRESHOLD = 8;
+// Pool-vs-serial cutover — single-sourced in cpu-pool.js (see the
+// POOL_SERIAL_THRESHOLD docstring for the tuning rationale).
+const SERIAL_THRESHOLD = POOL_SERIAL_THRESHOLD;
 // 1.1.0 — TypeScript support landed in 5.29.0. Bumped from 1.0.0 because
 // the scanner now emits CRAP rows for TS/TSX paths that the previous
 // kernel could never reach. The CRAP formula and per-method scoring

package/.agents/scripts/lib/duplicate-search.js

@@ -1,7 +1,7 @@
 /**
  * duplicate-search.js — Cross-Epic Duplicate Detection
  *
- * Used by `/epic-plan` Phase 2 (s-plan-ideation) to surface open Epics
+ * Used by `/plan` Phase 2 (s-plan-ideation) to surface open Epics
  * whose scope overlaps with a sharpened one-pager before a new Epic is
  * created. Returns ranked candidates with an overlap score and URL so
  * the host LLM can pause for HITL confirmation.

package/.agents/scripts/lib/dynamic-workflow/capability.js

@@ -26,7 +26,7 @@
  *
  * Both paths MUST emit the identical per-lens report contract
  * (`{{auditOutputDir}}/<lens>-results.md`), so downstream consumers
- * (`/epic-deliver` Phase 4 epic-audit, `audit-to-stories`) are agnostic to
+ * (`/deliver` Phase 4 epic-audit, `audit-to-stories`) are agnostic to
  * which path produced it.
  *
  * ## Why this is capability-degradation, not a contract shim

package/.agents/scripts/lib/dynamic-workflow/documentation-report-contract.js

@@ -0,0 +1,87 @@
+// .agents/scripts/lib/dynamic-workflow/documentation-report-contract.js
+import { assertSectionsContract } from './report-contract-core.js';
+
+/**
+ * The `audit-documentation` report contract (Story #4024).
+ *
+ * This is the **single source of truth** for the report shape that BOTH the
+ * sequential lens (`.agents/workflows/audit-documentation.md` Step 3) and the
+ * orchestrated dynamic-workflow path
+ * (`.claude/workflows/audit-documentation.workflow.js`) MUST emit to
+ * `{{auditOutputDir}}/audit-documentation-results.md`. Keeping it here lets
+ * the contract-tier test assert report conformance against one definition
+ * rather than re-deriving headings from prose in two places.
+ *
+ * @module dynamic-workflow/documentation-report-contract
+ */
+
+/** The artifact filename the lens writes under `auditOutputDir`. */
+export const REPORT_ARTIFACT_BASENAME = 'audit-documentation-results.md';
+
+/**
+ * The required top-level (`##`) section headings, in document order, that the
+ * lens markdown's Step 3 template defines. A conformant report MUST contain
+ * each of these headings; the orchestrated path assembles its verified
+ * findings into exactly this skeleton.
+ */
+export const REQUIRED_SECTIONS = Object.freeze([
+  'Executive Summary',
+  'Target Set Coverage',
+  'Detailed Findings',
+]);
+
+/** The H1 title the report opens with. */
+export const REPORT_TITLE = 'Documentation Audit Report';
+
+/**
+ * The required field labels inside each `### <finding>` block under
+ * `## Detailed Findings`. Mirrors the strict per-finding structure in the
+ * lens template.
+ */
+export const FINDING_FIELDS = Object.freeze([
+  'Category',
+  'Impact',
+  'Current State',
+  'Recommendation & Rationale',
+  'Agent Prompt',
+]);
+
+/**
+ * The finding categories the per-finding `Category` field draws from. These
+ * mirror the lens's Step 3 template enumeration: deterministic-gate findings
+ * (Generator Drift, Link Integrity) plus semantic-verification findings
+ * (Broken Instruction, Stale Description, Missing Coverage).
+ */
+export const FINDING_CATEGORIES = Object.freeze([
+  'Broken Instruction',
+  'Stale Description',
+  'Missing Coverage',
+  'Generator Drift',
+  'Link Integrity',
+]);
+
+/**
+ * The impact buckets the Executive Summary and per-finding `Impact` field draw
+ * from. The lens speaks in High/Medium/Low; this list is the canonical
+ * taxonomy the downstream `audit-to-stories` consumer maps onto Story
+ * priority.
+ */
+export const IMPACT_LEVELS = Object.freeze(['High', 'Medium', 'Low']);
+
+/**
+ * Assert that a rendered markdown report conforms to the contract: it has the
+ * H1 title and every required `##` section heading. Returns a structured
+ * result rather than throwing, so callers (tests, the orchestrated path's
+ * self-check) can report precisely which sections are missing.
+ *
+ * Pure function — string analysis only.
+ *
+ * @param {string} markdown - The rendered report body.
+ * @returns {{ conformant: boolean, missingSections: string[], hasTitle: boolean }}
+ */
+export function assertReportContract(markdown) {
+  return assertSectionsContract(markdown, {
+    title: REPORT_TITLE,
+    requiredSections: REQUIRED_SECTIONS,
+  });
+}

package/.agents/scripts/lib/epic-plan-clarity.js

@@ -10,7 +10,7 @@
  * Verdict rule: `clear` requires **both** (a) ≥ 4 of 5 canonical sections
  * present, **and** (b) the **Acceptance Criteria** section present. The
  * Acceptance-Criteria requirement is load-bearing: a downstream
- * `/epic-deliver` start gate and the close-time acceptance-spec reconciler
+ * `/deliver` start gate and the close-time acceptance-spec reconciler
  * both assume the Epic carries acceptance criteria, so a gate that passed an
  * Epic with no Acceptance Criteria (the pre-Story-#3910 `≥ 4 of 5` behaviour)
  * advertised a clarity guarantee it did not provide. AC is now a required

package/.agents/scripts/lib/epic-plan-ideation.js

@@ -1,5 +1,5 @@
 /**
- * epic-plan-ideation.js — Phase 3/4 helpers for /epic-plan
+ * epic-plan-ideation.js — Phase 3/4 helpers for /plan
  *
  * Phase 3: render an Epic body from a sharpened ideation one-pager
  * using the canonical template at `.agents/templates/epic-from-idea.md`.

package/.agents/scripts/lib/feedback-loop/memory-freshness.js

@@ -1,5 +1,5 @@
 /**
- * memory-freshness.js — walker + verifier for the `/epic-plan` Phase 0
+ * memory-freshness.js — walker + verifier for the `/plan` Phase 0
  * memory-freshness pre-flight. Story #2557 / Epic #2547. Tech Spec #2550.
  *
  * Walks every `.md` file under a memory directory (typically

package/.agents/scripts/lib/feedback-loop/prior-feedback-fetcher.js

@@ -1,6 +1,6 @@
 /**
  * prior-feedback-fetcher.js — gh-CLI-backed fetcher for open meta feedback
- * issues that feed the `/epic-plan` Phase 0 planner context.
+ * issues that feed the `/plan` Phase 0 planner context.
  *
  * Story #2554 / Epic #2547. Tech Spec #2550 specifies that the fetcher MUST
  * return open issues carrying the `meta::framework-gap` and

package/.agents/scripts/lib/findings/classify-finding.js

@@ -51,7 +51,7 @@ export const FINDING_CLASSES = Object.freeze([
 /**
  * Class → label-set routing table. Each class maps to exactly one label set.
  * `tooling-dx` is the framework-gap path: it carries `meta::framework-gap` so
- * the `/epic-plan` Phase 0 feedback fetcher surfaces it to the planner.
+ * the `/plan` Phase 0 feedback fetcher surfaces it to the planner.
  */
 const CLASS_TO_LABELS = Object.freeze({
   'product-bug': [FOCUS_LABELS.PRODUCT],

package/.agents/scripts/lib/findings/promote-finding.js

@@ -5,8 +5,8 @@
  * tail of the exploratory-QA Triage path: once an operator has dispositioned a
  * session's ledger items (see `.agents/schemas/qa-ledger.schema.json` and
  * `lib/qa/qa-session.js`), the still-untriaged backlog is clustered and each
- * cluster is promoted to a follow-up ticket — a single Story (via `/story-plan`)
- * for a tight, one-deliverable cluster, or an Epic (via `/epic-plan --idea`) for
+ * cluster is promoted to a follow-up ticket — a single Story (via `/plan`)
+ * for a tight, one-deliverable cluster, or an Epic (via `/plan --idea`) for
  * a broad cluster that spans multiple coverage surfaces. Each contributing
  * ledger item then has the resulting `routedTo` issue link written back onto it
  * so a resume run sees the item as filed rather than re-promoting it.
@@ -23,7 +23,7 @@
  * Pure orchestration: **no network I/O lives here.** Every GitHub side-effect
  * (issue search, ticket creation) flows through INJECTED PORTS so the unit test
  * runs with no network. Production wires the ports to the GitHub provider /
- * `/story-plan` / `/epic-plan` surfaces; tests pass in-memory stubs.
+ * `/plan` / `/plan` surfaces; tests pass in-memory stubs.
  */
 
 import { fingerprintFinding, routeFinding } from './route-finding.js';
@@ -40,8 +40,8 @@ export const PROMOTION_TARGETS = Object.freeze({
 
 /**
  * A cluster of more than this many distinct coverage surfaces is broad enough
- * to warrant an Epic (`/epic-plan --idea`) rather than a single Story
- * (`/story-plan`). One or two surfaces is a tight, single-deliverable cluster.
+ * to warrant an Epic (`/plan --idea`) rather than a single Story
+ * (`/plan`). One or two surfaces is a tight, single-deliverable cluster.
  */
 const EPIC_COVERAGE_THRESHOLD = 2;
 
@@ -159,8 +159,8 @@ export function clusterLedgerItems(items) {
 /**
  * Decide a cluster's promotion target. A cluster that spans more than
  * {@link EPIC_COVERAGE_THRESHOLD} distinct coverage surfaces is broad enough to
- * warrant an Epic (`/epic-plan --idea`); otherwise it is a single-deliverable
- * Story (`/story-plan`).
+ * warrant an Epic (`/plan --idea`); otherwise it is a single-deliverable
+ * Story (`/plan`).
  *
  * @param {{ coverages: string[] }} cluster
  * @returns {'story'|'epic'}
@@ -233,7 +233,7 @@ function routedToLink(issue, kind) {
  *      shared `routeFinding` against existing Issues (via the injected search
  *      port). This dedups against work already filed.
  *   2. On a `new` decision, open the follow-up ticket through the injected
- *      `createStory` (`/story-plan`) or `createEpic` (`/epic-plan --idea`) port,
+ *      `createStory` (`/plan`) or `createEpic` (`/plan --idea`) port,
  *      chosen by {@link targetForCluster}. On any other decision, link back to
  *      the matched Issue rather than creating a duplicate.
  *   3. Stamp the resolved `routedTo` link onto every contributing ledger item
@@ -250,9 +250,9 @@ function routedToLink(issue, kind) {
  * @param {(finding: object) => Promise<Array<{ number: number, state: string, title?: string, body?: string }>>} [ports.searchCandidates]
  *   Optional semantic candidate search, forwarded to `routeFinding`.
  * @param {(cluster: object) => Promise<{ number: number, url?: string }>} ports.createStory
- *   Opens a single Story (`/story-plan`) for a tight cluster.
+ *   Opens a single Story (`/plan`) for a tight cluster.
  * @param {(cluster: object) => Promise<{ number: number, url?: string }>} ports.createEpic
- *   Opens an Epic (`/epic-plan --idea`) for a broad cluster.
+ *   Opens an Epic (`/plan --idea`) for a broad cluster.
  * @returns {Promise<{
  *   promotions: Array<{
  *     clusterKey: string,

package/.agents/scripts/lib/git-utils.js

@@ -231,25 +231,28 @@ export function __setSleep(fn, opts = {}) {
 }
 
 /**
- * Run `git fetch …` with a bounded retry loop that only triggers on known
- * packed-refs lock-contention signatures. Non-contention failures surface
- * immediately (no retry). Success short-circuits the loop.
+ * Shared bounded retry loop for git commands that can hit packed-refs lock
+ * contention. Only contention signatures trigger a retry — non-contention
+ * failures surface immediately, and success short-circuits the loop.
  *
  * Backoff schedule: 250ms, 500ms, 1000ms (3 retries → 4 attempts total).
  * Deliberately no global lock — a mutex would erase the parallelism the
- * worktree-isolation model is designed to enable.
+ * worktree-isolation model is designed to enable. The schedule and the
+ * jitter policy (`_sleep` / `_jitterFactor` seams) live only here so a
+ * backoff tuning change has a single point of application.
  *
  * @param {string} cwd
- * @param {...string} args - Arguments after `fetch` (e.g. `'origin'`).
+ * @param {string[]} argvPrefix - Leading git argv (e.g. `['fetch']`).
+ * @param {string[]} args - Trailing arguments (e.g. `['origin']`).
  * @returns {Promise<{ status: number, stdout: string, stderr: string, attempts: number }>}
  */
-export async function gitFetchWithRetry(cwd, ...args) {
+async function gitWithContentionRetry(cwd, argvPrefix, args) {
   const backoff = [250, 500, 1000];
   let attempt = 0;
   let last;
   for (;;) {
     attempt++;
-    last = gitSpawn(cwd, 'fetch', ...args);
+    last = gitSpawn(cwd, ...argvPrefix, ...args);
     if (last.status === 0) return { ...last, attempts: attempt };
     if (!isPackedRefsContention(last.stderr))
       return { ...last, attempts: attempt };
@@ -260,6 +263,18 @@ export async function gitFetchWithRetry(cwd, ...args) {
   }
 }
 
+/**
+ * Run `git fetch …` with the bounded packed-refs-contention retry loop
+ * (see `gitWithContentionRetry`).
+ *
+ * @param {string} cwd
+ * @param {...string} args - Arguments after `fetch` (e.g. `'origin'`).
+ * @returns {Promise<{ status: number, stdout: string, stderr: string, attempts: number }>}
+ */
+export function gitFetchWithRetry(cwd, ...args) {
+  return gitWithContentionRetry(cwd, ['fetch'], args);
+}
+
 /**
  * Run `git pull --rebase …` with the same bounded retry loop as
  * `gitFetchWithRetry`. Packed-refs contention can occur during pulls
@@ -269,21 +284,8 @@ export async function gitFetchWithRetry(cwd, ...args) {
  * @param {...string} args - Arguments after `pull --rebase` (e.g. `'origin', 'main'`).
  * @returns {Promise<{ status: number, stdout: string, stderr: string, attempts: number }>}
  */
-export async function gitPullWithRetry(cwd, ...args) {
-  const backoff = [250, 500, 1000];
-  let attempt = 0;
-  let last;
-  for (;;) {
-    attempt++;
-    last = gitSpawn(cwd, 'pull', '--rebase', ...args);
-    if (last.status === 0) return { ...last, attempts: attempt };
-    if (!isPackedRefsContention(last.stderr))
-      return { ...last, attempts: attempt };
-    if (attempt > backoff.length) return { ...last, attempts: attempt };
-    const base = backoff[attempt - 1];
-    const jitter = Math.floor(Math.random() * base * _jitterFactor);
-    await _sleep(base + jitter);
-  }
+export function gitPullWithRetry(cwd, ...args) {
+  return gitWithContentionRetry(cwd, ['pull', '--rebase'], args);
 }
 
 /**

package/.agents/scripts/lib/label-constants.js

@@ -76,7 +76,6 @@ export function isValidTransition(fromState, toState) {
 
 export const TYPE_LABELS = {
   EPIC: 'type::epic',
-  FEATURE: 'type::feature',
   STORY: 'type::story',
 };
 
@@ -104,7 +103,7 @@ export const CONTEXT_LABELS = {
 export const CONTEXT_ACCEPTANCE_SPEC = CONTEXT_LABELS.ACCEPTANCE_SPEC;
 
 /**
- * Acceptance-axis labels for opt-out signalling on Stories and Features that
+ * Acceptance-axis labels for opt-out signalling on Stories that
  * intentionally have no acceptance-spec coverage. Separate namespace from
  * `context::` because it expresses absence rather than a linked context
  * ticket.
@@ -120,7 +119,7 @@ export const ACCEPTANCE_NA = ACCEPTANCE_LABELS.N_A;
  * loop). `meta::framework-gap` is applied to issues that surface a defect or
  * missing capability in the framework itself; `meta::consumer-improvement`
  * is applied to issues that surface improvements to a consumer project
- * (workflow tweaks, ergonomic asks, doc polish). The `/epic-plan` Phase 0
+ * (workflow tweaks, ergonomic asks, doc polish). The `/plan` Phase 0
  * fetcher (see `lib/feedback-loop/prior-feedback-fetcher.js`) reads open
  * issues carrying either label and surfaces them to the planner so retro
  * signals are routed into durable substrates rather than lost in chat.
@@ -133,7 +132,7 @@ export const META_LABELS = {
 /**
  * Planning-axis labels (Epic #2880 F7). Currently scoped to the
  * `planning::healthcheck-waived` operator-applied waiver, which is the
- * documented escape hatch for the `/epic-plan` Phase 10 readiness
+ * documented escape hatch for the `/plan` Phase 10 readiness
  * healthcheck (`epic-plan-healthcheck.js`). The persist half of
  * `epic-plan-decompose.js` refuses to flip an Epic to `agent::ready`
  * when the healthcheck returned `ok: false` unless this label is

package/.agents/scripts/lib/label-taxonomy.js

@@ -53,15 +53,10 @@ export const LABEL_TAXONOMY = [
     color: LABEL_COLORS.TYPE,
     description: 'Epic-level work item',
   },
-  {
-    name: TYPE_LABELS.FEATURE,
-    color: LABEL_COLORS.TYPE,
-    description: 'Feature under an Epic',
-  },
   {
     name: TYPE_LABELS.STORY,
     color: LABEL_COLORS.TYPE,
-    description: 'User story under a Feature',
+    description: 'User story under an Epic',
   },
 
   // Agent State
@@ -75,7 +70,7 @@ export const LABEL_TAXONOMY = [
     name: AGENT_LABELS.READY,
     color: LABEL_COLORS.AGENT,
     description:
-      'Parking state — frozen dispatch manifest exists; awaiting local /epic-deliver',
+      'Parking state — frozen dispatch manifest exists; awaiting local /deliver',
   },
   {
     name: AGENT_LABELS.EXECUTING,
@@ -120,7 +115,7 @@ export const LABEL_TAXONOMY = [
     description: 'Acceptance Specification (Gherkin scenarios)',
   },
 
-  // Acceptance axis — explicit opt-out signal for Stories/Features that
+  // Acceptance axis — explicit opt-out signal for Stories that
   // intentionally have no acceptance-spec coverage.
   {
     name: ACCEPTANCE_LABELS.N_A,

package/.agents/scripts/lib/maintainability-engine.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import escomplex from 'typhonjs-escomplex';
-import { transpileIfNeeded } from './maintainability-utils.js';
+import { transpileIfNeeded } from './transpile.js';
 
 /**
  * Calculates the maintainability score of a JavaScript source file or string.