mandrel 1.93.0 → 2.0.0

package/.agents/scripts/lib/orchestration/epic-plan-state-store.js

@@ -1,117 +0,0 @@
-/**
- * epic-plan-state-store — stateless functions for reading and writing the
- * `epic-plan-state` structured comment on the Epic issue.
- *
- * This module is the function-based replacement for the legacy
- * `PlanCheckpointer` class that previously lived at
- * `./plan-runner/plan-checkpointer.js`. Bodies were lifted verbatim from
- * the corresponding `PlanCheckpointer` methods so the structured-comment
- * shape is preserved byte-for-byte. Story #2423 (Epic #2307) deleted
- * the class file; the class API survives as a tests-only fixture at
- * `tests/fixtures/epic-plan-state-store.js`.
- *
- * Schema (see Tech Spec #351):
- *
- * ```json
- * {
- *   "version": 1,
- *   "epicId": 349,
- *   "startedAt": "...",
- *   "lastUpdatedAt": "...",
- *   "spec": { "techSpecPersisted": false, "acceptanceTable": "none", "completedAt": null },
- *   "decompose": { "ticketCount": null, "completedAt": null },
- *   "planningRisk": { "overallLevel": "...", "requiresReview": true, "gateDecision": "..." },
- *   "reviewRouting": { "decision": "review-required|auto-proceed|operator-override-review", "requiresStop": true, "forceReviewApplied": false },
- *   "manifestCommentId": null
- * }
- * ```
- *
- * The checkpoint no longer carries a write-only `phase` field (Story #3909):
- * the lifecycle phase is already authoritative on the Epic's `agent::*` labels,
- * so the duplicate `phase` telemetry (and its `setPhase` round-trips) was
- * deleted. The fields that survive — `spec`, `decompose`, `planningRisk`,
- * `reviewRouting`, `manifestCommentId` — are the ones `/plan --resume`
- * reads to skip already-completed work.
- */
-
-import { parseFencedJsonComment } from './structured-comment-parser.js';
-import { findStructuredComment, upsertStructuredComment } from './ticketing.js';
-
-export const EPIC_PLAN_STATE_TYPE = 'epic-plan-state';
-export const PLAN_CHECKPOINT_SCHEMA_VERSION = 1;
-
-function assertProvider(provider) {
-  if (!provider)
-    throw new TypeError('epic-plan-state-store requires a provider');
-}
-
-function assertEpicId(epicId) {
-  if (!Number.isInteger(epicId)) {
-    throw new TypeError('epic-plan-state-store requires a numeric epicId');
-  }
-}
-
-/**
- * Read and parse the checkpoint. Returns null if the comment is missing or
- * unparseable (callers treat null as "start fresh").
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number }} opts
- * @returns {Promise<object | null>}
- */
-export async function read({ provider, epicId } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const comment = await findStructuredComment(
-    provider,
-    epicId,
-    EPIC_PLAN_STATE_TYPE,
-  );
-  return parseFencedJsonComment(comment);
-}
-
-/**
- * Overwrite the checkpoint with the supplied merged state.
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number, state: object }} opts
- */
-export async function write({ provider, epicId, state } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const payload = {
-    version: PLAN_CHECKPOINT_SCHEMA_VERSION,
-    ...state,
-    lastUpdatedAt: new Date().toISOString(),
-  };
-  const body = `\`\`\`json\n${JSON.stringify(payload, null, 2)}\n\`\`\``;
-  await upsertStructuredComment(provider, epicId, EPIC_PLAN_STATE_TYPE, body);
-  return payload;
-}
-
-/**
- * Initialize the checkpoint. Idempotent — returns the existing state if one
- * is present, otherwise writes a fresh skeleton. Overrides from `seed` are
- * merged into a freshly-written skeleton; an already-present checkpoint is
- * returned unchanged.
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number, seed?: object }} opts
- * @returns {Promise<object>}
- */
-export async function initialize({ provider, epicId, seed = {} } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const existing = await read({ provider, epicId });
-  if (existing) return existing;
-  const now = new Date().toISOString();
-  const skeleton = {
-    epicId,
-    startedAt: now,
-    spec: {
-      techSpecPersisted: false,
-      acceptanceTable: 'none',
-      completedAt: null,
-    },
-    decompose: { ticketCount: null, completedAt: null },
-    manifestCommentId: null,
-  };
-  return write({ provider, epicId, state: { ...skeleton, ...seed } });
-}

