mandrel 2.64.0 → 2.66.0

package/.agents/scripts/lib/orchestration/single-story-close/phases/options.js

@@ -25,6 +25,17 @@ function resolveFlag(paramValue, parsedValue) {
   return paramValue ?? parsedValue;
 }
 
+/**
+ * A boolean flag: param beats parsed arg, absent reads as `false`.
+ *
+ * @param {unknown} paramValue
+ * @param {unknown} parsedValue
+ * @returns {boolean}
+ */
+function booleanFlag(paramValue, parsedValue) {
+  return !!resolveFlag(paramValue, parsedValue);
+}
+
 /**
  * Junk reads as absent (so the config default applies), never coerced.
  *
@@ -88,7 +99,7 @@ const RETIRED_FLAGS = Object.freeze({
  * @param {string[]} argv
  * @throws {Error}
  */
-function assertNoRetiredFlags(argv) {
+export function assertNoRetiredFlags(argv) {
   for (const [flag, why] of Object.entries(RETIRED_FLAGS)) {
     const present = argv.some((a) => a === flag || a.startsWith(`${flag}=`));
     if (!present) continue;
@@ -102,8 +113,8 @@ function assertNoRetiredFlags(argv) {
 /**
  * Returns raw wait-for-merge intent; the runner resolves it after the arm.
  *
- * @param {{ storyIdParam, cwdParam, skipValidationParam, skipSyncParam, noAutoMergeParam, waitForMergeParam, noWaitForMergeParam, maxWaitSecondsParam, mergeWatchModeParam, rerunAdvisoryParam, overrideReviewBlockParam }} raw
- * @returns {{ storyId, cwd, skipValidation, skipSync, noAutoMerge, waitForMergeExplicit, noWaitForMerge, maxWaitSeconds, mergeWatchMode, rerunAdvisory, overrideReviewBlock }}
+ * @param {{ storyIdParam, cwdParam, skipValidationParam, skipSyncParam, noAutoMergeParam, waitForMergeParam, noWaitForMergeParam, maxWaitSecondsParam, mergeWatchModeParam, rerunAdvisoryParam, overrideReviewBlockParam, workerTokensParam }} raw
+ * @returns {{ storyId, cwd, skipValidation, skipSync, noAutoMerge, waitForMergeExplicit, noWaitForMerge, maxWaitSeconds, mergeWatchMode, rerunAdvisory, overrideReviewBlock, workerTokens }}
  */
 export function parseCloseOptions({
   storyIdParam,
@@ -117,6 +128,7 @@ export function parseCloseOptions({
   mergeWatchModeParam,
   rerunAdvisoryParam,
   overrideReviewBlockParam,
+  workerTokensParam,
 }) {
   // An injecting caller never reads argv (the host's flags are not its
   // business), so `parsed` stays empty and the retired-flag guard is skipped.
@@ -145,17 +157,19 @@ export function parseCloseOptions({
       resolveFlag(mergeWatchModeParam, parsed.mergeWatchMode),
     ),
     rerunAdvisory: intAtLeast(rerunAdvisory, 0),
-    skipValidation: !!resolveFlag(skipValidationParam, parsed.skipValidation),
-    skipSync: !!resolveFlag(skipSyncParam, parsed.skipSync),
-    noAutoMerge: !!resolveFlag(noAutoMergeParam, parsed.noAutoMerge),
+    skipValidation: booleanFlag(skipValidationParam, parsed.skipValidation),
+    skipSync: booleanFlag(skipSyncParam, parsed.skipSync),
+    noAutoMerge: booleanFlag(noAutoMergeParam, parsed.noAutoMerge),
     waitForMergeExplicit:
       typeof waitForMergeExplicit === 'boolean'
         ? waitForMergeExplicit
         : undefined,
-    noWaitForMerge: !!resolveFlag(noWaitForMergeParam, parsed.noWaitForMerge),
+    noWaitForMerge: booleanFlag(noWaitForMergeParam, parsed.noWaitForMerge),
     // Both doors validate, so neither can arm a reasonless override.
     overrideReviewBlock: parseOverrideReviewBlock(
       resolveFlag(overrideReviewBlockParam, parsed.overrideReviewBlock),
     ),
+    // Raw: validated best-effort by the runner, never thrown on.
+    workerTokens: resolveFlag(workerTokensParam, parsed.workerTokens),
   };
 }

package/.agents/scripts/lib/orchestration/single-story-close/phases/post-land.js

@@ -282,11 +282,61 @@ async function stepPlanRunLabelReap({
 }
 
 /**
- * Run the post-land tail, sequentially. The ref reap and fast-forward (the
- * local-checkout mutations, reap first) run under a cross-process lock on the
- * main checkout, since concurrent closes race on the base ref and worktree
- * registry; GitHub steps stay outside it. The lock is best-effort: on
- * timeout the mutations run anyway.
+ * The local-checkout mutations (ref reap first, then fast-forward) under a
+ * cross-process lock on the main checkout, since concurrent closes race on
+ * the base ref and worktree registry. Best-effort: on timeout they run anyway.
+ */
+async function runLockedLocalSteps({
+  storyId,
+  storyBranch,
+  baseBranch,
+  cwd,
+  config,
+  progress,
+  gitSpawnFn,
+  planFastForwardFn,
+  executeFastForwardFn,
+  acquireLockWithWaitFn,
+}) {
+  const lockCfg = config?.delivery?.postLandLock ?? {};
+  const lock = await acquireLockWithWaitFn({
+    lockPath: postLandLockPath(cwd),
+    waitMs: lockCfg.waitMs,
+    pollMs: lockCfg.pollMs,
+    timeoutMs: lockCfg.timeoutMs,
+    ownerId: `post-land-${storyId}`,
+  });
+  if (!lock.acquired) {
+    progress?.(
+      'POST-LAND',
+      `⚠️ post-land lock not acquired (${lock.reason}); proceeding unserialized.`,
+    );
+  }
+  try {
+    const refCleanup = await step(
+      () => stepRefCleanup({ cwd, storyBranch, progress, gitSpawnFn }),
+      { name: 'local ref cleanup', progress },
+    );
+    const baseFastForward = await step(
+      () =>
+        stepBaseFastForward({
+          cwd,
+          baseBranch,
+          progress,
+          planFastForwardFn,
+          executeFastForwardFn,
+        }),
+      { name: 'base fast-forward', progress },
+    );
+    return { refCleanup, baseFastForward };
+  } finally {
+    if (lock.acquired) lock.release();
+  }
+}
+
+/**
+ * Run the post-land tail: friction markers, then the GitHub steps and the
+ * locked local steps concurrently, then temp purge, then lease release.
  *
  * @param {object} args
  * @param {number} args.storyId
@@ -348,87 +398,67 @@ export async function runPostLandTail({
     config,
   });
 
-  const followUps = await step(
-    () =>
-      stepFollowUps({
-        storyId,
-        provider,
-        config,
-        cwd,
-        progress,
-        captureStoryFollowUpsFn,
-      }),
-    { name: 'follow-up capture', progress },
-  );
-  const statusResync = await step(
-    () =>
-      stepStatusResync({
-        storyId,
-        provider,
-        config,
-        progress,
-        reassertStatusColumnFn,
-      }),
-    { name: 'status-column resync', progress },
-  );
-  await step(
-    () =>
-      stepPlanRunLabelReap({
-        storyId,
-        provider,
-        progress,
-        reapPlanRunLabelsForStoryFn,
-      }),
-    { name: 'plan-run label reap', progress },
-  );
-
-  const epicRollup = await step(
-    () =>
-      stepEpicRollup({
-        storyId,
-        provider,
-        config,
-        progress,
-        rollUpEpicForStoryFn,
-      }),
-    { name: 'epic rollup', progress },
-  );
-
-  const lockCfg = config?.delivery?.postLandLock ?? {};
-  const lock = await acquireLockWithWaitFn({
-    lockPath: postLandLockPath(cwd),
-    waitMs: lockCfg.waitMs,
-    pollMs: lockCfg.pollMs,
-    timeoutMs: lockCfg.timeoutMs,
-    ownerId: `post-land-${storyId}`,
-  });
-  if (!lock.acquired) {
-    progress?.(
-      'POST-LAND',
-      `⚠️ post-land lock not acquired (${lock.reason}); proceeding unserialized.`,
-    );
-  }
-  let refCleanup;
-  let baseFastForward;
-  try {
-    refCleanup = await step(
-      () => stepRefCleanup({ cwd, storyBranch, progress, gitSpawnFn }),
-      { name: 'local ref cleanup', progress },
-    );
-    baseFastForward = await step(
+  // The GitHub steps are independent of each other and of the local
+  // lock-held mutations, so all of them run concurrently.
+  const [followUps, statusResync, , epicRollup, local] = await Promise.all([
+    step(
       () =>
-        stepBaseFastForward({
+        stepFollowUps({
+          storyId,
+          provider,
+          config,
           cwd,
-          baseBranch,
           progress,
-          planFastForwardFn,
-          executeFastForwardFn,
+          captureStoryFollowUpsFn,
         }),
-      { name: 'base fast-forward', progress },
-    );
-  } finally {
-    if (lock.acquired) lock.release();
-  }
+      { name: 'follow-up capture', progress },
+    ),
+    step(
+      () =>
+        stepStatusResync({
+          storyId,
+          provider,
+          config,
+          progress,
+          reassertStatusColumnFn,
+        }),
+      { name: 'status-column resync', progress },
+    ),
+    step(
+      () =>
+        stepPlanRunLabelReap({
+          storyId,
+          provider,
+          progress,
+          reapPlanRunLabelsForStoryFn,
+        }),
+      { name: 'plan-run label reap', progress },
+    ),
+    step(
+      () =>
+        stepEpicRollup({
+          storyId,
+          provider,
+          config,
+          progress,
+          rollUpEpicForStoryFn,
+        }),
+      { name: 'epic rollup', progress },
+    ),
+    runLockedLocalSteps({
+      storyId,
+      storyBranch,
+      baseBranch,
+      cwd,
+      config,
+      progress,
+      gitSpawnFn,
+      planFastForwardFn,
+      executeFastForwardFn,
+      acquireLockWithWaitFn,
+    }),
+  ]);
+  const { refCleanup, baseFastForward } = local;
 
   // After every step that reads the temp artifacts; `signals.ndjson` survives.
   const tempPurge = await step(

package/.agents/scripts/lib/orchestration/single-story-close/phases/review-override.js

@@ -65,6 +65,7 @@ async function postAuditRecord({ post, surface }) {
  *   prUrl: string,
  *   prNumber: number|null,
  *   criticalCount: number,
+ *   criticalByProvider?: Record<string, number>,
  *   reason: string,
  *   config?: object,
  *   emitFrictionFn?: typeof emitRuntimeFriction,
@@ -77,6 +78,7 @@ export async function handleOverriddenReviewBlock({
   prUrl,
   prNumber,
   criticalCount,
+  criticalByProvider = {},
   reason,
   config,
   emitFrictionFn = emitRuntimeFriction,
@@ -104,6 +106,8 @@ export async function handleOverriddenReviewBlock({
     details: {
       prUrl,
       criticalCount,
+      // The false-positive proxy: attributed like the halt it rejected.
+      criticalByProvider,
       reason: reason.slice(0, REASON_SIGNAL_LIMIT),
     },
     config,