mandrel 1.94.0 → 2.1.0

package/.agents/scripts/lib/orchestration/story-close/baseline-attribution/phases/gate-failure.js

@@ -1,211 +0,0 @@
-/**
- * gate-failure.js — phase 4 of baseline-attribution.
- *
- * The per-failure classifier wired between the close-validation gate chain
- * and the rest of the baseline-attribution pipeline:
- *
- *   - `handleBaselineGateFailure` — given a baseline-style gate name and
- *     its projected regressions, classify the drift against the Story's
- *     diff and either refresh-and-retry, post a friction comment, or
- *     rethrow.
- *
- * The bounded retry driver that wraps this classifier
- * (`runPreMergeGatesWithAttribution`) lives in the sibling
- * `pre-merge-attribution.js` (split out under refs #3685 so each module
- * scores at or above the maintainability floor).
- */
-
-import fs from 'node:fs';
-import { refreshBaseline as defaultRefreshBaseline } from '../../../../baselines/refresh-service.js';
-import { gitSpawn as defaultGitSpawn } from '../../../../git-utils.js';
-import { upsertStructuredComment as defaultUpsertStructuredComment } from '../../../ticketing.js';
-import { classifyBaselineDrift as defaultClassifyBaselineDrift } from '../../baseline-attribution.js';
-import { renderBaselineFrictionBody as defaultRenderBaselineFrictionBody } from '../../baseline-friction-body.js';
-import { buildKindScorer, runRefreshCommit } from './refresh-commit.js';
-import { computeStoryDiffPaths } from './scope-discovery.js';
-
-/**
- * Map gate names → metadata used to project regressions and refresh the
- * baseline. Only baseline-style gates appear here; non-baseline gates
- * (typecheck, lint, test, format) fall through and the orchestrator
- * re-throws the original gate error.
- *
- * Story #2205 — the `refreshCmd` shell-out is gone. Each gate now declares
- * the `kind` (matching `refreshBaseline`'s supported kinds) and the
- * timeout block is retained as informational metadata only.
- */
-export const DEFAULT_GATE_REGISTRY = {
-  'check-maintainability': {
-    kind: 'maintainability',
-    baselineHint: 'maintainability',
-    timeoutBlockKey: 'maintainability',
-  },
-  'check-crap': {
-    kind: 'crap',
-    baselineHint: 'crap',
-    timeoutBlockKey: 'crap',
-  },
-};
-
-/** Gate names that fan out to per-kind refreshers via `_gateKind` tags. */
-const COMPOSITE_GATE_KINDS = new Set(['check-baselines']);
-
-/**
- * Resolve the refresh metadata + the regression subset a single failure
- * cycle should act on.
- *
- * A direct per-kind gate (`check-maintainability` / `check-crap`) maps
- * straight through. The unified `check-baselines` gate is a **composite**:
- * its projected regressions are tagged with `_gateKind`, and each attribution
- * cycle picks the first regressed kind not already refreshed this cycle
- * (`cycleState.refreshedKinds`), scoping classify + refresh to that one kind.
- * The retry loop re-drives for any remaining kinds — so a close that regresses
- * both maintainability and CRAP converges in two cycles instead of dead-ending
- * on an unrecognised gate name (framework-gap #4377).
- *
- * @returns {{ meta: object, regressions: Array } | null}
- */
-export function resolveGateMeta({
-  gateName,
-  regressions,
-  cycleState = null,
-  gateRegistry = DEFAULT_GATE_REGISTRY,
-}) {
-  if (!Array.isArray(regressions) || regressions.length === 0) return null;
-
-  const direct = gateRegistry[gateName];
-  if (direct) return { meta: direct, regressions };
-
-  if (COMPOSITE_GATE_KINDS.has(gateName)) {
-    const refreshed = cycleState?.refreshedKinds ?? new Set();
-    for (const row of regressions) {
-      const kind = row?._gateKind;
-      const subMeta = kind ? gateRegistry[`check-${kind}`] : null;
-      if (subMeta && !refreshed.has(subMeta.kind)) {
-        return {
-          meta: subMeta,
-          regressions: regressions.filter((r) => r?._gateKind === kind),
-        };
-      }
-    }
-  }
-  return null;
-}
-
-/**
- * Top-level: handle a baseline gate failure by classifying drift and
- * either auto-refreshing (attributable-only) or posting friction (any
- * non-attributable). Non-baseline gates short-circuit with `{ action:
- * 'rethrow' }` and the caller re-throws the original gate error so
- * compile/lint/test failures still hard-fail the close.
- *
- * @param {object} input
- * @param {string} input.gateName
- * @param {Array<{ path?: string, file?: string }>} input.regressions
- * @param {string} input.cwd Worktree path (where refresh + commit run).
- * @param {string} input.epicBranch e.g. `epic/1114` (no `origin/` prefix).
- * @param {string} input.storyBranch e.g. `story-1124`.
- * @param {number|string} input.storyId
- * @param {number|string} input.epicId
- * @param {object} input.provider Ticketing provider for friction post.
- * @param {{ refreshedKinds?: Set<string>, lastRefreshSha?: string|null } | null} [input.cycleState]
- * @param {object} [input.gateRegistry]
- * @param {object} [input.deps] Injected seams for tests.
- * @returns {Promise<{
- *   action: 'refreshed' | 'blocked' | 'rethrow',
- *   sha?: string,
- *   skipped?: boolean,
- *   nonAttributable?: Array,
- *   commentId?: number|string|null,
- * }>}
- */
-export async function handleBaselineGateFailure({
-  gateName,
-  regressions,
-  cwd,
-  epicBranch,
-  storyBranch,
-  storyId,
-  epicId,
-  config,
-  provider,
-  cycleState = null,
-  gateRegistry = DEFAULT_GATE_REGISTRY,
-  deps = {},
-} = {}) {
-  const resolved = resolveGateMeta({
-    gateName,
-    regressions,
-    cycleState,
-    gateRegistry,
-  });
-  if (!resolved) return { action: 'rethrow' };
-  const { meta, regressions: scopedRegressions } = resolved;
-
-  const classify = deps.classifyBaselineDrift ?? defaultClassifyBaselineDrift;
-  const renderBody =
-    deps.renderBaselineFrictionBody ?? defaultRenderBaselineFrictionBody;
-  const upsertComment =
-    deps.upsertStructuredComment ?? defaultUpsertStructuredComment;
-  const gitRunner = deps.gitRunner ?? { gitSpawn: defaultGitSpawn };
-  const refreshBaseline = deps.refreshBaseline ?? defaultRefreshBaseline;
-  const scorerBuilder = deps.scorerBuilder ?? buildKindScorer;
-  const fsImpl = deps.fsImpl ?? fs;
-  const computePaths = deps.computeStoryDiffPaths ?? computeStoryDiffPaths;
-
-  const storyDiffPaths = computePaths({
-    cwd,
-    epicBranch,
-    storyBranch,
-    gitRunner,
-  });
-
-  const epicRef = `origin/${epicBranch}`;
-  const { attributable, nonAttributable } = classify({
-    regressions: scopedRegressions,
-    storyDiffPaths,
-    epicRef,
-    cwd,
-    gitRunner,
-  });
-
-  if (nonAttributable.length > 0) {
-    const body = renderBody({ rows: nonAttributable, epicId, storyId });
-    let commentId = null;
-    try {
-      const res = await upsertComment(provider, storyId, 'friction', body);
-      commentId = res?.commentId ?? null;
-    } catch (err) {
-      deps.logger?.warn?.(
-        `[baseline-attribution-wiring] failed to upsert friction comment: ${err?.message ?? err}`,
-      );
-    }
-    return { action: 'blocked', nonAttributable, commentId };
-  }
-
-  if (attributable.length === 0) return { action: 'rethrow' };
-
-  const refresh = await runRefreshCommit({
-    cwd,
-    kind: meta.kind,
-    storyId,
-    epicBranch,
-    storyBranch,
-    config,
-    cycleState,
-    refreshBaseline,
-    scorerBuilder,
-    fsImpl,
-    gitRunner,
-    logger: deps.logger,
-  });
-  if (!refresh.ok) {
-    return { action: 'rethrow', error: refresh.error };
-  }
-  return {
-    action: 'refreshed',
-    sha: refresh.sha,
-    skipped: refresh.skipped === true,
-    reason: refresh.reason,
-  };
-}

