mandrel 1.94.0 → 2.0.0

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

@@ -1,23 +1,27 @@
 /**
- * duplicate-search.js — Cross-Epic Duplicate Detection
+ * duplicate-search.js — Cross-Story Duplicate Detection
  *
- * 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.
+ * Used by `/plan` to surface open Stories whose scope overlaps with a
+ * seed / seed-file / tickets corpus before new Stories are created.
+ * Returns ranked candidates with an overlap score and URL so the host
+ * LLM can pause for HITL confirmation.
  *
  * Design notes:
- *  - The provider abstraction (`ITicketingProvider#getEpics`) is the
- *    only I/O surface; the scoring routine is pure and trivially
- *    testable in isolation.
- *  - Scoring is intentionally simple (token Jaccard over title +
- *    structured one-pager sections). It is a triage signal, not a
- *    semantic-search replacement.
- *  - Provider errors propagate verbatim — the caller is responsible
- *    for translating them into a friction comment or operator-visible
- *    failure.
+ *  - Prefer `provider.searchIssues` to narrow open Stories server-side
+ *    (`label:"type::story" state:open` + top seed tokens), capped at
+ *    ~100 hits, then rank that set. Fall back to `listIssuesByLabel`
+ *    when search errors or is unavailable (same try/catch pattern as
+ *    `TicketGateway.getTickets`).
+ *  - Scoring is intentionally simple (token Jaccard over title + body).
+ *    It is a triage signal, not a semantic-search replacement.
+ *  - Provider errors on the list fallback propagate verbatim — the
+ *    caller is responsible for translating them into a friction comment
+ *    or operator-visible failure.
  */
 
