mandrel 1.62.0 → 1.64.0

package/.agents/scripts/lib/baseline-snapshot.js

@@ -452,6 +452,219 @@ export function commitSnapshotsToEpicBranch({
  *   files: Array<{ kind: 'maintainability'|'crap', path: string, didChange: boolean, reason?: 'no-coverage'|'unchanged'|'updated' }>,
  * }>}
  */
+/**
+ * Build the `files[]` entry for a baseline write, choosing between the
+ * structural-equality short-circuit (no write, `reason: 'unchanged'`) and
+ * the stamp-and-write path (`reason: 'updated'`). Story #4075 — collapses
+ * the duplicated short-circuit branch shared by the MI and CRAP passes.
+ *
+ * @returns {{ entry: object, wrote: boolean }}
+ */
+function commitBaselineEnvelope({
+  kind,
+  abs,
+  envelope,
+  priorEnvelope,
+  writeFileFn,
+  fsImpl,
+}) {
+  if (priorEnvelope && envelope === priorEnvelope) {
+    return {
+      entry: { kind, path: abs, didChange: false, reason: 'unchanged' },
+      wrote: false,
+    };
+  }
+  writeFileFn(abs, envelope, { fsImpl });
+  return {
+    entry: { kind, path: abs, didChange: true, reason: 'updated' },
+    wrote: true,
+  };
+}
+
+/**
+ * Regenerate the maintainability baseline from a fresh tree scan. Returns
+ * `null` when no maintainability baseline path is configured. The scanned
+ * source list is returned so the CRAP pass can reuse it when the two passes
+ * target the same dirs (Story #3663). Story #4075 — extracted from
+ * `regenerateMainFromTree`.
+ */
+async function regenerateMaintainability({
+  cwd,
+  baselines,
+  quality,
+  scanDirectoryFn,
+  calculateAllFn,
+  writeFn,
+  writeFileFn,
+  loadPriorFn,
+  fsImpl,
+}) {
+  const miPath = baselines?.maintainability?.path;
+  if (typeof miPath !== 'string' || miPath.length === 0) return null;
+
+  const miTargetDirs = quality?.maintainability?.targetDirs ?? [];
+  const miIgnoreGlobs = quality?.maintainability?.ignoreGlobs ?? [];
+  const miAbs = path.isAbsolute(miPath) ? miPath : path.resolve(cwd, miPath);
+  const miSourceList = [];
+  for (const dir of miTargetDirs) {
+    const abs = path.isAbsolute(dir) ? dir : path.resolve(cwd, dir);
+    scanDirectoryFn(abs, miSourceList, { cwd, ignoreGlobs: miIgnoreGlobs });
+  }
+  const scores = await calculateAllFn(miSourceList);
+
+  // Project the scoring helper's `{path: mi}` map onto the writer's
+  // canonical row shape. Story #2079 path-canon defence stays in place —
+  // the writer would canonicalise again, but doing it here keeps any
+  // pre-canonicalised comparison inside the function meaningful.
+  const miRows = filterExcludedRows(
+    Object.entries(scores).map(([key, mi]) => {
+      const rel = path.isAbsolute(key) ? path.relative(cwd, key) : key;
+      const posixRel = rel.split(path.sep).join('/');
+      return { path: canonicalisePath(posixRel), mi };
+    }),
+  );
+
+  const priorMi = loadPriorFn(miAbs, 'maintainability');
+  const envelope = writeFn({
+    kind: 'maintainability',
+    rows: miRows,
+    priorEnvelope: priorMi,
+  });
+  const { entry, wrote } = commitBaselineEnvelope({
+    kind: 'maintainability',
+    abs: miAbs,
+    envelope,
+    priorEnvelope: priorMi,
+    writeFileFn,
+    fsImpl,
+  });
+  return { entry, wrote, miSourceList, miTargetDirs, miIgnoreGlobs };
+}
+
+/**
+ * Decide whether the CRAP pass can reuse the MI scan's file list — true only
+ * when both passes target the same dirs with the same ignore globs
+ * (Story #3663).
+ */
+function crapDirsMatchMi({
+  miSourceList,
+  crapTargetDirs,
+  crapIgnoreGlobs,
+  miTargetDirs,
+  miIgnoreGlobs,
+}) {
+  return (
+    miSourceList !== null &&
+    crapTargetDirs.length === miTargetDirs.length &&
+    crapTargetDirs.every((d, i) => d === miTargetDirs[i]) &&
+    crapIgnoreGlobs.length === miIgnoreGlobs.length &&
+    crapIgnoreGlobs.every((g, i) => g === miIgnoreGlobs[i])
+  );
+}
+
+/**
+ * Regenerate the CRAP baseline from a fresh tree scan + coverage map.
+ * Returns `null` when no CRAP baseline path is configured. Story #4075 —
+ * extracted from `regenerateMainFromTree`.
+ */
+async function regenerateCrap({
+  cwd,
+  baselines,
+  quality,
+  logger,
+  miScan,
+  scanAndScoreFn,
+  loadCoverageFn,
+  resolveEscomplexVersionFn,
+  resolveTsTranspilerVersionFn,
+  writeFn,
+  writeFileFn,
+  loadPriorFn,
+  fsImpl,
+}) {
+  const crapPath = baselines?.crap?.path;
+  if (typeof crapPath !== 'string' || crapPath.length === 0) return null;
+
+  const crapCfg = quality?.crap ?? {};
+  const crapTargetDirs = Array.isArray(crapCfg.targetDirs)
+    ? crapCfg.targetDirs
+    : [];
+  const crapIgnoreGlobs = Array.isArray(crapCfg.ignoreGlobs)
+    ? crapCfg.ignoreGlobs
+    : [];
+  const requireCoverage = crapCfg.requireCoverage !== false;
+  const coveragePath = crapCfg.coveragePath ?? 'coverage/coverage-final.json';
+  const crapAbs = path.isAbsolute(crapPath)
+    ? crapPath
+    : path.resolve(cwd, crapPath);
+  const coverageAbs = path.isAbsolute(coveragePath)
+    ? coveragePath
+    : path.resolve(cwd, coveragePath);
+  const coverage = loadCoverageFn(coverageAbs);
+
+  if (!coverage && requireCoverage) {
+    logger.warn?.(
+      `[baseline-snapshot] ⚠ no coverage at ${coveragePath} — skipping crap regeneration (refresh stays clean for this file).`,
+    );
+    return {
+      entry: {
+        kind: 'crap',
+        path: crapAbs,
+        didChange: false,
+        reason: 'no-coverage',
+      },
+      wrote: false,
+    };
+  }
+
+  const reusePreScan = crapDirsMatchMi({
+    miSourceList: miScan?.miSourceList ?? null,
+    crapTargetDirs,
+    crapIgnoreGlobs,
+    miTargetDirs: miScan?.miTargetDirs ?? [],
+    miIgnoreGlobs: miScan?.miIgnoreGlobs ?? [],
+  });
+  const { rows } = await scanAndScoreFn({
+    targetDirs: crapTargetDirs,
+    coverage,
+    requireCoverage,
+    cwd,
+    ignoreGlobs: crapIgnoreGlobs,
+    ...(reusePreScan && { preScannedFiles: miScan.miSourceList }),
+  });
+  // scanAndScore yields rows keyed by `file:`; the per-kind crap module's
+  // `projectRow` handles `path ?? file`, so the writer takes either.
+  // Filter to actually-scored rows here (crap is nullable for trivial
+  // methods); the writer's `assertEnvelope` would reject otherwise.
+  const crapRows = (rows ?? []).filter(
+    (r) => typeof r?.crap === 'number' && Number.isFinite(r.crap),
+  );
+
+  // CRAP gates need the running scorer's versions present on the
+  // envelope-adjacent shape; the V2 envelope itself only carries
+  // `kernelVersion`, so we stamp escomplex/tsTranspiler via the writer's
+  // `kernelVersion` override and let the existing per-kind module resolve
+  // the rest. We also resolve them eagerly so a test stub can pin them
+  // deterministically.
+  resolveEscomplexVersionFn(cwd);
+  resolveTsTranspilerVersionFn();
+
+  const priorCrap = loadPriorFn(crapAbs, 'crap');
+  const envelope = writeFn({
+    kind: 'crap',
+    rows: crapRows,
+    priorEnvelope: priorCrap,
+  });
+  return commitBaselineEnvelope({
+    kind: 'crap',
+    abs: crapAbs,
+    envelope,
+    priorEnvelope: priorCrap,
+    writeFileFn,
+    fsImpl,
+  });
+}
+
 export async function regenerateMainFromTree({
   cwd = process.cwd(),
   resolveConfig = defaultResolveConfig,
@@ -476,149 +689,40 @@ export async function regenerateMainFromTree({
   const files = [];
   let didChange = false;
 
-  // ── maintainability ──────────────────────────────────────────────────────
-  const miPath = baselines?.maintainability?.path;
-  const miTargetDirs = quality?.maintainability?.targetDirs ?? [];
-  const miIgnoreGlobs = quality?.maintainability?.ignoreGlobs ?? [];
-  // Hoisted so the CRAP pass can reuse it when targetDirs match — avoids a
-  // second full-tree walk over the same directories (Story #3663).
-  let miSourceList = null;
-  if (typeof miPath === 'string' && miPath.length > 0) {
-    const miAbs = path.isAbsolute(miPath) ? miPath : path.resolve(cwd, miPath);
-    miSourceList = [];
-    for (const dir of miTargetDirs) {
-      const abs = path.isAbsolute(dir) ? dir : path.resolve(cwd, dir);
-      scanDirectoryFn(abs, miSourceList, { cwd, ignoreGlobs: miIgnoreGlobs });
-    }
-    const scores = await calculateAllFn(miSourceList);
-
-    // Project the scoring helper's `{path: mi}` map onto the writer's
-    // canonical row shape. Story #2079 path-canon defence stays in place —
-    // the writer would canonicalise again, but doing it here keeps any
-    // pre-canonicalised comparison inside the function meaningful.
-    const miRows = filterExcludedRows(
-      Object.entries(scores).map(([key, mi]) => {
-        const rel = path.isAbsolute(key) ? path.relative(cwd, key) : key;
-        const posixRel = rel.split(path.sep).join('/');
-        return { path: canonicalisePath(posixRel), mi };
-      }),
-    );
-
-    const priorMi = loadPriorFn(miAbs, 'maintainability');
-    const envelope = writeFn({
-      kind: 'maintainability',
-      rows: miRows,
-      priorEnvelope: priorMi,
-    });
-    if (priorMi && envelope === priorMi) {
-      // Structural-equality short-circuit fired — on-disk bytes are
-      // guaranteed identical, no writeFile invocation needed.
-      files.push({
-        kind: 'maintainability',
-        path: miAbs,
-        didChange: false,
-        reason: 'unchanged',
-      });
-    } else {
-      writeFileFn(miAbs, envelope, { fsImpl });
-      didChange = true;
-      files.push({
-        kind: 'maintainability',
-        path: miAbs,
-        didChange: true,
-        reason: 'updated',
-      });
-    }
+  const miScan = await regenerateMaintainability({
+    cwd,
+    baselines,
+    quality,
+    scanDirectoryFn,
+    calculateAllFn,
+    writeFn,
+    writeFileFn,
+    loadPriorFn,
+    fsImpl,
+  });
+  if (miScan) {
+    files.push(miScan.entry);
+    didChange = didChange || miScan.wrote;
   }
 
-  // ── crap ─────────────────────────────────────────────────────────────────
-  const crapPath = baselines?.crap?.path;
-  const crapCfg = quality?.crap ?? {};
-  const crapTargetDirs = Array.isArray(crapCfg.targetDirs)
-    ? crapCfg.targetDirs
-    : [];
-  const crapIgnoreGlobs = Array.isArray(crapCfg.ignoreGlobs)
-    ? crapCfg.ignoreGlobs
-    : [];
-  const requireCoverage = crapCfg.requireCoverage !== false;
-  const coveragePath = crapCfg.coveragePath ?? 'coverage/coverage-final.json';
-  if (typeof crapPath === 'string' && crapPath.length > 0) {
-    const crapAbs = path.isAbsolute(crapPath)
-      ? crapPath
-      : path.resolve(cwd, crapPath);
-    const coverageAbs = path.isAbsolute(coveragePath)
-      ? coveragePath
-      : path.resolve(cwd, coveragePath);
-    const coverage = loadCoverageFn(coverageAbs);
-    if (!coverage && requireCoverage) {
-      logger.warn?.(
-        `[baseline-snapshot] ⚠ no coverage at ${coveragePath} — skipping crap regeneration (refresh stays clean for this file).`,
-      );
-      files.push({
-        kind: 'crap',
-        path: crapAbs,
-        didChange: false,
-        reason: 'no-coverage',
-      });
-    } else {
-      // Reuse the MI scan's file list when CRAP and MI target the same
-      // directories with the same ignore globs — avoids a second full-tree
-      // walk over identical source trees (Story #3663).
-      const crapDirsMatchMi =
-        miSourceList !== null &&
-        crapTargetDirs.length === miTargetDirs.length &&
-        crapTargetDirs.every((d, i) => d === miTargetDirs[i]) &&
-        crapIgnoreGlobs.length === miIgnoreGlobs.length &&
-        crapIgnoreGlobs.every((g, i) => g === miIgnoreGlobs[i]);
-      const { rows } = await scanAndScoreFn({
-        targetDirs: crapTargetDirs,
-        coverage,
-        requireCoverage,
-        cwd,
-        ignoreGlobs: crapIgnoreGlobs,
-        ...(crapDirsMatchMi && { preScannedFiles: miSourceList }),
-      });
-      // scanAndScore yields rows keyed by `file:`; the per-kind crap module's
-      // `projectRow` handles `path ?? file`, so the writer takes either.
-      // Filter to actually-scored rows here (crap is nullable for trivial
-      // methods); the writer's `assertEnvelope` would reject otherwise.
-      const crapRows = (rows ?? []).filter(
-        (r) => typeof r?.crap === 'number' && Number.isFinite(r.crap),
-      );
-
-      // CRAP gates need the running scorer's versions present on the
-      // envelope-adjacent shape; the V2 envelope itself only carries
-      // `kernelVersion`, so we stamp escomplex/tsTranspiler via the writer's
-      // `kernelVersion` override and let the existing per-kind module
-      // resolve the rest. We also resolve them eagerly so a test stub can
-      // pin them deterministically.
-      resolveEscomplexVersionFn(cwd);
-      resolveTsTranspilerVersionFn();
-
-      const priorCrap = loadPriorFn(crapAbs, 'crap');
-      const envelope = writeFn({
-        kind: 'crap',
-        rows: crapRows,
-        priorEnvelope: priorCrap,
-      });
-      if (priorCrap && envelope === priorCrap) {
-        files.push({
-          kind: 'crap',
-          path: crapAbs,
-          didChange: false,
-          reason: 'unchanged',
-        });
-      } else {
-        writeFileFn(crapAbs, envelope, { fsImpl });
-        didChange = true;
-        files.push({
-          kind: 'crap',
-          path: crapAbs,
-          didChange: true,
-          reason: 'updated',
-        });
-      }
-    }
+  const crapResult = await regenerateCrap({
+    cwd,
+    baselines,
+    quality,
+    logger,
+    miScan,
+    scanAndScoreFn,
+    loadCoverageFn,
+    resolveEscomplexVersionFn,
+    resolveTsTranspilerVersionFn,
+    writeFn,
+    writeFileFn,
+    loadPriorFn,
+    fsImpl,
+  });
+  if (crapResult) {
+    files.push(crapResult.entry);
+    didChange = didChange || crapResult.wrote;
   }
 
   return { didChange, files };

package/.agents/scripts/lib/bootstrap/branch-protection.js

@@ -126,7 +126,7 @@ export async function applyBranchProtection({
 
   if (enforce === false) {
     log(
-      `[bootstrap] Branch protection on '${baseBranch}': skipped (github.branchProtection.enforce=false).`,
+      `[Bootstrap] Branch protection on '${baseBranch}': skipped (github.branchProtection.enforce=false).`,
     );
     return { status: 'skipped', reason: 'opt-out' };
   }
@@ -136,7 +136,7 @@ export async function applyBranchProtection({
     .filter((n) => typeof n === 'string' && n.length > 0);
   if (checkNames.length === 0) {
     log(
-      `[bootstrap] Branch protection on '${baseBranch}': skipped (no github.branchProtection.requiredChecks configured).`,
+      `[Bootstrap] Branch protection on '${baseBranch}': skipped (no github.branchProtection.requiredChecks configured).`,
     );
     return { status: 'skipped', reason: 'no-checks' };
   }
@@ -152,12 +152,12 @@ export async function applyBranchProtection({
       exists = await provider.branchExists(baseBranch);
     } catch (err) {
       log(
-        `[bootstrap] Branch protection on '${baseBranch}': existence probe failed — ${err.message}. Proceeding with the write attempt.`,
+        `[Bootstrap] Branch protection on '${baseBranch}': existence probe failed — ${err.message}. Proceeding with the write attempt.`,
       );
     }
     if (!exists) {
       log(
-        `[bootstrap] Branch protection on '${baseBranch}': skipped (base branch does not exist on the remote — push an initial commit first).`,
+        `[Bootstrap] Branch protection on '${baseBranch}': skipped (base branch does not exist on the remote — push an initial commit first).`,
       );
       return { status: 'skipped', reason: 'no-base-branch' };
     }
@@ -169,7 +169,7 @@ export async function applyBranchProtection({
     current = probe?.enabled ? (probe.raw ?? null) : null;
   } catch (err) {
     log(
-      `[bootstrap] Branch protection on '${baseBranch}': read failed — ${err.message}. Proceeding as if no rule exists.`,
+      `[Bootstrap] Branch protection on '${baseBranch}': read failed — ${err.message}. Proceeding as if no rule exists.`,
     );
   }
 
@@ -193,7 +193,7 @@ export async function applyBranchProtection({
         : false;
     if (!approved) {
       log(
-        `[bootstrap] Branch protection on '${baseBranch}': diverges from framework stance; HITL declined / non-TTY — leaving the operator's rule untouched.`,
+        `[Bootstrap] Branch protection on '${baseBranch}': diverges from framework stance; HITL declined / non-TTY — leaving the operator's rule untouched.`,
       );
       return { status: 'skipped', reason: 'hitl-declined', diff };
     }
@@ -210,12 +210,12 @@ export async function applyBranchProtection({
       ? ` (added: ${result.added.join(', ')})`
       : ' (all required checks already present)';
     log(
-      `[bootstrap] Branch protection on '${baseBranch}': ${verb} rule${addedSuffix}.`,
+      `[Bootstrap] Branch protection on '${baseBranch}': ${verb} rule${addedSuffix}.`,
     );
     return { status: result.created ? 'created' : 'merged', ...result };
   } catch (err) {
     log(
-      `[bootstrap] Branch protection on '${baseBranch}': failed — ${err.message}. Proceeding without it.`,
+      `[Bootstrap] Branch protection on '${baseBranch}': failed — ${err.message}. Proceeding without it.`,
     );
     return { status: 'failed', reason: err.message };
   }

package/.agents/scripts/lib/bootstrap/gh-preflight.js

@@ -253,16 +253,16 @@ export async function checkProjectScopes(opts = {}) {
 function classifyProjectScopes(scopeLine) {
   if (!scopeLine) {
     return {
-      name: 'gh-project-scope',
+      name: 'GitHub Projects V2 access',
       ok: true,
       detail: GH_SCOPES_UNREADABLE_NOTE,
     };
   }
   if (/\bproject\b/i.test(scopeLine[1])) {
-    return { name: 'gh-project-scope', ok: true };
+    return { name: 'GitHub Projects V2 access', ok: true };
   }
   return {
-    name: 'gh-project-scope',
+    name: 'GitHub Projects V2 access',
     ok: true,
     detail: GH_PROJECT_SCOPE_NOTE,
   };

package/.agents/scripts/lib/bootstrap/hitl-confirm.js

@@ -26,7 +26,7 @@
 import { createInterface } from 'node:readline';
 
 const ABORT_MESSAGE =
-  '[bootstrap] aborting: no TTY available for HITL confirm (opt in with --approve-github-admin for GitHub-admin mutations, or --assume-yes to accept every phase group)';
+  '[Bootstrap] aborting: no TTY available for HITL confirm (opt in with --approve-github-admin for GitHub-admin mutations, or --assume-yes to accept every phase group)';
 
 /**
  * @param {object} args
@@ -61,7 +61,7 @@ export async function confirm({ summary, current, proposed }, opts = {}) {
   // Render the diff. Single-line summary, then a JSON block so the
   // operator can pipe the prompt to a logger and still recover the
   // structured shape.
-  stdout.write(`\n[bootstrap] HITL confirm: ${summary}\n`);
+  stdout.write(`\nHITL confirm: ${summary}\n`);
   stdout.write(
     `  current:  ${JSON.stringify(current ?? null, null, 2)
       .split('\n')

package/.agents/scripts/lib/bootstrap/merge-methods.js

@@ -74,13 +74,13 @@ export async function applyMergeMethods({
   try {
     current = (await provider.getMergeMethods()) ?? {};
   } catch (err) {
-    log(`[bootstrap] Merge methods: read failed — ${err.message}.`);
+    log(`[Bootstrap] Merge methods: read failed — ${err.message}.`);
     return { status: 'failed', reason: err.message };
   }
 
   const diff = diffMergeMethods(current, target);
   if (!diff) {
-    log('[bootstrap] Merge methods: already at target stance (no-op).');
+    log('[Bootstrap] Merge methods: already at target stance (no-op).');
     return { status: 'unchanged' };
   }
 
@@ -94,8 +94,8 @@ export async function applyMergeMethods({
     });
     if (!approved) {
       log(
-        '[bootstrap] Merge methods: HITL declined — leaving operator settings ' +
-          'untouched. Note: auto-merge will remain disabled until the merge-method ' +
+        '[Bootstrap] Merge methods: HITL declined — leaving operator settings untouched\n\n' +
+          'Note: auto-merge will remain disabled until the merge-method ' +
           'settings match the framework stance (allow_squash_merge: true, ' +
           'allow_auto_merge: true, delete_branch_on_merge: true).',
       );
@@ -105,7 +105,7 @@ export async function applyMergeMethods({
     // Non-TTY: no operator present to confirm. Default-apply the framework
     // stance and log explicitly so the consequence is never silent.
     log(
-      '[bootstrap] Merge methods: non-TTY — applying framework stance automatically ' +
+      '[Bootstrap] Merge methods: non-TTY — applying framework stance automatically ' +
         '(allow_squash_merge, allow_auto_merge, delete_branch_on_merge). ' +
         'To opt out, pass a hitlConfirm gate or set github.mergeMethods overrides in .agentrc.json.',
     );
@@ -114,10 +114,10 @@ export async function applyMergeMethods({
 
   try {
     const result = await provider.setMergeMethods(target);
-    log(`[bootstrap] Merge methods: patched (${result.patched.join(', ')}).`);
+    log(`[Bootstrap] Merge methods: patched (${result.patched.join(', ')}).`);
     return { status: 'patched', ...result, diff };
   } catch (err) {
-    log(`[bootstrap] Merge methods: PATCH failed — ${err.message}.`);
+    log(`[Bootstrap] Merge methods: PATCH failed — ${err.message}.`);
     return { status: 'failed', reason: err.message };
   }
 }

package/.agents/scripts/lib/bootstrap/preflight.js

@@ -59,8 +59,8 @@ function defaultGitRunner(args) {
  */
 function checkNode(nodeCheck) {
   const result = nodeCheck();
-  if (result.ok) return { name: 'node', ok: true };
-  return { name: 'node', ok: false, remedy: NODE_REMEDY(result) };
+  if (result.ok) return { name: 'Node version', ok: true };
+  return { name: 'Node version', ok: false, remedy: NODE_REMEDY(result) };
 }
 
 /**
@@ -73,19 +73,19 @@ function checkNode(nodeCheck) {
 function checkGitAvailable(gitRunner) {
   const result = gitRunner(['--version']);
   if (result.error?.code === 'ENOENT') {
-    return { name: 'git', ok: false, remedy: GIT_INSTALL_HINT };
+    return { name: 'Git installed', ok: false, remedy: GIT_INSTALL_HINT };
   }
   if (result.status !== 0) {
     const snippet = (result.stderr || '').trim().slice(0, 200);
     return {
-      name: 'git',
+      name: 'Git installed',
       ok: false,
       remedy: `git --version failed (exit ${result.status})${
         snippet ? `: ${snippet}` : ''
       }. ${GIT_INSTALL_HINT}`,
     };
   }
-  return { name: 'git', ok: true };
+  return { name: 'Git installed', ok: true };
 }
 
 /**
@@ -99,9 +99,13 @@ function checkGitAvailable(gitRunner) {
 function checkInsideWorkTree(gitRunner) {
   const result = gitRunner(['rev-parse', '--is-inside-work-tree']);
   if (result.status === 0 && result.stdout.trim() === 'true') {
-    return { name: 'git-work-tree', ok: true };
+    return { name: 'Local git initialized', ok: true };
   }
-  return { name: 'git-work-tree', ok: false, remedy: GIT_WORKTREE_HINT };
+  return {
+    name: 'Local git initialized',
+    ok: false,
+    remedy: GIT_WORKTREE_HINT,
+  };
 }
 
 /**
@@ -115,9 +119,9 @@ function checkInsideWorkTree(gitRunner) {
 async function checkGh(gh) {
   try {
     await gh();
-    return { name: 'gh', ok: true };
+    return { name: 'GitHub CLI', ok: true };
   } catch (err) {
-    return { name: 'gh', ok: false, remedy: err.message };
+    return { name: 'GitHub CLI', ok: false, remedy: err.message };
   }
 }
 
@@ -170,15 +174,14 @@ export async function runPreflight(opts = {}) {
       checks.push(workTree);
     } else {
       // Non-fatal detection: record whether we are inside a git repo but
-      // never fail the gate on it — `bootstrap-new.js` can run pre-init and
-      // collect the remote/branch/owner in later steps.
+      // never fail the gate on it — bootstrap initialises git in a later
+      // phase. `ok` stays true so the gate passes; the rendered glyph is
+      // driven off `gitInitialized` (✓ when a repo exists, ✗ when not) so the
+      // operator sees the real state without the run aborting.
       checks.push({
-        name: 'git-work-tree',
+        name: 'Local git initialized',
         ok: true,
         gitInitialized,
-        detail: gitInitialized
-          ? 'inside a git work tree'
-          : 'not a git repo yet — will be collected in later steps',
       });
     }
   }

package/.agents/scripts/lib/bootstrap/project-bootstrap.js

@@ -277,7 +277,7 @@ export function ensureDependenciesInstalled(ctx) {
   });
   if (result.status !== 0) {
     throw new Error(
-      `[bootstrap] ${manager} install failed (exit ${result.status}). Resolve the install error and re-run.`,
+      `[Bootstrap] ${manager} install failed (exit ${result.status}). Resolve the install error and re-run.`,
     );
   }
   return { ran: true, manager, skipped: false };
@@ -462,7 +462,7 @@ export function runSyncCommands(ctx) {
   });
   if (result.status !== 0) {
     throw new Error(
-      `[bootstrap] sync-claude-commands.js failed (exit ${result.status}): ${(
+      `[Bootstrap] sync-claude-commands.js failed (exit ${result.status}): ${(
         result.stderr ?? ''
       )
         .trim()
@@ -615,12 +615,12 @@ export function checkWindowsGitPerf(ctx) {
 const fatalNodeCheck = (result) =>
   result.ok
     ? null
-    : `[bootstrap] Node ${result.version} is below required ${result.required}. Upgrade Node and re-run.`;
+    : `[Bootstrap] Node ${result.version} is below required ${result.required}. Upgrade Node and re-run.`;
 
 const fatalValidation = (result) =>
   result.ok
     ? null
-    : `[bootstrap] .agentrc.json failed schema validation: ${JSON.stringify(
+    : `[Bootstrap] .agentrc.json failed schema validation: ${JSON.stringify(
         result.errors,
         null,
         2,
@@ -629,7 +629,7 @@ const fatalValidation = (result) =>
 const fatalParity = (result) =>
   result.ok
     ? null
-    : `[bootstrap] Parity check failed — workflows missing commands: ${
+    : `[Bootstrap] Parity check failed — workflows missing commands: ${
         result.missingCommand.join(', ') || '(none)'
       }; orphan commands: ${result.orphanCommand.join(', ') || '(none)'}`;