git-coco 0.60.0 → 0.62.0

package/dist/index.esm.mjs

@@ -61,7 +61,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.60.0";
+const BUILD_VERSION = "0.62.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -292,10 +292,19 @@ class LangChainExecutionError extends LangChainError {
 }
 /**
  * Authentication-related errors (missing API keys, invalid credentials, etc.)
+ *
+ * Carries `provider` + `endpoint` context so the formatter (in
+ * `commandExecutor`) can render provider-specific recovery hints
+ * ("set OPENAI_API_KEY", "run `gh auth login`", etc.) instead of the
+ * generic "verify your API key" copy. Mirrors the shape of
+ * `LangChainNetworkError` so call sites can hand the same fields to
+ * either constructor depending on which condition fired.
  */
 class LangChainAuthenticationError extends LangChainError {
-    constructor(message, context) {
-        super(message, context);
+    constructor(message, provider, endpoint, context) {
+        super(message, { ...context, provider, endpoint });
+        this.provider = provider;
+        this.endpoint = endpoint;
     }
 }
 /**
@@ -433,21 +442,27 @@ function getDefaultServiceApiKey(config) {
     const requiresAuth = provider === 'openai' || provider === 'anthropic';
     if (service.authentication.type === 'APIKey') {
         const apiKey = service.authentication.credentials?.apiKey;
+        // `endpoint` is optional on some service variants (Ollama / OpenAI-
+        // compatible) and absent on others (managed OpenAI / Anthropic).
+        // Read defensively so we still attach it when present.
+        const endpoint = service.endpoint;
         if (requiresAuth && (!apiKey || apiKey.trim() === '')) {
-            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: API key is required for ${provider} provider but not provided`, { provider, authenticationType: service.authentication.type });
+            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: API key is required for ${provider} provider but not provided`, provider, endpoint, { authenticationType: service.authentication.type });
         }
         return apiKey || '';
     }
     if (service.authentication.type === 'OAuth') {
         const token = service.authentication.credentials?.token;
+        const endpoint = service.endpoint;
         if (requiresAuth && (!token || token.trim() === '')) {
-            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: OAuth token is required for ${provider} provider but not provided`, { provider, authenticationType: service.authentication.type });
+            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: OAuth token is required for ${provider} provider but not provided`, provider, endpoint, { authenticationType: service.authentication.type });
         }
         return token || '';
     }
     if (service.authentication.type === 'None') {
         if (requiresAuth) {
-            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: ${provider} provider requires authentication but 'None' was configured`, { provider, authenticationType: service.authentication.type });
+            const endpoint = service.endpoint;
+            throw new LangChainAuthenticationError(`getDefaultServiceApiKey: ${provider} provider requires authentication but 'None' was configured`, provider, endpoint, { authenticationType: service.authentication.type });
         }
         return '';
     }
@@ -2580,18 +2595,48 @@ function formatNetworkError(error, logger) {
         logger.log('  • Verify the service endpoint is correct', { color: 'white' });
         logger.log('  • Ensure the LLM service is running and accessible', { color: 'white' });
     }
+    logger.log('  • Run `coco doctor` to verify your configured provider + endpoint', { color: 'white' });
     logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
 }
 /**
- * Formats an authentication error with helpful information
+ * Formats an authentication error with provider-aware troubleshooting.
+ *
+ * Pre-MEDIUM-8 the formatter was generic — "verify your API key,
+ * check it hasn't expired" — because the error class didn't carry
+ * any provider context. Now that `LangChainAuthenticationError`
+ * carries `provider` + `endpoint` (mirroring `LangChainNetworkError`),
+ * we can name the env var the user actually needs to set and route
+ * Ollama / OpenAI-compatible / managed-provider users through the
+ * right next step.
  */
 function formatAuthenticationError(error, logger) {
+    const provider = error.provider || 'LLM service';
+    const endpoint = error.endpoint;
     logger.log('\nFailed to execute command', { color: 'yellow' });
-    logger.log('\nError: Authentication failed', { color: 'red' });
+    logger.log(`\nError: Authentication failed${error.provider ? ` for ${provider}` : ''}`, { color: 'red' });
+    if (endpoint) {
+        logger.log(`       Endpoint: ${endpoint}`, { color: 'red' });
+    }
     logger.log('\nTroubleshooting:', { color: 'cyan' });
-    logger.log('  • Verify your API key is correct', { color: 'white' });
-    logger.log('  • Check that your API key has not expired', { color: 'white' });
-    logger.log('  • Ensure the API key is set in your environment or config', { color: 'white' });
+    logger.log('  • Verify your API key is correct and has not expired', { color: 'white' });
+    // Provider-specific env var hint when we know the provider.
+    if (provider === 'openai' || provider === 'OpenAI') {
+        logger.log('  • Set `OPENAI_API_KEY` in your shell or `service.authentication.credentials.apiKey` in config', { color: 'white' });
+    }
+    else if (provider === 'anthropic' || provider === 'Anthropic') {
+        logger.log('  • Set `ANTHROPIC_API_KEY` in your shell or `service.authentication.credentials.apiKey` in config', { color: 'white' });
+    }
+    else if (provider === 'ollama' || provider === 'Ollama') {
+        logger.log('  • Ollama usually does not need a key — check `service.endpoint` and that `ollama serve` is running', { color: 'white' });
+    }
+    else if (provider === 'openai-compatible') {
+        logger.log('  • OpenAI-compatible endpoints need both `service.endpoint` and a valid API key', { color: 'white' });
+    }
+    else {
+        logger.log('  • Ensure the API key is set in your environment or config', { color: 'white' });
+    }
+    logger.log('  • Run `coco init` to (re)configure your provider + key', { color: 'white' });
+    logger.log('  • Run `coco doctor` to inspect the active config sources', { color: 'white' });
     logger.verbose(`\nOriginal error: ${error.message}`, { color: 'gray' });
 }
 /**
@@ -3561,8 +3606,7 @@ const handler$b = async (argv, logger) => {
         const result = clearDiffSummaryCache(repoPath);
         if (!result.ok) {
             logger.log(chalk.red(`Failed to clear diff-summary cache at ${cachePath}`));
-            process.exitCode = 1;
-            return;
+            commandExit(1, 'cache clear failed');
         }
         if (result.removed) {
             logger.log(chalk.green(`Cleared diff-summary cache at ${cachePath}`));
@@ -3602,8 +3646,7 @@ const handler$b = async (argv, logger) => {
         if (interactive) {
             const picked = await promptLanguageSelection(logger);
             if (!picked) {
-                process.exitCode = 1;
-                return;
+                commandExit(1, 'cache prefetch cancelled');
             }
             resolved = picked;
         }
@@ -3620,7 +3663,7 @@ const handler$b = async (argv, logger) => {
             `${chalk.dim(`${result.alreadyCached.length} already cached`)} · ` +
             `${chalk.red(`${result.failed.length} failed`)}`);
         if (result.failed.length > 0) {
-            process.exitCode = 1;
+            commandExit(1, `cache prefetch failed for ${result.failed.length} language(s)`);
         }
         return;
     }
@@ -3653,12 +3696,12 @@ const handler$b = async (argv, logger) => {
     }
     logger.log(chalk.red(`Unknown cache subcommand: ${subcommand}`));
     logger.log(chalk.dim('Use one of: clear, info, parsers, prefetch, clear-parsers, clear-github'));
-    process.exitCode = 1;
+    commandExit(1, `unknown cache subcommand: ${subcommand}`);
 };
 
 var cache = {
     command: command$b,
-    desc: 'Manage the diff-summary cache (clear, info)',
+    desc: 'Manage coco caches (clear, info, parsers, prefetch, github)',
     builder: builder$b,
     handler: commandExecutor(handler$b),
 };
@@ -8927,6 +8970,124 @@ async function generateAndReviewLoop({ label, factory, parser, noResult, agent,
     return result;
 }
 
+/**
+ * Centralised glyph + label vocabulary for diagnostic / status copy.
+ *
+ * Before this module each surface (commandExecutor, doctor, footer,
+ * cache, issues, prs, commit-hook flow) picked its own marks for
+ * pass / warn / fail / info — `✓` here, `✔` there, `✖` vs `✗`. Users
+ * couldn't lean on a consistent visual signal to scan output, and the
+ * audit flagged it as one of the bigger inconsistencies in the
+ * codebase.
+ *
+ * The vocabulary mirrors what Linux package managers + git-aware
+ * tools converge on (`pacman`, `apt`, `nala`, `npm doctor`, etc.) —
+ * green check / red fail / yellow warn / blue info. ASCII fallbacks
+ * are first-class so dumb terminals (TERM=dumb / vt100) still render
+ * a meaningful prefix.
+ *
+ * Conventions:
+ *   - Status glyphs (PASS / FAIL / WARN / INFO) — for diagnostic
+ *     output, command exit, doctor severity, footer message kinds.
+ *     Colour-coded variants live alongside as `*_COLORED` helpers
+ *     so callers can use either depending on context.
+ *   - Action glyphs (BULLET, ARROW) — for indented hint lines and
+ *     "next step" callouts.
+ *   - Domain glyphs (CHECK_RUN_*, DECISION_*) — keep their own
+ *     vocabularies (PR reviews, status checks) because their
+ *     semantic shape doesn't map cleanly onto pass/fail/warn/info.
+ *
+ * Use `pickGlyph(unicode, ascii, isAscii)` when you need to honor
+ * `theme.ascii` mode in a single call site.
+ */
+/**
+ * Status-severity glyph set. Same vocabulary as the workstation
+ * footer's `kind` field (info / warning / error / success / loading)
+ * plus `pass` for the doctor / "no problem" case.
+ */
+const GLYPHS = {
+    pass: '✓',
+    fail: '✖',
+    warn: '⚠',
+    info: 'ℹ',
+    bullet: '•'};
+/**
+ * Theme-tinted helpers for terminal output. These return chalk-wrapped
+ * strings so callers don't repeat the `chalk.<color>(GLYPHS.<key>)`
+ * pattern. Each maps to the canonical colour the codebase uses for
+ * that severity:
+ *
+ *   - PASS  → green
+ *   - FAIL  → red
+ *   - WARN  → yellow
+ *   - INFO  → blue
+ *
+ * Doctor's `SEVERITY_ICON` lookup is the canonical example — it now
+ * delegates here so the colours stay in sync if the theme palette
+ * shifts in the future.
+ */
+const PASS = () => chalk.green(GLYPHS.pass);
+const FAIL = () => chalk.red(GLYPHS.fail);
+const WARN = () => chalk.yellow(GLYPHS.warn);
+const INFO = () => chalk.blue(GLYPHS.info);
+
+/**
+ * Maps each provider to the env var users should set + the kebab-case
+ * provider label used in the recovery copy. `coco init` and `coco
+ * doctor` both reference these names; keeping the lookup in one place
+ * makes the messages stay aligned when a new provider lands.
+ */
+const PROVIDER_ENV_VARS = {
+    openai: { envVar: 'OPENAI_API_KEY', label: 'OpenAI' },
+    anthropic: { envVar: 'ANTHROPIC_API_KEY', label: 'Anthropic' },
+    ollama: { envVar: 'OLLAMA_API_KEY', label: 'Ollama' },
+    'openai-compatible': { envVar: 'OPENAI_API_KEY', label: 'OpenAI-compatible' },
+};
+/**
+ * Print a structured "missing API key" message + exit non-zero.
+ *
+ * Replaces the old `No API Key found. 🗝️🚪` one-liner that used to live
+ * inline in commit / changelog / recap / review handlers. Centralised
+ * because:
+ *
+ *   1. The message names the env var the user actually needs to set
+ *      (different per provider) — that was the single biggest gap in
+ *      the prior message.
+ *   2. It surfaces the configured provider + model so the user can tell
+ *      which of their providers tripped the check (useful when running
+ *      with dynamic model routing).
+ *   3. It points at `coco init` and `coco doctor` as the recovery
+ *      paths, mirroring the discoverability cue every other modern CLI
+ *      uses for first-run config errors.
+ *
+ * Throws `CommandExitError(1)` via `commandExit` — callers do NOT need
+ * to handle the return value.
+ */
+function handleMissingApiKey(logger, config, options) {
+    const provider = config.service?.provider || 'unknown';
+    const model = config.service?.model || 'unknown';
+    const providerInfo = PROVIDER_ENV_VARS[provider] || {
+        envVar: 'PROVIDER_API_KEY',
+        label: provider,
+    };
+    const lines = [
+        `${FAIL()} ${chalk.bold('Missing API key')} for ${chalk.cyan(providerInfo.label)} (model: ${chalk.cyan(model)})`,
+        '',
+        `${chalk.bold('Next step')} — set up an API key one of these ways:`,
+        `  ${chalk.dim(GLYPHS.bullet)} Run ${chalk.cyan('coco init')} to walk through provider + key setup`,
+        `  ${chalk.dim(GLYPHS.bullet)} Export ${chalk.cyan(providerInfo.envVar)} in your shell`,
+        `  ${chalk.dim(GLYPHS.bullet)} Add the key to ${chalk.cyan('.coco.config.json')} or ${chalk.cyan('~/.gitconfig')} (under ${chalk.cyan('[coco]')})`,
+        '',
+        `${chalk.dim('Run')} ${chalk.cyan('coco doctor')} ${chalk.dim('to diagnose the active config sources.')}`,
+    ];
+    for (const line of lines) {
+        logger.log(line);
+    }
+    // Tag the exit message with the failing command so process supervisors
+    // / CI logs can grep for it without parsing the full body.
+    commandExit(1, `${options.command}: missing API key for ${providerInfo.label}`);
+}
+
 const logSuccess = () => {
     console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
 };
@@ -14419,8 +14580,7 @@ const handler$a = async (argv, logger) => {
         commandExit(1);
     }
     if (config.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        commandExit(1);
+        handleMissingApiKey(logger, config, { command: 'changelog' });
     }
     const llm = getLlm(provider, model, { ...config, service: changelogService });
     const summaryLlm = getLlm(provider, summaryService.model, { ...config, service: summaryService });
@@ -16316,8 +16476,7 @@ const handler$9 = async (argv, logger) => {
     const splitService = resolveDynamicService(config, 'commitSplit');
     const model = commitService.model;
     if (config.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        commandExit(1);
+        handleMissingApiKey(logger, config, { command: 'commit' });
     }
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
     const llm = getLlm(provider, model, { ...config, service: commitService });
@@ -17047,9 +17206,9 @@ function checkProjectConfigFile(diagnostics) {
 }
 
 const SEVERITY_ICON = {
-    error: chalk.red('✖'),
-    warn: chalk.yellow('⚠'),
-    info: chalk.blue('ℹ'),
+    error: FAIL(),
+    warn: WARN(),
+    info: INFO(),
 };
 const SEVERITY_LABEL = {
     error: chalk.red('error'),
@@ -17068,10 +17227,10 @@ function formatSourceInfo(sources) {
     for (const source of sources) {
         const label = SOURCE_LABELS[source.source] || source.source;
         if (source.path) {
-            lines.push(`  ${chalk.green('✓')} ${label} ${chalk.dim(`(${source.path})`)}`);
+            lines.push(`  ${PASS()} ${label} ${chalk.dim(`(${source.path})`)}`);
         }
         else {
-            lines.push(`  ${chalk.green('✓')} ${label}`);
+            lines.push(`  ${PASS()} ${label}`);
         }
     }
     return lines;
@@ -17108,7 +17267,7 @@ const handler$8 = async (argv, logger) => {
     // Run diagnostics
     const diagnostics = runDiagnostics(config);
     if (diagnostics.length === 0) {
-        logger.log(chalk.green('✓ No issues found. Your configuration looks good!'));
+        logger.log(chalk.green(`${PASS()} No issues found. Your configuration looks good!`));
         return;
     }
     const errors = diagnostics.filter((d) => d.severity === 'error');
@@ -17161,7 +17320,7 @@ const handler$8 = async (argv, logger) => {
             const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
             for (const diagnostic of fixable) {
                 diagnostic.autoFix(raw);
-                logger.log(chalk.green(`  ✓ Fixed: ${diagnostic.message}`));
+                logger.log(chalk.green(`  ${PASS()} Fixed: ${diagnostic.message}`));
             }
             // Ensure $schema is present
             if (!raw.$schema) {
@@ -17180,6 +17339,15 @@ const handler$8 = async (argv, logger) => {
             logger.log(chalk.dim(`${fixable.length} issue(s) can be auto-fixed. Run \`coco doctor --fix\` to apply.`));
         }
     }
+    // Exit non-zero when error-severity diagnostics were surfaced so CI
+    // pipelines can gate on `coco doctor` without parsing its stdout.
+    // Warnings + infos still exit clean — they're informational, not
+    // blockers. Auto-fixed errors keep the non-zero exit so the CI run
+    // surfaces "we patched something for you, please commit it" rather
+    // than masquerading as a passing check.
+    if (errors.length > 0) {
+        commandExit(1, `${errors.length} doctor error(s)`);
+    }
 };
 
 var doctor = {
@@ -17187,6 +17355,7 @@ var doctor = {
     desc: 'Check your coco configuration for common issues and suggest fixes',
     builder: builder$8,
     handler: commandExecutor(handler$8),
+    options: options$8,
 };
 
 const command$7 = 'init';
@@ -17566,11 +17735,7 @@ const handler$7 = async (argv, logger) => {
     // writes the project config to X, not the launcher's cwd. The
     // chdir has to happen before getProjectConfigFilePath resolves
     // its target path (it reads process.cwd).
-    //
-    // `InitArgv` is `Argv<InitOptions>['argv']` which yargs types as a
-    // union including Promise — pass just the `repo` field as a plain
-    // object so the helper's narrow signature stays clean.
-    applyRepoCwd({ repo: argv.repo });
+    applyRepoCwd(argv);
     const options = loadConfig(argv);
     logger.log(LOGO);
     let scope = options?.scope;
@@ -17705,6 +17870,44 @@ const handler$7 = async (argv, logger) => {
             await installCommitlintPackages(scope, logger);
         }
         logger.log(`\ninit successful! 🦾🤖🎉`, { color: 'green' });
+        // Post-write verification — run the same check `coco doctor` runs
+        // so the user finds out about typos / structural issues now,
+        // before their first `coco commit`. Re-load from disk so we
+        // verify the persisted config (not the in-memory shape we just
+        // built), which catches transcription bugs in the appenders.
+        try {
+            const persistedConfig = loadConfig({});
+            const diagnostics = runDiagnostics(persistedConfig);
+            const errors = diagnostics.filter((d) => d.severity === 'error');
+            const warnings = diagnostics.filter((d) => d.severity === 'warn');
+            if (errors.length === 0 && warnings.length === 0) {
+                logger.log(`${PASS()} Verified: no issues found in your new config.`, { color: 'green' });
+            }
+            else {
+                if (errors.length > 0) {
+                    logger.log(`${FAIL()} ${errors.length} error(s) found in the persisted config:`, { color: 'red' });
+                    for (const diagnostic of errors) {
+                        logger.log(`  ${chalk.red(diagnostic.message)}`);
+                    }
+                }
+                if (warnings.length > 0) {
+                    logger.log(`${WARN()} ${warnings.length} warning(s) found in the persisted config:`, { color: 'yellow' });
+                    for (const diagnostic of warnings) {
+                        logger.log(`  ${chalk.yellow(diagnostic.message)}`);
+                    }
+                }
+                logger.log(`${chalk.dim('Run')} ${chalk.cyan('coco doctor')} ${chalk.dim('for the full diagnostic report.')}`);
+            }
+        }
+        catch (verifyError) {
+            // Verification is a polish step, not a blocker. If it crashes
+            // (e.g. config file written to a path the loader can't reach
+            // from the current cwd), fall through to a hint instead of
+            // failing the whole init flow — the config is on disk and
+            // the user can run `coco doctor` themselves.
+            logger.log(`${chalk.dim('Skipped post-init verification:')} ${verifyError.message}`, { color: 'gray' });
+            logger.log(`${chalk.dim('Run')} ${chalk.cyan('coco doctor')} ${chalk.dim('to verify your config manually.')}`);
+        }
     }
     else {
         logger.log('\ninit cancelled.', { color: 'yellow' });
@@ -17746,7 +17949,7 @@ async function installCommitlintPackages(scope, logger) {
 
 var init = {
     command: command$7,
-    desc: 'install & configure coco globally or for the current project',
+    desc: 'Install & configure coco globally or for the current project',
     builder: builder$7,
     handler: commandExecutor(handler$7),
     options: options$7,
@@ -17830,19 +18033,76 @@ async function getGitHubRepository(git) {
     return url ? parseGitHubRemoteUrl$1(url) : undefined;
 }
 /**
- * Probe `gh auth status` and return whether the GitHub CLI is
- * installed AND authenticated. Used by every data fetcher to short-
- * circuit before issuing real API calls — keeps the failure-mode
- * messaging consistent ("CLI missing or not authenticated") instead
- * of leaking through as a generic spawn error.
+ * Probe `gh auth status` and return a structured status describing
+ * exactly which of the failure modes is in play. Used by every data
+ * fetcher to short-circuit before issuing real API calls — and now
+ * lets the caller surface a tailored recovery hint per failure mode
+ * instead of one catch-all message.
+ *
+ * Distinguishing the modes:
+ *   - ENOENT (`gh: command not found`) → `not-installed`
+ *   - `gh auth status` exits non-zero with stderr matching the
+ *     "not logged into" / "authentication required" pattern →
+ *     `not-authenticated`
+ *   - Anything else (permission denied on the binary, timeout, etc.)
+ *     → `unknown` with the underlying error message attached for
+ *     diagnostic display.
  */
-async function isGhAuthenticated(runner) {
+async function getGhStatus(runner) {
     try {
         await runner(['auth', 'status', '--hostname', 'github.com']);
-        return true;
+        return { kind: 'ok' };
     }
-    catch {
-        return false;
+    catch (error) {
+        const err = error;
+        // ENOENT = the binary itself is missing. exec/spawn surfaces this
+        // as either `code === 'ENOENT'` (Node's spawn error code) or a
+        // message containing "ENOENT". Either form is unambiguous.
+        if (err.code === 'ENOENT' || (err.message && err.message.includes('ENOENT'))) {
+            return { kind: 'not-installed' };
+        }
+        // gh exits non-zero from `auth status` when the user isn't logged
+        // in. The message body contains "not logged into" or "logged in
+        // failed" depending on the gh version. Both patterns are stable
+        // enough to gate on without scope-locking to a specific gh
+        // release.
+        const stderr = err.stderr || err.message || '';
+        if (/not logged into|authentication.*required|you are not/i.test(stderr)) {
+            return { kind: 'not-authenticated', detail: stderr.trim().split('\n')[0] };
+        }
+        // Anything else — permission denied, timeout, etc. Surface the
+        // raw message so the user can read it; treat as unavailable.
+        return { kind: 'unknown', detail: err.message || 'gh auth status failed' };
+    }
+}
+/**
+ * Backwards-compatible boolean wrapper around `getGhStatus`. Kept so
+ * existing callers (data loaders, sidebar fetchers) don't all have to
+ * migrate at once. New call sites should use `getGhStatus` directly
+ * to access the discriminated failure modes.
+ */
+async function isGhAuthenticated(runner) {
+    const status = await getGhStatus(runner);
+    return status.kind === 'ok';
+}
+/**
+ * Render a user-facing recovery hint for a non-`ok` gh status. Used by
+ * `commands/issues` / `commands/prs` / pull-request workflow surfaces
+ * so every "gh is unavailable" message tells the user the exact next
+ * step. Keeps the wording in sync across surfaces — if a user runs
+ * `coco prs` and `coco issues` back to back, the same broken state
+ * surfaces the same fix.
+ */
+function describeGhStatus(status) {
+    switch (status.kind) {
+        case 'ok':
+            return 'GitHub CLI is installed and authenticated.';
+        case 'not-installed':
+            return 'GitHub CLI (`gh`) is not installed. Install it from https://cli.github.com/ and run `gh auth login`.';
+        case 'not-authenticated':
+            return `GitHub CLI is installed but not authenticated. Run \`gh auth login\` (scopes: \`repo\`, \`read:org\`).${status.detail ? ` Details: ${status.detail}` : ''}`;
+        case 'unknown':
+            return `GitHub CLI returned an unexpected error: ${status.detail}. Try \`gh auth status\` directly to diagnose.`;
     }
 }
 
@@ -18034,13 +18294,14 @@ async function getIssueList(git, filter = {}, runner = defaultGhRunner) {
             message: 'No GitHub remote detected.',
         };
     }
-    if (!(await isGhAuthenticated(runner))) {
+    const ghStatus = await getGhStatus(runner);
+    if (ghStatus.kind !== 'ok') {
         return {
             available: true,
             authenticated: false,
             repository,
             filter,
-            message: 'GitHub CLI is missing or not authenticated.',
+            message: describeGhStatus(ghStatus),
         };
     }
     try {
@@ -18152,6 +18413,7 @@ var issues = {
     desc: 'List GitHub issues for the current repository (read-only triage)',
     builder: builder$6,
     handler: commandExecutor(handler$6),
+    options: options$6,
 };
 
 const command$5 = 'log';
@@ -22171,6 +22433,18 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // No key binding — this is raised by the runtime as a second
+            // confirmation when a safe `delete-branch` (`git branch -d`) is
+            // rejected for an unmerged branch. Reachable from the `:` palette
+            // too, as an explicit force-delete that still gates on y-confirm.
+            id: 'force-delete-branch',
+            key: '',
+            label: 'Force-delete branch',
+            description: 'Force-delete the selected branch even if it is not fully merged (git branch -D).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
         {
             id: 'delete-tag',
             key: 'T',
@@ -22968,6 +23242,13 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Create a lightweight tag at the cursored commit.',
         contexts: ['history'],
     },
+    {
+        id: 'viewKeys',
+        keys: ['g?'],
+        label: 'keys',
+        description: 'Show the single-key actions available in the current view (which-key strip).',
+        contexts: ['normal'],
+    },
     {
         id: 'themePicker',
         keys: ['gC'],
@@ -23695,6 +23976,48 @@ function getLogInkHelpSections(options) {
         },
     ];
 }
+/**
+ * True when a key string is a single, bare printable key (e.g. `c`, `R`,
+ * `[`) rather than a chord (`gh`, `gg`) or a named special key (`up`,
+ * `page down`). Used by the which-key view-keys strip, which surfaces only
+ * the single-key overloads — the chord set already has its own overlay.
+ */
+function isBareSingleKey(key) {
+    return key.length === 1 && key !== ' ';
+}
+/**
+ * Single-key bindings available in the current view (#1137). Powers the
+ * `g?` which-key strip: the per-view counterpart to the `g`-chord overlay.
+ *
+ * Sourced entirely from `LOG_INK_KEY_BINDINGS` (no duplicated key data) and
+ * filtered the same way the help overlay's "This view" section is — by
+ * `contexts` against the active view + focus — then narrowed to bindings
+ * that expose at least one bare single key. Globals (`q`, `?`, `/`, `:`, …)
+ * are excluded: they're always available and already live in the footer and
+ * onboarding tour, so the strip stays focused on the deliberate per-view
+ * overloads (`c`, `R`, `a`, `m`, `S`, `[`/`]`, …) the keymap guard protects.
+ *
+ * Sorted by the first bare key for stable, scannable output.
+ */
+function getLogInkViewKeyBindings(options) {
+    return LOG_INK_KEY_BINDINGS
+        .filter((binding) => !GLOBAL_BINDING_IDS.includes(binding.id) &&
+        bindingMatchesViewContext(binding, options) &&
+        binding.keys.some(isBareSingleKey))
+        .sort((a, b) => {
+        const aKey = a.keys.find(isBareSingleKey) ?? '';
+        const bKey = b.keys.find(isBareSingleKey) ?? '';
+        return aKey.localeCompare(bKey);
+    });
+}
+/**
+ * Format only the bare single keys of a binding for the view-keys strip
+ * (e.g. `['up', 'k']` → `k`). Named/chord keys are dropped — the strip is
+ * about the single-key affordance, and the full key list lives in `?` help.
+ */
+function formatBindingBareKeys(binding) {
+    return binding.keys.filter(isBareSingleKey).join(' / ');
+}
 function bindingToPaletteCommand(binding) {
     return {
         id: binding.id,
@@ -24838,6 +25161,15 @@ function formatSortIndicator(mode, options = {}) {
     return `${options.ascii ? 'v' : '▼'} ${mode}`;
 }
 
+/**
+ * True when `pending` (a `state.pendingDeletion`) targets this exact row.
+ * Shared by every deletable surface + the sidebar so the spinner-swap
+ * test is identical everywhere. Takes the field value (not the whole
+ * state) so it can live next to the type without a forward reference.
+ */
+function isPendingDeletion(pending, kind, id) {
+    return pending?.kind === kind && pending.id === id;
+}
 const DEFAULT_CHANGELOG_VIEW_STATE = {
     status: 'idle',
     scrollOffset: 0,
@@ -25208,7 +25540,39 @@ function replaceRows(state, rows) {
 }
 function appendRows(state, rows) {
     const selected = getSelectedInkCommit(state);
-    const nextRows = [...state.rows, ...rows];
+    // Dedup the merged row list by commit hash so the graph renderer —
+    // which windows directly over `state.rows` (toFullGraphItems →
+    // expandRowsWithSpacers) — and the selection list (deduped commits)
+    // agree on one canonical, duplicate-free row order. Overlapping
+    // appends, notably the anchored `loadCommitContext` page that
+    // re-walks history from the tip, otherwise stack the newest commits
+    // below the oldest ones already loaded. The renderer then shows the
+    // initial commit directly above HEAD and the cursor can scroll
+    // forever through the duplicated tail — the history graph "looping
+    // back on itself". Drop graph-only topology rows that trail a dropped
+    // duplicate commit too, since they describe that duplicate's lanes
+    // and would otherwise dangle.
+    const seenHashes = new Set();
+    const nextRows = [];
+    let droppingTrailingGraph = false;
+    for (const row of [...state.rows, ...rows]) {
+        if (row.type === 'commit') {
+            if (seenHashes.has(row.hash)) {
+                droppingTrailingGraph = true;
+                continue;
+            }
+            seenHashes.add(row.hash);
+            droppingTrailingGraph = false;
+            nextRows.push(row);
+            continue;
+        }
+        // Graph-only topology row: keep it unless it trails a just-dropped
+        // duplicate commit (then it belongs to the duplicate page's lanes).
+        if (droppingTrailingGraph) {
+            continue;
+        }
+        nextRows.push(row);
+    }
     const seen = new Set();
     const commits = getCommitRows(nextRows).filter((commit) => {
         if (seen.has(commit.hash)) {
@@ -25300,6 +25664,7 @@ function createLogInkState(rows, options = {}) {
         fullGraph: options.fullGraph ?? true,
         showHelp: false,
         helpScrollOffset: 0,
+        showViewKeys: false,
         showCommandPalette: false,
         workflowActionId: undefined,
         pendingConfirmationId: undefined,
@@ -25805,6 +26170,22 @@ function applyLogInkAction(state, action) {
                 pendingKey: undefined,
             };
         }
+        case 'returnFromCommit': {
+            // After a successful commit we leave the compose view automatically.
+            // Where to: a still-dirty tree the user was staging from returns to
+            // the Status view so they can finish the rest; an otherwise-complete
+            // commit returns to the History view, where the new commit now shows.
+            // We pop frames one at a time (reusing withPoppedView) so sidebar-tab
+            // and diff-state restoration stays identical to manual Esc/back —
+            // this also unwinds an intermediate `diff` frame (status → diff →
+            // compose) back to the status frame it sits under.
+            const target = action.stillDirty && state.viewStack.includes('status') ? 'status' : HOME_VIEW;
+            let next = state;
+            while (next.viewStack.length > 1 && topOfStack(next.viewStack) !== target) {
+                next = withPoppedView(next);
+            }
+            return { ...next, pendingKey: undefined };
+        }
         case 'navigateOpenDiffForCommit': {
             const next = withPushedView(state, 'diff');
             const filteredCommits = state.filteredCommits;
@@ -25994,6 +26375,10 @@ function applyLogInkAction(state, action) {
                 workflowActionId: action.value ? undefined : state.workflowActionId,
                 pendingKey: undefined,
             };
+        case 'setPendingDeletion':
+            // Pure marker for the in-flight delete; touches nothing else so the
+            // list keeps rendering normally underneath the one spinner'd row.
+            return { ...state, pendingDeletion: action.value };
         case 'toggleFilterMode':
             return {
                 ...state,
@@ -26001,6 +26386,7 @@ function applyLogInkAction(state, action) {
                 showCommandPalette: false,
                 showHelp: false,
                 helpScrollOffset: 0,
+                showViewKeys: false,
                 pendingKey: undefined,
             };
         case 'toggleGraph':
@@ -26019,9 +26405,24 @@ function applyLogInkAction(state, action) {
                 // than picking up where the user last scrolled.
                 helpScrollOffset: 0,
                 showCommandPalette: false,
+                // Opening full help supersedes the compact view-keys strip — this
+                // is the progressive-disclosure step (`?` from the strip expands
+                // to the full categorized help, #1137).
+                showViewKeys: false,
                 pendingKey: undefined,
             };
         }
+        case 'toggleViewKeys':
+            return {
+                ...state,
+                showViewKeys: !state.showViewKeys,
+                // The view-keys strip is mutually exclusive with the other
+                // overlays; opening it closes anything else that was showing.
+                showHelp: false,
+                helpScrollOffset: 0,
+                showCommandPalette: false,
+                pendingKey: undefined,
+            };
         case 'scrollHelp':
             // No upper-bound clamp here — the renderer caps the offset
             // against the actual content height at render time. The
@@ -26038,6 +26439,7 @@ function applyLogInkAction(state, action) {
                 showCommandPalette: opening,
                 showHelp: false,
                 helpScrollOffset: 0,
+                showViewKeys: false,
                 // Reset palette interaction state on every open/close so the next
                 // session starts from a clean slate.
                 paletteFilter: '',
@@ -26085,8 +26487,9 @@ function applyLogInkAction(state, action) {
             return {
                 ...state,
                 showThemePicker: opening,
-                // Only one overlay at a time — close help / palette on open.
+                // Only one overlay at a time — close help / palette / view-keys on open.
                 showHelp: false,
+                showViewKeys: false,
                 showCommandPalette: false,
                 themePickerFilter: '',
                 themePickerIndex: 0,
@@ -26886,6 +27289,10 @@ function getLogInkPaletteExecuteEvents(command, state) {
             // Palette closes on execute (toggleCommandPalette runs first), then
             // this opens the theme picker.
             return [action({ type: 'toggleThemePicker' })];
+        case 'viewKeys':
+            // Palette closes on execute (toggleCommandPalette runs first), then
+            // this opens the per-view which-key strip (#1137).
+            return [action({ type: 'toggleViewKeys' })];
         case 'openProjectConfig':
             return [{ type: 'openConfigInEditor', scope: 'project' }];
         case 'openGlobalConfig':
@@ -27614,6 +28021,26 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return [];
     }
+    // #1137 — the `g?` which-key strip. While it's open the keyboard is
+    // claimed (mirrors the help overlay) so a stray keystroke can't drop
+    // the user into a per-view action they didn't mean to trigger. Esc
+    // closes; `?` is the progressive-disclosure step up to the full
+    // categorized help; `q` still quits. Everything else is swallowed —
+    // the user peeks, dismisses, then presses the key they came for.
+    if (state.showViewKeys) {
+        if (key.escape) {
+            return [action({ type: 'toggleViewKeys' })];
+        }
+        if (inputValue === '?') {
+            // Expand the compact strip into the full help overlay. `toggleHelp`
+            // clears `showViewKeys` so the two never render at once.
+            return [action({ type: 'toggleHelp' })];
+        }
+        if (inputValue === 'q') {
+            return [{ type: 'exit' }];
+        }
+        return [];
+    }
     // #879 item 4 — Esc cancels an in-flight bisect-start wizard. Runs
     // BEFORE the generic `popView` so we both clear the wizard state
     // and walk back to the bisect view in one keystroke. Without this
@@ -27657,6 +28084,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return [{ type: 'exit' }];
     }
+    // `g?` chord (#1137) — open the per-view which-key strip. Placed
+    // BEFORE the bare `?` (full help) check below so the chord is read as
+    // a unit: with `g` pending, `?` opens the view-keys strip rather than
+    // toggling full help. Surfaces automatically in the `g` which-key menu
+    // because its key is a two-char `g`-prefixed binding.
+    if (state.pendingKey === 'g' && inputValue === '?') {
+        return [
+            action({ type: 'setPendingKey', value: undefined }),
+            action({ type: 'toggleViewKeys' }),
+        ];
+    }
     if (inputValue === '?') {
         return [action({ type: 'toggleHelp' })];
     }
@@ -29565,6 +30003,24 @@ const SPINNER_TICK_MS = 80;
 function pickSpinnerFrame(tick) {
     return SPINNER_FRAMES[Math.max(0, tick) % SPINNER_FRAMES.length];
 }
+/**
+ * ASCII-safe spinner frames for `NO_COLOR` / ASCII terminals where the
+ * braille dots either don't render or look like noise. The four-frame
+ * `|/-\` cycle is the classic terminal spinner and reads as motion in
+ * any encoding.
+ */
+const ASCII_SPINNER_FRAMES = ['|', '/', '-', '\\'];
+/**
+ * Inline per-item pending glyph — used in place of (or appended to) a
+ * list row's status icon while that row's mutation (a delete) is in
+ * flight. Braille spinner normally; the ASCII cycle under `ascii`
+ * themes so the indicator survives `NO_COLOR` / dumb terminals.
+ */
+function inlineSpinnerGlyph(tick, ascii) {
+    return ascii
+        ? ASCII_SPINNER_FRAMES[Math.max(0, tick) % ASCII_SPINNER_FRAMES.length]
+        : pickSpinnerFrame(tick);
+}
 
 /**
  * Build the initial `LogInkContextStatus` for a freshly-created frame
@@ -30519,7 +30975,7 @@ function createBranch(git, branchName, startPoint) {
 function renameBranch(git, oldName, newName) {
     return runAction$5(() => git.raw(['branch', '-m', oldName, newName]), `Renamed ${oldName} to ${newName}`);
 }
-function deleteBranch(git, branch) {
+function deleteBranch(git, branch, force = false) {
     if (branch.type !== 'local') {
         return Promise.resolve({
             ok: false,
@@ -30532,7 +30988,18 @@ function deleteBranch(git, branch) {
             message: 'Cannot delete the current branch.',
         });
     }
-    return runAction$5(() => git.raw(['branch', '-d', branch.shortName]), `Deleted branch ${branch.shortName}`);
+    // `-d` is the safe delete (refuses unmerged branches); `-D` forces it.
+    // The TUI starts with `-d` and only escalates to `-D` after the user
+    // confirms a second time on the "not fully merged" error.
+    return runAction$5(() => git.raw(['branch', force ? '-D' : '-d', branch.shortName]), force ? `Force-deleted branch ${branch.shortName}` : `Deleted branch ${branch.shortName}`);
+}
+/**
+ * True when a failed `git branch -d` was rejected specifically because the
+ * branch isn't fully merged (the one case worth offering a force-delete
+ * for). Matches git's wording across versions ("not fully merged").
+ */
+function isBranchNotFullyMergedError(message) {
+    return /not fully merged/i.test(message || '');
 }
 function fetchRemotes(git) {
     return runAction$5(() => git.raw(['fetch', '--all', '--prune']), 'Fetched all remotes');
@@ -30639,7 +31106,7 @@ function fetchBranch(git, branch) {
     if (!branch.upstream || !branch.remote) {
         return Promise.resolve({
             ok: false,
-            message: `${branch.shortName} has no upstream — nothing to fetch.`,
+            message: `${branch.shortName} has no upstream — set one with \`git push -u <remote> ${branch.shortName}\` to enable fetch.`,
         });
     }
     // `branch.upstream` is the short form (e.g. `origin/main`); the
@@ -30677,7 +31144,7 @@ function pullBranch(git, branch, currentBranchName) {
     if (!branch.upstream || !branch.remote) {
         return Promise.resolve({
             ok: false,
-            message: `${branch.shortName} has no upstream — nothing to pull.`,
+            message: `${branch.shortName} has no upstream — set one with \`git push -u <remote> ${branch.shortName}\` to enable pull.`,
         });
     }
     // Current branch — defer to the in-place workflow.
@@ -31985,13 +32452,14 @@ async function getPullRequestList(git, filter = {}, runner = defaultGhRunner) {
             message: 'No GitHub remote detected.',
         };
     }
-    if (!(await isGhAuthenticated(runner))) {
+    const ghStatus = await getGhStatus(runner);
+    if (ghStatus.kind !== 'ok') {
         return {
             available: true,
             authenticated: false,
             repository,
             filter,
-            message: 'GitHub CLI is missing or not authenticated.',
+            message: describeGhStatus(ghStatus),
         };
     }
     try {
@@ -32857,6 +33325,7 @@ function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFr
     // of the runtime's `forcedPane` derivation in `app.ts`.
     const overlayForcesPane = Boolean(state.splitPlan ||
         state.showHelp ||
+        state.showViewKeys ||
         state.showCommandPalette ||
         state.showThemePicker ||
         state.gitignorePicker ||
@@ -33938,7 +34407,13 @@ function renderActiveStatusTabContent(h, Text, context, contextStatus, width, th
  * rows so they read as the same severity scale used in the main status
  * surface; every other tab falls through to selectable rows.
  */
-function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme) {
+function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme, spinnerFrame) {
+    // Inline pending-delete glyph: while a row's delete is in flight it
+    // shows this spinner in place of its leading marker (branches /
+    // worktrees) or appended to the row (tags / stashes, which have no
+    // leading status icon). `pending` is the single in-flight target.
+    const pending = state.pendingDeletion;
+    const spin = inlineSpinnerGlyph(spinnerFrame, theme.ascii);
     // Available rows for the active tab's list. The sidebar chrome
     // takes ~10 rows (panel title + spacer + 5 tab headers + 4 inter-tab
     // spacers); the branches tab eats 3 more for its summary header
@@ -33975,7 +34450,12 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         ];
         return [
             ...headerRows,
-            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => `${branchRowMarker(branch, { ascii: theme.ascii }).glyph} ${branch.shortName}`, 'tab-branches', visibleListCount),
+            ...renderSelectableSidebarRows(h, Text, sortedBranches, state.selectedBranchIndex, focused, width, theme, (branch) => {
+                const glyph = isPendingDeletion(pending, 'branch', branch.shortName)
+                    ? spin
+                    : branchRowMarker(branch, { ascii: theme.ascii }).glyph;
+                return `${glyph} ${branch.shortName}`;
+            }, 'tab-branches', visibleListCount),
         ];
     }
     if (tab === 'tags') {
@@ -33986,7 +34466,12 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         if (tags.length === 0) {
             return [h(Text, { key: 'tab-tags-empty', dimColor: true }, '  No tags found')];
         }
-        return renderSelectableSidebarRows(h, Text, tags, state.selectedTagIndex, focused, width, theme, (tag) => `${truncateCells(tag.name, 16)} ${tag.subject}`, 'tab-tags', visibleListCount);
+        return renderSelectableSidebarRows(h, Text, tags, state.selectedTagIndex, focused, width, theme, (tag) => {
+            const base = `${truncateCells(tag.name, 16)} ${tag.subject}`;
+            // Tags have no leading status icon, so the pending spinner is
+            // appended to the row instead of replacing a glyph.
+            return isPendingDeletion(pending, 'tag', tag.name) ? `${base} ${spin}` : base;
+        }, 'tab-tags', visibleListCount);
     }
     if (tab === 'stashes') {
         if (isLogInkContextKeyLoading(contextStatus, 'stashes')) {
@@ -33996,7 +34481,12 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         if (stashes.length === 0) {
             return [h(Text, { key: 'tab-stashes-empty', dimColor: true }, '  No stashes found')];
         }
-        return renderSelectableSidebarRows(h, Text, stashes, state.selectedStashIndex, focused, width, theme, (stash, index) => `@{${index}} ${stash.message || '(no message)'}`, 'tab-stashes', visibleListCount);
+        return renderSelectableSidebarRows(h, Text, stashes, state.selectedStashIndex, focused, width, theme, (stash, index) => {
+            const base = `@{${index}} ${stash.message || '(no message)'}`;
+            // `@{N}` is the stash ref, not a status icon, so append the
+            // spinner rather than replacing it.
+            return isPendingDeletion(pending, 'stash', stash.ref) ? `${base} ${spin}` : base;
+        }, 'tab-stashes', visibleListCount);
     }
     // worktrees
     if (isLogInkContextKeyLoading(contextStatus, 'worktreeList')) {
@@ -34007,12 +34497,14 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         return [h(Text, { key: 'tab-worktrees-empty', dimColor: true }, '  No linked worktrees')];
     }
     return renderSelectableSidebarRows(h, Text, worktrees, state.selectedWorktreeListIndex, focused, width, theme, (worktree) => {
-        const marker = worktree.current ? '*' : ' ';
+        const marker = isPendingDeletion(pending, 'worktree', worktree.path)
+            ? spin
+            : worktree.current ? '*' : ' ';
         const wstate = worktree.dirty ? 'dirty' : 'clean';
         return `${marker} ${worktree.branch || worktree.path} ${wstate}`;
     }, 'tab-worktrees', visibleListCount);
 }
-function renderSidebar$1(h, components, state, context, contextStatus, width, bodyRows, theme) {
+function renderSidebar$1(h, components, state, context, contextStatus, width, bodyRows, theme, spinnerFrame = 0) {
     const { Box, Text } = components;
     const focused = state.focus === 'sidebar';
     const tabs = getLogInkSidebarTabs();
@@ -34048,7 +34540,7 @@ function renderSidebar$1(h, components, state, context, contextStatus, width, bo
             inverse: headerSelected,
         }, headerText));
         if (isActive) {
-            blocks.push(...renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme));
+            blocks.push(...renderActiveSidebarContent(h, Text, tab, state, context, contextStatus, width, bodyRows, theme, spinnerFrame));
         }
         return blocks;
     });
@@ -34399,7 +34891,7 @@ function formatLogInkGitHubNoRemote({ resource, }) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderBranchesSurface(ctx) {
+function renderBranchesSurface(ctx, spinnerFrame = 0) {
     const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
@@ -34438,7 +34930,14 @@ function renderBranchesSurface(ctx) {
                 const isSelected = index === selected;
                 const cursor = isSelected ? '>' : ' ';
                 const marker = branchRowMarker(branch, { ascii: theme.ascii });
-                const markerColor = getBranchRowMarkerColor(marker.kind, theme);
+                // While this branch's delete is in flight, its sync-state marker
+                // is replaced by an inline spinner (accent-coloured) so the row
+                // reads as "deleting" until it vanishes on refresh.
+                const deleting = isPendingDeletion(state.pendingDeletion, 'branch', branch.shortName);
+                const glyph = deleting ? inlineSpinnerGlyph(spinnerFrame, theme.ascii) : marker.glyph;
+                const glyphColor = deleting
+                    ? (theme.noColor ? undefined : theme.colors.accent)
+                    : getBranchRowMarkerColor(marker.kind, theme);
                 const divergence = formatBranchDivergence(branch, { ascii: theme.ascii });
                 const lastTouched = formatBranchLastTouched(branch.date, getRenderNow());
                 // Split the row into spans so the timestamp stays dim even on the
@@ -34453,7 +34952,7 @@ function renderBranchesSurface(ctx) {
                 // Truncate the assembled line to the actual panel width so a
                 // narrow inspector / sidebar focus doesn't push branch rows
                 // onto a second visual line (#830).
-                const fullText = `${cursorAndPad}${marker.glyph}${trailingName}${timestampPadded}${trailingDivergence}`;
+                const fullText = `${cursorAndPad}${glyph}${trailingName}${timestampPadded}${trailingDivergence}`;
                 const truncated = truncateCells(fullText, Math.max(20, width - 4));
                 // If truncation chopped into the timestamp/divergence portion,
                 // fall back to a single Text to keep the visible width honest.
@@ -34476,7 +34975,7 @@ function renderBranchesSurface(ctx) {
                 // no-upstream kinds return undefined from
                 // `getBranchRowMarkerColor`, so those markers inherit the
                 // row's dim and read as quiet chrome.
-                h(Text, { color: markerColor, dimColor: markerColor ? false : undefined }, marker.glyph), trailingName, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
+                h(Text, { color: glyphColor, dimColor: glyphColor ? false : undefined }, glyph), trailingName, h(Text, { dimColor: true }, timestampPadded), trailingDivergence);
             });
     // Scroll indicators — same "N more above/below" pattern as the
     // sidebar and help overlay so the user knows the list continues.
@@ -34761,8 +35260,16 @@ function renderComposeSurface(ctx, spinnerFrame = 0) {
     const bodyVisualLines = compose.body
         ? compose.body.split('\n').flatMap((line) => wrapCells(line, bodyTextWidth)).slice(0, bodyRowsAvailable)
         : ['<empty>'];
-    const summaryVisualLines = wrapCells(`${compose.summary || '<empty>'}${summaryCursor}`, Math.max(8, width - 11) // "Summary  " (9) + 2 chrome = 11
-    );
+    // Summary now renders on its own indented line under the label (like the
+    // body), so it wraps at the full content width instead of the cramped
+    // "Summary  " (9) + chrome budget it had when label and value shared a row.
+    const summaryVisualLines = compose.summary
+        ? compose.summary.split('\n').flatMap((line) => wrapCells(line, bodyTextWidth))
+        : ['<empty>'];
+    // Subject length drives a subtle counter on the Summary label: dim under
+    // 50, warning past the conventional 50-char soft limit, danger past 72.
+    // Counted in code points so multibyte subjects aren't over-counted.
+    const summaryLength = [...compose.summary].length;
     // State-line cycles through three modes (#881 phase 3 added the
     // loading variant): editing copy when the user is typing, cancel
     // hint when an AI draft is generating, default guidance otherwise.
@@ -34782,6 +35289,52 @@ function renderComposeSurface(ctx, spinnerFrame = 0) {
     const noStagedHint = !isLogInkContextKeyLoading(contextStatus, 'worktree')
         ? formatLogInkComposeEmpty({ hasStaged: hasStagedFiles })
         : undefined;
+    // Section header for a field (Summary / Body). The active field's label
+    // carries an arrow marker + the repo's selection highlight (matching the
+    // status surface, see status/index.ts) so the user can see which field
+    // their keystrokes target — even before entering edit mode, and even
+    // under NO_COLOR where the marker + bold/dim carry the signal alone. An
+    // optional length counter (Summary only) trails the label outside the
+    // highlight so its own warning/danger color stays legible.
+    const renderSectionHeader = (name, field, count) => {
+        const active = compose.field === field;
+        const highlight = active && focused && !theme.noColor;
+        const marker = active ? (theme.ascii ? '> ' : '▸ ') : '  ';
+        const badge = active && compose.editing ? '  EDITING' : '';
+        const children = [
+            h(Text, {
+                key: `compose-${field}-label`,
+                bold: active,
+                dimColor: !active,
+                backgroundColor: highlight ? theme.colors.selection : undefined,
+                color: highlight ? theme.colors.selectionForeground : undefined,
+            }, `${marker}${name}${badge}`),
+        ];
+        if (count !== undefined) {
+            const countColor = theme.noColor
+                ? undefined
+                : count > 72
+                    ? theme.colors.danger
+                    : count > 50
+                        ? theme.colors.warning
+                        : undefined;
+            children.push(h(Text, {
+                key: `compose-${field}-count`,
+                color: countColor,
+                dimColor: countColor === undefined,
+            }, ` ${count}`));
+        }
+        return h(Box, { key: `compose-${field}-header` }, ...children);
+    };
+    // Content lines for a field — indented two cells under the header, with
+    // the edit cursor parked on the final line when this field is active.
+    const renderSectionContent = (lines, field, cursor) => lines.map((line, index) => {
+        const isLast = index === lines.length - 1;
+        return h(Text, {
+            key: `compose-${field}-${index}`,
+            dimColor: line === '<empty>',
+        }, `  ${line}${cursor && isLast ? cursor : ''}`);
+    });
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
         borderStyle: theme.borderStyle,
@@ -34789,20 +35342,7 @@ function renderComposeSurface(ctx, spinnerFrame = 0) {
         flexShrink: 0,
         paddingX: 1,
         width,
-    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Compose commit', focused)), h(Text, { dimColor: true }, statusLine)), h(Text, undefined, ''), h(Text, {
-        bold: compose.field === 'summary' && compose.editing,
-    }, `Summary  ${summaryVisualLines[0] || ''}`), ...summaryVisualLines.slice(1).map((line, index) => h(Text, {
-        key: `compose-summary-${index}`,
-        bold: compose.field === 'summary' && compose.editing,
-    }, `         ${line}`)), h(Text, undefined, ''), h(Text, {
-        bold: compose.field === 'body' && compose.editing,
-    }, 'Body'), ...bodyVisualLines.map((line, index) => {
-        const isLast = index === bodyVisualLines.length - 1;
-        return h(Text, {
-            key: `compose-body-${index}`,
-            dimColor: line === '<empty>',
-        }, `  ${line}${bodyCursor && isLast ? bodyCursor : ''}`);
-    }), 
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Compose commit', focused)), h(Text, { dimColor: true }, statusLine)), h(Text, undefined, ''), renderSectionHeader('Summary', 'summary', summaryLength > 0 ? summaryLength : undefined), ...renderSectionContent(summaryVisualLines, 'summary', summaryCursor), h(Text, undefined, ''), renderSectionHeader('Body', 'body'), ...renderSectionContent(bodyVisualLines, 'body', bodyCursor), 
     // Loading indicator + post-action message belong inline with the draft
     // (they describe what just happened to the fields above). The state-
     // line ("Editing — Enter switches summary↔body…" / "Press e to edit
@@ -37057,9 +37597,13 @@ function renderConfirmationPanel(h, components, state, width, theme, focused) {
         ? 'You have an unsaved commit draft. Press y to discard it and quit.'
         : state.pendingMutationConfirmation
             ? 'This discards local changes and cannot be undone by Coco.'
-            : action?.kind === 'ai'
-                ? `AI action requires confirmation. Estimated ${action.estimatedTokens || '<unknown>'} tokens.`
-                : 'Destructive Git action requires confirmation.';
+            // Second-stage confirm raised when a safe delete hit an unmerged
+            // branch — name the reason so the force isn't a blind "y again".
+            : state.pendingConfirmationId === 'force-delete-branch'
+                ? 'Not fully merged. Force-delete (git branch -D) is irreversible.'
+                : action?.kind === 'ai'
+                    ? `AI action requires confirmation. Estimated ${action.estimatedTokens || '<unknown>'} tokens.`
+                    : 'Destructive Git action requires confirmation.';
     return h(Box, {
         borderColor: focusBorderColor(theme, focused),
         borderStyle: theme.borderStyle,
@@ -37140,6 +37684,54 @@ function renderChordOverlay(h, components, state, width, theme, focused) {
         paddingX: 1,
     }, ...lines);
 }
+/**
+ * Which-key view-keys strip (#1137). The per-view counterpart to the
+ * `g`-chord overlay: opened by `g?`, it lists the single-key actions
+ * available in the current view (the deliberate overloads — `c`, `R`,
+ * `a`, `m`, `S`, `[`/`]`, …) with their labels, sourced from
+ * `LOG_INK_KEY_BINDINGS` filtered by the active view + focus.
+ *
+ * Renders in the detail panel slot like the chord overlay. `?` steps up
+ * to the full categorized help; Esc closes.
+ */
+function renderViewKeysOverlay(h, components, state, width, theme, focused) {
+    const { Box, Text } = components;
+    const bindings = getLogInkViewKeyBindings({
+        activeView: state.activeView,
+        focus: state.focus,
+    });
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const lines = [
+        h(Text, { key: 'view-keys-title', bold: true }, panelTitle(`keys · ${state.activeView}`, focused)),
+        h(Text, { key: 'view-keys-spacer' }, ''),
+    ];
+    if (bindings.length === 0) {
+        lines.push(h(Text, {
+            key: 'view-keys-empty',
+            dimColor: true,
+        }, truncateCells('No single-key actions in this view — use ? for the full help.', width - 4)));
+    }
+    else {
+        // Pad keys to the widest entry so labels align into a scannable column.
+        const keyColumn = bindings.reduce((max, binding) => Math.max(max, formatBindingBareKeys(binding).length), 0);
+        for (const binding of bindings) {
+            const keys = formatBindingBareKeys(binding);
+            lines.push(h(Text, { key: `view-keys-${binding.id}` }, h(Text, { color: accent, bold: true }, `  ${keys.padEnd(keyColumn)}  `), h(Text, undefined, truncateCells(`${binding.label.padEnd(14)} ${binding.description}`, width - keyColumn - 7))));
+        }
+    }
+    lines.push(h(Text, { key: 'view-keys-foot-spacer' }, ''));
+    lines.push(h(Text, {
+        key: 'view-keys-hint',
+        dimColor: true,
+    }, truncateCells('? full help · esc closes', width - 4)));
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        width,
+        paddingX: 1,
+    }, ...lines);
+}
 function renderHelpPanel(h, components, state, width, theme, focused, bodyRows = 0) {
     const { Box, Text } = components;
     // Build the full list of body rows (everything below the title).
@@ -38182,7 +38774,7 @@ function renderReflogSurface(ctx) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderStashSurface(ctx) {
+function renderStashSurface(ctx, spinnerFrame = 0) {
     const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
@@ -38228,11 +38820,18 @@ function renderStashSurface(ctx) {
                 const rowText = meta
                     ? `${cursor} ${stash.ref.padEnd(11)} ${meta}  ${stash.message}`
                     : `${cursor} ${stash.ref.padEnd(11)} ${stash.message}`;
+                // The `stash@{N}` ref is an identifier, not a status icon, so a
+                // delete-in-flight appends an accent spinner at the row's end
+                // (2 cells reserved from the width budget).
+                const deleting = isPendingDeletion(state.pendingDeletion, 'stash', stash.ref);
+                const spinnerSpan = deleting
+                    ? h(Text, { color: theme.noColor ? undefined : theme.colors.accent, dimColor: false }, ` ${inlineSpinnerGlyph(spinnerFrame, theme.ascii)}`)
+                    : null;
                 return h(Text, {
                     key: `stash-${index}`,
                     bold: isSelected,
                     dimColor: !isSelected,
-                }, truncateCells(rowText, rowWidth));
+                }, truncateCells(rowText, rowWidth - (deleting ? 2 : 0)), spinnerSpan);
             });
     const stashHasMoreAbove = startIndex > 0 && stashes.length > 0;
     const stashHasMoreBelow = startIndex + listRows < stashes.length;
@@ -38580,7 +39179,7 @@ function formatHyperlink(text, url, env = process.env) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderTagsSurface(ctx) {
+function renderTagsSurface(ctx, spinnerFrame = 0) {
     const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
@@ -38621,13 +39220,20 @@ function renderTagsSurface(ctx) {
                 // intact.
                 const url = buildRefUrl(context.provider?.repository, tag.name);
                 const namePadded = truncateCells(tag.name, tagNameColWidth).padEnd(tagNameColWidth);
-                const lineText = truncateCells(`${cursor} ${namePadded} ${tag.subject}`, Math.max(20, width - 4));
+                // Tags have no leading status icon, so a delete-in-flight appends
+                // an accent spinner at the row's end. Reserve its 2 cells from the
+                // truncation budget so it never pushes the row past the panel.
+                const deleting = isPendingDeletion(state.pendingDeletion, 'tag', tag.name);
+                const spinnerSpan = deleting
+                    ? h(Text, { color: theme.noColor ? undefined : theme.colors.accent, dimColor: false }, ` ${inlineSpinnerGlyph(spinnerFrame, theme.ascii)}`)
+                    : null;
+                const lineText = truncateCells(`${cursor} ${namePadded} ${tag.subject}`, Math.max(20, width - 4 - (deleting ? 2 : 0)));
                 if (!url || lineText.indexOf(namePadded) < 0) {
                     return h(Text, {
                         key: `tag-${index}`,
                         bold: isSelected,
                         dimColor: !isSelected,
-                    }, lineText);
+                    }, lineText, spinnerSpan);
                 }
                 const linkStart = lineText.indexOf(namePadded);
                 const before = lineText.slice(0, linkStart);
@@ -38636,7 +39242,7 @@ function renderTagsSurface(ctx) {
                     key: `tag-${index}`,
                     bold: isSelected,
                     dimColor: !isSelected,
-                }, before, formatHyperlink(namePadded, url), after);
+                }, before, formatHyperlink(namePadded, url), after, spinnerSpan);
             });
     const tagsHasMoreAbove = startIndex > 0 && tags.length > 0;
     const tagsHasMoreBelow = startIndex + listRows < tags.length;
@@ -38663,7 +39269,7 @@ function renderTagsSurface(ctx) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderWorktreesSurface(ctx) {
+function renderWorktreesSurface(ctx, spinnerFrame = 0) {
     const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
@@ -38699,7 +39305,9 @@ function renderWorktreesSurface(ctx) {
                 const index = startIndex + offset;
                 const isSelected = index === selected;
                 const cursor = isSelected ? '>' : ' ';
-                const marker = entry.current ? '*' : ' ';
+                const marker = isPendingDeletion(state.pendingDeletion, 'worktree', entry.path)
+                    ? inlineSpinnerGlyph(spinnerFrame, theme.ascii)
+                    : entry.current ? '*' : ' ';
                 const branchLabel = entry.branch ? entry.branch : entry.head || '<detached>';
                 const stateLabel = entry.dirty ? 'dirty' : 'clean';
                 const branchPadded = truncateCells(branchLabel, branchColWidth).padEnd(branchColWidth);
@@ -38769,10 +39377,10 @@ function renderMainPanel(surface, worktreeDiff, worktreeDiffLoading, worktreeHun
         return renderComposeSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'branches') {
-        return renderBranchesSurface(surface);
+        return renderBranchesSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'tags') {
-        return renderTagsSurface(surface);
+        return renderTagsSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'reflog') {
         return renderReflogSurface(surface);
@@ -38781,10 +39389,10 @@ function renderMainPanel(surface, worktreeDiff, worktreeDiffLoading, worktreeHun
         return renderBisectSurface(surface, bisectCandidateDetail, bisectCandidateLoading);
     }
     if (state.activeView === 'stash') {
-        return renderStashSurface(surface);
+        return renderStashSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'worktrees') {
-        return renderWorktreesSurface(surface);
+        return renderWorktreesSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'submodules') {
         return renderSubmodulesSurface(surface);
@@ -39818,6 +40426,12 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.showHelp) {
         return renderHelpPanel(h, components, state, width, theme, focused, bodyRows);
     }
+    // #1137 — the `g?` which-key strip lists the current view's single-key
+    // actions. Checked alongside the other overlays; the reducer keeps it
+    // mutually exclusive with help / palette / pickers.
+    if (state.showViewKeys) {
+        return renderViewKeysOverlay(h, components, state, width, theme, focused);
+    }
     if (state.showCommandPalette) {
         return renderCommandPalette(h, components, state, width, theme, focused);
     }
@@ -40151,6 +40765,53 @@ const REMOTE_OP_LOADERS = {
     'pull-selected-branch': { kind: 'pull', label: 'Pulling branch from remote…' },
     'push-selected-branch': { kind: 'push', label: 'Pushing branch to remote…' },
 };
+/**
+ * Resolve which list row a delete workflow is about to act on, so the
+ * runner can mark it pending (inline spinner) for the duration of the
+ * git call. Mirrors the cursored-target resolution inside each delete
+ * handler exactly — same sort, same promoted-filter, same selection
+ * index — so the spinner lands on the row that actually gets deleted.
+ * Returns `undefined` for non-delete workflows (and when nothing is
+ * selected), which the runner treats as "no pending marker".
+ */
+function resolvePendingDeletion(id, state, context) {
+    const { filter } = state;
+    if (id === 'delete-branch' || id === 'force-delete-branch') {
+        const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+        const visible = filter
+            ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], filter))
+            : all;
+        const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+        return branch ? { kind: 'branch', id: branch.shortName } : undefined;
+    }
+    if (id === 'delete-tag') {
+        const all = sortTags(context.tags?.tags || [], state.tagSort);
+        const visible = filter
+            ? all.filter((t) => matchesPromotedFilter([t.name, t.subject], filter))
+            : all;
+        const tag = visible[Math.min(state.selectedTagIndex, visible.length - 1)];
+        return tag ? { kind: 'tag', id: tag.name } : undefined;
+    }
+    if (id === 'drop-stash') {
+        const all = context.stashes?.stashes || [];
+        const visible = filter
+            ? all.filter((s) => matchesPromotedFilter([s.ref, s.message], filter))
+            : all;
+        const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
+        return stash ? { kind: 'stash', id: stash.ref } : undefined;
+    }
+    if (id === 'remove-worktree') {
+        const all = context.worktreeList?.worktrees || [];
+        const visible = filter
+            ? all.filter((w) => matchesPromotedFilter([w.path, w.branch || ''], filter))
+            : all;
+        const wt = visible.length
+            ? visible[Math.min(state.selectedWorktreeListIndex, visible.length - 1)]
+            : all[Math.min(state.selectedWorktreeListIndex, Math.max(0, all.length - 1))];
+        return wt ? { kind: 'worktree', id: wt.path } : undefined;
+    }
+    return undefined;
+}
 function predictNextFilter(action, currentFilter) {
     switch (action.type) {
         case 'appendFilter':
@@ -40467,7 +41128,10 @@ function LogInkApp(deps) {
         state.changelogView.status === 'loading' ||
         state.commitCompose.loading ||
         Boolean(state.remoteOp) ||
-        Boolean(state.statusLoading);
+        Boolean(state.statusLoading) ||
+        // Keep the shared spinner ticking while a list-item delete is in
+        // flight so its inline pending glyph animates instead of freezing.
+        Boolean(state.pendingDeletion);
     React.useEffect(() => {
         if (!anyLoading) {
             // Reset to 0 so the next loading state starts from a known
@@ -40723,6 +41387,10 @@ function LogInkApp(deps) {
             worktree,
         }), issuedAtDepth);
         setContextStatus((current) => updateLogInkContextStatus(current, 'worktree', 'ready'), issuedAtDepth);
+        // Returned so callers needing the *fresh* overview (e.g. post-commit
+        // navigation) can read it directly instead of racing the async
+        // `setContext` update, which won't be visible in their closure.
+        return worktree;
     }, [git, runtimes.length, setContext, setContextStatus]);
     // Live refresh: watch .git metadata + the working tree root and reload
     // context when something changes outside the TUI (editor save, external
@@ -41585,7 +42253,14 @@ function LogInkApp(deps) {
             // and see the pre-commit log (same silent-failure shape as
             // the split-apply case caught in this PR).
             await refreshHistoryRows();
-            await refreshWorktreeContext();
+            const worktree = await refreshWorktreeContext();
+            // Leave the compose view automatically: a still-dirty tree returns
+            // to Status (so the user can keep staging), an otherwise-complete
+            // commit returns to History (where the new commit now shows). The
+            // reducer inspects the live viewStack to pick the destination.
+            const stillDirty = Boolean(worktree &&
+                worktree.stagedCount + worktree.unstagedCount + worktree.untrackedCount > 0);
+            dispatch({ type: 'returnFromCommit', stillDirty });
         }
     }, [
         context.worktree?.stagedCount,
@@ -42613,6 +43288,16 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No branch selected' };
                 return deleteBranch(git, branch);
             },
+            'force-delete-branch': async () => {
+                const all = sortBranches(context.branches?.localBranches || [], state.branchSort);
+                const visible = state.filter
+                    ? all.filter((b) => matchesPromotedFilter([b.shortName, b.upstream || ''], state.filter))
+                    : all;
+                const branch = visible[Math.min(state.selectedBranchIndex, visible.length - 1)];
+                if (!branch)
+                    return { ok: false, message: 'No branch selected' };
+                return deleteBranch(git, branch, true);
+            },
             'delete-tag': async () => {
                 const all = sortTags(context.tags?.tags || [], state.tagSort);
                 const visible = state.filter
@@ -43386,9 +44071,26 @@ function LogInkApp(deps) {
         if (remoteOp) {
             dispatch({ type: 'setRemoteOp', value: remoteOp });
         }
+        // Mark the cursored row as deleting so it shows an inline pending
+        // spinner while the git call runs. Cleared in `finally` after the
+        // refresh, so a successful delete hands straight off to the row
+        // vanishing, and a failed one (e.g. an unmerged branch) restores
+        // the row's normal icon alongside the error status.
+        const pendingDeletion = resolvePendingDeletion(id, state, context);
+        if (pendingDeletion) {
+            dispatch({ type: 'setPendingDeletion', value: pendingDeletion });
+        }
         try {
             const result = await handler();
             dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
+            // A safe `delete-branch` (`git branch -d`) refuses branches that
+            // aren't fully merged. Rather than dead-end on git's raw error, raise
+            // a second y-confirm offering the force-delete (`git branch -D`). The
+            // cursor hasn't moved (the delete failed), so the force handler
+            // re-resolves the same branch.
+            if (id === 'delete-branch' && !result?.ok && isBranchNotFullyMergedError(result?.message)) {
+                dispatch({ type: 'setPendingConfirmation', value: 'force-delete-branch' });
+            }
             // Refresh history rows AS WELL when the workflow could have
             // changed the commits the user sees (#945 follow-up). The
             // workflow IDs below all either create/rewrite local commits or
@@ -43487,6 +44189,12 @@ function LogInkApp(deps) {
             if (remoteOp) {
                 dispatch({ type: 'setRemoteOp', value: undefined });
             }
+            // Same guarantee for the per-row delete spinner: clear it whether
+            // the delete succeeded, failed, or the refresh threw, so no row is
+            // left spinning forever.
+            if (pendingDeletion) {
+                dispatch({ type: 'setPendingDeletion', value: undefined });
+            }
         }
     }, [context, dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext,
         state.branchSort, state.filter, state.selectedBranchIndex,
@@ -44296,6 +45004,7 @@ function LogInkApp(deps) {
     const forcedPane = state.splitPlan
         ? 'main'
         : state.showHelp ||
+            state.showViewKeys ||
             state.showCommandPalette ||
             state.showThemePicker ||
             state.gitignorePicker ||
@@ -44345,7 +45054,7 @@ function LogInkApp(deps) {
     // Panel renderers are thunks so single-pane mode can build only the
     // visible pane — the main-panel render in particular is expensive, so
     // we don't want to invoke the two hidden ones just to drop them.
-    const sidebarPanel = () => renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme);
+    const sidebarPanel = () => renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme, spinnerFrame);
     const mainSurface = {
         h,
         components: { Box, Text },
@@ -45108,6 +45817,7 @@ var prs = {
     desc: 'List GitHub pull requests for the current repository (read-only triage)',
     builder: builder$4,
     handler: commandExecutor(handler$3),
+    options: options$4,
 };
 
 const RecapLlmResponseSchema = objectType({
@@ -45187,8 +45897,7 @@ const handler$2 = async (argv, logger) => {
     const summaryService = resolveDynamicService(config, 'summarize');
     const model = recapService.model;
     if (config.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        commandExit(1);
+        handleMissingApiKey(logger, config, { command: 'recap' });
     }
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
     const llm = getLlm(provider, model, { ...config, service: recapService });
@@ -45776,8 +46485,7 @@ const handler$1 = async (argv, logger) => {
     const summaryService = resolveDynamicService(config, argv.branch ? 'largeDiff' : 'summarize');
     const model = reviewService.model;
     if (config.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        commandExit(1);
+        handleMissingApiKey(logger, config, { command: 'review' });
     }
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
     const llm = getLlm(provider, model, { ...config, service: reviewService });