@imdeadpool/guardex 7.0.39 → 7.0.43

package/src/cli/main.js

@@ -5,7 +5,17 @@ const sandboxModule = require('../sandbox');
 const toolchainModule = require('../toolchain');
 const finishCommands = require('../finish');
 const doctorModule = require('../doctor');
+const submoduleModule = require('../submodule');
+const agentInspect = require('../agents/inspect');
+const agentStatus = require('../agents/status');
+const agentCleanupSessions = require('../agents/cleanup-sessions');
+const { finishAgentSession } = require('../agents/finish');
 const sessionSeverityReport = require('../report/session-severity');
+const budgetModule = require('../budget');
+const ciInitModule = require('../ci-init');
+const cockpitModule = require('../cockpit');
+const agentsStart = require('../agents/start');
+const prReviewModule = require('../pr-review');
 const {
   fs,
   path,
@@ -83,6 +93,7 @@ const {
   readConfiguredProtectedBranches,
   readProtectedBranches,
   ensureSetupProtectedBranches,
+  ensureSubmoduleAutoSync,
   writeProtectedBranches,
   readGitConfig,
   resolveBaseBranch,
@@ -127,6 +138,7 @@ const {
   parseDoctorArgs,
   parseTargetFlag,
   parseReviewArgs,
+  parsePrReviewArgs,
   parseAgentsArgs,
   parseReportArgs,
   parseSyncArgs,
@@ -177,6 +189,7 @@ const {
   installUserLevelAsset,
   removeLegacyManagedRepoFile,
   ensureAgentsSnippet,
+  ensureClaudeAgentsLink,
   ensureManagedGitignore,
   buildRepoVscodeSettings,
   ensureRepoVscodeSettings,
@@ -377,6 +390,9 @@ function runSetupBootstrapInternal(options) {
   installPayload.operations.push(
     ensureSetupProtectedBranches(installPayload.repoRoot, Boolean(options.dryRun)),
   );
+  installPayload.operations.push(
+    ...ensureSubmoduleAutoSync(installPayload.repoRoot, Boolean(options.dryRun)),
+  );
 
   let parentWorkspace = null;
   if (options.parentWorkspaceView) {
@@ -880,6 +896,17 @@ function isInteractiveTerminal() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
+function legacyDefaultStatusEnabled() {
+  return envFlagIsTruthy(process.env.GUARDEX_LEGACY_STATUS);
+}
+
+function defaultCockpitDisabled() {
+  const raw = process.env.GUARDEX_DEFAULT_COCKPIT;
+  if (raw == null) return false;
+  const normalized = String(raw).trim().toLowerCase();
+  return ['0', 'false', 'no', 'off'].includes(normalized);
+}
+
 function parseAutoApproval(name) {
   const raw = process.env[name];
   if (raw == null) return null;
@@ -1241,84 +1268,6 @@ function promptYesNoStrict(question) {
   }
 }
 
-const VSCODE_EXTENSION_ID = 'Recodee.gitguardex-active-agents';
-const VSCODE_EXTENSION_DISPLAY_NAME = 'GitGuardex Active Agents';
-
-function maybePromptInstallVscodeExtension(options) {
-  if (options.dryRun) {
-    console.log(
-      `[${TOOL_NAME}] (dry-run) Would offer to install VS Code extension '${VSCODE_EXTENSION_ID}'.`,
-    );
-    return;
-  }
-
-  if (envFlagIsTruthy(process.env.GUARDEX_SKIP_VSCODE_EXT_PROMPT)) {
-    return;
-  }
-
-  const codeProbe = cp.spawnSync('code', ['--version'], { stdio: 'ignore' });
-  if (codeProbe.error || codeProbe.status !== 0) {
-    return;
-  }
-
-  const listProbe = cp.spawnSync('code', ['--list-extensions'], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  if (!listProbe.error && listProbe.status === 0) {
-    const alreadyInstalled = String(listProbe.stdout || '')
-      .split('\n')
-      .some((line) => line.trim().toLowerCase() === VSCODE_EXTENSION_ID.toLowerCase());
-    if (alreadyInstalled) {
-      console.log(
-        `[${TOOL_NAME}] ✅ VS Code extension '${VSCODE_EXTENSION_ID}' already installed.`,
-      );
-      return;
-    }
-  }
-
-  let approved;
-  if (options.yesGlobalInstall) {
-    approved = true;
-  } else if (options.noGlobalInstall) {
-    approved = false;
-  } else if (!isInteractiveTerminal()) {
-    console.log(
-      `[${TOOL_NAME}] Optional VS Code extension '${VSCODE_EXTENSION_ID}' ` +
-        `(${VSCODE_EXTENSION_DISPLAY_NAME}) not installed. ` +
-        `Install later: code --install-extension ${VSCODE_EXTENSION_ID}`,
-    );
-    return;
-  } else {
-    approved = promptYesNoStrict(
-      `Install VS Code extension '${VSCODE_EXTENSION_ID}' (${VSCODE_EXTENSION_DISPLAY_NAME}) now?`,
-    );
-  }
-
-  if (!approved) {
-    console.log(
-      `[${TOOL_NAME}] ⚠️ VS Code extension skipped. ` +
-        `Set GUARDEX_SKIP_VSCODE_EXT_PROMPT=1 to silence or run 'code --install-extension ${VSCODE_EXTENSION_ID}' later.`,
-    );
-    return;
-  }
-
-  const install = cp.spawnSync('code', ['--install-extension', VSCODE_EXTENSION_ID], {
-    stdio: 'inherit',
-  });
-  if (install.error || install.status !== 0) {
-    console.log(
-      `[${TOOL_NAME}] ⚠️ VS Code extension install failed. ` +
-        `Retry manually: code --install-extension ${VSCODE_EXTENSION_ID}`,
-    );
-    return;
-  }
-  console.log(
-    `[${TOOL_NAME}] ✅ VS Code extension '${VSCODE_EXTENSION_ID}' installed. ` +
-      `Reload the VS Code window to activate it.`,
-  );
-}
-
 function resolveGlobalInstallApproval(options) {
   if (options.yesGlobalInstall && options.noGlobalInstall) {
     throw new Error('Cannot use both --yes-global-install and --no-global-install');
@@ -1557,6 +1506,7 @@ function runInstallInternal(options) {
 
   if (!options.skipAgents) {
     operations.push(ensureAgentsSnippet(repoRoot, Boolean(options.dryRun), { force: Boolean(options.force) }));
+    operations.push(ensureClaudeAgentsLink(repoRoot, Boolean(options.dryRun)));
   }
 
   const hookResult = configureHooks(repoRoot, Boolean(options.dryRun));
@@ -1640,6 +1590,7 @@ function runFixInternal(options) {
 
   if (!options.skipAgents) {
     operations.push(ensureAgentsSnippet(repoRoot, Boolean(options.dryRun), { force: Boolean(options.force) }));
+    operations.push(ensureClaudeAgentsLink(repoRoot, Boolean(options.dryRun)));
   }
 
   const hookResult = configureHooks(repoRoot, Boolean(options.dryRun));
@@ -1947,6 +1898,7 @@ function collectServicesSnapshot() {
     ...requiredSystemTools.map((tool) => ({
       name: tool.name,
       displayName: tool.displayName || tool.name,
+      command: tool.command,
       status: tool.status,
     })),
   ];
@@ -2016,9 +1968,7 @@ function status(rawArgs) {
     target: process.cwd(),
     json: false,
   });
-  const forceCompact = envFlagIsTruthy(process.env.GUARDEX_COMPACT_STATUS);
   const forceExpand = envFlagIsTruthy(process.env.GUARDEX_VERBOSE_STATUS) || verboseFlag;
-  const interactive = Boolean(process.stdout.isTTY);
   const invokedBasename = getInvokedCliName();
 
   let snapshot = collectServicesSnapshot();
@@ -2071,17 +2021,24 @@ function status(rawArgs) {
     return payload;
   }
 
-  const allServicesActive = toolchain.ok && services.every((service) => service.status === 'active');
-  const compact = !forceExpand && (forceCompact || (interactive && allServicesActive));
+  const compact = !forceExpand;
+  const activeServiceCount = services.filter((service) => service.status === 'active').length;
+  const inactiveServiceCount = services.length - activeServiceCount;
 
   console.log(`[${TOOL_NAME}] CLI: ${payload.cli.runtime}`);
   if (!toolchain.ok) {
-    console.log(`[${TOOL_NAME}] ⚠️ Could not detect global services: ${toolchain.error}`);
+    const detectionError = compact
+      ? String(toolchain.error || '').split(/\r?\n/).find(Boolean) || 'unknown error'
+      : toolchain.error;
+    console.log(`[${TOOL_NAME}] ⚠️ Could not detect global services: ${detectionError}`);
   }
 
   if (compact) {
+    const serviceSummary = inactiveServiceCount === 0
+      ? `${activeServiceCount}/${services.length} ${statusDot('active')} active`
+      : `${activeServiceCount}/${services.length} ${statusDot('degraded')} active (${inactiveServiceCount} inactive)`;
     console.log(
-      `[${TOOL_NAME}] Global services: ${services.length}/${services.length} ${statusDot('active')} active`,
+      `[${TOOL_NAME}] Global services: ${serviceSummary}`,
     );
   } else {
     console.log(`[${TOOL_NAME}] Global services:`);
@@ -2094,19 +2051,25 @@ function status(rawArgs) {
     .filter((service) => service.status !== 'active')
     .map((service) => service.displayName || service.name);
   if (inactiveOptionalCompanions.length > 0) {
-    console.log(
-      `[${TOOL_NAME}] Optional companion tools inactive: ${inactiveOptionalCompanions.join(', ')}`,
-    );
-    for (const warning of toolchainModule.describeMissingGlobalDependencyWarnings(
-      npmServices
-        .filter((service) => service.status === 'inactive')
-        .map((service) => service.packageName),
-    )) {
-      console.log(`[${TOOL_NAME}] ${warning}`);
+    if (compact) {
+      console.log(
+        `[${TOOL_NAME}] Optional companion tools inactive: ${inactiveOptionalCompanions.length} (run '${SHORT_TOOL_NAME} setup')`,
+      );
+    } else {
+      console.log(
+        `[${TOOL_NAME}] Optional companion tools inactive: ${inactiveOptionalCompanions.join(', ')}`,
+      );
+      for (const warning of toolchainModule.describeMissingGlobalDependencyWarnings(
+        npmServices
+          .filter((service) => service.status === 'inactive')
+          .map((service) => service.packageName),
+      )) {
+        console.log(`[${TOOL_NAME}] ${warning}`);
+      }
+      console.log(
+        `[${TOOL_NAME}] Run '${SHORT_TOOL_NAME} setup' to install missing companions with an explicit Y/N prompt.`,
+      );
     }
-    console.log(
-      `[${TOOL_NAME}] Run '${SHORT_TOOL_NAME} setup' to install missing companions with an explicit Y/N prompt.`,
-    );
   }
   const missingSystemTools = requiredSystemTools.filter((tool) => tool.status !== 'active');
   if (missingSystemTools.length > 0) {
@@ -2114,9 +2077,11 @@ function status(rawArgs) {
       .map((tool) => tool.displayName || tool.name)
       .join(', ');
     console.log(`[${TOOL_NAME}] ⚠️ Missing required system tool(s): ${tools}`);
-    for (const tool of missingSystemTools) {
-      const reasonText = tool.reason ? ` (${tool.reason})` : '';
-      console.log(`  - install ${tool.name}: ${tool.installHint}${reasonText}`);
+    if (!compact) {
+      for (const tool of missingSystemTools) {
+        const reasonText = tool.reason ? ` (${tool.reason})` : '';
+        console.log(`  - install ${tool.name}: ${tool.installHint}${reasonText}`);
+      }
     }
   }
 
@@ -2387,6 +2352,10 @@ function doctor(rawArgs) {
     target: topRepoRoot,
   };
 
+  if (!singleRepoOptions.json) {
+    printRequiredSystemToolStatus();
+  }
+
   const blocked = protectedBaseWriteBlock(singleRepoOptions, { requireBootstrap: false });
   if (blocked) {
     doctorModule.runDoctorInSandbox(singleRepoOptions, blocked, {
@@ -2501,6 +2470,13 @@ function review(rawArgs) {
   process.exitCode = typeof result.status === 'number' ? result.status : 1;
 }
 
+function prReview(rawArgs) {
+  const options = parsePrReviewArgs(rawArgs);
+  const result = prReviewModule.runPrReview(options);
+  prReviewModule.printPrReviewResult(result);
+  process.exitCode = 0;
+}
+
 function agentsStatePathForRepo(repoRoot) {
   return path.join(repoRoot, AGENTS_BOTS_STATE_RELATIVE);
 }
@@ -2642,10 +2618,58 @@ function spawnDetachedAgentProcess({ command, args, cwd, logPath }) {
 
 function agents(rawArgs) {
   const options = parseAgentsArgs(rawArgs);
+  if (['files', 'diff', 'locks'].includes(options.subcommand)) {
+    process.stdout.write(agentInspect.runInspectCommand(options));
+    process.exitCode = 0;
+    return;
+  }
+
   const repoRoot = resolveRepoRoot(options.target);
   const statePath = agentsStatePathForRepo(repoRoot);
 
+  if (options.subcommand === 'finish') {
+    const result = finishAgentSession(repoRoot, options);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(result.evidence, null, 2)}\n`);
+    }
+    process.exitCode = 0;
+    return;
+  }
+
+  if (options.subcommand === 'cleanup-sessions') {
+    process.stdout.write(agentCleanupSessions.runCleanupSessionsCommand(repoRoot, options));
+    process.exitCode = 0;
+    return;
+  }
+
   if (options.subcommand === 'start') {
+    if (agentsStart.shouldUseInteractivePanel(options, process.stdin, process.stdout)) {
+      agentsStart.startInteractiveAgentPanel(repoRoot, options, {
+        onDone(result) {
+          process.exitCode = result.status;
+        },
+      });
+      return;
+    }
+    if (options.dryRun) {
+      const output = agentsStart.dryRunStart(options, repoRoot);
+      process.stdout.write(output.endsWith('\n') ? output : `${output}\n`);
+      process.exitCode = 0;
+      return;
+    }
+    if (options.panel && !options.task) {
+      process.stderr.write('[gitguardex] gx agents start --panel requires an interactive terminal when no task is provided.\n');
+      process.exitCode = 1;
+      return;
+    }
+    if (options.task) {
+      const result = agentsStart.startAgentLane(repoRoot, options);
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.stderr) process.stderr.write(result.stderr);
+      process.exitCode = result.status;
+      return;
+    }
+
     const existingState = readAgentsState(repoRoot);
     const existingReviewPid = Number.parseInt(String(existingState?.review?.pid || ''), 10);
     const existingCleanupPid = Number.parseInt(String(existingState?.cleanup?.pid || ''), 10);
@@ -2786,18 +2810,7 @@ function agents(rawArgs) {
     return;
   }
 
-  const existingState = readAgentsState(repoRoot);
-  if (!existingState) {
-    console.log(`[${TOOL_NAME}] Repo agents status: inactive (${repoRoot})`);
-    process.exitCode = 0;
-    return;
-  }
-
-  const reviewPid = Number.parseInt(String(existingState?.review?.pid || ''), 10);
-  const cleanupPid = Number.parseInt(String(existingState?.cleanup?.pid || ''), 10);
-  console.log(
-    `[${TOOL_NAME}] Repo agents status: review=${processAlive(reviewPid) ? 'running' : 'stopped'}(pid=${reviewPid || 0}), cleanup=${processAlive(cleanupPid) ? 'running' : 'stopped'}(pid=${cleanupPid || 0})`,
-  );
+  process.stdout.write(agentStatus.runStatusCommand(repoRoot, options));
   process.exitCode = 0;
 }
 
@@ -2955,20 +2968,7 @@ function setup(rawArgs) {
     }
   }
 
-  maybePromptInstallVscodeExtension(options);
-
-  const requiredSystemTools = toolchainModule.detectRequiredSystemTools();
-  const missingSystemTools = requiredSystemTools.filter((tool) => tool.status !== 'active');
-  if (missingSystemTools.length === 0) {
-    console.log(`[${TOOL_NAME}] ✅ Required system tools available (${requiredSystemTools.map((tool) => tool.name).join(', ')}).`);
-  } else {
-    const names = missingSystemTools.map((tool) => tool.name).join(', ');
-    console.log(`[${TOOL_NAME}] ⚠️ Missing required system tool(s): ${names}`);
-    for (const tool of missingSystemTools) {
-      const reasonText = tool.reason ? ` (${tool.reason})` : '';
-      console.log(`[${TOOL_NAME}] Install ${tool.name}: ${tool.installHint}${reasonText}`);
-    }
-  }
+  printRequiredSystemToolStatus();
 
   const topRepoRoot = resolveRepoRoot(options.target);
   const discoveredRepos = options.recursive
@@ -3082,6 +3082,22 @@ function setup(rawArgs) {
   }
 }
 
+function printRequiredSystemToolStatus() {
+  const requiredSystemTools = toolchainModule.detectRequiredSystemTools();
+  const missingSystemTools = requiredSystemTools.filter((tool) => tool.status !== 'active');
+  if (missingSystemTools.length === 0) {
+    console.log(`[${TOOL_NAME}] ✅ Required system tools available (${requiredSystemTools.map((tool) => tool.name).join(', ')}).`);
+    return;
+  }
+
+  const names = missingSystemTools.map((tool) => tool.name).join(', ');
+  console.log(`[${TOOL_NAME}] ⚠️ Missing required system tool(s): ${names}`);
+  for (const tool of missingSystemTools) {
+    const reasonText = tool.reason ? ` (${tool.reason})` : '';
+    console.log(`[${TOOL_NAME}] Install ${tool.name}: ${tool.installHint}${reasonText}`);
+  }
+}
+
 function ensureMainBranch(repoRoot) {
   const branchResult = gitRun(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD'], { allowFailure: true });
   if (branchResult.status !== 0) {
@@ -3249,6 +3265,25 @@ function renderGeneratedReleaseNotes(entries, currentTag, previousTag) {
   return `GitGuardex ${currentTag}\n\n${intro}\n\n${sections}`;
 }
 
+function describeGhAuthFailure(ghBin, authStatus) {
+  if (authStatus.error) {
+    return `unable to run '${ghBin} auth status': ${authStatus.error.message}`;
+  }
+
+  const authDetails = (authStatus.stderr || authStatus.stdout || '').trim();
+  const apiProbe = run(ghBin, ['api', 'user', '--jq', '.login'], { timeout: 20_000 });
+  if (apiProbe.status === 0) {
+    return '';
+  }
+
+  const apiDetails = (apiProbe.stderr || apiProbe.stdout || apiProbe.error?.message || '').trim();
+  if (/error connecting to api\.github\.com|could not resolve host|failed to connect|network is unreachable|connection timed out|temporary failure in name resolution/i.test(apiDetails)) {
+    return `GitHub API is unreachable, so '${ghBin} auth status' cannot validate the stored token. This is a network or sandbox connectivity problem, not proof that the token is invalid.${apiDetails ? `\n${apiDetails}` : ''}`;
+  }
+
+  return `'${ghBin}' auth is unavailable.${authDetails ? `\n${authDetails}` : ''}`;
+}
+
 function buildReleaseNotesFromReadme(repoRoot, currentTag, previousTag) {
   const readme = readRepoReadme(repoRoot);
   const entries = parseReadmeReleaseEntries(readme);
@@ -3276,12 +3311,11 @@ function release(rawArgs) {
   }
 
   const ghAuthStatus = run(GH_BIN, ['auth', 'status'], { timeout: 20_000 });
-  if (ghAuthStatus.error) {
-    throw new Error(`Release blocked: unable to run '${GH_BIN} auth status': ${ghAuthStatus.error.message}`);
-  }
   if (ghAuthStatus.status !== 0) {
-    const details = (ghAuthStatus.stderr || ghAuthStatus.stdout || '').trim();
-    throw new Error(`Release blocked: '${GH_BIN}' auth is unavailable.${details ? `\n${details}` : ''}`);
+    const ghAuthFailure = describeGhAuthFailure(GH_BIN, ghAuthStatus);
+    if (ghAuthFailure) {
+      throw new Error(`Release blocked: ${ghAuthFailure}`);
+    }
   }
 
   const releasePackageJson = readReleaseRepoPackageJson(repoRoot);
@@ -3416,6 +3450,7 @@ function prompt(rawArgs) {
 }
 
 function branch(rawArgs) {
+  const activeCwd = process.cwd();
   const [subcommand, ...rest] = rawArgs;
   if (subcommand === 'start') {
     const { target, passthrough } = extractTargetedArgs(rest);
@@ -3424,7 +3459,10 @@ function branch(rawArgs) {
   }
   if (subcommand === 'finish') {
     const { target, passthrough } = extractTargetedArgs(rest);
-    invokePackageAsset('branchFinish', passthrough, { cwd: resolveRepoRoot(target) });
+    invokePackageAsset('branchFinish', passthrough, {
+      cwd: resolveRepoRoot(target),
+      env: { GUARDEX_FINISH_ACTIVE_CWD: activeCwd },
+    });
     return;
   }
   if (subcommand === 'merge') return merge(rest);
@@ -3501,10 +3539,14 @@ function locks(rawArgs) {
 }
 
 function worktree(rawArgs) {
+  const activeCwd = process.cwd();
   const [subcommand, ...rest] = rawArgs;
   if (subcommand === 'prune') {
     const { target, passthrough } = extractTargetedArgs(rest);
-    invokePackageAsset('worktreePrune', passthrough, { cwd: resolveRepoRoot(target) });
+    invokePackageAsset('worktreePrune', passthrough, {
+      cwd: resolveRepoRoot(target),
+      env: { GUARDEX_PRUNE_ACTIVE_CWD: process.env.GUARDEX_PRUNE_ACTIVE_CWD || activeCwd },
+    });
     return;
   }
   throw new Error(`Usage: ${SHORT_TOOL_NAME} worktree prune [cleanup-options]`);
@@ -3616,6 +3658,81 @@ function sync(rawArgs) {
   return finishCommands.sync(rawArgs);
 }
 
+function submodule(rawArgs) {
+  const parsed = parseTargetFlag(rawArgs || [], process.cwd());
+  const [subcommand, ...rest] = parsed.args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    console.log(
+      `${TOOL_NAME} submodule commands:\n` +
+      `  ${TOOL_NAME} submodule advance [<path>] [--push] [--dry-run] [--branch <ref>] [--no-commit] [--target <path>]\n\n` +
+      `  advance — for each submodule listed in .gitmodules, fetch the tracked branch's\n` +
+      `            remote tip, advance the parent pointer, and (when on a non-protected\n` +
+      `            branch) commit the bump. Use --push to publish in one step.`,
+    );
+    return;
+  }
+
+  if (subcommand !== 'advance') {
+    throw new Error(`Unknown submodule subcommand: ${subcommand}. Try '${SHORT_TOOL_NAME} submodule help'.`);
+  }
+
+  let push = false;
+  let dryRun = false;
+  let commit = true;
+  let branchOverride = '';
+  let pathArg = '';
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === '--push') {
+      push = true;
+      continue;
+    }
+    if (arg === '--dry-run' || arg === '-n') {
+      dryRun = true;
+      continue;
+    }
+    if (arg === '--no-commit') {
+      commit = false;
+      continue;
+    }
+    if (arg === '--branch' || arg === '-b') {
+      branchOverride = rest[i + 1] || '';
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--branch=')) {
+      branchOverride = arg.slice('--branch='.length);
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      throw new Error(`Unknown option for '${SHORT_TOOL_NAME} submodule advance': ${arg}`);
+    }
+    if (pathArg) {
+      throw new Error(`'${SHORT_TOOL_NAME} submodule advance' accepts at most one submodule path (got '${pathArg}' and '${arg}')`);
+    }
+    pathArg = arg;
+  }
+
+  const result = submoduleModule.advance({
+    target: parsed.target,
+    path: pathArg,
+    push,
+    dryRun,
+    commit,
+    branch: branchOverride,
+  });
+  submoduleModule.printAdvanceResult(result);
+}
+
+function cockpit(rawArgs) {
+  cockpitModule.openCockpit(rawArgs, {
+    resolveRepoRoot,
+    toolName: TOOL_NAME,
+  });
+  process.exitCode = 0;
+}
+
 function protect(rawArgs) {
   const parsed = parseTargetFlag(rawArgs, process.cwd());
   const [subcommand, ...rest] = parsed.args;
@@ -3698,6 +3815,14 @@ async function main() {
   const args = process.argv.slice(2);
 
   if (args.length === 0) {
+    if (isInteractiveTerminal() && !legacyDefaultStatusEnabled() && !defaultCockpitDisabled()) {
+      cockpitModule.openDefaultCockpit({
+        resolveRepoRoot,
+        toolName: TOOL_NAME,
+      });
+      process.exitCode = 0;
+      return;
+    }
     toolchainModule.maybeSelfUpdateBeforeStatus();
     toolchainModule.maybeOpenSpecUpdateBeforeStatus();
     const statusPayload = status([]);
@@ -3747,6 +3872,7 @@ async function main() {
   }
 
   if (command === 'prompt') return prompt(rest);
+  if (command === 'pr-review') return prReview(rest);
   if (command === 'doctor') return doctor(rest);
   if (command === 'branch') return branch(rest);
   if (command === 'pivot') return pivot(rest);
@@ -3758,13 +3884,17 @@ async function main() {
   if (command === 'install-agent-skills') return installAgentSkills(rest);
   if (command === 'internal') return internal(rest);
   if (command === 'agents') return agents(rest);
+  if (command === 'cockpit') return cockpit(rest);
   if (command === 'merge') return merge(rest);
   if (command === 'finish') return finish(rest);
   if (command === 'report') return report(rest);
   if (command === 'protect') return protect(rest);
   if (command === 'sync') return sync(rest);
+  if (command === 'submodule') return submodule(rest);
   if (command === 'cleanup') return cleanup(rest);
   if (command === 'release') return release(rest);
+  if (command === 'budget') return budgetModule.runBudgetCommand(rest);
+  if (command === 'ci-init') return ciInitModule.runCiInitCommand(rest);
 
   const suggestion = maybeSuggestCommand(command);
   if (suggestion) {

package/src/cockpit/action-runner.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./pane-actions');

package/src/cockpit/actions.js

@@ -0,0 +1,80 @@
+'use strict';
+
+function parseAgentBranchStartMetadata(output) {
+  const outputText = String(output || '');
+  const branchMatch = outputText.match(/^\[agent-branch-start\] (?:Created branch|Reusing existing branch): (.+)$/m);
+  const worktreeMatch = outputText.match(/^\[agent-branch-start\] Worktree: (.+)$/m);
+  return {
+    branch: branchMatch ? branchMatch[1].trim() : undefined,
+    worktreePath: worktreeMatch ? worktreeMatch[1].trim() : undefined,
+  };
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.length > 0) return value;
+  }
+  return undefined;
+}
+
+function normalizeStartResult(result) {
+  const payload = result && typeof result === 'object' ? result : {};
+  const metadata = parseAgentBranchStartMetadata(payload.stdout);
+  const ok = Object.prototype.hasOwnProperty.call(payload, 'ok')
+    ? Boolean(payload.ok)
+    : typeof payload.status === 'number'
+      ? payload.status === 0
+    : true;
+
+  return {
+    ok,
+    sessionId: firstString(payload.sessionId, payload.session?.id, payload.id),
+    branch: firstString(payload.branch, payload.lane?.branch, metadata.branch),
+    worktreePath: firstString(payload.worktreePath, payload.worktree?.path, payload.path, metadata.worktreePath),
+    message: firstString(
+      payload.message,
+      ok ? payload.stdout : payload.stderr,
+      ok ? 'Started agent lane.' : 'Failed to start agent lane.',
+    ),
+  };
+}
+
+function resolveStartImplementation(deps = {}) {
+  if (typeof deps.startImplementation === 'function') return deps.startImplementation;
+  if (typeof deps.startAgentLane === 'function') return deps.startAgentLane;
+  if (typeof deps.startAgent === 'function') return deps.startAgent;
+
+  const startModule = require('../agents/start');
+  if (typeof startModule === 'function') return startModule;
+  if (typeof startModule.startAgentLane === 'function') return startModule.startAgentLane;
+  if (typeof startModule.startAgent === 'function') return startModule.startAgent;
+  if (typeof startModule.start === 'function') return startModule.start;
+
+  throw new Error('gx agents start implementation is unavailable');
+}
+
+function startAgentLane(options = {}, deps = {}) {
+  const repoRoot = firstString(options.repoRoot, deps.repoRoot, process.cwd());
+  const normalizedOptions = {
+    task: options.task,
+    agent: options.agent,
+    base: options.base,
+    claims: Array.isArray(options.claims) ? options.claims : [],
+    metadata: options.metadata && typeof options.metadata === 'object' ? options.metadata : {},
+  };
+  const startImplementation = resolveStartImplementation(deps);
+  const result = startImplementation(repoRoot, normalizedOptions);
+
+  if (result && typeof result.then === 'function') {
+    return result.then(normalizeStartResult);
+  }
+
+  return normalizeStartResult(result);
+}
+
+module.exports = {
+  startAgentLane,
+  normalizeStartResult,
+  parseAgentBranchStartMetadata,
+  resolveStartImplementation,
+};