+import { Logger } from './Logger.js';
+import { TYPE_LABELS } from './label-constants.js';
+
 const STOPWORDS = new Set([
   'a',
   'an',
@@ -75,6 +79,10 @@ const STOPWORDS = new Set([
 
 const DEFAULT_MIN_SCORE = 0.15;
 const DEFAULT_MAX_RESULTS = 5;
+/** How many seed tokens to pass as free-text search terms. */
+const DEFAULT_SEARCH_TOKEN_CAP = 8;
+/** Hard cap on search hits ranked client-side (~one Search API page). */
+const SEARCH_RESULT_CAP = 100;
 
 /**
  * Tokenize freeform text into a deduplicated set of meaningful words.
@@ -92,6 +100,33 @@ export function tokenize(text) {
   return new Set(tokens);
 }
 
+/**
+ * Pick the highest-signal seed tokens for a Search API free-text query.
+ * Longer tokens first (specificity proxy), then alphabetical for stability.
+ *
+ * @param {string} seed
+ * @param {number} [maxTokens]
+ * @returns {string[]}
+ */
+export function pickSearchTokens(seed, maxTokens = DEFAULT_SEARCH_TOKEN_CAP) {
+  const tokens = tokenize(seed);
+  return [...tokens]
+    .sort((a, b) => b.length - a.length || a.localeCompare(b))
+    .slice(0, maxTokens);
+}
+
+/**
+ * Build the `/search/issues` query for open Stories overlapping a seed.
+ * Repo scoping is left to `provider.searchIssues`.
+ *
+ * @param {string} seed
+ * @returns {string}
+ */
+export function buildOpenStorySearchQuery(seed) {
+  const tokens = pickSearchTokens(seed);
+  return [`label:"${TYPE_LABELS.STORY}"`, 'state:open', ...tokens].join(' ');
+}
+
 /**
  * Compute the Jaccard overlap between two token sets.
  *
@@ -108,14 +143,14 @@ export function overlapScore(a, b) {
 }
 
 /**
- * Build the Epic URL for an issue id. The candidate exposes the URL so
- * the HITL pause can render clickable links without a second round-trip.
+ * Build the issue URL for an id. The candidate exposes the URL so the
+ * HITL pause can render clickable links without a second round-trip.
  *
  * @param {number|string} id
  * @param {{ owner?: string, repo?: string }} [opts]
  * @returns {string}
  */
-function buildEpicUrl(id, opts = {}) {
+function buildIssueUrl(id, opts = {}) {
   const owner = opts.owner || process.env.GITHUB_OWNER;
   const repo = opts.repo || process.env.GITHUB_REPO;
   if (owner && repo) {
@@ -125,54 +160,72 @@ function buildEpicUrl(id, opts = {}) {
 }
 
 /**
- * Find open Epics whose title + body overlap with the supplied
- * one-pager above a configurable threshold.
+ * Normalize a provider issue (list or search hit) into the ranking shape.
+ *
+ * @param {object} issue
+ * @returns {{ id: number, title: string, body: string, url?: string }}
+ */
+function normalizeIssue(issue) {
+  return {
+    id: Number(issue.number ?? issue.id),
+    title: issue.title ?? '',
+    body: issue.body ?? '',
+    url: issue.html_url ?? issue.url ?? undefined,
+  };
+}
+
+/**
+ * Rank a pre-fetched open-Story list against a seed corpus.
+ * Pure helper shared by the provider-backed search and tests.
  *
  * @param {{
- *   onePager: string,
- *   provider: import('./ITicketingProvider.js').ITicketingProvider,
+ *   seed: string,
+ *   openStories: Array<{ id:number, title?:string, body?:string, url?:string }>,
  *   minScore?: number,
  *   maxResults?: number,
  *   owner?: string,
  *   repo?: string,
+ *   excludeIds?: Iterable<number|string>,
  * }} args
- * @returns {Promise<Array<{ id: number, title: string, score: number, url: string }>>}
+ * @returns {Array<{ id: number, title: string, score: number, url: string }>}
  */
-export async function findSimilarOpenEpics({
-  onePager,
-  provider,
+export function rankOpenStoryDuplicates({
+  seed,
+  openStories,
   minScore = DEFAULT_MIN_SCORE,
   maxResults = DEFAULT_MAX_RESULTS,
   owner,
   repo,
+  excludeIds = [],
 }) {
-  if (!onePager || typeof onePager !== 'string') {
-    throw new Error(
-      'findSimilarOpenEpics: onePager must be a non-empty string',
-    );
+  if (!seed || typeof seed !== 'string') {
+    throw new Error('rankOpenStoryDuplicates: seed must be a non-empty string');
   }
-  if (!provider || typeof provider.getEpics !== 'function') {
-    throw new Error('findSimilarOpenEpics: provider must implement getEpics()');
+  if (!Array.isArray(openStories)) {
+    throw new Error('rankOpenStoryDuplicates: openStories must be an array');
   }
 
-  const seedTokens = tokenize(onePager);
+  const seedTokens = tokenize(seed);
   if (seedTokens.size === 0) return [];
 
-  // Provider errors propagate verbatim — caller decides how to surface.
-  const epics = await provider.getEpics({ state: 'open' });
-  if (!Array.isArray(epics) || epics.length === 0) return [];
+  const excluded = new Set(
+    [...excludeIds].map((id) => Number(id)).filter((n) => Number.isFinite(n)),
+  );
 
   const ranked = [];
-  for (const epic of epics) {
-    const corpus = `${epic.title || ''}\n${epic.body || ''}`;
+  for (const story of openStories) {
+    const id = Number(story?.id ?? story?.number);
+    if (!Number.isFinite(id) || excluded.has(id)) continue;
+    const title = story.title || '';
+    const corpus = `${title}\n${story.body || ''}`;
     const candidateTokens = tokenize(corpus);
     const score = overlapScore(seedTokens, candidateTokens);
     if (score >= minScore) {
       ranked.push({
-        id: epic.id,
-        title: epic.title,
+        id,
+        title,
         score: Number(score.toFixed(4)),
-        url: buildEpicUrl(epic.id, { owner, repo }),
+        url: story.url || buildIssueUrl(id, { owner, repo }),
       });
     }
   }
@@ -181,9 +234,126 @@ export async function findSimilarOpenEpics({
   return ranked.slice(0, maxResults);
 }
 
+/**
+ * Server-narrowed open-Story fetch via `/search/issues`.
+ *
+ * @param {object} provider
+ * @param {string} seed
+ * @returns {Promise<Array<{ id:number, title:string, body:string, url?:string }>>}
+ */
+async function fetchOpenStoriesViaSearch(provider, seed) {
+  const query = buildOpenStorySearchQuery(seed);
+  const hits = await provider.searchIssues({ query });
+  if (!Array.isArray(hits)) return [];
+  return hits.slice(0, SEARCH_RESULT_CAP).map(normalizeIssue);
+}
+
+/**
+ * Full open-Story backlog via label listing (fallback path).
+ *
+ * @param {object} provider
+ * @returns {Promise<Array<{ id:number, title:string, body:string, url?:string }>>}
+ */
+async function fetchOpenStoriesViaList(provider) {
+  if (typeof provider.listIssuesByLabel !== 'function') {
+    throw new Error(
+      'findSimilarOpenStories: provider must implement listIssuesByLabel()',
+    );
+  }
+  const issues = await provider.listIssuesByLabel({
+    state: 'open',
+    labels: TYPE_LABELS.STORY,
+  });
+  if (!Array.isArray(issues)) return [];
+  return issues.map(normalizeIssue);
+}
+
+/**
+ * Fetch open-Story candidates: prefer Search API narrowing, fall back to
+ * `listIssuesByLabel` when search errors or is unavailable.
+ *
+ * @param {object} provider
+ * @param {string} seed
+ * @returns {Promise<Array<{ id:number, title:string, body:string, url?:string }>>}
+ */
+async function fetchOpenStoryCandidates(provider, seed) {
+  if (!provider || typeof provider !== 'object') {
+    throw new Error('findSimilarOpenStories: provider is required');
+  }
+
+  const hasSearch = typeof provider.searchIssues === 'function';
+  const hasList = typeof provider.listIssuesByLabel === 'function';
+  if (!hasSearch && !hasList) {
+    throw new Error(
+      'findSimilarOpenStories: provider must implement searchIssues() or listIssuesByLabel()',
+    );
+  }
+
+  if (hasSearch) {
+    try {
+      return await fetchOpenStoriesViaSearch(provider, seed);
+    } catch (err) {
+      if (!hasList) throw err;
+      const msg = typeof err?.message === 'string' ? err.message : String(err);
+      Logger.warn(
+        `[duplicate-search] search-based candidate fetch failed (${msg}); ` +
+          'falling back to listIssuesByLabel',
+      );
+    }
+  }
+
+  return fetchOpenStoriesViaList(provider);
+}
+
+/**
+ * Find open Stories whose title + body overlap with the supplied seed
+ * above a configurable threshold.
+ *
+ * @param {{
+ *   seed: string,
+ *   provider: import('./ITicketingProvider.js').ITicketingProvider,
+ *   minScore?: number,
+ *   maxResults?: number,
+ *   owner?: string,
+ *   repo?: string,
+ *   excludeIds?: Iterable<number|string>,
+ * }} args
+ * @returns {Promise<Array<{ id: number, title: string, score: number, url: string }>>}
+ */
+export async function findSimilarOpenStories({
+  seed,
+  provider,
+  minScore = DEFAULT_MIN_SCORE,
+  maxResults = DEFAULT_MAX_RESULTS,
+  owner,
+  repo,
+  excludeIds = [],
+}) {
+  if (!seed || typeof seed !== 'string') {
+    throw new Error('findSimilarOpenStories: seed must be a non-empty string');
+  }
+
+  // Avoid a network round-trip when the seed cannot produce a score.
+  if (tokenize(seed).size === 0) return [];
+
+  const openStories = await fetchOpenStoryCandidates(provider, seed);
+  return rankOpenStoryDuplicates({
+    seed,
+    openStories,
+    minScore,
+    maxResults,
+    owner,
+    repo,
+    excludeIds,
+  });
+}
+
 export const __test = {
   STOPWORDS,
   DEFAULT_MIN_SCORE,
   DEFAULT_MAX_RESULTS,
-  buildEpicUrl,
+  DEFAULT_SEARCH_TOKEN_CAP,
+  SEARCH_RESULT_CAP,
+  buildIssueUrl,
+  buildEpicUrl: buildIssueUrl,
 };

package/.agents/scripts/lib/feedback-loop/retro-proposals-graduator.js

@@ -30,8 +30,8 @@
  * failure path is captured in `errors[]`.
  */
 
+import { DEFAULT_FRAMEWORK_REPO } from '../github/framework-repo.js';
 import { META_LABELS } from '../label-constants.js';
-import { DEFAULT_FRAMEWORK_REPO } from '../orchestration/retro/phases/gather-signals.js';
 import {
   contentFingerprint,
   DEFAULT_MAX_FILINGS_PER_RUN,

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

@@ -6,7 +6,7 @@
  * 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 `/plan`)
- * for a tight, one-deliverable cluster, or an Epic (via `/plan --idea`) for
+ * for a tight, one-deliverable cluster, or an Epic (via `/plan --seed`) 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.
@@ -40,7 +40,7 @@ export const PROMOTION_TARGETS = Object.freeze({
 
 /**
  * A cluster of more than this many distinct coverage surfaces is broad enough
- * to warrant an Epic (`/plan --idea`) rather than a single Story
+ * to warrant an Epic (`/plan --seed`) rather than a single Story
  * (`/plan`). One or two surfaces is a tight, single-deliverable cluster.
  */
 const EPIC_COVERAGE_THRESHOLD = 2;
@@ -159,7 +159,7 @@ 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 (`/plan --idea`); otherwise it is a single-deliverable
+ * warrant an Epic (`/plan --seed`); otherwise it is a single-deliverable
  * Story (`/plan`).
  *
  * @param {{ coverages: string[] }} cluster
@@ -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` (`/plan`) or `createEpic` (`/plan --idea`) port,
+ *      `createStory` (`/plan`) or `createEpic` (`/plan --seed`) 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
@@ -252,7 +252,7 @@ function routedToLink(issue, kind) {
  * @param {(cluster: object) => Promise<{ number: number, url?: string }>} ports.createStory
  *   Opens a single Story (`/plan`) for a tight cluster.
  * @param {(cluster: object) => Promise<{ number: number, url?: string }>} ports.createEpic
- *   Opens an Epic (`/plan --idea`) for a broad cluster.
+ *   Opens an Epic (`/plan --seed`) for a broad cluster.
  * @returns {Promise<{
  *   promotions: Array<{
  *     clusterKey: string,

package/.agents/scripts/lib/framework-version.js

@@ -8,9 +8,8 @@
  * 1. **Version resolution.** Under npm distribution the root `package.json`
  *    is the canonical version marker. {@link resolveFrameworkVersion} reads it
  *    and degrades to `'unknown'` (never throws) so a missing/unreadable
- *    manifest can never crash an authoring or hydration path. The private
- *    `getVersion()` in `lib/orchestration/context-hydration-engine.js`
- *    delegates here (DRY — one manifest reader).
+ *    manifest can never crash an authoring path. All ticket-body stamp
+ *    producers delegate here (DRY — one manifest reader).
  *
  * 2. **Ticket-body stamp.** Epics and Stories are stamped **once at authoring
  *    time** with the running version and the authoring date, via a hybrid

package/.agents/scripts/lib/git-branch-cleanup.js

@@ -2,7 +2,7 @@
  * git-branch-cleanup.js — Shared branch deletion helpers (local + remote).
  *
  * Consolidates the "delete this branch from local and/or origin" pattern
- * used by `story-close.js` and other branch-reaping flows. Originally
+ * used by `single-story-close.js` and other branch-reaping flows. Originally
  * carved out when more than one caller re-implemented the same idempotency
  * rules with subtle drift.
  *
@@ -117,15 +117,6 @@ export function deleteBranchEverywhere(name, opts = {}) {
   return { deleted: bothOk, reason, local, remote };
 }
 
-/**
- * Backwards-compatible alias for `deleteBranchEverywhere`. Older call
- * sites and tests imported this name; keeping the alias avoids touching
- * them in the migration.
- *
- * @deprecated prefer `deleteBranchEverywhere`.
- */
-export const deleteBranchBoth = deleteBranchEverywhere;
-
 /**
  * Delete N branches in a single batched git call (push --delete X Y Z, or
  * branch -D X Y Z), falling back to per-ref delete via

package/.agents/scripts/lib/git-branch-lifecycle.js

@@ -3,7 +3,8 @@
  *
  * Consolidates the "does this branch exist locally / remotely?" and
  * "ensure this branch exists and is checked out" logic that
- * `story-init.js` and `dispatch-engine.js` had each re-implemented.
+ * `single-story-init.js` centralizes (formerly duplicated across the deleted
+ * `story-init.js` and `dispatch-engine.js` entry seams).
  *
  * All helpers take an explicit `cwd`. Callers with worktree isolation
  * enabled pass the worktree path; single-tree callers pass `PROJECT_ROOT`.
@@ -87,18 +88,16 @@ export function branchExistsViaTrackingRef(branch, cwd) {
 
 /**
  * Pure: classify how a `story-<id>` branch should be seeded from the (local,
- * remote) ref-presence matrix. This is the single source of truth shared by
- * both story-init paths (Story #3513):
- *   - `single-story-init.js#decideStoryBranchSeed` (standalone path)
- *   - `story-init/branch-initializer.js#planStoryBranchSeed` (Epic path)
+ * remote) ref-presence matrix. This is the single source of truth for
+ * `single-story-init.js#decideStoryBranchSeed` (v2 `/deliver` path).
  *
- * Both call sites previously re-implemented the same `local → no-op, remote →
- * fetch, else create` decision tree; they now delegate here so the branching
- * logic lives in exactly one place. The two callers keep their own keyword for
+ * The init path previously re-implemented the same `local → no-op, remote →
+ * fetch, else create` decision tree; it now delegates here so the branching
+ * logic lives in exactly one place. The caller keeps its own keyword for
  * the "local ref already exists" outcome (`reuse` vs `none`) — synonyms for
- * "do not re-create / do not re-seed" preserved for their existing public/test
- * contracts — so this classifier returns the neutral `'local'` keyword and
- * each caller maps it onto its own vocabulary.
+ * "do not re-create / do not re-seed" preserved for its existing public/test
+ * contract — so this classifier returns the neutral `'local'` keyword and
+ * the caller maps it onto its own vocabulary.
  *
  * @param {{ localHas: boolean, remoteHas: boolean }} presence
  * @returns {'local'|'fetch'|'create'}
@@ -116,22 +115,18 @@ export function classifyBranchSeed({ localHas, remoteHas }) {
 
 /**
  * Single-home for the story-branch seed-action *switch shell* that
- * `single-story-init.js#seedStoryBranch` (standalone path) and
- * `story-init/branch-initializer.js#ensureStoryBranchSeed` (Epic path) had
- * each re-implemented (Story #4255). Both already delegated the (local,
- * remote) decision to `classifyBranchSeed`; only the act-on-the-decision
- * shell (reuse / fetch / create) was duplicated, and that shell was the
- * drift surface for the seed-decision contract.
+ * `single-story-init.js#seedStoryBranch` owns (Story #4255). The deleted
+ * Epic `story-init/branch-initializer.js` path had duplicated the same
+ * shell before v2 cutover.
  *
  * The two callers differ in exactly two behavioural axes, both of which are
  * parameters here — no other conditional branching is introduced:
- *   - **`baseRef`** — the ref to branch from on `create` (`main` for the
- *     standalone path, the Epic branch for the Epic path).
+ *   - **`baseRef`** — the ref to branch from on `create` (`main` for v2
+ *     `/deliver`; pre-v2 Epic close used the Epic branch).
  *   - **`swallowCreateRace`** — when `true`, a `git branch` that exits
  *     non-zero with an "already exists" stderr is treated as reuse rather
- *     than a fatal error (closes the probe→create race the Epic path runs
- *     under concurrent wave dispatch). When `false`, any create failure
- *     throws (the standalone path has no concurrent creator to race).
+ *     than a fatal error (pre-v2 concurrent wave dispatch). When `false`, any create failure
+ *     throws (the v2 standalone path has no concurrent creator to race).
  *
  * The asymmetric surrounding wrappers (merged-sweep, fast-forward,
  * donor-prime, workspace-verify, phase-timer) are deliberately NOT folded

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

@@ -43,6 +43,18 @@ import { execFileSync, spawnSync } from 'node:child_process';
 let _execFileSync = execFileSync;
 let _spawnSync = spawnSync;
 
+/**
+ * Memoized cleaned env shared by every `gitSync` / `gitSpawn` /
+ * `createGitInterface` invocation in this process. Built lazily on first
+ * use so cold imports pay nothing. Call sites pass the object through to
+ * `child_process` only — none mutate `GIT_*` (or any other key) between
+ * git calls, so reuse is safe. Tests that mutate `process.env` and need
+ * a fresh snapshot must call {@link __resetCleanGitEnv}.
+ *
+ * @type {NodeJS.ProcessEnv | null}
+ */
+let _cleanGitEnv = null;
+
 /**
  * Build a child-process env that drops every `GIT_*` variable inherited from
  * the parent. When this module's helpers run inside a git hook (e.g. husky
@@ -53,13 +65,28 @@ let _spawnSync = spawnSync;
  * that spin up real git fixtures break reproducibly under that shape.
  *
  * Stripping every `GIT_*` is broader than strictly necessary but cheap and
- * impossible to drift out of sync with future git releases. Author/committer
- * identity is restored via per-call `env:` overrides where required.
+ * impossible to drift out of sync with future git releases. The result is
+ * memoized per process (see `_cleanGitEnv`); author/committer identity is
+ * restored via per-call `env:` overrides where required.
+ *
+ * @returns {NodeJS.ProcessEnv}
  */
 function cleanGitEnv() {
-  return Object.fromEntries(
-    Object.entries(process.env).filter(([k]) => !k.startsWith('GIT_')),
+  if (_cleanGitEnv) return _cleanGitEnv;
+  _cleanGitEnv = Object.freeze(
+    Object.fromEntries(
+      Object.entries(process.env).filter(([k]) => !k.startsWith('GIT_')),
+    ),
   );
+  return _cleanGitEnv;
+}
+
+/**
+ * Drop the memoized cleaned env so the next git call rebuilds from
+ * `process.env`. Testing-only seam — not part of the stable API.
+ */
+export function __resetCleanGitEnv() {
+  _cleanGitEnv = null;
 }
 
 /**
@@ -321,11 +348,10 @@ export function slugify(text) {
 /**
  * Resolves the canonical branch name for a Story.
  * v5 Standard: story-[STORY_ID]
- * @param {string|number} _epicId - Unused; retained for back-compat call sites.
  * @param {string|number} storyId
  * @returns {string}
  */
-export function getStoryBranch(_epicId, storyId) {
+export function getStoryBranch(storyId) {
   const id =
     typeof storyId === 'number' ? storyId : Number.parseInt(storyId, 10);
   if (!Number.isFinite(id) || id <= 0) {

package/.agents/scripts/lib/github/framework-repo.js

@@ -0,0 +1,6 @@
+/**
+ * Canonical framework repository slug used by follow-up / graduator
+ * paths when the consumer config does not supply owner/repo.
+ */
+
+export const DEFAULT_FRAMEWORK_REPO = 'dsj1984/mandrel';

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

@@ -1,8 +1,8 @@
 /**
  * Central source of truth for all GitHub label names used by the orchestrator.
  *
- * Every other module (label-taxonomy, dispatch-engine, story-close,
- * etc.) should import from here rather than using string literals. Renames
+ * Every other module (label-taxonomy, single-story-close.js,
+ * stories-wave-tick.js, etc.) should import from here rather than using string literals. Renames
  * land in one place.
  */
 
@@ -10,12 +10,12 @@ export const AGENT_LABELS = {
   REVIEW_SPEC: 'agent::review-spec',
   READY: 'agent::ready',
   EXECUTING: 'agent::executing',
-  // Story #2144 — intermediate state owned by `story-close.js`. A Story
+  // Story #2144 — intermediate state owned by `single-story-close.js`. A Story
   // flips to `agent::closing` after preflight validation succeeds and
-  // before the merge into `epic/<id>` is attempted. It flips to
-  // `agent::done` only after the post-merge pipeline confirms the merge
+  // the Story PR is opened against `main`. It flips to
+  // `agent::done` only after the close pipeline confirms the PR merge
   // landed; if the close is killed mid-flight, the Story remains at
-  // `agent::closing` so a `/story-execute --resume` can pick up at the
+  // `agent::closing` so `/deliver` can pick up at the
   // post-merge phase rather than re-running preflight. The label is the
   // distinguishing signal between "hung close" and "finished work".
   CLOSING: 'agent::closing',
@@ -75,7 +75,6 @@ export function isValidTransition(fromState, toState) {
 }
 
 export const TYPE_LABELS = {
-  EPIC: 'type::epic',
   STORY: 'type::story',
 };
 
@@ -83,14 +82,6 @@ export const STATUS_LABELS = {
   BLOCKED: 'status::blocked',
 };
 
-/**
- * Persona labels are derived at bootstrap time from `.agents/personas/*.md`
- * (see `label-taxonomy.js`), not hard-coded here — the persona file is the
- * source of truth, and ticket hydration resolves the label value to the
- * matching filename.
- */
-export const PERSONA_LABEL_PREFIX = 'persona::';
-
 /**
  * Acceptance-axis labels for opt-out signalling on Epics that
  * intentionally have no acceptance-table coverage. (Story #4324 retired
@@ -122,13 +113,10 @@ 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 inline post-plan readiness
- * healthcheck (`runPlanHealthcheck`). The persist surface
- * (`plan-persist.js`) refuses to flip an Epic to `agent::ready`
- * when the healthcheck returned `ok: false` unless this label is
- * present — see `.agents/docs/SDLC.md` § "`agent::ready` exit conditions"
- * for the full handoff contract.
+ * `planning::healthcheck-waived` operator-applied waiver — a historical
+ * escape hatch for the retired post-plan readiness healthcheck. The
+ * label remains in the taxonomy for tickets that still carry it; the
+ * healthcheck CLI itself was deleted in the v2 epic-scripts sweep.
  *
  * Future planning-axis waivers (one per failing exit condition) extend
  * this enum so consumers can reference them by symbol.
@@ -166,7 +154,6 @@ export const LABEL_COLORS = {
   TYPE: '#7057FF',
   AGENT: '#0E8A16',
   STATUS_BLOCKED: '#D93F0B',
-  PERSONA: '#C5DEF5',
   ACCEPTANCE: '#FBCA04',
   PLANNING: '#FEF2C0',
   DELIVERY: '#BFD4F2',