mandrel 2.65.0 → 2.67.0

package/.agents/scripts/lib/orchestration/plan-runner/worktree-sweep.js

@@ -1,11 +1,17 @@
 /**
- * plan-runner/worktree-sweep.js — plan-boot sweep that force-removes
+ * plan-runner/worktree-sweep.js — boot sweep that removes
  * `.worktrees/story-<id>/` entries whose Story is closed or `agent::done`,
- * after draining the pending-cleanup manifest.
+ * after draining the pending-cleanup manifest. Called by `runBootSweep`
+ * (`boot-sweep.js`) under the shared merged-branch sweep lock.
  *
- * `--force` is deliberate: a done Story's branch is already merged, so any
- * residue (dirty artifacts, an interrupted rebase, a Windows lock) is noise;
- * the `WorktreeManager.reap` safety rails are for the active close path.
+ * Removal goes through `removeWorktreeWithRecovery` — the same seam close
+ * uses: Windows lock retries, an `fs.rm` fallback that discards residue a
+ * done Story's merged branch no longer needs, and the pending-cleanup
+ * hand-off when that exhausts. Branches are never deleted here; the
+ * merged-branch sweep owns them.
+ *
+ * Two trees are never touched: an open Story's, and the one the running
+ * process was loaded from or is working in (`findRunningCodeInside`).
  */
 
 import path from 'node:path';
@@ -13,8 +19,13 @@ import * as defaultGit from '../../git-utils.js';
 import { NOOP_LOGGER } from '../../Logger.js';
 import { AGENT_LABELS } from '../../label-constants.js';
 import { concurrentMap } from '../../util/concurrent-map.js';
-import { parseWorktreePorcelain } from '../../worktree/inspector.js';
+import { canonicalPath } from '../../worktree/canonical-path.js';
+import { parseWorktreePorcelain, samePath } from '../../worktree/inspector.js';
 import { forceDrainPendingCleanup } from '../../worktree/lifecycle/force-drain.js';
+import {
+  findRunningCodeInside,
+  removeWorktreeWithRecovery,
+} from '../../worktree/lifecycle/reap.js';
 
 const TICKET_READ_CONCURRENCY = 8;
 
@@ -27,33 +38,32 @@ function isStoryDone(ticket) {
   return labels.includes(DONE_LABEL);
 }
 
