@imdeadpool/guardex 7.0.22 → 7.0.23

package/README.md

@@ -340,6 +340,7 @@ gx sync
 ```sh
 gx agents start           # review monitor + stale cleanup
 gx agents stop
+gx agents stop --pid 12345
 gx agents status
 
 # tuning
@@ -671,6 +672,11 @@ npm pack --dry-run
 <details>
 <summary><strong>v7.x</strong></summary>
 
+### v7.0.23
+- Bumped `@imdeadpool/guardex` from `7.0.22` to `7.0.23` so GitHub release and npm can advance together after `7.0.22` reached npm without a matching published GitHub release.
+- Active Agents stays easier to scan and more truthful: the package repo remains the canonical source, inspect/install paths stay loadable across VS Code churn, and session rows group under worktrees with clearer merged-cleanup truth.
+- Guardex prompt and finish guidance now pushes faster phase-based execution, keeps helper behavior single-sourced, and avoids fragmented probe loops when cleanup or branch-deletion races appear.
+
 ### v7.0.22
 - Bumped `@imdeadpool/guardex` from `7.0.21` to `7.0.22` so npm can publish the next release from the current merged mainline.
 - The shipped `main` payload already includes lower-token prompt slices, SCM-selected lane visibility, truthful merged-cleanup evidence, the Active Agents brand/icon refresh, and the remaining CLI extraction cleanups without changing Guardex behavior.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imdeadpool/guardex",
-  "version": "7.0.22",
+  "version": "7.0.23",
   "description": "Guardian T-Rex for your multi-agent repo. Isolated worktrees, file locks, and PR-only merges stop parallel Codex & Claude agents from overwriting each other's work. Auto-wires Oh My Codex, Oh My Claude, OpenSpec, and Caveman.",
   "license": "MIT",
   "preferGlobal": true,
@@ -69,5 +69,9 @@
   },
   "devDependencies": {
     "fast-check": "^3.23.2"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1",
+    "semver": "^7.7.4"
   }
 }

package/src/cli/args.js

@@ -271,6 +271,7 @@ function parseAgentsArgs(rawArgs) {
     reviewIntervalSeconds: 30,
     cleanupIntervalSeconds: 60,
     idleMinutes: DEFAULT_SHADOW_CLEANUP_IDLE_MINUTES,
+    pid: null,
   };
 
   for (let index = 0; index < rest.length; index += 1) {
@@ -314,12 +315,28 @@ function parseAgentsArgs(rawArgs) {
       index += 1;
       continue;
     }
+    if (arg === '--pid') {
+      const next = rest[index + 1];
+      if (!next) {
+        throw new Error('--pid requires a positive integer value');
+      }
+      const parsedValue = Number.parseInt(next, 10);
+      if (!Number.isInteger(parsedValue) || parsedValue <= 0) {
+        throw new Error('--pid must be a positive integer');
+      }
+      options.pid = parsedValue;
+      index += 1;
+      continue;
+    }
     throw new Error(`Unknown option: ${arg}`);
   }
 
   if (!['start', 'stop', 'status'].includes(options.subcommand)) {
     throw new Error(`Unknown agents subcommand: ${options.subcommand}`);
   }
+  if (options.pid !== null && options.subcommand !== 'stop') {
+    throw new Error('--pid is only supported with `gx agents stop`');
+  }
 
   return options;
 }
@@ -332,6 +349,15 @@ function parseReportArgs(rawArgs) {
     scorecardJson: '',
     outputDir: '',
     date: '',
+    taskSize: '',
+    tokens: '',
+    execCount: '',
+    writeStdinCount: '',
+    completionBeforeTail: '',
+    expectedBound: '',
+    fragmentation: '',
+    finishPath: '',
+    postProof: '',
     dryRun: false,
     json: false,
   };
@@ -373,6 +399,69 @@ function parseReportArgs(rawArgs) {
       index += 1;
       continue;
     }
+    if (arg === '--task-size') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--task-size requires a value');
+      options.taskSize = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--tokens') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--tokens requires a value');
+      options.tokens = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--exec-count') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--exec-count requires a value');
+      options.execCount = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--write-stdin-count') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--write-stdin-count requires a value');
+      options.writeStdinCount = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--completion-before-tail') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--completion-before-tail requires yes or no');
+      options.completionBeforeTail = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--expected-bound') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--expected-bound requires a value');
+      options.expectedBound = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--fragmentation') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--fragmentation requires a value');
+      options.fragmentation = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--finish-path') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--finish-path requires a value');
+      options.finishPath = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--post-proof') {
+      const next = rawArgs[index + 1];
+      if (!next) throw new Error('--post-proof requires a value');
+      options.postProof = next;
+      index += 1;
+      continue;
+    }
     if (arg === '--dry-run') {
       options.dryRun = true;
       continue;

package/src/cli/main.js

@@ -5,6 +5,7 @@ const sandboxModule = require('../sandbox');
 const toolchainModule = require('../toolchain');
 const finishCommands = require('../finish');
 const doctorModule = require('../doctor');
+const sessionSeverityReport = require('../report/session-severity');
 const {
   fs,
   path,
@@ -113,6 +114,12 @@ const {
   runReviewBotCommand,
   invokePackageAsset,
 } = require('../core/runtime');
+const {
+  parseVersionString,
+  compareParsedVersions,
+  isNewerVersion,
+} = require('../core/versions');
+const { readSingleLineFromStdin } = require('../core/stdin');
 const {
   normalizeManagedForcePath,
   parseCommonArgs,
@@ -159,6 +166,7 @@ const {
   ensureHookShim,
   copyTemplateFile,
   ensureTemplateFilePresent,
+  materializePackageRepoTemplateFiles,
   ensureOmxScaffold,
   ensureLockRegistry,
   lockStateOrError,
@@ -168,9 +176,6 @@ const {
   removeLegacyManagedRepoFile,
   ensureAgentsSnippet,
   ensureManagedGitignore,
-  stripJsonComments,
-  stripJsonTrailingCommas,
-  parseJsonObjectLikeFile,
   buildRepoVscodeSettings,
   ensureRepoVscodeSettings,
   configureHooks,
@@ -866,44 +871,6 @@ function isInteractiveTerminal() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
-const stdinWaitArray = new Int32Array(new SharedArrayBuffer(4));
-
-function sleepSyncMs(milliseconds) {
-  Atomics.wait(stdinWaitArray, 0, 0, milliseconds);
-}
-
-function readSingleLineFromStdin() {
-  let input = '';
-  const buffer = Buffer.alloc(1);
-
-  while (true) {
-    let bytesRead = 0;
-    try {
-      bytesRead = fs.readSync(process.stdin.fd, buffer, 0, 1);
-    } catch (error) {
-      if (error && ['EAGAIN', 'EWOULDBLOCK', 'EINTR'].includes(error.code)) {
-        sleepSyncMs(15);
-        continue;
-      }
-      return input;
-    }
-
-    if (bytesRead === 0) {
-      if (process.stdin.isTTY) {
-        sleepSyncMs(15);
-        continue;
-      }
-      return input;
-    }
-
-    const char = buffer.toString('utf8', 0, bytesRead);
-    if (char === '\n' || char === '\r') {
-      return input;
-    }
-    input += char;
-  }
-}
-
 function parseAutoApproval(name) {
   const raw = process.env[name];
   if (raw == null) return null;
@@ -982,38 +949,6 @@ function describeGuardexRepoToggle(toggle) {
   return `${toggle.source} (${GUARDEX_REPO_TOGGLE_ENV}=${toggle.raw})`;
 }
 
-function parseVersionString(version) {
-  const match = String(version || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return null;
-  return [
-    Number.parseInt(match[1], 10),
-    Number.parseInt(match[2], 10),
-    Number.parseInt(match[3], 10),
-  ];
-}
-
-function compareParsedVersions(left, right) {
-  if (!left || !right) return 0;
-  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
-    const leftValue = left[index] || 0;
-    const rightValue = right[index] || 0;
-    if (leftValue > rightValue) return 1;
-    if (leftValue < rightValue) return -1;
-  }
-  return 0;
-}
-
-function isNewerVersion(latest, current) {
-  const latestParts = parseVersionString(latest);
-  const currentParts = parseVersionString(current);
-
-  if (!latestParts || !currentParts) {
-    return String(latest || '').trim() !== String(current || '').trim();
-  }
-
-  return compareParsedVersions(latestParts, currentParts) > 0;
-}
-
 function parseNpmVersionOutput(stdout) {
   const trimmed = String(stdout || '').trim();
   if (!trimmed) return '';
@@ -1445,6 +1380,7 @@ function runInstallInternal(options) {
       ),
     );
   }
+  operations.push(...materializePackageRepoTemplateFiles(repoRoot, TEMPLATE_FILES, Boolean(options.dryRun)));
   operations.push(...ensureTargetedLegacyWorkflowShims(repoRoot, options));
   for (const hookName of HOOK_NAMES) {
     const hookRelativePath = path.posix.join('.githooks', hookName);
@@ -1501,6 +1437,7 @@ function runFixInternal(options) {
     }
     operations.push(ensureTemplateFilePresent(repoRoot, templateFile, Boolean(options.dryRun)));
   }
+  operations.push(...materializePackageRepoTemplateFiles(repoRoot, TEMPLATE_FILES, Boolean(options.dryRun)));
   operations.push(...ensureTargetedLegacyWorkflowShims(repoRoot, options));
   for (const hookName of HOOK_NAMES) {
     const hookRelativePath = path.posix.join('.githooks', hookName);
@@ -2219,10 +2156,15 @@ function processAlive(pid) {
   }
   try {
     process.kill(normalizedPid, 0);
-    return true;
   } catch (_error) {
     return false;
   }
+
+  const state = readProcessState(normalizedPid);
+  if (state.startsWith('Z')) {
+    return false;
+  }
+  return true;
 }
 
 function sleepSeconds(seconds) {
@@ -2240,6 +2182,14 @@ function readProcessCommand(pid) {
   return String(result.stdout || '').trim();
 }
 
+function readProcessState(pid) {
+  const result = run('ps', ['-o', 'stat=', '-p', String(pid)]);
+  if (isSpawnFailure(result) || result.status !== 0) {
+    return '';
+  }
+  return String(result.stdout || '').trim();
+}
+
 function stopAgentProcessByPid(pid, expectedToken = '') {
   const normalizedPid = Number.parseInt(String(pid || ''), 10);
   if (!Number.isInteger(normalizedPid) || normalizedPid <= 0) {
@@ -2431,6 +2381,16 @@ function agents(rawArgs) {
   }
 
   if (options.subcommand === 'stop') {
+    if (options.pid) {
+      const stopResult = stopAgentProcessByPid(options.pid);
+      const success = ['stopped', 'not-running'].includes(stopResult.status);
+      console.log(
+        `[${TOOL_NAME}] Stopped agent pid ${options.pid} (${stopResult.status}).`,
+      );
+      process.exitCode = success ? 0 : 1;
+      return;
+    }
+
     const existingState = readAgentsState(repoRoot);
     if (!existingState) {
       console.log(`[${TOOL_NAME}] Repo agents are not running for ${repoRoot}.`);
@@ -2474,15 +2434,29 @@ function report(rawArgs) {
     console.log(
       `${TOOL_NAME} report commands:\n` +
       `  ${TOOL_NAME} report scorecard [--target <path>] [--repo github.com/<owner>/<repo>] [--scorecard-json <file>] [--output-dir <path>] [--date YYYY-MM-DD] [--dry-run] [--json]\n` +
+      `  ${TOOL_NAME} report session-severity --task-size <narrow-patch|medium-change|large-change> --tokens <count> --exec-count <count> --write-stdin-count <count> --completion-before-tail <yes|no> [--expected-bound <count>] [--fragmentation <preset|0-25>] [--finish-path <preset|0-15>] [--post-proof <preset|0-15>] [--json]\n` +
       `\n` +
       `Examples:\n` +
       `  ${TOOL_NAME} report scorecard --repo github.com/recodeecom/multiagent-safety\n` +
-      `  ${TOOL_NAME} report scorecard --scorecard-json ./scorecard.json --date 2026-04-10`,
+      `  ${TOOL_NAME} report scorecard --scorecard-json ./scorecard.json --date 2026-04-10\n` +
+      `  ${TOOL_NAME} report session-severity --task-size narrow-patch --tokens 3850000 --exec-count 18 --write-stdin-count 6 --completion-before-tail yes --fragmentation 14 --finish-path 6 --post-proof 4`,
     );
     process.exitCode = 0;
     return;
   }
 
+  if (subcommand === 'session-severity') {
+    const payload = sessionSeverityReport.buildSessionSeverityReport(options);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      process.exitCode = 0;
+      return;
+    }
+    console.log(sessionSeverityReport.renderSessionSeverityReport(payload));
+    process.exitCode = 0;
+    return;
+  }
+
   if (subcommand !== 'scorecard') {
     throw new Error(`Unknown report subcommand: ${subcommand}`);
   }

package/src/context.js

@@ -128,8 +128,19 @@ const TEMPLATE_FILES = [
   'vscode/guardex-active-agents/extension.js',
   'vscode/guardex-active-agents/session-schema.js',
   'vscode/guardex-active-agents/README.md',
+  'vscode/guardex-active-agents/icon.png',
 ];
 
+const PACKAGE_ROOT_SOURCE_OVERRIDES = new Set([
+  'scripts/agent-session-state.js',
+  'scripts/install-vscode-active-agents-extension.js',
+  'vscode/guardex-active-agents/package.json',
+  'vscode/guardex-active-agents/extension.js',
+  'vscode/guardex-active-agents/session-schema.js',
+  'vscode/guardex-active-agents/README.md',
+  'vscode/guardex-active-agents/icon.png',
+]);
+
 const LEGACY_WORKFLOW_SHIM_SPECS = [
   { relativePath: 'scripts/agent-branch-start.sh', kind: 'shell', command: ['branch', 'start'] },
   { relativePath: 'scripts/agent-branch-finish.sh', kind: 'shell', command: ['branch', 'finish'] },
@@ -202,6 +213,7 @@ const PACKAGE_SCRIPT_ASSETS = {
   branchMerge: path.join(TEMPLATE_ROOT, 'scripts', 'agent-branch-merge.sh'),
   codexAgent: path.join(TEMPLATE_ROOT, 'scripts', 'codex-agent.sh'),
   reviewBot: path.join(TEMPLATE_ROOT, 'scripts', 'review-bot-watch.sh'),
+  sessionState: path.join(TEMPLATE_ROOT, 'scripts', 'agent-session-state.js'),
   worktreePrune: path.join(TEMPLATE_ROOT, 'scripts', 'agent-worktree-prune.sh'),
   lockTool: path.join(TEMPLATE_ROOT, 'scripts', 'agent-file-locks.py'),
   planInit: path.join(TEMPLATE_ROOT, 'scripts', 'openspec', 'init-plan-workspace.sh'),
@@ -349,7 +361,7 @@ const CLI_COMMAND_DESCRIPTIONS = [
   ['release', 'Create or update the current GitHub release with README-generated notes'],
   ['agents', 'Start/stop repo-scoped review + cleanup bots'],
   ['prompt', 'Print AI setup checklist or named slices (--exec, --part, --list-parts, --snippet)'],
-  ['report', 'Security/safety reports (e.g. OpenSSF scorecard)'],
+  ['report', 'Security/safety reports (e.g. OpenSSF scorecard, session severity)'],
   ['help', 'Show this help output'],
   ['version', 'Print GitGuardex version'],
 ];
@@ -413,7 +425,8 @@ const AI_SETUP_PARTS = [
     label: 'Task loop',
     promptLines: [
       'gx branch start "<task>" "<agent>"',
-      'then gx locks claim --branch "<agent-branch>" <file...> -> gx branch finish',
+      'then gx locks claim --branch "<agent-branch>" <file...> -> inspect once -> patch once -> verify once -> gx branch finish',
+      'batch discovery, git/PR, and CI by phase; avoid repeated peeks or stdin loops',
     ],
     execLines: [
       'gx branch start "<task>" "<agent>"',
@@ -619,6 +632,7 @@ module.exports = {
   HOOK_NAMES,
   toDestinationPath,
   TEMPLATE_FILES,
+  PACKAGE_ROOT_SOURCE_OVERRIDES,
   LEGACY_WORKFLOW_SHIM_SPECS,
   LEGACY_WORKFLOW_SHIMS,
   MANAGED_TEMPLATE_DESTINATIONS,

package/src/core/stdin.js

@@ -0,0 +1,52 @@
+const fs = require('node:fs');
+const { StringDecoder } = require('node:string_decoder');
+
+const stdinWaitArray = new Int32Array(new SharedArrayBuffer(4));
+
+function sleepSyncMs(milliseconds) {
+  Atomics.wait(stdinWaitArray, 0, 0, milliseconds);
+}
+
+function readSingleLineFromStdin(options = {}) {
+  const fsModule = options.fsModule || fs;
+  const input = options.input || process.stdin;
+  const sleepSync = options.sleepSync || sleepSyncMs;
+  const retryDelayMs = options.retryDelayMs == null ? 15 : options.retryDelayMs;
+  const buffer = Buffer.alloc(1);
+  const decoder = new StringDecoder('utf8');
+  let text = '';
+
+  while (true) {
+    let bytesRead = 0;
+    try {
+      bytesRead = fsModule.readSync(input.fd, buffer, 0, 1);
+    } catch (error) {
+      if (error && ['EAGAIN', 'EWOULDBLOCK', 'EINTR'].includes(error.code)) {
+        sleepSync(retryDelayMs);
+        continue;
+      }
+      return text + decoder.end();
+    }
+
+    if (bytesRead === 0) {
+      if (input.isTTY) {
+        sleepSync(retryDelayMs);
+        continue;
+      }
+      return text + decoder.end();
+    }
+
+    const char = decoder.write(buffer.subarray(0, bytesRead));
+    if (!char) {
+      continue;
+    }
+    if (char === '\n' || char === '\r') {
+      return text;
+    }
+    text += char;
+  }
+}
+
+module.exports = {
+  readSingleLineFromStdin,
+};

package/src/core/versions.js

@@ -0,0 +1,33 @@
+const semver = require('semver');
+
+function parseVersionString(version) {
+  const trimmed = String(version || '').trim();
+  if (!trimmed) {
+    return null;
+  }
+  return semver.valid(trimmed) || null;
+}
+
+function compareParsedVersions(left, right) {
+  if (!left || !right) {
+    return 0;
+  }
+  return semver.compare(left, right);
+}
+
+function isNewerVersion(latest, current) {
+  const latestParts = parseVersionString(latest);
+  const currentParts = parseVersionString(current);
+
+  if (!latestParts || !currentParts) {
+    return String(latest || '').trim() !== String(current || '').trim();
+  }
+
+  return semver.gt(latestParts, currentParts);
+}
+
+module.exports = {
+  parseVersionString,
+  compareParsedVersions,
+  isNewerVersion,
+};

package/src/hooks/index.js

@@ -1,5 +1,39 @@
 const path = require('node:path');
 
+function requireFlagValue(rawArgs, index, flagName) {
+  const value = rawArgs[index + 1];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`${flagName} requires a value`);
+  }
+  return value;
+}
+
+function parseHeartbeatArgs(rawArgs) {
+  let branch = '';
+  let state = '';
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+    if (arg === '--branch') {
+      branch = requireFlagValue(rawArgs, index, '--branch');
+      index += 1;
+      continue;
+    }
+    if (arg === '--state') {
+      state = requireFlagValue(rawArgs, index, '--state');
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown heartbeat option: ${arg}`);
+  }
+
+  if (!branch) {
+    throw new Error('heartbeat requires --branch <agent/...>');
+  }
+
+  return { branch, state };
+}
+
 function hook(rawArgs, deps) {
   const {
     extractTargetedArgs,
@@ -55,6 +89,36 @@ function internal(rawArgs, deps) {
   } = deps;
 
   const [subcommand, assetKey, ...rest] = rawArgs;
+  if (subcommand === 'heartbeat') {
+    const { target, passthrough } = extractTargetedArgs([assetKey, ...rest].filter(Boolean));
+    const repoRoot = resolveRepoRoot(target);
+    const options = parseHeartbeatArgs(passthrough);
+    const heartbeatArgs = ['heartbeat', '--repo', repoRoot, '--branch', options.branch];
+    if (options.state) {
+      heartbeatArgs.push('--state', options.state);
+    }
+    const result = runPackageAsset('sessionState', heartbeatArgs, { cwd: repoRoot });
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    process.exitCode = result.status;
+    return;
+  }
+  if (subcommand === 'stop-session') {
+    const { target, passthrough } = extractTargetedArgs([assetKey, ...rest].filter(Boolean));
+    const repoRoot = resolveRepoRoot(target);
+    const options = parseHeartbeatArgs(passthrough);
+    const result = runPackageAsset('sessionState', [
+      'terminate',
+      '--repo',
+      repoRoot,
+      '--branch',
+      options.branch,
+    ], { cwd: repoRoot });
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    process.exitCode = result.status;
+    return;
+  }
   if (subcommand !== 'run-shell') {
     throw new Error(`Unknown internal command: ${subcommand || '(missing)'}`);
   }

package/src/output/index.js

@@ -87,6 +87,62 @@ function detectAutoFinishSummaryStatus(summary) {
   return null;
 }
 
+const AUTO_FINISH_DETAIL_PRIORITY = new Map([
+  ['fail', 0],
+  ['pending', 1],
+  ['done', 2],
+  ['skip', 3],
+]);
+
+function autoFinishDetailPriority(status) {
+  return AUTO_FINISH_DETAIL_PRIORITY.get(status) ?? AUTO_FINISH_DETAIL_PRIORITY.size;
+}
+
+function sortAutoFinishDetailEntries(details) {
+  return details
+    .map((detail, index) => {
+      const status = detectAutoFinishDetailStatus(detail) || 'other';
+      return {
+        detail,
+        index,
+        status,
+        priority: autoFinishDetailPriority(status),
+      };
+    })
+    .sort((left, right) => (left.priority - right.priority) || (left.index - right.index));
+}
+
+function summarizeHiddenAutoFinishDetails(hiddenEntries) {
+  const counts = new Map();
+  for (const entry of hiddenEntries) {
+    counts.set(entry.status, (counts.get(entry.status) || 0) + 1);
+  }
+
+  const segments = ['fail', 'pending', 'done', 'skip', 'other']
+    .map((status) => {
+      const count = counts.get(status) || 0;
+      return count > 0 ? `${status}=${count}` : '';
+    })
+    .filter(Boolean);
+
+  let status = null;
+  if ((counts.get('fail') || 0) > 0) {
+    status = 'fail';
+  } else if ((counts.get('pending') || 0) > 0) {
+    status = 'pending';
+  } else if ((counts.get('done') || 0) > 0) {
+    status = 'done';
+  } else if ((counts.get('skip') || 0) > 0) {
+    status = 'skip';
+  }
+
+  return {
+    status,
+    message: `… ${hiddenEntries.length} more branch result(s) hidden: ${segments.join(', ')}. ` +
+      'Re-run with --verbose-auto-finish for full details.',
+  };
+}
+
 function statusDot(status) {
   if (status === 'active') {
     return colorize('●', '32');
@@ -360,15 +416,19 @@ function printAutoFinishSummary(summary, options = {}) {
         detectAutoFinishSummaryStatus(summary),
       ),
     );
-    const visibleDetails = verbose ? details : details.slice(0, detailLimit).map(summarizeAutoFinishDetail);
+    const sortedDetailEntries = verbose ? [] : sortAutoFinishDetailEntries(details);
+    const visibleDetails = verbose
+      ? details
+      : sortedDetailEntries.slice(0, detailLimit).map((entry) => summarizeAutoFinishDetail(entry.detail));
     for (const detail of visibleDetails) {
       console.log(colorizeDoctorOutput(`[${TOOL_NAME}]   ${detail}`, detectAutoFinishDetailStatus(detail)));
     }
-    if (!verbose && details.length > visibleDetails.length) {
+    if (!verbose && sortedDetailEntries.length > visibleDetails.length) {
+      const hiddenSummary = summarizeHiddenAutoFinishDetails(sortedDetailEntries.slice(visibleDetails.length));
       console.log(
         colorizeDoctorOutput(
-          `[${TOOL_NAME}]   … ${details.length - visibleDetails.length} more branch result(s). Re-run with --verbose-auto-finish for full details.`,
-          'warn',
+          `[${TOOL_NAME}]   ${hiddenSummary.message}`,
+          hiddenSummary.status || 'warn',
         ),
       );
     }