mandrel 1.63.0 → 1.64.0

package/.agents/scripts/bootstrap.js

@@ -195,13 +195,13 @@ function runGit(args, cwd) {
  * `GhExecError` — so a bare "gh exited with code 1" is actually diagnosable.
  */
 function logGhError(label, err) {
-  Logger.error(`[bootstrap] ${label} failed: ${err.message}`);
+  Logger.error(`[Bootstrap] ${label} failed: ${err.message}`);
   if (err.stderr)
-    Logger.error(`[bootstrap]   gh stderr: ${String(err.stderr).trim()}`);
+    Logger.error(`[Bootstrap]   gh stderr: ${String(err.stderr).trim()}`);
   if (err.stdout)
-    Logger.error(`[bootstrap]   gh stdout: ${String(err.stdout).trim()}`);
+    Logger.error(`[Bootstrap]   gh stdout: ${String(err.stdout).trim()}`);
   if (Array.isArray(err.args)) {
-    Logger.error(`[bootstrap]   gh args: ${err.args.join(' ')}`);
+    Logger.error(`[Bootstrap]   gh args: ${err.args.join(' ')}`);
   }
 }
 
@@ -249,7 +249,7 @@ function ensureGitInitialized(state) {
     initialized = true;
     state.gitInitialized = true;
     Logger.info(
-      `[bootstrap] Initialized git repo (branch ${branch}) at ${cwd}.`,
+      `[Bootstrap] Initialized git repo (branch ${branch}) at ${cwd}.`,
     );
   }
 
@@ -281,7 +281,7 @@ function ensureGitInitialized(state) {
       return { ok: false, error: commit.stderr || 'git commit failed' };
     }
     committed = true;
-    Logger.info('[bootstrap] Created initial commit.');
+    Logger.info('[Bootstrap] Created initial commit.');
   }
   return { ok: true, initialized, committed };
 }
@@ -303,21 +303,21 @@ async function ensureGitRemote(state, execImpl = exec) {
   if (runGit(['remote', 'get-url', 'origin'], cwd).ok) return;
   if (!(await repoExists(owner, repo, execImpl))) {
     Logger.warn(
-      `[bootstrap] No 'origin' remote and ${owner}/${repo} does not exist on GitHub — skipping remote wiring.`,
+      `[Bootstrap] No 'origin' remote and ${owner}/${repo} does not exist on GitHub — skipping remote wiring.`,
     );
     return;
   }
   const url = `https://github.com/${owner}/${repo}.git`;
   const add = runGit(['remote', 'add', 'origin', url], cwd);
   if (!add.ok) {
-    Logger.warn(`[bootstrap] Could not add 'origin' remote: ${add.stderr}`);
+    Logger.warn(`[Bootstrap] Could not add 'origin' remote: ${add.stderr}`);
     return;
   }
-  Logger.info(`[bootstrap] Wired 'origin' → ${url}.`);
+  Logger.info(`[Bootstrap] Wired 'origin' → ${url}.`);
   const push = runGit(['push', '-u', 'origin', branch], cwd);
   if (!push.ok) {
     Logger.warn(
-      `[bootstrap] 'origin' is set but push of '${branch}' failed (resolve manually, e.g. \`git pull --rebase origin ${branch}\`): ${push.stderr}`,
+      `[Bootstrap] 'origin' is set but push of '${branch}' failed (resolve manually, e.g. \`git pull --rebase origin ${branch}\`): ${push.stderr}`,
     );
   }
 }
@@ -359,11 +359,11 @@ async function ensureProjectLinked(state, execImpl = exec) {
       args: ['project', 'link', pn, '--owner', owner, '--repo', repo],
     });
     Logger.info(
-      `[bootstrap] Linked repo ${owner}/${repo} to Project V2 #${pn}.`,
+      `[Bootstrap] Linked repo ${owner}/${repo} to Project V2 #${pn}.`,
     );
   } catch (err) {
     Logger.warn(
-      `[bootstrap] Could not link repo ${owner}/${repo} to Project V2 #${pn} (continuing): ${err.message}`,
+      `[Bootstrap] Could not link repo ${owner}/${repo} to Project V2 #${pn} (continuing): ${err.message}`,
     );
   }
 }
