mandrel 2.0.0 → 2.1.0

package/.agents/scripts/lib/signals/index.js

@@ -10,8 +10,8 @@
  *     + `schema`; `buildSpanTree` was a throwing placeholder.
  *   - Epic #1181 / Story #1440 / Task #1461 — placeholder replaced by
  *     the real export from `./span-tree.js`.
- *   - Story #1476 — `appendSignal` / `appendTrace` / `appendEpicSignal`
- *     re-exported here via `./write.js` so the gate scripts (and any
+ *   - Story #1476 — `appendSignal` / `appendTrace` re-exported here
+ *     via `./write.js` so the gate scripts (and any
  *     new code) converge on `lib/signals/` instead of importing the
  *     writer directly from `lib/observability/`.
  *
@@ -21,19 +21,6 @@
 import { read } from './read.js';
 import * as schema from './schema.js';
 import { buildSpanTree } from './span-tree.js';
-import {
-  appendEpicSignal,
-  appendSignal,
-  appendTrace,
-  forEachLine,
-} from './write.js';
+import { appendSignal, appendTrace, forEachLine } from './write.js';
 
-export {
-  appendEpicSignal,
-  appendSignal,
-  appendTrace,
-  buildSpanTree,
-  forEachLine,
-  read,
-  schema,
-};
+export { appendSignal, appendTrace, buildSpanTree, forEachLine, read, schema };

package/.agents/scripts/lib/signals/read.js

@@ -1,18 +1,18 @@
 /**
  * Streaming signals reader (Epic #1181 / Story #1438 / Task #1459).
  *
- * Provides one async-iterator entry point — `read({ epic, story?, kind?,
+ * Provides one async-iterator entry point — `read({ run, story?, kind?,
  * config? })` — that consumers use instead of opening the NDJSON file
  * themselves. The reader streams line-by-line so callers never load the
  * full file into memory (50MB+ traces stay under file size in RSS).
  *
  * On-disk layout (resolved via `lib/config/temp-paths.js`):
  *
- *   <tempRoot>/epic-<epic>/story-<story>/signals.ndjson
+ *   <tempRoot>/run-<run>/story-<story>/signals.ndjson
  *
  * When `story` is omitted, the reader fans out across every
- * `story-<id>/signals.ndjson` under `<tempRoot>/epic-<epic>/`. When the
- * Epic directory is missing, the iterator yields nothing (consumers
+ * `story-<id>/signals.ndjson` under `<tempRoot>/run-<run>/`. When the
+ * run directory is missing, the iterator yields nothing (consumers
  * treat absence as "no signals yet").
  *
  * ## Filter semantics
@@ -21,7 +21,7 @@
  *     argument are yielded. Filtering happens after the per-line JSON
  *     parse + envelope guard (see `lib/signals/schema.js`).
  *   - `story` — narrows to a single Story's stream; otherwise we walk
- *     every Story directory under the Epic.
+ *     every Story directory under the run.
  *
  * ## Warn-once policy (AC #3)
  *
@@ -46,8 +46,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createInterface } from 'node:readline';
 import {
-  epicArtifactPath,
-  epicTempDir,
+  runArtifactPath,
+  runTempDir,
   signalsFile,
   storyTempDir,
 } from '../config/temp-paths.js';
@@ -145,43 +145,43 @@ async function* streamFile(target, kindFilter) {
 }
 
 /**
- * List every `stories/story-<id>/signals.ndjson` path under the Epic's
- * `<tempRoot>/epic-<epic>/` directory. Returns an empty array when the
- * Epic directory is missing.
+ * List every `stories/story-<id>/signals.ndjson` path under the run's
+ * `<tempRoot>/run-<run>/` directory. Returns an empty array when the
+ * run directory is missing.
  *
  * The returned paths are sorted by Story ID ascending so the iterator's
  * output is stable across runs.
  *
  * Story #2940 nested per-Story directories under a `stories/` segment.
- * Epic-level signals continue to live at the Epic root.
+ * Run-level signals continue to live at the run root.
  *
- * @param {number} epic
+ * @param {number} run
  * @param {object | undefined} config
  * @returns {Promise<string[]>}
  */
-async function listEpicStorySignalsFiles(epic, config) {
-  const epicDir = epicTempDir(epic, config);
-  let epicEntries;
+async function listRunStorySignalsFiles(run, config) {
+  const runDir = runTempDir(run, config);
+  let runEntries;
   try {
-    epicEntries = await fs.readdir(epicDir, { withFileTypes: true });
+    runEntries = await fs.readdir(runDir, { withFileTypes: true });
   } catch {
     return [];
   }
-  let hasEpicLevelSignals = false;
+  let hasRunLevelSignals = false;
   let hasStoriesDir = false;
-  for (const ent of epicEntries) {
+  for (const ent of runEntries) {
     if (ent.isDirectory() && ent.name === 'stories') {
       hasStoriesDir = true;
     } else if (ent.isFile() && ent.name === 'signals.ndjson') {
       // Story #1430 — wave-runner lifecycle signals land here.
-      hasEpicLevelSignals = true;
+      hasRunLevelSignals = true;
     }
   }
   const storyIds = [];
   if (hasStoriesDir) {
     let storyEntries;
     try {
-      storyEntries = await fs.readdir(path.join(epicDir, 'stories'), {
+      storyEntries = await fs.readdir(path.join(runDir, 'stories'), {
         withFileTypes: true,
       });
     } catch {
@@ -195,43 +195,43 @@ async function listEpicStorySignalsFiles(epic, config) {
     }
   }
   storyIds.sort((a, b) => a - b);
-  // Yield epic-level signals first (wave-start precedes per-Story friction),
+  // Yield run-level signals first (wave-start precedes per-Story friction),
   // then walk the per-Story streams in ascending ID order.
-  const targets = hasEpicLevelSignals
-    ? [epicArtifactPath(epic, 'signals.ndjson', config)]
+  const targets = hasRunLevelSignals
+    ? [runArtifactPath(run, 'signals.ndjson', config)]
     : [];
   for (const sid of storyIds) {
-    targets.push(path.join(storyTempDir(epic, sid, config), 'signals.ndjson'));
+    targets.push(path.join(storyTempDir(run, sid, config), 'signals.ndjson'));
   }
   return targets;
 }
 
 /**
- * Stream every event matching `{ epic, story?, kind? }` from the
- * configured `tempRoot`'s `epic-<epic>/[story-<story>/]signals.ndjson`
+ * Stream every event matching `{ run, story?, kind? }` from the
+ * configured `tempRoot`'s `run-<run>/[story-<story>/]signals.ndjson`
  * file(s).
  *
  * Returns an async iterable so callers can `for await` over it without
  * buffering. The reader is **streaming** — peak memory stays below the
  * file size for any input.
  *
- * @param {{ epic: number, story?: number, kind?: string, config?: object }} args
+ * @param {{ run: number, story?: number, kind?: string, config?: object }} args
  * @returns {AsyncGenerator<object>}
  *
  * @example
- *   for await (const evt of read({ epic: 1181 })) { ... }
- *   for await (const evt of read({ epic: 1181, story: 1438, kind: 'friction' })) { ... }
+ *   for await (const evt of read({ run: 1181 })) { ... }
+ *   for await (const evt of read({ run: 1181, story: 1438, kind: 'friction' })) { ... }
  */
 export async function* read(args) {
   if (args == null || typeof args !== 'object') {
     throw new TypeError(
-      `signals/read: args must be an object with at minimum { epic }; got ${args}`,
+      `signals/read: args must be an object with at minimum { run }; got ${args}`,
     );
   }
-  const { epic, story, kind, config } = args;
-  if (!isPositiveInt(epic)) {
+  const { run, story, kind, config } = args;
+  if (!isPositiveInt(run)) {
     throw new RangeError(
-      `signals/read: epic must be a positive integer (got ${epic})`,
+      `signals/read: run must be a positive integer (got ${run})`,
     );
   }
   if (story !== undefined && !isPositiveInt(story)) {
@@ -259,8 +259,8 @@ export async function* read(args) {
   const kindFilter = kind ?? null;
   const targets =
     story !== undefined
-      ? [signalsFile(epic, story, config)]
-      : await listEpicStorySignalsFiles(epic, config);
+      ? [signalsFile(run, story, config)]
+      : await listRunStorySignalsFiles(run, config);
 
   for (const target of targets) {
     yield* streamFile(target, kindFilter);

package/.agents/scripts/lib/signals/schema.js

@@ -3,7 +3,7 @@
  * shape guards (Epic #1181 / Story #1438 / Task #1458).
  *
  * Both writers (`lib/observability/signals-writer.js` callers) and
- * readers (`lib/signals/read.js`, `lib/observability/perf-aggregator.js`)
+ * readers (`lib/signals/read.js`, the retro's gather-signals phase)
  * import their field names from this module so the on-disk NDJSON shape
  * stays under one schema.
  *
@@ -19,15 +19,12 @@
  *
  * Signals-writer `appendSignal` call sites:
  *   - `friction`       — quality-gate / runtime friction (diagnose-friction.js,
- *                        lib/gates/friction.js, auto-refresh-runner.js,
- *                        worktree-reap.js, lifecycle-emit.js)
+ *                        lib/gates/friction.js)
  *   - `acceptance-eval` — acceptance-eval.js per-criterion terminus signal.
- *   - `wave-start` / `wave-complete` — `lib/wave-runner/tick.js` (read by
- *                        perf-aggregator's `waveParallelism` report;
- *                        `wave-start` also anchors span-tree Story spans)
+ *   - `wave-start` / `wave-complete` — wave-window anchors; `wave-start` also
+ *                        anchors span-tree Story spans
  *   - `wave-end`       — span-tree pairing anchor (retained for span-tree)
- *   - `state-transition` — notification-derived window anchor read by the
- *                        waveParallelism bucketer.
+ *   - `state-transition` — notification-derived window anchor.
  *
  * The `dispatched` kind was deleted in the Epic #4406 signal-contract
  * cutover — it had no live emitter and no consumer.
@@ -80,9 +77,9 @@ export const EVENT_KINDS = Object.freeze({
   FRICTION: 'friction',
   TRACE: 'trace',
   // Wave-window forensics signals: `wave-start` / `wave-end` anchor the
-  // span-tree's Story spans, and the perf-aggregator brackets each wave's
-  // wall-clock from `wave-start` → `wave-complete` (the `waveParallelism`
-  // report). These are READ — they survive.
+  // span-tree's Story spans. Story #4545 deleted the `waveParallelism`
+  // consumer (perf-aggregator) with the execution-analysis surface; these
+  // kinds stay as the span-tree's anchors.
   WAVE_START: 'wave-start',
   WAVE_END: 'wave-end',
   WAVE_COMPLETE: 'wave-complete',

package/.agents/scripts/lib/signals/span-tree.js

@@ -192,15 +192,15 @@ function bootstrapStoryWindow(storyNode, ts) {
  * from `buildSpanTree` so the outer function's CRAP score stays under
  * the new-method ceiling.
  *
- * @param {object} state — mutable accumulator (stories, tasksByStory, epic)
+ * @param {object} state — mutable accumulator (stories, tasksByStory, run)
  * @param {unknown} evt
  * @returns {void}
  */
 function ingestEvent(state, evt) {
   if (evt == null || typeof evt !== 'object') return;
 
-  const eEpic = epicOf(evt);
-  if (state.epic == null && eEpic != null) state.epic = eEpic;
+  const eRun = epicOf(evt);
+  if (state.run == null && eRun != null) state.run = eRun;
 
   const ts = tsOf(evt);
   const sid = storyOf(evt);
@@ -258,11 +258,11 @@ function finalizeStory(state, story) {
  * Build the span tree from an async iterable of signal events.
  *
  * @param {AsyncIterable<object> | Iterable<object>} iter
- * @returns {Promise<{ epic: number | null, stories: Array<object> }>}
+ * @returns {Promise<{ run: number | null, stories: Array<object> }>}
  *
  * @example
  *   import { read, buildSpanTree } from './lib/signals/index.js';
- *   const tree = await buildSpanTree(read({ epic: 1181 }));
+ *   const tree = await buildSpanTree(read({ run: 1181 }));
  */
 export async function buildSpanTree(iter) {
   if (iter == null || typeof iter !== 'object') {
@@ -274,7 +274,7 @@ export async function buildSpanTree(iter) {
   // Accumulator state. `stories` keys are `storyKeyOf(sid)` strings;
   // `tasksByStory` mirrors that and holds per-task sub-maps.
   const state = {
-    epic: null,
+    run: null,
     stories: new Map(),
     tasksByStory: new Map(),
   };
@@ -287,5 +287,5 @@ export async function buildSpanTree(iter) {
   storyEntries.sort(compareNodeIds);
   for (const story of storyEntries) finalizeStory(state, story);
 
-  return { epic: state.epic, stories: storyEntries };
+  return { run: state.run, stories: storyEntries };
 }

package/.agents/scripts/lib/signals/write.js

@@ -12,7 +12,6 @@
  */
 
 export {
-  appendEpicSignal,
   appendSignal,
   appendTrace,
   forEachLine,

package/.agents/scripts/lib/single-story/story-merged-notify.js

@@ -41,7 +41,13 @@ export async function flipLabelAndNotify({
   config,
   progress,
 }) {
-  const labelFlipped = await flipLabel(provider, storyId, story, progress);
+  const labelFlipped = await flipLabel(
+    provider,
+    storyId,
+    story,
+    progress,
+    config,
+  );
   if (!labelFlipped) return;
   await fireStoryClosingNotify({
     notifyFn: notifyFn ?? defaultNotify,
@@ -55,7 +61,7 @@ export async function flipLabelAndNotify({
   });
 }
 
-async function flipLabel(provider, storyId, story, progress) {
+async function flipLabel(provider, storyId, story, progress, config) {
   try {
     // Story #3385 — flip to `agent::closing`, NOT `agent::done`. The
     // canonical mutator (`transitionTicketState`) only closes the GitHub
@@ -81,8 +87,13 @@ async function flipLabel(provider, storyId, story, progress) {
     // notification that `transitionTicketState` would dispatch is
     // redundant with the typed `story-closing` event that
     // `fireStoryClosingNotify` emits immediately afterwards.
+    //
+    // `config` is threaded so the on-disk board-metadata cache (issue #4555)
+    // lands under the project's configured `tempRoot` rather than the
+    // framework default, matching every other transition call site.
     await transitionTicketState(provider, storyId, STATE_LABELS.CLOSING, {
       ticketSnapshot: story,
+      config,
     });
     progress?.('LABELS', `🏷️  Story #${storyId} → agent::closing`);
     return true;

package/.agents/scripts/lib/skills/parse-skill.js

@@ -30,6 +30,8 @@ const FRONTMATTER_DELIMITER = '---';
 const POLICY_HEADING_RE = /^## Policy Capsule\s*$/;
 const ANY_H2_RE = /^## /;
 const BULLET_RE = /^- /;
+/** An indented (wrapped) continuation of the bullet above it. */
+const CONTINUATION_RE = /^\s+\S/;
 
 /**
  * Repo root resolver. Walks up from the SKILL.md path until we find a
@@ -85,8 +87,14 @@ function extractFrontmatterBlock(lines, skillPath) {
 /**
  * Scan the body for the '## Policy Capsule' heading and count contiguous
  * top-level '- ' bullets that follow it, stopping at the next '## ' heading
- * or end-of-file. Blank lines inside the bullet run do not reset the count;
- * a non-bullet, non-blank line does.
+ * or end-of-file. Blank lines inside the bullet run do not reset the count.
+ *
+ * An **indented** continuation line belongs to the bullet above it — capsule
+ * bullets routinely wrap at the document's prose width — so it neither counts
+ * as a new bullet nor terminates the run. Only a **flush-left**, non-blank,
+ * non-bullet line after the run terminates it (Story #4546: treating any
+ * non-bullet line as a terminator counted a wrapped 5-bullet capsule as 1 and
+ * tripped the floor in validate-skills.js).
  */
 function findPolicyCapsule(lines, bodyStart) {
   let headingIndex = -1;
@@ -114,8 +122,13 @@ function findPolicyCapsule(lines, bodyStart) {
       // Blank lines inside or before the bullet run are tolerated.
       continue;
     }
+    if (sawBulletRun && CONTINUATION_RE.test(line)) {
+      // Indented continuation of the bullet above — same bullet, not a
+      // terminator. Wrapped capsule bullets are the norm, not an error.
+      continue;
+    }
     if (sawBulletRun) {
-      // Non-blank, non-bullet line after the bullet run terminates it.
+      // Flush-left, non-blank, non-bullet line after the run terminates it.
       break;
     }
     // Leading prose between heading and the first bullet is allowed.

package/.agents/scripts/lib/story-adjacency.js

@@ -42,16 +42,17 @@ import { parseBlockedBy } from './dependency-parser.js';
  *   Story records (live ticket payloads, fixture tickets, or operator
  *   DAG nodes).
  * @param {object} [opts]
- * @param {boolean} [opts.dropForeign=true] When true (the default,
- *   matching pre-v2 Epic-scoped wrappers), edges pointing at ids outside
+ * @param {boolean} [opts.dropForeign=false] When `false` (the v2 default,
+ *   matching the `/deliver` path — `stories-wave-tick.js` and the
+ *   `selectReadySet` core), the operator-DAG contract is preserved: a
+ *   dependency on an id absent from the input is treated as not-yet-done
+ *   and withholds the dependent until it completes. When `true` (the
+ *   pre-v2 Epic-scoped-wrapper semantics), edges pointing at ids outside
  *   the supplied story set are dropped so the DAG stays closed over the
- *   scheduled set. The v2 `/deliver` path (`stories-wave-tick.js` and the
- *   `selectReadySet` core) passes `false` to preserve the operator-DAG
- *   contract, where a dependency on an id absent from the input is treated
- *   as not-yet-done and withholds the dependent until it completes.
+ *   scheduled set.
  * @returns {Map<number, number[]>}
  */
-export function buildStoryAdjacency(stories, { dropForeign = true } = {}) {
+export function buildStoryAdjacency(stories, { dropForeign = false } = {}) {
   const records = Array.isArray(stories) ? stories : [];
   const storyIds = new Set(records.map((s) => Number(s?.id ?? s?.number)));
   const adjacency = new Map();

package/.agents/scripts/lib/story-body/story-body.js

@@ -105,10 +105,9 @@ import { FILE_ASSUMPTION_VALUES } from '../orchestration/file-assumption-enum.js
 
 /**
  * @typedef {object} SerializeOptions
- * @property {boolean} [includeFooter=false] - Include `---\nparent/epic/blocked-by` footer.
+ * @property {boolean} [includeFooter=false] - Include `---\nparent/blocked-by` footer.
  * @property {object}  [footer]              - Footer fields when `includeFooter` is true.
  * @property {number}  [footer.parent]       - Parent feature issue number.
- * @property {number}  [footer.epic]         - Epic issue number.
  */
 
 // ---------------------------------------------------------------------------
@@ -967,8 +966,8 @@ function serializeAuthoredMarker(body) {
 }
 
 /**
- * Build the optional `---` footer block (`parent` / `Epic` / `blocked by`
- * lines). Returns the empty string when `opts.includeFooter` is falsy.
+ * Build the optional `---` footer block (`parent` / `blocked by` lines).
+ * Returns the empty string when `opts.includeFooter` is falsy.
  *
  * @param {StoryBody} body
  * @param {SerializeOptions} opts
@@ -978,7 +977,9 @@ function serializeFooter(body, opts) {
   if (!opts.includeFooter) return '';
   const footerLines = ['---'];
   if (opts.footer?.parent) footerLines.push(`parent: #${opts.footer.parent}`);
-  if (opts.footer?.epic) footerLines.push(`Epic: #${opts.footer.epic}`);
+  // Story #4545 — no `Epic: #N` branch. `pr-base-guard.js` hard-refuses a
+  // Story body carrying that footer, so composing one here would let the
+  // framework generate work it would then reject at delivery.
   if (Array.isArray(body.depends_on)) {
     for (const dep of body.depends_on) {
       footerLines.push(`blocked by ${dep}`);

package/.agents/scripts/lib/templates/decomposer-prompts.js

@@ -82,7 +82,9 @@ Your job is to turn a plan seed / Tech Spec into a Story ticket array for an AI
    - Thematic grouping is prose in the Story's folded \`## Spec\` / \`## Slicing\`, never sibling tickets for coupled work.
 
 ### LABEL CONVENTIONS:
-- Every ticket must have the \`type::story\` label. No other type label is allowed — the retired Feature and Task tiers have no labels under this hierarchy.
+- \`type::story\` is applied automatically by persist — you do not need to emit it, and no other type label is allowed (the retired Feature and Task tiers have no labels under this hierarchy).
+- \`labels[]\` is **optional**. Emit it only to request an *additional* label; persist sanitizes the list before applying it.
+- Do **not** emit \`agent::*\` labels — lifecycle state is runtime-owned, and persist applies \`agent::ready\` itself once every checkpoint is on the ticket.
 - Do **not** emit \`persona::*\` labels — the behavioral persona concept (and its label axis) was removed in v2.
 
 ### OUTPUT FORMAT:
@@ -97,7 +99,7 @@ You MUST respond ONLY with a valid JSON array of objects. No prose, no markdown
     "body": <string — see STORY BODY SCHEMA below>,
     "acceptance": ["<testable, observable criterion>", ...],
     "verify": ["<exact command or test path> (<tier>)", ...],
-    "labels": ["type::story"],
+    "labels": ["<extra-label>"] (optional — type::story is applied automatically; omit this field unless you need an additional label),
     "depends_on": ["slug-of-blocking-dependency"] (optional array of Story slugs that block execution)
   }
 ]
@@ -107,7 +109,9 @@ You MUST respond ONLY with a valid JSON array of objects. No prose, no markdown
 ### STORY BODY SCHEMA (REQUIRED FOR EVERY STORY):
 \`body\` MUST be a **string** — the serialized markdown produced by \`serialize()\` from \`lib/story-body/story-body.js\`. Do NOT emit \`body\` as a JSON object: an object body throws \`StoryBodyParseError\` in the reconciler (Story #3302) and is discarded by the GitHub provider, producing an empty issue body. Stories are consumed by non-interactive sub-agents that must self-verify from the Story ticket alone — so the ticket must carry everything an agent needs to execute and self-verify.
 
-The \`acceptance[]\` and \`verify[]\` arrays live at the **top level** of the Story ticket object — that is the machine contract the validator reads. Persist syncs those arrays into the body's \`## Acceptance\` / \`## Verify\` sections so the GitHub issue stays a complete executable document. Prefer authoring the lists **once at top-level** and omitting those sections from the authored \`body\` string (or mirroring the exact same items). Do **not** invent a second criteria list inside \`## Spec\`, and do not author a separate Acceptance Spec / PRD artifact.
+The \`acceptance[]\` and \`verify[]\` arrays live at the **top level** of the Story ticket object — that is the machine contract the validator reads. Author each list **once, at top level**, and **omit** the \`## Acceptance\` / \`## Verify\` sections from the authored \`body\` string: persist syncs the top-level arrays into those sections so the GitHub issue stays a complete executable document. The validator resolves both fields from the top level, so an omitted section is the expected shape, not a violation.
+
+If you do write those sections into the \`body\` string anyway, they must mirror the top-level arrays **item for item** — persist fails closed on a disagreement rather than guessing which list is authoritative. Do **not** invent a second criteria list inside \`## Spec\`, and do not author a separate Acceptance Spec / PRD artifact.
 
 The serialized \`body\` string renders these markdown sections (in order):
 

package/.agents/scripts/lib/test-env.js

@@ -17,12 +17,25 @@
  *     the NODE_ENV band-aid was removed in Story #3342. Tests that need to
  *     exercise the webhook POST inject `opts.fetchImpl` instead, so the
  *     request never reaches the real network even if a URL resolves.)
+ *   - Every `GIT_*` variable is dropped. When the suite runs inside a git
+ *     hook (husky pre-push via the coverage-capture path), the parent git
+ *     invocation exports `GIT_DIR` — from a linked worktree, the absolute
+ *     `<main>/.git/worktrees/<name>` path. A test fixture's `git init`
+ *     under that env re-initializes the shared gitdir and writes
+ *     `core.bare=true` into the MAIN checkout's `.git/config`, breaking
+ *     every worktree at once (#4580). Production git call sites are
+ *     covered by `cleanGitEnv` in `git-utils.js`; this is the same scrub
+ *     for test child processes, which may spawn git directly. Tests that
+ *     need a `GIT_*` variable set it explicitly on their own spawn.
  *
  * @param {NodeJS.ProcessEnv} baseEnv
  * @returns {NodeJS.ProcessEnv}
  */
 export function buildWebhookSafeTestEnv(baseEnv = process.env) {
-  const env = { ...baseEnv, NODE_ENV: baseEnv.NODE_ENV ?? 'test' };
+  const env = Object.fromEntries(
+    Object.entries(baseEnv).filter(([k]) => !k.startsWith('GIT_')),
+  );
+  env.NODE_ENV = baseEnv.NODE_ENV ?? 'test';
   if (env.MANDREL_ALLOW_TEST_WEBHOOKS !== '1') {
     delete env.NOTIFICATION_WEBHOOK_URL;
   }

package/.agents/scripts/lib/test-tiers.js

@@ -12,13 +12,10 @@ import picomatch from 'picomatch';
  */
 export const INTEGRATION_INCLUDE = [
   'tests/**/*.integration.test.js',
-  'tests/epic-execute/epic-execute-record-wave.test.js',
   'tests/hook-chain-reflog-invariant.test.js',
-  'tests/push-epic-retry.test.js',
   'tests/contract/check-baselines-regression.test.js',
   'tests/contract/check-baselines-kernel-mismatch.test.js',
   'tests/integration-prime-after-sweep.test.js',
-  'tests/concurrency-wiring.test.js',
   'tests/scripts/git-cleanup.test.js',
   'tests/lib/checks/runner-integration.test.js',
   'tests/single-story-close-sync.test.js',

package/.agents/scripts/lib/ticket-body-sections.js

@@ -107,20 +107,6 @@ export function hasTicketSection(body, kind) {
   return locate(body, kind) !== null;
 }
 
-/**
- * Extract a managed region's content (between the markers, trimmed).
- * Returns `null` when the region is absent.
- *
- * @param {string} body
- * @param {'techSpec'|'acceptanceTable'} kind
- * @returns {string|null}
- */
-export function extractTicketSection(body, kind) {
-  const loc = locate(body, kind);
-  if (!loc) return null;
-  return body.slice(loc.contentStart, loc.contentEnd).trim();
-}
-
 /**
  * Insert or replace a managed region, preserving every byte outside it.
  *