mandrel 1.85.0 → 1.86.0

package/.agents/scripts/lib/orchestration/git-cleanup/phases/git-probes-ff.js

@@ -34,54 +34,107 @@ export function isWorktreeLockFailure(stderr) {
 
 /* node:coverage ignore next */
 export function isWorkingTreeClean(cwd) {
-  const res = gitSpawn(cwd, 'status', '--porcelain');
-  if (res.status !== 0) return false;
-  return res.stdout.trim() === '';
+  return defaultFfProbes.isClean(cwd);
 }
 
 /* node:coverage ignore next */
 export function fetchRef(cwd, remoteName, ref) {
-  const res = gitSpawn(cwd, 'fetch', '--quiet', remoteName, ref);
-  if (res.status !== 0) return { ok: false, stderr: res.stderr };
-  return { ok: true };
+  return defaultFfProbes.fetch(cwd, remoteName, ref);
 }
 
 /* node:coverage ignore next */
 export function canFastForward(cwd, baseBranch, remoteName) {
-  const ref = `${remoteName}/${baseBranch}`;
-  const ahead = gitSpawn(
-    cwd,
-    'rev-list',
-    '--left-right',
-    '--count',
-    `${baseBranch}...${ref}`,
-  );
-  if (ahead.status !== 0) {
-    return { ok: false, behind: 0, reason: 'rev-list-failed' };
-  }
-  const parts = ahead.stdout.trim().split(/\s+/);
-  const localAhead = Number(parts[0]) || 0;
-  const remoteAhead = Number(parts[1]) || 0;
-  if (localAhead > 0) {
-    return { ok: false, behind: remoteAhead, reason: 'not-fast-forward' };
-  }
-  return { ok: true, behind: remoteAhead };
+  return defaultFfProbes.canFastForward(cwd, baseBranch, remoteName);
 }
 
 /* node:coverage ignore next */
 export function checkoutBranch(cwd, branch) {
-  const res = gitSpawn(cwd, 'checkout', branch);
-  if (res.status !== 0) return { ok: false, stderr: res.stderr };
-  return { ok: true };
+  return defaultFfProbes.checkout(cwd, branch);
 }
 
 /* node:coverage ignore next */
 export function mergeFastForward(cwd, ref) {
-  const res = gitSpawn(cwd, 'merge', '--ff-only', ref);
-  if (res.status !== 0) return { ok: false, stderr: res.stderr };
-  return { ok: true };
+  return defaultFfProbes.merge(cwd, ref);
 }
 
+/**
+ * Build the fast-forward probe bundle bound to a `gitSpawn`.
+ *
+ * This is the **single implementation** of the FF/base-sync git wrappers.
+ * The standalone exports above delegate to a default instance bound to the
+ * shared `gitSpawn`; callers that need to inject their own spawn for testing
+ * (e.g. the epic-cleanup runner) call this factory directly instead of
+ * hand-rolling a parallel copy (framework-gap #4379). The bundle also carries
+ * `currentBranch` so an injecting caller gets the whole FF surface from one
+ * place.
+ *
+ * @param {(cwd: string, ...args: string[]) => { status: number, stdout: string, stderr: string }} [spawn]
+ * @returns {{
+ *   isClean: (cwd: string) => boolean,
+ *   currentBranch: (cwd: string) => string|null,
+ *   fetch: (cwd: string, remoteName: string, ref: string) => { ok: boolean, stderr?: string },
+ *   canFastForward: (cwd: string, baseBranch: string, remoteName: string) => { ok: boolean, behind: number, reason?: string },
+ *   checkout: (cwd: string, branch: string) => { ok: boolean, stderr?: string },
+ *   merge: (cwd: string, ref: string) => { ok: boolean, stderr?: string },
+ * }}
+ */
+export function makeFfProbes(spawn = gitSpawn) {
+  return {
+    isClean: (cwd) => {
+      const res = spawn(cwd, 'status', '--porcelain');
+      return res.status === 0 && String(res.stdout ?? '').trim() === '';
+    },
+    currentBranch: (cwd) => {
+      const res = spawn(cwd, 'symbolic-ref', '--quiet', '--short', 'HEAD');
+      return res.status !== 0 ? null : String(res.stdout ?? '').trim() || null;
+    },
+    fetch: (cwd, remoteName, ref) => {
+      const res = spawn(cwd, 'fetch', '--quiet', remoteName, ref);
+      return res.status === 0
+        ? { ok: true }
+        : { ok: false, stderr: res.stderr };
+    },
+    canFastForward: (cwd, baseBranch, remoteName) => {
+      const ref = `${remoteName}/${baseBranch}`;
+      const ahead = spawn(
+        cwd,
+        'rev-list',
+        '--left-right',
+        '--count',
+        `${baseBranch}...${ref}`,
+      );
+      if (ahead.status !== 0) {
+        return { ok: false, behind: 0, reason: 'rev-list-failed' };
+      }
+      const parts = String(ahead.stdout ?? '')
+        .trim()
+        .split(/\s+/);
+      const localAhead = Number(parts[0]) || 0;
+      const remoteAhead = Number(parts[1]) || 0;
+      if (localAhead > 0) {
+        return { ok: false, behind: remoteAhead, reason: 'not-fast-forward' };
+      }
+      return { ok: true, behind: remoteAhead };
+    },
+    checkout: (cwd, branch) => {
+      const res = spawn(cwd, 'checkout', branch);
+      return res.status === 0
+        ? { ok: true }
+        : { ok: false, stderr: res.stderr };
+    },
+    merge: (cwd, ref) => {
+      const res = spawn(cwd, 'merge', '--ff-only', ref);
+      return res.status === 0
+        ? { ok: true }
+        : { ok: false, stderr: res.stderr };
+    },
+  };
+}
+
+// Default instance bound to the shared gitSpawn; the standalone wrappers
+// above delegate to it so there is exactly one FF-probe implementation.
+const defaultFfProbes = makeFfProbes(gitSpawn);
+
 /* node:coverage ignore next */
 export function removeWorktree(worktreePath, cwd) {
   const plain = gitSpawn(cwd, 'worktree', 'remove', worktreePath);

package/.agents/scripts/lib/orchestration/lifecycle/listeners/branch-cleaner.js

@@ -40,7 +40,11 @@
  *      - runs `git remote prune` to drop stale `<remote>/...` tracking
  *        refs left behind by `gh pr merge --delete-branch`;
  *      - deletes the `wt-branch` scratch ref left by `story-close.js`'s
- *        internal merge worktree when it is no longer checked out.
+ *        internal merge worktree when it is no longer checked out;
+ *      - fast-forwards the base branch to `<remote>/<baseBranch>` after the
+ *        confirmed merge so the local checkout converges to origin with no
+ *        manual `git pull` (skipped when the epic branch is kept for an
+ *        open PR).
  *   3. Record one classification entry per invocation (`reaped`,
  *      `no-state`, `failed`, or `skipped-duplicate`) so failures surface
  *      in the lifecycle ledger alongside Cleaner's archival outcome.
@@ -243,8 +247,8 @@ export class BranchCleaner {
  * Pure: condense a `reapEpicBranches()` result into the counts that the
  * classification log carries. Exported for tests.
  *
- * @param {{ reaped: Array<object>, pruned: { pruned: string[] }|null, wtBranch: { deleted: boolean }|null }} result
- * @returns {{ branchesDeleted: number, worktreesRemoved: number, tracksPruned: number, wtBranchDeleted: boolean }}
+ * @param {{ reaped: Array<object>, pruned: { pruned: string[] }|null, wtBranch: { deleted: boolean }|null, fastForward: { applied: boolean }|null }} result
+ * @returns {{ branchesDeleted: number, worktreesRemoved: number, tracksPruned: number, wtBranchDeleted: boolean, fastForwarded: boolean }}
  */
 export function summarizeReap(result) {
   const reaped = Array.isArray(result?.reaped) ? result.reaped : [];
@@ -255,5 +259,6 @@ export function summarizeReap(result) {
     ).length,
     tracksPruned: result?.pruned?.pruned?.length ?? 0,
     wtBranchDeleted: result?.wtBranch?.deleted === true,
+    fastForwarded: result?.fastForward?.applied === true,
   };
 }

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

@@ -47,6 +47,51 @@ export const DEFAULT_GATE_REGISTRY = {
   },
 };
 
+/** 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
@@ -88,11 +133,14 @@ export async function handleBaselineGateFailure({
   gateRegistry = DEFAULT_GATE_REGISTRY,
   deps = {},
 } = {}) {
-  const meta = gateRegistry[gateName];
-  if (!meta) return { action: 'rethrow' };
-  if (!Array.isArray(regressions) || regressions.length === 0) {
-    return { action: 'rethrow' };
-  }
+  const resolved = resolveGateMeta({
+    gateName,
+    regressions,
+    cycleState,
+    gateRegistry,
+  });
+  if (!resolved) return { action: 'rethrow' };
+  const { meta, regressions: scopedRegressions } = resolved;
 
   const classify = deps.classifyBaselineDrift ?? defaultClassifyBaselineDrift;
   const renderBody =
@@ -114,7 +162,7 @@ export async function handleBaselineGateFailure({
 
   const epicRef = `origin/${epicBranch}`;
   const { attributable, nonAttributable } = classify({
-    regressions,
+    regressions: scopedRegressions,
     storyDiffPaths,
     epicRef,
     cwd,

package/.agents/scripts/lib/orchestration/story-close/baseline-attribution/phases/regression-projection.js

@@ -244,6 +244,24 @@ export const PROJECTORS = {
   'check-crap': projectCrapForGate,
 };
 
+/**
+ * Composite gates fan out to per-kind projectors. The baseline pipeline was
+ * unified behind a single `check-baselines` gate (per-kind pipeline: schema →
+ * floor → tolerance), but the attribution layer still keys on the original
+ * per-kind gate names. Without this map a `check-baselines` failure projects
+ * zero regressions, the gate-failure handler sees an empty list, and the
+ * auto-refresh path silently no-ops — so a legitimate MI/CRAP regression
+ * hard-fails the close instead of self-healing (framework-gap #4377).
+ */
+export const COMPOSITE_SUBGATES = {
+  'check-baselines': ['check-maintainability', 'check-crap'],
+};
+
+/** `check-maintainability` → `maintainability`. */
+function gateKind(gateName) {
+  return gateName.replace(/^check-/, '');
+}
+
 export function projectRegressionsForGate({
   gateName,
   cwd,
@@ -253,14 +271,27 @@ export function projectRegressionsForGate({
   projectMaintainability = defaultProjectMaintainabilityRegressions,
   getBaselines = defaultGetBaselines,
 }) {
-  const project = PROJECTORS[gateName];
-  if (!project) return [];
-  return project({
+  const ctx = {
     cwd,
     epicBranch,
     storyBranch,
     config,
     projectMaintainability,
     getBaselines,
-  });
+  };
+  const subGates = COMPOSITE_SUBGATES[gateName];
+  if (subGates) {
+    // Union the per-kind regressions, tagging each row with its baseline
+    // kind so the gate-failure handler can refresh the right baseline (one
+    // kind per attribution cycle; the retry loop converges the rest).
+    return subGates.flatMap((sub) => {
+      const project = PROJECTORS[sub];
+      if (!project) return [];
+      const kind = gateKind(sub);
+      return project(ctx).map((row) => ({ _gateKind: kind, ...row }));
+    });
+  }
+  const project = PROJECTORS[gateName];
+  if (!project) return [];
+  return project(ctx);
 }

package/.agents/scripts/lib/single-story-sweep/protection-ctx.js

@@ -0,0 +1,75 @@
+/**
+ * single-story-sweep/protection-ctx.js
+ *
+ * Shared builder for the `evaluateProtection` context the boot-sweep
+ * engine ([`sweepMergedBranches`](../single-story-sweep.js)) threads into
+ * every candidate protection check. Single-homed here so the three boot
+ * callers — `single-story-init.js`, `epic-deliver-prepare.js`, and the
+ * `boot-sweep.js` CLI — build an identical ctx instead of each re-wiring
+ * the git/gh/ticket ports.
+ *
+ * Story #2990: the sweep protection-ctx `ghRunner` stays on raw
+ * `spawnSync('gh', …)` (not the `lib/gh-exec.js` async facade) because
+ * `executeCleanup` invokes the protection checks inside a synchronous
+ * candidate-filter loop. The runner contract is the legacy
+ * `(args, opts) => stdout string` shape.
+ */
+
+import { spawnSync as defaultSpawnSync } from 'node:child_process';
+import { gitSpawn } from '../git-utils.js';
+
+/**
+ * Build the synchronous `gh` runner the sweep uses for its
+ * candidate-protection checks.
+ *
+ * Story #4073: the `spawnImpl` seam injects the `spawnSync` boundary so
+ * the runner's success/error handling can be unit-tested without a live
+ * `gh` binary. It defaults to `child_process.spawnSync`, so the
+ * production CLI path is unchanged.
+ *
+ * @param {string} cwd Repo root used as the default spawn cwd.
+ * @param {typeof defaultSpawnSync} [spawnImpl] Injectable spawn boundary —
+ *   defaults to `child_process.spawnSync`.
+ * @returns {(args: string[], opts?: { cwd?: string }) => string}
+ */
+export function makeGhRunner(cwd, spawnImpl = defaultSpawnSync) {
+  return (args, opts) => {
+    const result = spawnImpl('gh', args, {
+      cwd: opts?.cwd ?? cwd,
+      encoding: 'utf-8',
+      shell: false,
+    });
+    if (result.status !== 0) {
+      throw new Error(
+        `gh ${args.join(' ')} exit ${result.status}: ${result.stderr ?? ''}`,
+      );
+    }
+    return result.stdout ?? '';
+  };
+}
+
+/**
+ * Build the `evaluateProtection` ctx bag: the repo root, the `gitSpawn`
+ * port, the synchronous `gh` runner, and a `getTicket` port bound to the
+ * supplied provider.
+ *
+ * @param {{
+ *   cwd: string,
+ *   provider: { getTicket: (id: number) => Promise<object> },
+ *   spawnImpl?: typeof defaultSpawnSync,
+ * }} args
+ * @returns {{
+ *   repoRoot: string,
+ *   gitSpawn: typeof gitSpawn,
+ *   ghRunner: (args: string[], opts?: { cwd?: string }) => string,
+ *   getTicket: (id: number) => Promise<object>,
+ * }}
+ */
+export function buildProtectionCtx({ cwd, provider, spawnImpl }) {
+  return {
+    repoRoot: cwd,
+    gitSpawn,
+    ghRunner: makeGhRunner(cwd, spawnImpl),
+    getTicket: (id) => provider.getTicket(id),
+  };
+}