@@ -413,7 +413,7 @@ async function createGithubRepo(state, execImpl = exec) {
     ],
   });
   Logger.info(
-    `[bootstrap] Created GitHub repo ${slug} (${visibility}) and pushed.`,
+    `[Bootstrap] Created GitHub repo ${slug} (${visibility}) and pushed.`,
   );
 }
 
@@ -480,7 +480,7 @@ async function createGithubProject(state, execImpl = exec) {
   if (Number.isInteger(existing)) {
     state.answers.projectNumber = String(existing);
     Logger.info(
-      `[bootstrap] Reusing existing GitHub Project V2 "${title}" (#${existing}) — no duplicate created.`,
+      `[Bootstrap] Reusing existing GitHub Project V2 "${title}" (#${existing}) — no duplicate created.`,
     );
     return existing;
   }
@@ -510,7 +510,7 @@ async function createGithubProject(state, execImpl = exec) {
     );
   }
   state.answers.projectNumber = String(number);
-  Logger.info(`[bootstrap] Created GitHub Project V2 "${title}" (#${number}).`);
+  Logger.info(`[Bootstrap] Created GitHub Project V2 "${title}" (#${number}).`);
   return number;
 }
 
@@ -539,7 +539,7 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
       key: 'owner',
       flag: 'owner',
       env: 'GH_OWNER',
-      message: 'Github repo owner',
+      message: '\n\nGitHub repo owner',
       default: defaults.owner,
       required: true,
       validate: (v) =>
@@ -549,7 +549,8 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
       key: 'operatorHandle',
       flag: 'operator-handle',
       env: 'GH_OPERATOR_HANDLE',
-      message: 'Github username/handle (without the @)',
+      message:
+        'GitHub username/handle without preceding@ (default: same as owner)',
       // Default tracks the repo owner; resolved post-collect if left blank.
       default: defaults.owner,
       required: false,
@@ -562,8 +563,9 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
       key: 'repo',
       flag: 'repo',
       env: 'GH_REPO',