package/.agents/scripts/lib/orchestration/epic-run-state-store.js

@@ -1,388 +0,0 @@
-/**
- * epic-run-state-store — stateless functions for reading and writing the
- * `epic-run-state` structured comment used by `/deliver`.
- *
- * Story #4155 (Epic #4151) — the Epic `/deliver` runtime cut over from
- * the wave-batch scheduler to the continuous ready-set core
- * (`lib/wave-runner/ready-set.js`). The checkpoint shrank with it: it no
- * longer carries `currentWave`, `plan[][]`, `totalWaves`, or the
- * per-wave `waves[]` aggregation. The durable run state is now a flat
- * **per-Story status map** (`stories: { [storyId]: { status, title?,
- * blockerCommentId? } }`) plus the run-level `concurrencyCap` (the
- * GLOBAL in-flight cap the ready-set selector honours), `phase`,
- * `startedAt`, and `manualInterventions[]`. There is no resume-pointer
- * to reconcile — the ready-set core re-derives adjacency and readiness
- * from live Story bodies/labels on every tick, so the checkpoint only
- * records terminal Story outcomes (for the auto-merge predicate, branch
- * cleanup, and the operator rollup) and the run-level knobs.
- *
- * This module is the function-based replacement for the legacy
- * `Checkpointer` class that previously lived at
- * `./epic-runner/checkpointer.js`. Story #2423 (Epic #2307) deleted the
- * class file; the class API survives as a tests-only fixture at
- * `tests/fixtures/epic-run-state-store.js`.
- *
- * The comment is identified by a stable HTML marker so it can be overwritten
- * idempotently across orchestrator restarts. The body is a fenced JSON block.
- */
-
-import { assertValidDeliverPhase } from './epic-runner/deliver-phases.js';
-import { parseFencedJsonComment } from './structured-comment-parser.js';
-import { findStructuredComment, upsertStructuredComment } from './ticketing.js';
-
-export const EPIC_RUN_STATE_TYPE = 'epic-run-state';
-export const CHECKPOINT_SCHEMA_VERSION = 2;
-
-/** Terminal / in-progress per-Story statuses persisted on the checkpoint. */
-export const STORY_STATUSES = Object.freeze([
-  'pending',
-  'done',
-  'blocked',
-  'failed',
-]);
-
-// Re-export the phase enum + index helper so downstream importers continue
-// to use this module as a single import target.
-export {
-  DELIVER_PHASES,
-  phaseIndex,
-} from './epic-runner/deliver-phases.js';
-
-function assertProvider(provider) {
-  if (!provider)
-    throw new TypeError('epic-run-state-store requires a provider');
-}
-
-function assertEpicId(epicId) {
-  if (!Number.isInteger(epicId)) {
-    throw new TypeError('epic-run-state-store requires a numeric epicId');
-  }
-}
-
-/**
- * Normalize an inbound Story id (accepts the ticket `id` shape, the raw
- * GitHub `number` shape, and a bare integer) to a positive integer, or
- * `null` when it is absent / non-positive / non-integer.
- *
- * @param {object|number|string} entry
- * @returns {number|null}
- */
-function storyIdOf(entry) {
-  if (typeof entry === 'number') {
-    return Number.isInteger(entry) && entry > 0 ? entry : null;
-  }
-  if (!entry || typeof entry !== 'object') {
-    const n = Number(entry);
-    return Number.isInteger(n) && n > 0 ? n : null;
-  }
-  const raw = entry.id ?? entry.storyId ?? entry.number;
-  const id = Number(raw);
-  return Number.isInteger(id) && id > 0 ? id : null;
-}
-
-/**
- * Build the initial per-Story status map from a list of Story records (or
- * ids). Every Story seeds at `status: 'pending'`; an optional `title` is
- * carried through when the record supplies one so the operator rollup and
- * branch-cleanup surfaces have a label without a second fetch. Keys are the
- * positive-integer Story ids as strings (JSON object keys are strings);
- * shapeless / non-positive entries are dropped.
- *
- * Pure helper — exported for unit tests.
- *
- * @param {Array<object|number>} stories
- * @returns {Record<string, { status: string, title?: string }>}
- */
-export function buildStoryStatusMap(stories) {
-  const out = {};
-  for (const entry of Array.isArray(stories) ? stories : []) {
-    const id = storyIdOf(entry);
-    if (id === null) continue;
-    const record = { status: 'pending' };
-    const title =
-      entry && typeof entry === 'object' && typeof entry.title === 'string'
-        ? entry.title
-        : undefined;
-    if (title) record.title = title;
-    out[String(id)] = record;
-  }
-  return out;
-}
-
-/**
- * Read and parse the checkpoint. Returns null if the comment is missing or
- * unparseable (callers treat null as "start fresh").
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number }} opts
- * @returns {Promise<object | null>}
- */
-export async function read({ provider, epicId } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const comment = await findStructuredComment(
-    provider,
-    epicId,
-    EPIC_RUN_STATE_TYPE,
-  );
-  return parseFencedJsonComment(comment);
-}
-
-/**
- * Overwrite the checkpoint with `state`. Idempotent — callers may invoke
- * freely per tick; the marker-scoped upsert deletes the prior comment.
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number, state: object }} opts
- */
-export async function write({ provider, epicId, state } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const payload = {
-    version: CHECKPOINT_SCHEMA_VERSION,
-    ...state,
-    lastUpdatedAt: new Date().toISOString(),
-  };
-  const body = `\`\`\`json\n${JSON.stringify(payload, null, 2)}\n\`\`\``;
-  await upsertStructuredComment(provider, epicId, EPIC_RUN_STATE_TYPE, body);
-  return payload;
-}
-
-/**
- * Initial checkpoint for a brand-new run. Idempotent against re-dispatch:
- * when an existing checkpoint is found and the persisted `concurrencyCap`
- * matches the incoming value, the existing state is returned verbatim (no
- * rewrite) so a re-prepare preserves `startedAt`, prior Story statuses, and
- * `manualInterventions`. When the cap differs (an operator re-tuned the
- * global in-flight cap) it is refreshed in place; the Story status map is
- * **merged** so any Story that already reached a terminal status keeps it
- * while newly-discovered Stories are seeded at `pending`. Prepare owns the
- * Story set (it overwrites it on every run) but never clobbers recorded
- * progress.
- *
- * @param {{
- *   provider: import('../ITicketingProvider.js').ITicketingProvider,
- *   epicId: number,
- *   storyIds: Array<object|number>,
- *   concurrencyCap: number,
- * }} opts
- *   `concurrencyCap` is the GLOBAL in-flight cap the ready-set selector
- *   honours (`selectReadySet({ globalCap })`).
- */
-export async function initialize({
-  provider,
-  epicId,
-  storyIds,
-  concurrencyCap,
-} = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const seededStories = buildStoryStatusMap(storyIds);
-  const existing = await read({ provider, epicId });
-  if (existing) {
-    const mergedStories = mergeStoryStatuses(existing.stories, seededStories);
-    if (
-      existing.concurrencyCap === concurrencyCap &&
-      storyMapsEqual(existing.stories, mergedStories)
-    ) {
-      return existing;
-    }
-    return write({
-      provider,
-      epicId,
-      state: { ...existing, concurrencyCap, stories: mergedStories },
-    });
-  }
-  return write({
-    provider,
-    epicId,
-    state: {
-      epicId,
-      startedAt: new Date().toISOString(),
-      concurrencyCap,
-      phase: 'prepare',
-      stories: seededStories,
-      manualInterventions: [],
-    },
-  });
-}
-
-/**
- * Merge a freshly-seeded Story status map onto a persisted one. Every Story
- * present in either map appears in the result; when a Story exists in the
- * prior map its recorded status / blockerCommentId win (recorded progress is
- * never lost), while its `title` is refreshed from the incoming seed when the
- * seed supplies one. Stories present only in the incoming seed are added at
- * their seeded (`pending`) status. Pure — exported for unit tests.
- *
- * @param {Record<string, object>|undefined} prior
- * @param {Record<string, object>} incoming
- * @returns {Record<string, object>}
- */
-export function mergeStoryStatuses(prior, incoming) {
-  const priorMap = prior && typeof prior === 'object' ? prior : {};
-  const seedMap = incoming && typeof incoming === 'object' ? incoming : {};
-  const out = {};
-  for (const key of new Set([
-    ...Object.keys(priorMap),
-    ...Object.keys(seedMap),
-  ])) {
-    const priorEntry = priorMap[key];
-    const seedEntry = seedMap[key];
-    if (priorEntry && typeof priorEntry === 'object') {
-      const merged = { ...priorEntry };
-      if (seedEntry && typeof seedEntry.title === 'string') {
-        merged.title = seedEntry.title;
-      }
-      out[key] = merged;
-    } else {
-      out[key] = seedEntry;
-    }
-  }
-  return out;
-}
-
-/**
- * Structural equality on two Story status maps — same key set and, per key,
- * the same `status`, `title`, and `blockerCommentId`. Used by `initialize`
- * to decide whether an idempotent re-prepare needs a rewrite. Pure.
- *
- * @param {Record<string, object>|undefined} a
- * @param {Record<string, object>|undefined} b
- * @returns {boolean}
- */
-function storyMapsEqual(a, b) {
-  const left = a && typeof a === 'object' ? a : {};
-  const right = b && typeof b === 'object' ? b : {};
-  const keys = Object.keys(left);
-  if (keys.length !== Object.keys(right).length) return false;
-  for (const key of keys) {
-    const l = left[key] ?? {};
-    const r = right[key];
-    if (!r) return false;
-    if (
-      l.status !== r.status ||
-      l.title !== r.title ||
-      l.blockerCommentId !== r.blockerCommentId
-    ) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * Record a per-Story terminal (or in-progress) status on the checkpoint.
- * Reads the current state first, splices the single Story's record into the
- * `stories` map, and re-writes. Other Stories and all run-level fields are
- * preserved verbatim. Tolerant of a legacy/absent `stories` map (treated as
- * empty) so a checkpoint that predates a field is upgraded in place.
- *
- * @param {{
- *   provider: import('../ITicketingProvider.js').ITicketingProvider,
- *   epicId: number,
- *   storyId: number,
- *   status: string,
- *   title?: string,
- *   blockerCommentId?: string|number|null,
- * }} opts
- * @returns {Promise<object>} the persisted state
- */
-export async function recordStoryStatus({
-  provider,
-  epicId,
-  storyId,
-  status,
-  title,
-  blockerCommentId,
-} = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  const id = storyIdOf(storyId);
-  if (id === null) {
-    throw new TypeError(
-      'recordStoryStatus: storyId must be a positive integer',
-    );
-  }
-  if (!STORY_STATUSES.includes(status)) {
-    throw new RangeError(
-      `recordStoryStatus: status "${status}" must be one of: ${STORY_STATUSES.join(', ')}`,
-    );
-  }
-  const existing = (await read({ provider, epicId })) ?? {};
-  const stories =
-    existing.stories && typeof existing.stories === 'object'
-      ? { ...existing.stories }
-      : {};
-  const prior = stories[String(id)] ?? {};
-  const record = { ...prior, status };
-  if (typeof title === 'string' && title) record.title = title;
-  if (status === 'blocked' && blockerCommentId != null) {
-    record.blockerCommentId = String(blockerCommentId);
-  }
-  stories[String(id)] = record;
-  return write({
-    provider,
-    epicId,
-    state: { ...existing, stories },
-  });
-}
-
-/**
- * Append a manual-intervention record to the checkpoint. Out-of-band
- * recovery steps the host LLM performs during a delivery — `AskUserQuestion`
- * calls, `git restore`/`git reset` against the working tree, manual `--no-ff`
- * recovery merges, story-close `--skipValidation` overrides — disqualify the
- * Epic from auto-merge. The auto-merge predicate reads this array and only
- * fires when it is empty.
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number, entry: { reason: string, source?: string, ts?: string } }} opts
- * @returns {Promise<object>} the persisted state
- */
-export async function appendIntervention({ provider, epicId, entry } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  if (!entry || typeof entry.reason !== 'string' || entry.reason.length === 0) {
-    throw new TypeError('appendIntervention: { reason: string } is required.');
-  }
-  const existing = (await read({ provider, epicId })) ?? {};
-  const list = Array.isArray(existing.manualInterventions)
-    ? existing.manualInterventions
-    : [];
-  const record = {
-    reason: entry.reason,
-    source: typeof entry.source === 'string' ? entry.source : 'host-llm',
-    ts: typeof entry.ts === 'string' ? entry.ts : new Date().toISOString(),
-  };
-  return write({
-    provider,
-    epicId,
-    state: {
-      ...existing,
-      manualInterventions: [...list, record],
-    },
-  });
-}
-
-/**
- * Advance the checkpoint's `phase` field to the next `/deliver`
- * phase. Reads the current state first so the caller does not need to
- * keep an in-memory copy. Other state fields are preserved verbatim.
- *
- * Story #1155 / Epic #1142 — phase-granular resume. The runner writes
- * the **next phase to run** here, not the phase that just finished, so
- * a resume can match `phase === 'code-review'` to mean "Phase D is the
- * next thing to do."
- *
- * @param {{ provider: import('../ITicketingProvider.js').ITicketingProvider, epicId: number, nextPhase: string }} opts
- *   nextPhase - One of `DELIVER_PHASES` or `'done'`.
- */
-export async function setPhase({ provider, epicId, nextPhase } = {}) {
-  assertProvider(provider);
-  assertEpicId(epicId);
-  assertValidDeliverPhase(nextPhase);
-  const existing = (await read({ provider, epicId })) ?? {};
-  return write({
-    provider,
-    epicId,
-    state: { ...existing, phase: nextPhase },
-  });
-}

package/.agents/scripts/lib/orchestration/epic-runner/concurrency-gate.js

@@ -1,186 +0,0 @@
-/**
- * Cross-Story conflict-finding gate for `epic-deliver-prepare.js`.
- *
- * Story #2297 — when the bounded `/plan` flow emitted concurrency
- * findings (Story #2296's validator pass), the operator may have shipped
- * them through to `/deliver` without resolving the underlying
- * `depends_on` gaps. This gate runs at Phase 1 of `/deliver` and
- * refuses to flip the Epic to `agent::executing` when the upcoming
- * waves still contain unresolved conflicts — surfacing the exact
- * remediation commands the operator should run before retrying.
- *
- * The gate is opt-in by default:
- *   - Advisory findings (severity 'soft') only log a summary.
- *   - Hard findings (severity 'hard') OR `delivery.failOnConcurrencyHazards: true`
- *     promote a hard-stop.
- *
- * `--ignore-concurrency-hazards` bypasses the gate; the flag use is
- * recorded on the Epic checkpoint so retro tooling can flag a run that
- * shipped despite an outstanding hazard.
- *
- * The module is pure: it consumes a findings array and a wave plan and
- * returns either a `{ ok: true }` envelope or throws. No I/O.
- */
-
-/**
- * Build the set of "pending" story identifiers from a wave plan. A Story
- * is pending unless its labels carry `agent::done`. Identifiers are
- * collected in three shapes — `id` (number), `number`, and `slug` — so
- * the caller can match findings keyed by any of them.
- *
- * @param {Array<Array<{ id?: number|string, number?: number|string, slug?: string, labels?: string[] }>>} wavePlan
- * @returns {Set<string>}
- */
-export function collectPendingStoryKeys(wavePlan) {
-  const pending = new Set();
-  if (!Array.isArray(wavePlan)) return pending;
-  for (const wave of wavePlan) {
-    if (!Array.isArray(wave)) continue;
-    for (const story of wave) {
-      if (!story || typeof story !== 'object') continue;
-      const labels = Array.isArray(story.labels) ? story.labels : [];
-      if (labels.includes('agent::done')) continue;
-      if (story.id != null) pending.add(String(story.id));
-      if (story.number != null) pending.add(String(story.number));
-      if (story.slug != null) pending.add(String(story.slug));
-    }
-  }
-  return pending;
-}
-
-/**
- * Extract every story identifier a finding references. Both finding
- * kinds in #2296's shape carry slugs; future persisted shapes may carry
- * numeric IDs — accept both transparently.
- */
-function findingStoryKeys(finding) {
-  const keys = [];
-  if (Array.isArray(finding?.storySlugs)) {
-    for (const s of finding.storySlugs) keys.push(String(s));
-  }
-  if (finding?.producer?.storySlug != null) {
-    keys.push(String(finding.producer.storySlug));
-  }
-  if (finding?.consumer?.storySlug != null) {
-    keys.push(String(finding.consumer.storySlug));
-  }
-  return keys;
-}
-
-/**
- * Filter findings to those that touch at least one pending Story. A
- * finding all of whose referenced Stories are already `agent::done` is
- * harmless — the conflict has already played out — and is dropped.
- *
- * When `pendingKeys` is empty (every wave is done) every finding is
- * filtered out. When a finding carries no identifiers (shape drift),
- * conservatively keep it so the operator sees the signal.
- *
- * @param {object[]} findings
- * @param {Set<string>} pendingKeys
- * @returns {object[]}
- */
-export function filterFindingsToPending(findings, pendingKeys) {
-  if (!Array.isArray(findings)) return [];
-  if (!(pendingKeys instanceof Set)) return findings;
-  return findings.filter((f) => {
-    const keys = findingStoryKeys(f);
-    if (keys.length === 0) return true;
-    return keys.some((k) => pendingKeys.has(k));
-  });
-}
-
-function isHardFinding(f) {
-  return f && f.severity === 'hard';
-}
-
-/**
- * Render the operator-facing remediation block for a hard-gate trip.
- * Produces a single multi-line string suitable for `throw new Error(...)`
- * — names every offending path, the affected Stories, and the exact
- * `gh issue edit` commands needed to add the missing `depends_on` links.
- */
-export function renderGateErrorMessage(findings, ownerRepo) {
-  const lines = [
-    'Refusing to flip Epic to agent::executing — cross-Story concurrency hazards remain unresolved.',
-    '',
-  ];
-  const sharedEditors = findings.filter((f) => f.kind === 'shared-editor');
-  const implicit = findings.filter(
-    (f) => f.kind === 'implicit-cross-story-dep',
-  );
-  if (sharedEditors.length > 0) {
-    lines.push('Shared-editor conflicts:');
-    for (const f of sharedEditors) {
-      const stories = Array.isArray(f.storySlugs) ? f.storySlugs : [];
-      lines.push(
-        `  - "${f.path}" written by ${stories.length} concurrent Stories: ${stories.map((s) => `#${s}`).join(', ')}`,
-      );
-      lines.push(
-        '    Remediation: add a `depends_on` chain or split the edits into a dedicated late-wave wiring Story.',
-      );
-    }
-    lines.push('');
-  }
-  if (implicit.length > 0) {
-    lines.push('Implicit cross-Story dependencies:');
-    for (const f of implicit) {
-      const p = f.producer ?? {};
-      const c = f.consumer ?? {};
-      lines.push(
-        `  - "${f.path}" produced by Story #${p.storySlug ?? '?'} consumed by Story #${c.storySlug ?? '?'} (body.${c.sourceField ?? '?'})`,
-      );
-      const repoFlag = ownerRepo ? ` --repo ${ownerRepo}` : '';
-      lines.push(
-        `    Remediation: gh issue edit ${c.storySlug ?? '?'}${repoFlag} --add-body $'\\n\\nblocked by #${p.storySlug ?? '?'}'`,
-      );
-    }
-    lines.push('');
-  }
-  lines.push(
-    'Resolve the listed conflicts and re-run `/deliver`, or pass `--ignore-concurrency-hazards` to bypass this gate.',
-  );
-  return lines.join('\n');
-}
-
-/**
- * Apply the gate to a findings array.
- *
- * @param {object}    input
- * @param {object[]}  input.findings        - Findings filtered to pending waves.
- * @param {object}    [input.policy]        - Resolved `delivery.failOnConcurrencyHazards` (boolean).
- * @param {boolean}   [input.ignore]        - `--ignore-concurrency-hazards` flag value.
- * @param {string}    [input.ownerRepo]     - "owner/repo" string for `gh issue edit` hints.
- * @returns {{ tripped: boolean, reason: 'hard-severity'|'config-fail-on'|null, findings: object[], bypassed: boolean }}
- *          When the gate trips and `ignore` is false the caller should
- *          throw `renderGateErrorMessage(findings, ownerRepo)`. The
- *          returned `bypassed` is true when `ignore` short-circuits a
- *          trip; record it on the checkpoint.
- */
-export function evaluateConcurrencyGate({
-  findings = [],
-  policy = {},
-  ignore = false,
-  ownerRepo,
-} = {}) {
-  void ownerRepo;
-  const hardFindings = findings.filter(isHardFinding);
-  const failOnConcurrencyHazards = policy.failOnConcurrencyHazards === true;
-  if (hardFindings.length > 0) {
-    return {
-      tripped: true,
-      reason: 'hard-severity',
-      findings: hardFindings,
-      bypassed: ignore === true,
-    };
-  }
-  if (failOnConcurrencyHazards && findings.length > 0) {
-    return {
-      tripped: true,
-      reason: 'config-fail-on',
-      findings,
-      bypassed: ignore === true,
-    };
-  }
-  return { tripped: false, reason: null, findings: [], bypassed: false };
-}