-function storyIdFromPath(wtPath) {
-  const parts = wtPath.replace(/\\/g, '/').split('/');
-  const last = parts[parts.length - 1] ?? '';
-  return defaultGit.parseStoryBranch(last);
+/**
+ * The Story id of a `<worktreeRoot>/story-<id>` entry, else `null` — a
+ * `story-<id>` directory anywhere else (e.g. `.claude/worktrees/`) is not
+ * this sweep's to judge.
+ *
+ * @param {string} wtPath
+ * @param {string} worktreeRoot
+ * @param {string} platform
+ * @returns {number|null}
+ */
+function storyIdFromPath(wtPath, worktreeRoot, platform) {
+  const parent = path.dirname(canonicalPath(wtPath));
+  if (!samePath(parent, canonicalPath(worktreeRoot), platform)) return null;
+  return defaultGit.parseStoryBranch(path.basename(path.resolve(wtPath)));
 }
 
 /**
- * Never touches a worktree whose Story is still open.
+ * Validate and normalise the options bag.
  *
  * @param {object} opts
- * @param {object} opts.provider    Only `getTicket(id)` is required.
- * @param {string} opts.repoRoot    Absolute path to the main checkout.
- * @param {object} [opts.git]
- * @param {object} [opts.logger]
- * @returns {Promise<{
- *   reaped: Array<{ storyId: number, path: string }>,
- *   skipped: Array<{ storyId: number|null, path: string, reason: string }>,
- * }>}
+ * @returns {object}
  */
-export async function sweepStaleStoryWorktrees(opts = {}) {
+function resolveSweepOptions(opts) {
   const ctx = opts.ctx;
   const provider = opts.provider ?? ctx?.provider;
   const repoRoot = opts.repoRoot ?? ctx?.cwd;
-  const git = opts.git ?? defaultGit;
-  const logger = opts.logger ?? ctx?.logger ?? NOOP_LOGGER;
-  const fsRm = opts.fsRm;
-  const worktreeRoot = opts.worktreeRoot;
   if (!provider || typeof provider.getTicket !== 'function') {
     throw new Error(
       'sweepStaleStoryWorktrees: provider with getTicket(id) is required',
@@ -62,107 +72,149 @@ export async function sweepStaleStoryWorktrees(opts = {}) {
   if (!repoRoot || typeof repoRoot !== 'string') {
     throw new Error('sweepStaleStoryWorktrees: repoRoot is required');
   }
+  const platform = opts.platform ?? process.platform;
+  return {
+    provider,
+    repoRoot,
+    platform,
+    git: opts.git ?? defaultGit,
+    logger: opts.logger ?? ctx?.logger ?? NOOP_LOGGER,
+    fsRm: opts.fsRm,
+    sleepFn: opts.sleepFn,
+    worktreeRoot: path.resolve(
+      opts.worktreeRoot ?? path.join(repoRoot, '.worktrees'),
+    ),
+    guardPaths: [process.cwd(), ...(opts.runningPaths ?? [])],
+  };
+}
 
-  const resolvedWorktreeRoot =
-    worktreeRoot ?? path.join(repoRoot, '.worktrees');
+/**
+ * Read every Story worktree's ticket; each mapper captures its own error so
+ * one provider hiccup cannot abort the sweep via concurrentMap's
+ * first-rejection-wins policy.
+ */
+function readStoryTickets(entries, o) {
+  return concurrentMap(
+    entries,
+    async (entry) => {
+      const wtPath = entry.path;
+      const storyId = wtPath
+        ? storyIdFromPath(wtPath, o.worktreeRoot, o.platform)
+        : null;
+      if (storyId === null) return { kind: 'non-story' };
+      try {
+        const ticket = await o.provider.getTicket(storyId);
+        return { kind: 'ok', wtPath, storyId, ticket };
+      } catch (err) {
+        return { kind: 'provider-error', wtPath, storyId, error: err };
+      }
+    },
+    { concurrency: TICKET_READ_CONCURRENCY },
+  );
+}
+
+/**
+ * Why a read entry must be kept, or `null` when it may be removed.
+ *
+ * @returns {string|null}
+ */
+function keepReason(r, o) {
+  if (r.kind === 'provider-error') {
+    o.logger.warn(
+      `worktree-sweep: provider.getTicket(#${r.storyId}) failed: ${r.error.message}`,
+    );
+    return `provider-error: ${r.error.message}`;
+  }
+  if (!isStoryDone(r.ticket)) return 'story-open';
+  const selfPath = findRunningCodeInside(o, r.wtPath, o.guardPaths);
+  if (selfPath) {
+    o.logger.warn(
+      `worktree-sweep: skipped storyId=${r.storyId} path=${r.wtPath} — the running process uses it (${selfPath})`,
+    );
+    return 'running-from-target-tree';
+  }
+  return null;
+}
+
+async function removeOne(r, o) {
+  const ctx = {
+    repoRoot: o.repoRoot,
+    git: o.git,
+    logger: o.logger,
+    platform: o.platform,
+    worktreeRoot: o.worktreeRoot,
+    listCache: { list: null, ts: 0 },
+    fsRm: o.fsRm,
+  };
+  const res = await removeWorktreeWithRecovery(ctx, r.wtPath, {
+    storyId: r.storyId,
+    ...(o.sleepFn ? { sleepFn: o.sleepFn, retryDelay: 0 } : {}),
+  });
+  return res.removed
+    ? null
+    : `remove-failed: ${res.reason ?? 'worktree-remove-failed'}`;
+}
+
+/**
+ * Never touches a worktree whose Story is still open, nor the one the
+ * running process uses.
+ *
+ * @param {object} opts
+ * @param {object} opts.provider    Only `getTicket(id)` is required.
+ * @param {string} opts.repoRoot    Absolute path to the main checkout.
+ * @param {object} [opts.git]
+ * @param {object} [opts.logger]
+ * @param {string[]} [opts.runningPaths] Extra paths the running process owns.
+ * @returns {Promise<{
+ *   reaped: Array<{ storyId: number, path: string }>,
+ *   skipped: Array<{ storyId: number|null, path: string, reason: string }>,
+ * }>}
+ */
+export async function sweepStaleStoryWorktrees(opts = {}) {
+  const o = resolveSweepOptions(opts);
 
   // Drain the pending-cleanup manifest first so entries whose Windows locks
   // have released self-heal instead of accumulating.
   const drainResult = await forceDrainPendingCleanup({
-    repoRoot,
-    worktreeRoot: resolvedWorktreeRoot,
-    git,
-    fsRm,
-    logger,
+    repoRoot: o.repoRoot,
+    worktreeRoot: o.worktreeRoot,
+    git: o.git,
+    fsRm: o.fsRm,
+    logger: o.logger,
   });
 
   const reaped = [];
   const skipped = [];
 
-  const listRes = git.gitSpawn(repoRoot, 'worktree', 'list', '--porcelain');
+  const listRes = o.git.gitSpawn(o.repoRoot, 'worktree', 'list', '--porcelain');
   if (listRes.status !== 0) {
-    logger.warn(
+    o.logger.warn(
       `worktree-sweep: git worktree list failed: ${listRes.stderr || listRes.stdout || 'unknown'}`,
     );
     return { reaped, skipped };
   }
 
-  const entries = parseWorktreePorcelain(listRes.stdout || '');
-
-  // Each mapper captures its own error so one provider hiccup cannot abort
-  // the sweep via concurrentMap's first-rejection-wins policy.
-  const reads = await concurrentMap(
-    entries,
-    async (entry) => {
-      const wtPath = entry.path;
-      if (!wtPath) return { kind: 'no-path' };
-      const storyId = storyIdFromPath(wtPath);
-      if (storyId === null) return { kind: 'non-story' };
-      try {
-        const ticket = await provider.getTicket(storyId);
-        return { kind: 'ok', wtPath, storyId, ticket };
-      } catch (err) {
-        return { kind: 'provider-error', wtPath, storyId, error: err };
-      }
-    },
-    { concurrency: TICKET_READ_CONCURRENCY },
+  const reads = await readStoryTickets(
+    parseWorktreePorcelain(listRes.stdout || ''),
+    o,
   );
 
   // Removes stay sequential: they mutate .git/worktrees/, and racing git's
   // locking on Windows can leave a partial admin dir the next remove trips on.
   for (const r of reads) {
-    if (r.kind === 'no-path' || r.kind === 'non-story') continue;
-    if (r.kind === 'provider-error') {
-      skipped.push({
-        storyId: r.storyId,
-        path: r.wtPath,
-        reason: `provider-error: ${r.error.message}`,
-      });
-      logger.warn(
-        `worktree-sweep: provider.getTicket(#${r.storyId}) failed: ${r.error.message}`,
-      );
-      continue;
-    }
-
-    if (!isStoryDone(r.ticket)) {
-      skipped.push({
-        storyId: r.storyId,
-        path: r.wtPath,
-        reason: 'story-open',
-      });
-      continue;
-    }
-
-    const res = git.gitSpawn(
-      repoRoot,
-      'worktree',
-      'remove',
-      '--force',
-      r.wtPath,
-    );
-    if (res.status !== 0) {
-      const reason = (
-        res.stderr ||
-        res.stdout ||
-        'worktree-remove-failed'
-      ).trim();
-      skipped.push({
-        storyId: r.storyId,
-        path: r.wtPath,
-        reason: `remove-failed: ${reason}`,
-      });
-      logger.warn(
-        `worktree-sweep: failed to reap storyId=${r.storyId} path=${r.wtPath}: ${reason}`,
-      );
+    if (r.kind === 'non-story') continue;
+    const reason = keepReason(r, o) ?? (await removeOne(r, o));
+    if (reason) {
+      skipped.push({ storyId: r.storyId, path: r.wtPath, reason });
       continue;
     }
     reaped.push({ storyId: r.storyId, path: r.wtPath });
-    logger.info(
+    o.logger.info(
       `worktree-sweep: reaped stale worktree storyId=${r.storyId} path=${r.wtPath}`,
     );
   }
 
-  git.gitSpawn(repoRoot, 'worktree', 'prune');
+  o.git.gitSpawn(o.repoRoot, 'worktree', 'prune');
 
   return {
     reaped,

package/.agents/scripts/lib/orchestration/review-providers/review-provider-factory.js

@@ -195,6 +195,16 @@ export function buildProviderChain(entries, ctx) {
   return { inline, prompts };
 }
 
+/**
+ * @param {Record<string, number>} tally
+ * @param {string} name
+ * @param {Finding[]} findings
+ */
+function recordCritical(tally, name, findings) {
+  const critical = findings.filter((f) => f?.severity === 'critical').length;
+  if (critical > 0) tally[name] = critical;
+}
+
 /**
  * Inline findings merge in declaration order; prompt entries render via
  * `getPromptMessages`.
@@ -203,11 +213,14 @@ export function buildProviderChain(entries, ctx) {
  * @param {{ logger?: { info?: Function, warn?: Function } }} [opts]
  * @returns {ReviewProvider & {
  *   getPromptMessages: (input: ReviewInput) => Promise<string[]>,
+ *   getCriticalByProvider: () => Record<string, number>,
  *   chain: ProviderChain,
  * }}
  */
 export function createChainProvider(chain, opts = {}) {
   const logger = opts.logger;
+  /** Critical findings per entry from the last `runReview`, for attribution. */
+  let criticalByProvider = {};
 
   return {
     chain,
@@ -218,6 +231,7 @@ export function createChainProvider(chain, opts = {}) {
     async runReview(input) {
       /** @type {Finding[]} */
       const merged = [];
+      criticalByProvider = {};
       const ctx = {
         scope: input?.scope,
         labels: /** @type {ReadonlyArray<string>} */ (
@@ -238,9 +252,18 @@ export function createChainProvider(chain, opts = {}) {
           );
         }
         for (const f of findings) merged.push(f);
+        recordCritical(criticalByProvider, entry.name, findings);
       }
       return merged;
     },
+    /**
+     * Which entries raised the last run's critical findings, and how many.
+     *
+     * @returns {Record<string, number>}
+     */
+    getCriticalByProvider() {
+      return { ...criticalByProvider };
+    },
     /**
      * Called after `runReview`.
      *

package/.agents/scripts/lib/orchestration/run-epilogue.js

@@ -10,6 +10,7 @@ import { selectAudits } from '../audit-suite/index.js';
 import { graduateRetroProposals } from '../feedback-loop/retro-proposals-graduator.js';
 import { gitSpawn } from '../git-utils.js';
 import { Logger } from '../Logger.js';
+import { gatherRunTelemetry } from '../observability/close-telemetry.js';
 import { isEpicTicket } from './epic-container.js';
 import { composeRoutedProposals } from './retro-proposals.js';
 import {
@@ -657,6 +658,8 @@ async function executeFollowUpRollup({
     graduateFn,
   });
   const categories = summarizeSignalCategories(signals);
+  // Step result only, never the roll-up comment: telemetry stays local.
+  const telemetry = await gatherRunTelemetry(stories, config);
   const proposalCount = proposals.framework.length + proposals.consumer.length;
   const outcome = assessRollupOutcome({
     signalCount: signals.length,
@@ -687,6 +690,7 @@ async function executeFollowUpRollup({
     categories,
     outcome,
     frictionWindow,
+    telemetry,
   });
 }
 
@@ -743,6 +747,7 @@ function buildRollupStepResult({
   categories,
   outcome,
   frictionWindow,
+  telemetry = null,
 }) {
   return {
     kind: 'follow-up-rollup',
@@ -766,6 +771,7 @@ function buildRollupStepResult({
       fingerprint: item.fingerprint ?? null,
     })),
     emptyRollupSuspect: signals.length === 0 && storyCount > 1,
+    telemetry,
   };
 }
 

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

@@ -134,6 +134,7 @@ async function postStoryReviewCrossRef({
  *   halted: boolean,
  *   skipped?: boolean,
  *   severity?: { critical: number, high: number, medium: number, suggestion: number },
+ *   criticalByProvider?: Record<string, number>,
  *   posted?: boolean,
  *   postedCommentId?: number|null,
  *   degraded?: boolean,
@@ -214,6 +215,7 @@ export async function runStoryScopeReview({
   return {
     halted: !!result.halted,
     severity: sev,
+    criticalByProvider: result.criticalByProvider,
     posted: result.posted,
     postedCommentId: result.postedCommentId ?? null,
     ...degradationEnvelope(result.degradations),