package/.agents/scripts/lib/orchestration/story-close/baseline-attribution/phases/pre-merge-attribution.js

@@ -1,158 +0,0 @@
-/**
- * pre-merge-attribution.js — phase 4 (retry driver) of baseline-attribution.
- *
- * Houses `runPreMergeGatesWithAttribution`, the public wrapper around
- * `runPreMergeGates` that drives the bounded retry loop. Extracted from
- * `gate-failure.js` (refs #3685) so the per-failure classifier
- * (`handleBaselineGateFailure`) and the retry driver each live in a
- * file that scores at or above the restored maintainability floor; the
- * two were previously fused in a single module whose aggregate volume
- * sat below 70.
- *
- * The retry loop wears a single mutable `cycleState` object so the
- * idempotency token enforces AC-9 (one refresh commit per kind per close
- * cycle).
- */
-
-import { COVERAGE_TIMEOUT_EXIT_CODE } from '../../../../coverage-capture.js';
-import { Logger as DefaultLogger } from '../../../../Logger.js';
-import { runPreMergeGates as defaultRunPreMergeGates } from '../../pre-merge-validation.js';
-import { handleBaselineGateFailure } from './gate-failure.js';
-import { projectRegressionsForGate } from './regression-projection.js';
-
-/**
- * Wrap `runPreMergeGates` with the Story #1124 baseline-attribution flow.
- *
- * On a baseline-gate failure we project the regressions, classify them
- * against the Story's diff vs `epic/<id>`, and either refresh-and-retry,
- * post a friction comment, or rethrow.
- *
- * Story #2205 — the retry-loop wears a single mutable `cycleState` object
- * carrying `refreshedKinds` (the idempotency token enforcing AC-9). Each
- * `runRefreshCommit` call short-circuits when its kind is already in that
- * set, so a fail-then-pass sequence emits at most one
- * `chore(baselines): refresh <kind> for story-<id>` commit per cycle.
- *
- * @returns {Promise<
- *   | { status: 'ok' }
- *   | { status: 'blocked', nonAttributable: Array, commentId: string|number|null }
- * >}
- */
-export async function runPreMergeGatesWithAttribution({
-  cwd,
-  worktreePath,
-  epicBranch,
-  storyBranch,
-  config,
-  storyId,
-  epicId,
-  useEvidence,
-  phaseTimer,
-  provider,
-  bus = null,
-  runPreMergeGates = defaultRunPreMergeGates,
-  handleBaselineGateFailureFn = handleBaselineGateFailure,
-  projectRegressionsFn = projectRegressionsForGate,
-  logger = DefaultLogger,
-  maxAttempts = 2,
-  cycleState: cycleStateParam = null,
-} = {}) {
-  let attempt = 0;
-  const gateCwd = worktreePath || cwd;
-  // Story #2205: single mutable cycle state object — `refreshedKinds`
-  // gates the idempotency token enforcing AC-9 (one refresh commit per
-  // kind per close cycle). Story #4017: the caller may thread the close
-  // cycle's shared object so the post-gates auto-refresh sees the kinds
-  // already refreshed by this retry loop and never re-scores them.
-  const cycleState = cycleStateParam ?? {
-    refreshedKinds: new Set(),
-    lastRefreshSha: null,
-  };
-  while (attempt < maxAttempts) {
-    attempt += 1;
-    try {
-      await runPreMergeGates({
-        cwd,
-        worktreePath,
-        epicBranch,
-        config,
-        storyId,
-        epicId,
-        useEvidence,
-        phaseTimer,
-        bus,
-        logger,
-      });
-      return { status: 'ok' };
-    } catch (err) {
-      // Story #2136 / Task #2143 — short-circuit when coverage-capture
-      // tripped the bounded-timeout watchdog (exit 124).
-      const errGateName = err?.gateName ?? null;
-      const errExitCode = err?.exitCode ?? null;
-      if (
-        errGateName === 'coverage-capture' &&
-        errExitCode === COVERAGE_TIMEOUT_EXIT_CODE
-      ) {
-        return {
-          status: 'blocked-timeout',
-          gateName: errGateName,
-          exitCode: errExitCode,
-        };
-      }
-      const m = /failed at "([^"]+)"/.exec(err?.message ?? '');
-      const gateName = m ? m[1] : null;
-      const regressions = projectRegressionsFn({
-        gateName,
-        cwd: gateCwd,
-        epicBranch,
-        storyBranch,
-        config,
-      });
-      const outcome = await handleBaselineGateFailureFn({
-        gateName,
-        regressions,
-        cwd: gateCwd,
-        epicBranch,
-        storyBranch,
-        storyId,
-        epicId,
-        config,
-        provider,
-        cycleState,
-      });
-      if (outcome.action === 'refreshed') {
-        const verb = outcome.skipped
-          ? `baseline-refresh skipped (${outcome.reason ?? 'no drift'})`
-          : 'baseline-refresh committed';
-        logger.info?.(
-          `[baseline-attribution-wiring] ${verb} (${outcome.sha}); re-running pre-merge gates.`,
-        );
-        continue;
-      }
-      if (outcome.action === 'blocked') {
-        return {
-          status: 'blocked',
-          nonAttributable: outcome.nonAttributable ?? [],
-          commentId: outcome.commentId ?? null,
-        };
-      }
-      // 'rethrow' — and any unexpected action — surfaces the original error.
-      throw err;
-    }
-  }
-  // maxAttempts exhausted → re-run so the throw propagates with the
-  // canonical hint.
-  await runPreMergeGates({
-    cwd,
-    worktreePath,
-    epicBranch,
-    config,
-    storyId,
-    epicId,
-    useEvidence,
-    phaseTimer,
-    bus,
-    logger,
-  });
-  return { status: 'ok' };
-}