-      message:
-        'Github repo name - Select from the list or enter a new name to create one',
+      message: 'New GitHub repo name',
+      pickerMessage:
+        'GitHub repo name  - Select existing or press ENTER to create',
       default: defaults.repo,
       required: true,
       picker: {
@@ -590,8 +592,9 @@ export function buildQuestions(defaults, flags, env = process.env, lists = {}) {
       key: 'projectNumber',
       flag: 'project-number',
       env: 'GH_PROJECT_NUMBER',
-      message:
-        'Github Project V2 name - Select from the list or enter a new name to create one',
+      message: 'New GitHub Project V2 name',
+      pickerMessage:
+        'GitHub Project V2 name  - Select existing or press ENTER to create',
       // Prefer the already-stored numeric project number (an
       // already-provisioned project on a re-run) so `--assume-yes` resolves a
       // numeric answer that `detectCreation` treats as existing — never a
@@ -750,7 +753,7 @@ export function parseAndValidate(argv, opts = {}) {
   // `--assume-yes` path did.)
   if (!interactive && !assumeYes && !approveGithubAdmin) {
     Logger.error(
-      '[bootstrap] non-TTY run requires --assume-yes or --approve-github-admin ' +
+      '[Bootstrap] non-TTY run requires --assume-yes or --approve-github-admin ' +
         '(no operator is present to confirm the GitHub-admin mutations).',
     );
     return { ok: false, exit: 1 };
@@ -760,7 +763,7 @@ export function parseAndValidate(argv, opts = {}) {
   const githubAdminApproved = interactive || assumeYes || approveGithubAdmin;
   if (resolveRepoVisibility(flags) === null) {
     Logger.error(
-      `[bootstrap] invalid --visibility "${flags.visibility}". ` +
+      `[Bootstrap] invalid --visibility "${flags.visibility}". ` +
         `Expected one of: ${REPO_VISIBILITIES.join(', ')}.`,
     );
     return { ok: false, exit: 1 };
@@ -783,11 +786,12 @@ export function prepareContext(state, opts = {}) {
   const defaults = inferDefaults(projectRoot);
   const silentAccept = resolveSilentAccept(defaults, state.flags);
 
-  Logger.info('[bootstrap] Detected from local git:');
-  Logger.info(`  owner          ${defaults.owner ?? '(none)'}`);
-  Logger.info(`  repo           ${defaults.repo ?? '(none)'}`);
-  Logger.info(`  base branch    ${defaults.baseBranch ?? '(none)'}`);
-  Logger.info(`  username       ${defaults.operatorHandle ?? '(none)'}`);
+  Logger.info('[\n');
+  Logger.info('[Bootstrap] Checking existing GitHub values:');
+  Logger.info(`  GitHub Repo Owner  ${defaults.owner ?? '(unknown)'}`);
+  Logger.info(`  GitHub Repo Name   ${defaults.repo ?? '(unknown)'}`);
+  Logger.info(`  Base Branch        ${defaults.baseBranch ?? '(unknown)'}`);
+  Logger.info(`  GitHub Username    ${defaults.operatorHandle ?? '(unknown)'}`);
 
   return {
     ok: true,
@@ -811,24 +815,34 @@ export async function runPreflightPhase(state, opts = {}) {
 
   for (const check of result.checks) {
     if (check.ok) {
+      // A non-fatal informational check (it carries `gitInitialized`) shows a
+      // glyph reflecting the real state rather than its always-true gate pass:
+      // ✓ when the git repo exists, ✗ when it does not (bootstrap initialises
+      // it in a later phase regardless — the ✗ never aborts the run).
+      const glyph =
+        typeof check.gitInitialized === 'boolean' && !check.gitInitialized
+          ? '✗'
+          : '✓';
       Logger.info(
-        `[bootstrap] ✓ ${check.name}${check.detail ? ` — ${check.detail}` : ''}`,
+        `[Bootstrap] ${glyph} ${check.name}${check.detail ? ` — ${check.detail}` : ''}`,
       );
     } else {
-      Logger.error(`[bootstrap] ✗ ${check.name}: ${check.remedy}`);
+      Logger.error(`[Bootstrap] ✗ ${check.name}: ${check.remedy}`);
     }
   }
 
   if (!result.ok) {
     Logger.error(
-      '[bootstrap] Preflight failed. Resolve the issues above and re-run.',
+      '[Bootstrap] Preflight failed. Resolve the issues above and re-run.',
     );
     return { ok: false, exit: 1 };
   }
 
-  Logger.info(
-    `[bootstrap] git initialized: ${result.gitInitialized ? 'yes' : 'no'}`,
-  );
+  // The git-repo state is already reported by the (non-fatal) "Local git
+  // initialized" check above — both derive from the same
+  // `git rev-parse --is-inside-work-tree` probe — so there is no separate
+  // "git initialized" line here (it would duplicate, and contradict, that
+  // check). The boolean is still threaded through the payload for later phases.
   return {
     ok: true,
     payload: { preflight: result, gitInitialized: result.gitInitialized },
@@ -844,15 +858,15 @@ function renderAnswerSummary(
   visibility,
 ) {
   const newRepoNote = creation.newRepo
-    ? `  (NEW — will be created, ${visibility})`
+    ? `  will be created as ${visibility}`
     : '';
   const lines = [
-    '\n=== Review your answers ===',
+    '=== Review choices ===',
     `  Repo owner       ${answers.owner}`,
     `  Username/handle  ${answers.operatorHandle || '(none)'}`,
     `  Repo name        ${answers.repo}${newRepoNote}`,
     `  Base branch      ${answers.baseBranch}`,
-    `  Project V2 name  ${project.name}${creation.newProject ? '  (NEW — will be created)' : ''}`,
+    `  Project V2 name  ${project.name}${creation.newProject ? '  will be created' : ''}`,
     `  Project V2 #     ${project.number}`,
     `  Local git        ${gitInitialized ? 'initialized' : 'will be initialized'}`,
   ];
@@ -943,7 +957,7 @@ export async function collectAndConfirm(state) {
     });
     if (missing.length > 0) {
       Logger.error(
-        `[bootstrap] missing required answers: ${missing.join(', ')}`,
+        `[Bootstrap] missing required answers: ${missing.join(', ')}`,
       );
       return { ok: false, exit: 1 };
     }
@@ -968,7 +982,7 @@ export async function collectAndConfirm(state) {
     );
     const correct = await confirmYesNo('Is this correct?', state.interactive);
     if (!correct) {
-      Logger.info('[bootstrap] Okay — let’s try again.');
+      Logger.info('[Bootstrap] Okay — let’s try again.');
       // Re-prompt everything on the next pass (drop silent-accept).
       silentAccept = [];
       continue;
@@ -982,7 +996,7 @@ export async function collectAndConfirm(state) {
       );
       if (!approved) {
         Logger.error(
-          '[bootstrap] Creation declined — cannot continue without the repo/project. Exiting.',
+          '[Bootstrap] Creation declined — cannot continue without the repo/project. Exiting.',
         );
         return { ok: false, exit: 1 };
       }
@@ -1025,7 +1039,7 @@ function renderDryRunPlan(state) {
 export function dryRunPlan(state) {
   if (!state.flags['dry-run']) return { ok: true, payload: {} };
   Logger.info(
-    '[bootstrap] --dry-run: no files, GitHub settings, or labels will be changed.',
+    '[Bootstrap] --dry-run: no files, GitHub settings, or labels will be changed.',
   );
   Logger.info(renderDryRunPlan(state));
   return { ok: false, exit: 0 };
@@ -1062,18 +1076,18 @@ export async function provisionResources(state, deps = {}) {
   // 1. Local git — initialize + first commit when missing (idempotent).
   const git = ensureGitInitialized(state);
   if (!git.ok) {
-    Logger.error(`[bootstrap] git initialization failed: ${git.error}`);
+    Logger.error(`[Bootstrap] git initialization failed: ${git.error}`);
     return { ok: false, exit: 1 };
   }
   if (!git.initialized && !git.committed) {
-    Logger.info('[bootstrap] git already initialized — leaving as-is.');
+    Logger.info('[Bootstrap] git already initialized — leaving as-is.');
   }
 
   const { newRepo, newProject } = state.creation;
   if (skipGithub) {
     if (newRepo || newProject) {
       Logger.info(
-        '[bootstrap] --skip-github set; not creating the GitHub repo/project.',
+        '[Bootstrap] --skip-github set; not creating the GitHub repo/project.',
       );
     }
     return { ok: true, payload: {} };
@@ -1108,7 +1122,7 @@ export async function provisionResources(state, deps = {}) {
   }
 
   if (!newRepo && !newProject) {
-    Logger.info('[bootstrap] No new GitHub resources needed.');
+    Logger.info('[Bootstrap] No new GitHub resources needed.');
   }
 
   // 4. Link the repo to the project board so issues/PRs surface on it
@@ -1125,7 +1139,7 @@ export async function provisionResources(state, deps = {}) {
  */
 export async function executeBootstrap(state) {
   Logger.info(
-    `[bootstrap] Starting project bootstrap at ${state.projectRoot} (owner=${state.answers.owner} repo=${state.answers.repo} base=${state.answers.baseBranch})`,
+    `[Bootstrap] Starting project bootstrap at ${state.projectRoot} (owner=${state.answers.owner} repo=${state.answers.repo} base=${state.answers.baseBranch})`,
   );
   const approvedGroups = new Set(Object.values(PHASE_GROUPS));
   const report = await applyProjectBootstrap({
@@ -1158,7 +1172,7 @@ export function persistProjectNumber(state) {
     config = JSON.parse(fs.readFileSync(target, 'utf8'));
   } catch (err) {
     Logger.error(
-      `[bootstrap] Could not read ${target} to store projectNumber: ${err.message}`,
+      `[Bootstrap] Could not read ${target} to store projectNumber: ${err.message}`,
     );
     return { ok: true, payload: {} };
   }
@@ -1172,14 +1186,14 @@ export function persistProjectNumber(state) {
   }
   config.github.projectNumber = Number(pn);
   fs.writeFileSync(target, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
-  Logger.info(`[bootstrap] Stored github.projectNumber=${pn} in .agentrc.json`);
+  Logger.info(`[Bootstrap] Stored github.projectNumber=${pn} in .agentrc.json`);
   return { ok: true, payload: {} };
 }
 
 /** Step 6b — GitHub-side bootstrap. Honours `--skip-github`. */
 export async function executeGithubBootstrap(state) {
   if (state.flags['skip-github']) {
-    Logger.info('[bootstrap] --skip-github set; skipping GitHub bootstrap.');
+    Logger.info('[Bootstrap] --skip-github set; skipping GitHub bootstrap.');
     return { ok: true, payload: {} };
   }
   try {
@@ -1274,7 +1288,7 @@ export async function offerCommitPush(state, deps = {}) {
   // Non-interactive (--assume-yes / no TTY): never push unprompted. Print the
   // exact commands and leave the working tree untouched.
   if (!state.interactive) {
-    Logger.info(`\n[bootstrap] ${instructions}`);
+    Logger.info(`\n[Bootstrap] ${instructions}`);
     return { ok: true, payload: { commitPush: { action: 'instructed' } } };
   }
 
@@ -1283,14 +1297,14 @@ export async function offerCommitPush(state, deps = {}) {
     state.interactive,
   );
   if (!accepted) {
-    Logger.info(`\n[bootstrap] ${instructions}`);
+    Logger.info(`\n[Bootstrap] ${instructions}`);
     return { ok: true, payload: { commitPush: { action: 'declined' } } };
   }
 
   const staged = stageBootstrapFiles({ projectRoot: cwd, runGit: runGitImpl });
   if (!staged.ok) {
-    Logger.warn(`[bootstrap] Could not stage the wiring: ${staged.error}`);
-    Logger.info(`\n[bootstrap] ${instructions}`);
+    Logger.warn(`[Bootstrap] Could not stage the wiring: ${staged.error}`);
+    Logger.info(`\n[Bootstrap] ${instructions}`);
     return { ok: true, payload: { commitPush: { action: 'stage-failed' } } };
   }
   const commit = runGitImpl(
@@ -1300,20 +1314,20 @@ export async function offerCommitPush(state, deps = {}) {
   if (!commit.ok) {
     // A "nothing to commit" exit is benign — the wiring is already committed.
     Logger.warn(
-      `[bootstrap] git commit did not create a commit (already committed?): ${commit.stderr || commit.stdout}`,
+      `[Bootstrap] git commit did not create a commit (already committed?): ${commit.stderr || commit.stdout}`,
     );
-    Logger.info(`\n[bootstrap] ${instructions}`);
+    Logger.info(`\n[Bootstrap] ${instructions}`);
     return { ok: true, payload: { commitPush: { action: 'commit-skipped' } } };
   }
-  Logger.info('[bootstrap] Committed the Mandrel wiring.');
+  Logger.info('[Bootstrap] Committed the Mandrel wiring.');
   const push = runGitImpl(['push', '-u', 'origin', branch], cwd);
   if (!push.ok) {
     Logger.warn(
-      `[bootstrap] Commit landed but push of '${branch}' failed (push it manually with \`git push -u origin ${branch}\`): ${push.stderr}`,
+      `[Bootstrap] Commit landed but push of '${branch}' failed (push it manually with \`git push -u origin ${branch}\`): ${push.stderr}`,
     );
     return { ok: true, payload: { commitPush: { action: 'push-failed' } } };
   }
-  Logger.info(`[bootstrap] Pushed '${branch}' to origin.`);
+  Logger.info(`[Bootstrap] Pushed '${branch}' to origin.`);
   return { ok: true, payload: { commitPush: { action: 'committed-pushed' } } };
 }
 
@@ -1357,7 +1371,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
   const githubError = result.state?.report?.github?.error;
   if (githubError) {
     Logger.error(
-      `\n[bootstrap] GitHub bootstrap failed: ${githubError}. ` +
+      `\n[Bootstrap] GitHub bootstrap failed: ${githubError}. ` +
         'Project-side setup (labels are GitHub-side; the local .agentrc.json / ' +
         'quality-gate / workflow files that were applied are recorded in the ' +
         'install ledger) completed, but the GitHub label/board/views/protection ' +
@@ -1368,7 +1382,7 @@ export async function main(argv = process.argv.slice(2), deps = {}) {
     return 1;
   }
 
-  Logger.info('\n[bootstrap] Done.');
+  Logger.info('\n[Bootstrap] Done.');
   return 0;
 }
 

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',
       });
     }
   }