git-coco 0.59.1 → 0.61.0

package/dist/index.js

@@ -78,7 +78,7 @@ var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.59.1";
+const BUILD_VERSION = "0.61.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -309,10 +309,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;
     }
 }
 /**
@@ -450,21 +459,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 '';
     }
@@ -2597,18 +2612,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' });
 }
 /**
@@ -3578,8 +3623,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}`));
@@ -3619,8 +3663,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;
         }
@@ -3637,7 +3680,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;
     }
@@ -3670,12 +3713,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),
 };
@@ -8944,6 +8987,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! 🦾🤖')));
 };
@@ -14436,8 +14597,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 });
@@ -16333,8 +16493,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 });
@@ -17064,9 +17223,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'),
@@ -17085,10 +17244,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;
@@ -17125,7 +17284,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');
@@ -17178,7 +17337,7 @@ const handler$8 = async (argv, logger) => {
             const raw = JSON.parse(fs__namespace.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) {
@@ -17197,6 +17356,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 = {
@@ -17204,6 +17372,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';
@@ -17583,11 +17752,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;
@@ -17722,6 +17887,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' });
@@ -17763,7 +17966,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,
@@ -17847,19 +18050,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.`;
     }
 }
 
@@ -18051,13 +18311,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 {
@@ -18169,6 +18430,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';
@@ -18920,9 +19182,17 @@ async function getStashOverview(git) {
     //   %gd  — stash reflog selector (stash@{N})
     //   %H   — stash commit hash
     //   %P   — space-separated parent hashes (first = base, see StashEntry.baseHash)
-    //   %ci  — committer date, ISO format
+    //   %cI  — committer date, strict ISO 8601
     //   %gs  — reflog subject ("WIP on main: <subject>")
-    const stashes = parseStashList(await git.raw(['stash', 'list', '--date=iso', '--format=%gd%x1f%H%x1f%P%x1f%ci%x1f%gs']));
+    //
+    // NOTE: we deliberately do NOT pass `--date=iso`. That flag rewrites the
+    // `%gd` selector from the index form (`stash@{0}`) into a timestamp
+    // (`stash@{2026-06-03 17:29:23 -0400}`), which is noisy in the list, eats
+    // row width, and — critically — breaks `renameStash`, which parses the
+    // `stash@{N}` index out of the ref. `%cI` gives a strict-ISO date that's
+    // independent of `--date`, so we get both a clean index ref and a
+    // parseable date.
+    const stashes = parseStashList(await git.raw(['stash', 'list', '--format=%gd%x1f%H%x1f%P%x1f%cI%x1f%gs']));
     return {
         stashes: await Promise.all(stashes.map(async (stash) => ({
             ...stash,
@@ -20591,7 +20861,7 @@ function applyCommitComposeAction(state, action) {
                     loading: false,
                     streamingPreview: undefined,
                     pendingAiDraft: action.value,
-                    message: 'AI draft ready. Press R to replace your text, or Esc to keep what you have.',
+                    message: 'AI draft ready. Press Enter (or R) to replace your text, or Esc to keep what you have.',
                     details: undefined,
                 };
             }
@@ -20640,7 +20910,7 @@ function applyCommitComposeAction(state, action) {
                 loading: false,
                 streamingPreview: undefined,
                 pendingAiDraft: action.value,
-                message: 'AI draft ready. Press R to replace your text, or Esc to keep what you have.',
+                message: 'AI draft ready. Press Enter (or R) to replace your text, or Esc to keep what you have.',
                 details: undefined,
             };
         case 'acceptPendingAiDraft':
@@ -22196,6 +22466,25 @@ function getLogInkWorkflowActions() {
             kind: 'destructive',
             requiresConfirmation: true,
         },
+        {
+            // Palette-only create variants (empty `key`): no global hotkey to
+            // collide with `S` / `gZ`, reachable from `:`. Both stash a quick
+            // WIP entry with the requested scope.
+            id: 'stash-staged',
+            key: '',
+            label: 'Stash staged only',
+            description: 'Stash just the staged (index) changes — `git stash push --staged`.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
+        {
+            id: 'stash-keep-index',
+            key: '',
+            label: 'Stash keeping index',
+            description: 'Stash everything but leave the index intact for an immediate commit — `git stash push --keep-index`.',
+            kind: 'normal',
+            requiresConfirmation: false,
+        },
         {
             id: 'remove-worktree',
             key: 'W',
@@ -22707,6 +22996,13 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Push the stash view (gz; gs is reserved for status).',
         contexts: ['normal'],
     },
+    {
+        id: 'createStash',
+        keys: ['gZ'],
+        label: 'stash changes',
+        description: 'Stash all changes (tracked + untracked) with an optional message — works from any view, including status/diff/compose. Empty message creates a quick WIP stash.',
+        contexts: ['normal'],
+    },
     {
         id: 'navigateWorktrees',
         keys: ['gw'],
@@ -22951,6 +23247,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'],
@@ -22979,6 +23282,20 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Add the cursored file or folder to .gitignore (pick a pattern).',
         contexts: ['status'],
     },
+    {
+        id: 'stageAll',
+        keys: ['A'],
+        label: 'stage all',
+        description: 'Stage every change in the worktree (git add -A).',
+        contexts: ['status', 'compose'],
+    },
+    {
+        id: 'stagePathspec',
+        keys: ['+'],
+        label: 'stage paths',
+        description: 'Stage files matching a typed pathspec (. / src/ / *.ts / a list).',
+        contexts: ['status', 'compose'],
+    },
     {
         id: 'viewChangelog',
         keys: ['L'],
@@ -23052,6 +23369,19 @@ const GLOBAL_BINDING_IDS = [
     'navigateBack',
 ];
 const NORMAL_GLOBAL_HINTS = ['g jump', '< back', '? help', ': cmds', 'q quit'];
+/**
+ * Narrow single-pane footer budget (#1135). On terminals below the
+ * single-pane breakpoint the pane switcher (`tab: …`, ~29 cells) plus
+ * the snap-back / peek affordance already claim most of an 80-cell row,
+ * so the per-view hint tail and the global cluster are trimmed to what
+ * fits without clipping — the switcher is the orientation anchor and
+ * must stay whole. The dropped bindings remain one `?` (help) away.
+ *
+ *   - keep only the first view hint (the most actionable for the view)
+ *   - shrink the global cluster to the two recovery essentials
+ */
+const SINGLE_PANE_GLOBAL_HINTS = ['? help', 'q quit'];
+const SINGLE_PANE_VIEW_HINT_LIMIT = 1;
 /**
  * Per-binding category mapping. Used to subdivide the help overlay's
  * Global and view sections into named clusters so users don't face a
@@ -23072,6 +23402,9 @@ const BINDING_CATEGORY_BY_ID = {
     openProjectConfig: 'view',
     openGlobalConfig: 'view',
     gitignoreFile: 'mutate',
+    stageAll: 'mutate',
+    stagePathspec: 'mutate',
+    createStash: 'mutate',
     quit: 'essentials',
     refresh: 'essentials',
     navigateBack: 'essentials',
@@ -23223,18 +23556,20 @@ function formatLogInkBreadcrumb(viewStack) {
     if (viewStack.length === 1 && viewStack[0] === 'history') {
         return '';
     }
-    // Trailing back-hint (P2.5) reminds the user how to walk back when
-    // they're nested deeper than the root view.
-    return `${viewStack.join(' › ')}   ← <`;
+    // Pure location breadcrumb — no trailing back-hint. The footer's
+    // global `< back` hint already names the walk-back key, so repeating
+    // `← <` on every nested view was redundant header chrome (TUI audit).
+    return viewStack.join(' › ');
 }
 /**
  * Render the nested-repo navigation stack (#931) as a breadcrumb suitable
  * for the chrome header. Returns an empty string for a root-only stack
  * so the header stays compact when nothing has been pushed.
  *
- * The trailing `← esc` reminds the user that Esc is the way out — same
- * shape as the view breadcrumb's `← <` so the two read consistently.
- * The repo breadcrumb shows in addition to the view breadcrumb when
+ * The trailing `← esc` reminds the user that Esc (not `<`) pops the
+ * repo stack — a distinct key from the footer's global `< back`, so
+ * unlike the view breadcrumb (pure location) the repo crumb keeps its
+ * hint. The repo breadcrumb shows in addition to the view breadcrumb when
  * both stacks are non-trivial; the chrome layer is responsible for
  * laying them out side by side.
  *
@@ -23277,7 +23612,53 @@ function combineLogInkBreadcrumbSegments(repoCrumb, viewCrumb) {
     }
     return '';
 }
+/**
+ * Single-pane pane switcher hint, e.g. `tab: [sidebar] main inspector`.
+ * The active pane (derived from focus: sidebar → sidebar, detail →
+ * inspector, otherwise main) is bracketed so the user can see which of
+ * the three panes Tab will move them away from. Surfaced only on narrow
+ * terminals where the other two panes aren't on screen.
+ */
+function singlePaneSwitcherHint(focus) {
+    const active = focus === 'sidebar' ? 'sidebar' : focus === 'detail' ? 'inspector' : 'main';
+    const label = (pane) => (pane === active ? `[${pane}]` : pane);
+    return `tab: ${label('sidebar')} ${label('main')} ${label('inspector')}`;
+}
 function getLogInkFooterHints(options) {
+    const hints = computeLogInkFooterHints(options);
+    // While peeking the sidebar (#1135 v2) the footer shows the snap-back
+    // affordance instead of the switcher — the user is mid-glance, not
+    // navigating, so `v`/Esc returning to main is the relevant action. The
+    // view-hint tail + globals are trimmed to fit the narrow row (see
+    // SINGLE_PANE_GLOBAL_HINTS).
+    if (options.peeking) {
+        return {
+            contextual: ['v/esc → main', ...hints.contextual.slice(0, SINGLE_PANE_VIEW_HINT_LIMIT)],
+            global: SINGLE_PANE_GLOBAL_HINTS,
+        };
+    }
+    // On narrow terminals only one pane is on screen, so prepend a Tab
+    // pane switcher for orientation. The caller (footer) only sets
+    // `singlePane` in the plain per-pane states — while an overlay or
+    // filter owns the screen the visible pane is forced (or input is
+    // captured) and Tab does something else, so the switcher is
+    // suppressed there to avoid showing a pane that isn't active. From the
+    // main / inspector pane we also surface `v peek` so the momentary
+    // sidebar glance is discoverable. The full per-view hint cluster +
+    // global cluster don't fit alongside the switcher at the 80-col floor,
+    // so both are trimmed (the dropped keys stay reachable via `?`).
+    if (options.singlePane) {
+        const lead = options.focus === 'sidebar'
+            ? [singlePaneSwitcherHint(options.focus)]
+            : [singlePaneSwitcherHint(options.focus), 'v peek'];
+        return {
+            contextual: [...lead, ...hints.contextual.slice(0, SINGLE_PANE_VIEW_HINT_LIMIT)],
+            global: SINGLE_PANE_GLOBAL_HINTS,
+        };
+    }
+    return hints;
+}
+function computeLogInkFooterHints(options) {
     if (options.pendingKey) {
         const continuations = getLogInkChordContinuations(options.pendingKey);
         if (continuations.length > 0) {
@@ -23394,7 +23775,7 @@ function getLogInkFooterHints(options) {
     }
     if (options.activeView === 'status') {
         return {
-            contextual: ['↑/↓ files', 'enter diff', 'space stage', 'z revert', 'i ignore', 'e/c compose', 'y yank'],
+            contextual: ['↑/↓ files', 'enter hunks', 'space stage', 'A stage all', 'z revert', 'e/c compose'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -23406,16 +23787,19 @@ function getLogInkFooterHints(options) {
         const splitToggleHint = options.diffViewMode === 'split' ? 'd unified' : 'd split';
         if (options.diffSource === 'stash') {
             return {
-                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'H apply hunk', 'o edit', splitToggleHint, 'y yank', 'esc back'],
+                contextual: ['j/k lines', '[/] file', 'c cherry-pick', 'H apply hunk', splitToggleHint, 'esc back'],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
         if (options.diffSource === 'commit') {
             // Commit-diff explore: read-only diff, but `c` cherry-picks the
             // cursored file from the commit into the worktree, and `H`
-            // (or `gH` for index) applies just the cursored hunk.
+            // (or `gH` for index) applies just the cursored hunk. `j/k`
+            // line-scroll the diff body; `[`/`]` jump between hunks — the
+            // footer labels match the actual handlers (commit diff has no
+            // per-file `[/]` jump; that's the stash diff).
             return {
-                contextual: ['j/k hunks', '[/] file', 'c cherry-pick', 'H apply hunk', splitToggleHint, 'y/Y yank', 'esc back'],
+                contextual: ['j/k lines', '[/] hunk', 'c cherry-pick', 'H apply hunk', splitToggleHint, 'esc back'],
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
@@ -23428,14 +23812,17 @@ function getLogInkFooterHints(options) {
                 global: NORMAL_GLOBAL_HINTS,
             };
         }
+        // Worktree (staging) diff. The hunk is the unit of action: ↑/↓ walk
+        // hunks, space stages/unstages the selected one, a stages the whole
+        // file, z discards the hunk.
         return {
-            contextual: ['j/k hunks', 'space stage', 'z revert', 'o edit', 'e/c compose', 'y yank'],
+            contextual: ['↑/↓ hunk', 'space stage', 'a stage file', 'z discard', 'o edit', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
     if (options.activeView === 'compose') {
         return {
-            contextual: ['e edit', 'E $EDITOR', 'c commit', 'S split', 'I AI draft', 'gs hunks', 'esc back'],
+            contextual: ['e edit', 'c commit', 'A stage all', '+ stage…', 'S split', 'I AI draft', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -23465,7 +23852,7 @@ function getLogInkFooterHints(options) {
     }
     if (options.activeView === 'stash') {
         return {
-            contextual: ['↑/↓ stashes', 'enter diff', 'a apply', 'p pop', 'X drop', 'y yank'],
+            contextual: ['↑/↓ stashes', 'enter diff', 'a/A apply', 'p pop', 'R rename', 'b branch', 'X drop · u undo'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -23594,6 +23981,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,
@@ -24856,7 +25285,7 @@ function topOfStack(stack) {
 }
 function withPushedView(state, value) {
     if (topOfStack(state.viewStack) === value) {
-        return { ...state, pendingKey: undefined };
+        return { ...state, peekReturnFocus: undefined, pendingKey: undefined };
     }
     const viewStack = [...state.viewStack, value];
     return {
@@ -24879,12 +25308,15 @@ function withPushedView(state, value) {
         compareHead: value === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
+        // Changing the view is a deliberate destination — cancel any pending
+        // peek return so the user isn't snapped back afterward.
+        peekReturnFocus: undefined,
         pendingKey: undefined,
     };
 }
 function withPoppedView(state) {
     if (state.viewStack.length <= 1) {
-        return { ...state, pendingKey: undefined };
+        return { ...state, peekReturnFocus: undefined, pendingKey: undefined };
     }
     const viewStack = state.viewStack.slice(0, -1);
     const next = topOfStack(viewStack);
@@ -24911,6 +25343,8 @@ function withPoppedView(state) {
         compareHead: next === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: next === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: next === 'status' ? state.statusGroupHeaderFocused : false,
+        // Backing out is a deliberate navigation — cancel any peek return.
+        peekReturnFocus: undefined,
         pendingKey: undefined,
     };
 }
@@ -25023,7 +25457,7 @@ function withPoppedRepoFrame(state) {
 }
 function withReplacedView(state, value) {
     if (topOfStack(state.viewStack) === value) {
-        return { ...state, pendingKey: undefined };
+        return { ...state, peekReturnFocus: undefined, pendingKey: undefined };
     }
     const viewStack = [...state.viewStack.slice(0, -1), value];
     return {
@@ -25037,6 +25471,9 @@ function withReplacedView(state, value) {
         compareHead: value === 'diff' ? state.compareHead : undefined,
         pendingCommitFocused: value === 'history' ? state.pendingCommitFocused : false,
         statusGroupHeaderFocused: value === 'status' ? state.statusGroupHeaderFocused : false,
+        // Changing the view is a deliberate destination — cancel any pending
+        // peek return so the user isn't snapped back afterward.
+        peekReturnFocus: undefined,
         pendingKey: undefined,
     };
 }
@@ -25099,7 +25536,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)) {
@@ -25191,6 +25660,7 @@ function createLogInkState(rows, options = {}) {
         fullGraph: options.fullGraph ?? true,
         showHelp: false,
         helpScrollOffset: 0,
+        showViewKeys: false,
         showCommandPalette: false,
         workflowActionId: undefined,
         pendingConfirmationId: undefined,
@@ -25270,6 +25740,9 @@ function applyLogInkAction(state, action) {
                 // from 'commits' should always land back on a real file when
                 // the user returns.
                 statusGroupHeaderFocused: false,
+                // Explicit focus cycle cancels a pending peek return — the
+                // user has taken manual control of the focus.
+                peekReturnFocus: undefined,
                 pendingKey: undefined,
             };
         case 'focusPrevious':
@@ -25278,6 +25751,7 @@ function applyLogInkAction(state, action) {
                 focus: cycleValue(FOCUS_ORDER, state.focus, -1),
                 sidebarHeaderFocused: false,
                 statusGroupHeaderFocused: false,
+                peekReturnFocus: undefined,
                 pendingKey: undefined,
             };
         case 'move':
@@ -25692,6 +26166,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;
@@ -25775,8 +26265,35 @@ function applyLogInkAction(state, action) {
                 // the status view — clear when focus moves away so a
                 // re-entry starts on a real file.
                 statusGroupHeaderFocused: action.value === 'commits' ? state.statusGroupHeaderFocused : false,
+                // An explicit focus set cancels a pending peek return.
+                peekReturnFocus: undefined,
                 pendingKey: undefined,
             };
+        case 'togglePeek': {
+            // Peek = "focus the sidebar with a return ticket." Closing returns
+            // to the stashed focus; opening (only from a non-sidebar pane)
+            // stashes the current focus and jumps to the sidebar. The render
+            // layer needs no special case — `focus: 'sidebar'` already drives
+            // the single-pane layout to show the sidebar full-width.
+            if (state.peekReturnFocus !== undefined) {
+                return {
+                    ...state,
+                    focus: state.peekReturnFocus,
+                    peekReturnFocus: undefined,
+                    sidebarHeaderFocused: false,
+                    pendingKey: undefined,
+                };
+            }
+            if (state.focus === 'sidebar') {
+                return state;
+            }
+            return {
+                ...state,
+                focus: 'sidebar',
+                peekReturnFocus: state.focus,
+                pendingKey: undefined,
+            };
+        }
         case 'setPendingKey':
             return {
                 ...state,
@@ -25861,6 +26378,7 @@ function applyLogInkAction(state, action) {
                 showCommandPalette: false,
                 showHelp: false,
                 helpScrollOffset: 0,
+                showViewKeys: false,
                 pendingKey: undefined,
             };
         case 'toggleGraph':
@@ -25879,9 +26397,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
@@ -25898,6 +26431,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: '',
@@ -25945,8 +26479,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,
@@ -26643,6 +27178,12 @@ function getLogInkPaletteExecuteEvents(command, state) {
             return [action({ type: 'toggleGraph' })];
         case 'navigateHome':
             return [action({ type: 'navigateHome' })];
+        case 'createStash':
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'create-stash',
+                    label: 'Stash message (empty = WIP)',
+                })];
         case 'navigateStatus':
             return [action({ type: 'pushView', value: 'status' })];
         case 'navigateDiff':
@@ -26740,6 +27281,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':
@@ -26748,6 +27293,14 @@ function getLogInkPaletteExecuteEvents(command, state) {
             // Runtime resolves the cursored worktree file and opens the picker
             // (no-ops with a warning when there's no file under the cursor).
             return [{ type: 'openGitignorePicker' }];
+        case 'stageAll':
+            return [{ type: 'runWorkflowAction', id: 'stage-all' }];
+        case 'stagePathspec':
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'stage-pathspec',
+                    label: 'Stage pathspec (e.g. `.`, `src/`, `*.ts`, or a space-separated list)',
+                })];
         case 'workflowDeleteBranch':
         case 'workflowDeleteTag':
         case 'workflowDropStash':
@@ -26838,6 +27391,15 @@ function submitInputPrompt(state) {
     if (!state.inputPrompt)
         return [];
     const value = state.inputPrompt.value.trim();
+    // create-stash allows an EMPTY value → quick WIP stash (git supplies its
+    // own "WIP on <branch>" subject). Handled before the generic empty guard
+    // so an empty stash prompt commits a WIP stash instead of bouncing.
+    if (state.inputPrompt.kind === 'create-stash') {
+        return [
+            { type: 'runWorkflowAction', id: 'create-stash', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     if (!value) {
         return [action({ type: 'setStatus', value: 'enter a value or press esc to cancel', kind: 'warning' })];
     }
@@ -26847,6 +27409,12 @@ function submitInputPrompt(state) {
             action({ type: 'closeInputPrompt' }),
         ];
     }
+    if (state.inputPrompt.kind === 'stage-pathspec') {
+        return [
+            { type: 'runWorkflowAction', id: 'stage-pathspec', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     if (state.inputPrompt.kind === 'reset-mode') {
         const mode = value.toLowerCase();
         if (mode !== 'soft' && mode !== 'mixed' && mode !== 'hard') {
@@ -27073,7 +27641,9 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     // draft was pending should see the original `R` / Esc semantics of
     // wherever they are now.
     if (state.activeView === 'compose' && state.commitCompose.pendingAiDraft) {
-        if (inputValue === 'R' && !key.ctrl && !key.meta) {
+        // `R` or `Enter` accept the swap (the AI draft becomes the new
+        // content); `Enter` is the natural "yes, use it" confirmation.
+        if ((inputValue === 'R' && !key.ctrl && !key.meta) || key.return) {
             return [action({ type: 'commitCompose', action: { type: 'acceptPendingAiDraft' } })];
         }
         if (key.escape) {
@@ -27443,6 +28013,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
@@ -27459,6 +28049,15 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return events;
     }
+    // #1135 v2 — while peeking the sidebar, Esc or the peek key (`v`)
+    // snaps back to the pane the user came from. Placed before the
+    // generic Esc → popView so a peek glance returns to main rather than
+    // walking the view stack. Every other key falls through to normal
+    // handling (focus is on the sidebar during a peek), so ←/→ and ↑/↓
+    // browse the sidebar and keep the peek open until an explicit exit.
+    if (state.peekReturnFocus !== undefined && (key.escape || inputValue === 'v')) {
+        return [action({ type: 'togglePeek' })];
+    }
     if (key.escape && state.viewStack.length > 1) {
         return [action({ type: 'popView' })];
     }
@@ -27477,6 +28076,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' })];
     }
@@ -27525,6 +28135,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'jumped to stash' }),
         ];
     }
+    // `gZ` chord: stash all changes from ANY view — including status / diff /
+    // compose, where bare `S` is claimed by the commit-split flow. Mnemonic
+    // pair with `gz` (jump to the stash *view*). Opens the same message
+    // prompt; an empty message creates a quick WIP stash.
+    if (state.pendingKey === 'g' && inputValue === 'Z') {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'create-stash',
+                label: 'Stash message (empty = WIP)',
+            })];
+    }
     if (state.pendingKey === 'g' && inputValue === 'w') {
         return [
             action({ type: 'pushView', value: 'worktrees' }),
@@ -27888,6 +28509,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (key.tab) {
         return [action({ type: key.shift ? 'focusPrevious' : 'focusNext' })];
     }
+    // #1135 v2 — `v` peeks the sidebar from the main / inspector pane on
+    // narrow (single-pane) terminals: a momentary glance that snaps back
+    // with `v` / Esc (handled above once peeking). No-op in the three-pane
+    // layout (every pane is already on screen) and from the sidebar itself.
+    if (inputValue === 'v' && context.singlePane && state.focus !== 'sidebar') {
+        return [action({ type: 'togglePeek' })];
+    }
     // ←/→ on the sidebar switch tabs (Status ↔ Branches ↔ Tags ↔
     // Stashes ↔ Worktrees) — the horizontal axis is "between tabs", the
     // vertical axis (↑/↓ below) is "within the active tab's items".
@@ -27973,10 +28601,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     fileCount: context.worktreeFileCount,
                 })];
         }
-        // Diff view: j/k scrolls the visible diff one line. Hunk navigation
-        // moved to ]/[ so single-hunk files (longer than the preview pane)
-        // can scroll bidirectionally instead of getting pinned to a hunk
-        // anchor.
+        // Worktree (staging) diff: ↑/↓ move between hunks — the hunk is the
+        // unit you stage, so the cursor walks hunks (auto-scrolling to the
+        // selected one). Single-hunk files fall through to line-scroll so a
+        // long lone hunk stays readable; `[`/`]` remain hunk-jump aliases.
+        if (state.activeView === 'diff' && (context.worktreeHunkOffsets?.length ?? 0) > 1) {
+            return [action({
+                    type: 'jumpWorktreeHunk',
+                    delta: -1,
+                    hunkOffsets: context.worktreeHunkOffsets,
+                })];
+        }
         if (state.activeView === 'diff' && context.worktreeDiffLineCount) {
             return [action({
                     type: 'pageWorktreeDiff',
@@ -28091,6 +28726,15 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                     fileCount: context.worktreeFileCount,
                 })];
         }
+        // Worktree (staging) diff: ↓ walks to the next hunk (see the ↑
+        // handler). Multi-hunk only; single-hunk files line-scroll.
+        if (state.activeView === 'diff' && (context.worktreeHunkOffsets?.length ?? 0) > 1) {
+            return [action({
+                    type: 'jumpWorktreeHunk',
+                    delta: 1,
+                    hunkOffsets: context.worktreeHunkOffsets,
+                })];
+        }
         if (state.activeView === 'diff' && context.worktreeDiffLineCount) {
             return [action({
                     type: 'pageWorktreeDiff',
@@ -28497,6 +29141,25 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'p' && isStashActionTarget(state) && context.stashCount) {
         return [{ type: 'runWorkflowAction', id: 'pop-stash' }];
     }
+    // `A` applies restoring the staged/unstaged split (`git stash apply
+    // --index`) — distinct from `a` (plain apply).
+    if (inputValue === 'A' && isStashActionTarget(state) && context.stashCount) {
+        return [{ type: 'runWorkflowAction', id: 'apply-stash-index' }];
+    }
+    // `b` turns the cursored stash into a new branch (`git stash branch`).
+    if (inputValue === 'b' && isStashActionTarget(state) && context.stashCount) {
+        return [action({ type: 'openInputPrompt', kind: 'stash-branch', label: 'New branch from stash' })];
+    }
+    // `R` renames the cursored stash (store-under-new-message + drop old).
+    if (inputValue === 'R' && isStashActionTarget(state) && context.stashCount) {
+        return [action({ type: 'openInputPrompt', kind: 'rename-stash', label: 'Rename stash' })];
+    }
+    // `u` undoes the last drop. Gated on the view, NOT the count, so it
+    // still works right after you drop your only stash (the list is empty
+    // but the dropped commit is recoverable by hash).
+    if (inputValue === 'u' && isStashActionTarget(state)) {
+        return [{ type: 'runWorkflowAction', id: 'undo-drop-stash' }];
+    }
     // Per-view tag action: `P` pushes the selected tag to origin. Letter
     // is scoped to the tags target so it doesn't collide with `p` for
     // pop-stash. Note: this also takes precedence over the global
@@ -28725,7 +29388,7 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         return [action({
                 type: 'openInputPrompt',
                 kind: 'create-stash',
-                label: 'Stash message',
+                label: 'Stash message (empty = WIP)',
             })];
     }
     // `o` opens the file under the cursor in $EDITOR. Available on the
@@ -28994,9 +29657,35 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === ' ' && state.activeView === 'status' && context.worktreeFileCount) {
         return [{ type: 'toggleSelectedFileStage' }];
     }
+    // `A` — stage everything (git add -A); `+` — stage by typed pathspec.
+    // Both available from the status AND compose views so you can stage
+    // without leaving the message editor.
+    if (inputValue === 'A' && (state.activeView === 'status' || state.activeView === 'compose')) {
+        return [{ type: 'runWorkflowAction', id: 'stage-all' }];
+    }
+    if (inputValue === '+' && (state.activeView === 'status' || state.activeView === 'compose')) {
+        return [action({
+                type: 'openInputPrompt',
+                kind: 'stage-pathspec',
+                label: 'Stage pathspec (e.g. `.`, `src/`, `*.ts`, or a space-separated list)',
+            })];
+    }
     if (inputValue === ' ' && state.activeView === 'diff' && context.worktreeHunkOffsets?.length) {
         return [{ type: 'toggleSelectedHunkStage' }];
     }
+    // Worktree diff with no hunks (a new/untracked file) — `space` stages
+    // the whole file, since there's nothing to partial-stage.
+    if (inputValue === ' ' &&
+        state.activeView === 'diff' &&
+        state.diffSource === 'worktree' &&
+        !context.worktreeHunkOffsets?.length) {
+        return [{ type: 'toggleSelectedFileStage' }];
+    }
+    // `a` stages/unstages the WHOLE current file from the staging diff —
+    // an escape hatch out of hunk-by-hunk back to all-or-nothing.
+    if (inputValue === 'a' && state.activeView === 'diff' && state.diffSource === 'worktree') {
+        return [{ type: 'toggleSelectedFileStage' }];
+    }
     if (inputValue === 'z' && state.activeView === 'status' && context.worktreeFileCount) {
         return [action({ type: 'setPendingMutationConfirmation', value: 'revert-file' })];
     }
@@ -29771,21 +30460,22 @@ const INSPECTOR_TABBED_BELOW_ROWS = 28;
  *   wide   >= 160 — plenty of room; keep absolute dates
  *   normal >= 120 — relative dates save 8-ish cells without hiding info
  *   tight  >= 100 — drop date entirely; subject + refs are the priority
- *   rail   <  100 — even with side panels collapsed the row is tight;
- *                   stack to two lines and rail the side panels at rest
+ *   rail   <  100 — history rows stack to two lines; the UI also drops
+ *                   to single-pane mode (see `LAYOUT_SINGLE_PANE_BELOW`)
  */
 const LAYOUT_TIGHT_BELOW = 120;
 const LAYOUT_NORMAL_BELOW = 160;
 const LAYOUT_RAIL_BELOW = 100;
 /**
- * Fixed cell width for a railed side panel. Just wide enough for a
- * 1-cell icon + a 2-3 digit count after subtracting border (2) and
- * padding (2). Going narrower clips the count; going wider defeats
- * the purpose of railing in the first place.
+ * Width below which the three-panel layout can't tile without starving
+ * every pane, so the UI shows exactly one full-width pane (the focused
+ * one) and Tab cycles which pane is visible. Coincides with the `rail`
+ * density breakpoint — single-pane mode replaces the old 8-cell icon
+ * rails that used to render at this width.
  */
-const LAYOUT_RAIL_PANEL_WIDTH = 8;
+const LAYOUT_SINGLE_PANE_BELOW = LAYOUT_RAIL_BELOW;
 const SIDEBAR_AT_REST_BY_TIER = {
-    rail: { min: 22, max: 28, fraction: 0.24 }, // unused — rail collapses to LAYOUT_RAIL_PANEL_WIDTH
+    rail: { min: 22, max: 28, fraction: 0.24 }, // unused at rest — single-pane mode overrides the width
     tight: { min: 22, max: 28, fraction: 0.24 },
     normal: { min: 22, max: 30, fraction: 0.22 },
     wide: { min: 28, max: 32, fraction: 0.20 },
@@ -29804,14 +30494,25 @@ function getLogInkLayout(input) {
             : columns >= LAYOUT_RAIL_BELOW
                 ? 'tight'
                 : 'rail';
-    // Rail collapse: only happens at the narrowest tier, and only for
-    // the panel that does NOT currently hold focus AND is not being
-    // commandeered by the help overlay. Focus always wins — pressing
-    // tab to the sidebar pops it back open even on an 80-cell terminal
-    // so the user can actually use it. The help overlay also wins for
-    // the inspector since that's where its descriptions render.
-    const sidebarRailed = density === 'rail' && !input.sidebarFocused;
-    const inspectorRailed = density === 'rail' && !input.inspectorFocused && !input.helpOverlayActive;
+    // Below the single-pane breakpoint the three-panel layout can't tile
+    // without starving every pane, so we show exactly one full-width pane
+    // — the focused one — and Tab cycles which pane is visible. This
+    // replaces the retired 8-cell icon rails (an 8-cell stub showed a tab
+    // glyph + count and nothing actionable).
+    const singlePane = columns < LAYOUT_SINGLE_PANE_BELOW;
+    // Which pane shows in single-pane mode. Defaults to the focused pane
+    // (focus and visibility coalesce, so the existing Tab focus cycle
+    // drives it). An active overlay can force a specific pane via
+    // `forcedPane` so its surface isn't hidden behind whatever pane focus
+    // points at.
+    const focusPane = input.sidebarFocused
+        ? 'sidebar'
+        : input.inspectorFocused
+            ? 'inspector'
+            : 'main';
+    const visiblePane = singlePane
+        ? input.forcedPane ?? focusPane
+        : focusPane;
     // Inspector width — at rest 20-32 cells (~22% of width), focused
     // 36-60 cells (~40% of width). Narrow rest state keeps the commit
     // graph dominant; focus expansion gives the inspector room for long
@@ -29823,42 +30524,48 @@ function getLogInkLayout(input) {
     // "Move focus...". Capped at 100 cells so a wide terminal doesn't
     // waste an absurd amount of horizontal space on the cheat sheet.
     //
-    // Rail collapse wins over the at-rest range but loses to focus and
-    // to the help overlay — both of those represent deliberate user
-    // intent to read the panel.
+    // (In single-pane mode these three-panel widths are recomputed below
+    // so the visible pane gets the full terminal.)
     const detailWidth = input.helpOverlayActive
         ? Math.max(60, Math.min(100, Math.floor(columns * 0.50)))
         : input.inspectorFocused
             ? Math.max(36, Math.min(60, Math.floor(columns * 0.40)))
-            : inspectorRailed
-                ? LAYOUT_RAIL_PANEL_WIDTH
-                : Math.max(20, Math.min(32, Math.floor(columns * 0.22)));
+            : Math.max(20, Math.min(32, Math.floor(columns * 0.22)));
     // Sidebar at rest is tier-aware (see `SIDEBAR_AT_REST_BY_TIER`):
     // tight stays compact (22-28), normal shrinks slightly (22-30),
     // wide grows naturally (28-48) so the side panel doesn't get pinned
     // at an arbitrary cap on big terminals while the main panel hogs
     // 80% of the width. Focused: 32-50 cells (~36% of width),
     // regardless of tier — deliberate user intent to read the sidebar
-    // deserves the extra width. Rail mode (narrow terminal, unfocused)
-    // collapses to a fixed 8-cell strip with tab glyphs only.
+    // deserves the extra width.
     const sidebarWidth = input.sidebarFocused
         ? Math.max(32, Math.min(50, Math.floor(columns * 0.36)))
-        : sidebarRailed
-            ? LAYOUT_RAIL_PANEL_WIDTH
-            : calcSidebarAtRestWidth(columns, density);
+        : calcSidebarAtRestWidth(columns, density);
+    // Single-pane mode: exactly one pane renders, full-width; the other
+    // two are hidden (width 0), not railed. Above the breakpoint the
+    // three panels tile flush across the terminal.
+    const paneWidths = singlePane
+        ? {
+            sidebarWidth: visiblePane === 'sidebar' ? columns : 0,
+            mainPanelWidth: visiblePane === 'main' ? columns : 0,
+            detailWidth: visiblePane === 'inspector' ? columns : 0,
+        }
+        : {
+            sidebarWidth,
+            mainPanelWidth: Math.max(20, columns - sidebarWidth - detailWidth),
+            detailWidth,
+        };
     return {
         bodyRows: Math.max(8, rows - 5),
         columns,
-        detailWidth,
-        mainPanelWidth: Math.max(20, columns - sidebarWidth - detailWidth),
         rows,
-        sidebarWidth,
         tooSmall: columns < LOG_INK_MIN_COLUMNS || rows < LOG_INK_MIN_ROWS,
         inspectorTabbed: rows < INSPECTOR_TABBED_BELOW_ROWS,
         density,
-        sidebarRailed,
-        inspectorRailed,
+        singlePane,
+        visiblePane,
         historyRowMode: density === 'rail' ? 'stacked' : 'single',
+        ...paneWidths,
     };
 }
 
@@ -30362,7 +31069,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
@@ -30400,7 +31107,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.
@@ -30907,6 +31614,45 @@ async function highlightDiffCode(filePath, lines) {
     return result;
 }
 
+/**
+ * Humanize raw AI-provider / LangChain error strings into a short,
+ * actionable line for the compose surface.
+ *
+ * The underlying errors are verbose and developer-facing — e.g.
+ * `executeChain: Chain execution failed: 429 You exceeded your current
+ * quota …`. We classify the common failure modes (rate limit, auth,
+ * network, context length) into a concise message that tells the user
+ * what happened and what to do, and fall back to the original (trimmed)
+ * text for anything we don't recognize. Pure + tested.
+ */
+function humanizeAiError(raw) {
+    const message = (raw || '').trim();
+    if (!message)
+        return 'AI request failed.';
+    const lower = message.toLowerCase();
+    // Rate limit / quota — the 429 in the screenshot.
+    if (/\b429\b/.test(message) || /rate.?limit|too many requests|exceeded your current quota|quota/i.test(lower)) {
+        return 'Rate limited by your AI provider (429) — too many requests or quota exceeded. Wait a moment, then press I to retry.';
+    }
+    // Auth / API key problems.
+    if (/\b401\b|\b403\b/.test(message) || /unauthor|forbidden|invalid api key|incorrect api key|no api key|authentication/i.test(lower)) {
+        return 'AI provider rejected the request — check your API key (run `coco init`, or press gK to edit the global config).';
+    }
+    // Context window overflow.
+    if (/context length|maximum context|too many tokens|reduce the length|context_length_exceeded/i.test(lower)) {
+        return 'The staged diff is too large for the model’s context window — stage fewer changes (or split the commit) and retry with I.';
+    }
+    // Network / connectivity.
+    if (/etimedout|econnreset|enotfound|econnrefused|network error|fetch failed|socket hang up|timeout/i.test(lower)) {
+        return 'Network error reaching the AI provider — check your connection, then press I to retry.';
+    }
+    // Unknown: strip the noisy `executeChain: Chain execution failed:`
+    // prefix if present so the meaningful part leads, and keep it to one
+    // line so it doesn't blow out the panel.
+    const stripped = message.replace(/^.*?chain execution failed:\s*/i, '').trim() || message;
+    return stripped.split('\n')[0];
+}
+
 async function runAction$4(action, successMessage) {
     try {
         await action();
@@ -30950,15 +31696,104 @@ async function runAction$3(action, successMessage) {
         };
     }
 }
-function createStash(git, message) {
+function createStash(git, message, options = {}) {
     const trimmedMessage = message.trim();
-    if (!trimmedMessage) {
-        return Promise.resolve({
-            ok: false,
-            message: 'Stash cancelled: empty message.',
-        });
+    const args = ['stash', 'push'];
+    // `--staged` is index-only, so untracked / `--keep-index` don't apply;
+    // every other mode includes untracked (`-u`). `--keep-index` leaves the
+    // index populated for an immediate follow-up commit.
+    if (options.stagedOnly) {
+        args.push('--staged');
     }
-    return runAction$3(() => git.raw(['stash', 'push', '-u', '-m', trimmedMessage]), `Created stash: ${trimmedMessage}`);
+    else {
+        args.push('-u');
+        if (options.keepIndex)
+            args.push('--keep-index');
+    }
+    if (trimmedMessage)
+        args.push('-m', trimmedMessage);
+    const paths = options.pathspec?.trim();
+    if (paths)
+        args.push('--', ...paths.split(/\s+/));
+    const what = options.stagedOnly
+        ? 'staged changes'
+        : paths
+            ? `“${paths}”`
+            : options.keepIndex
+                ? 'changes (index kept)'
+                : '';
+    const success = trimmedMessage
+        ? `Created stash: ${trimmedMessage}`
+        : what
+            ? `Stashed ${what}`
+            : 'Created WIP stash';
+    return runAction$3(() => git.raw(args), success);
+}
+/**
+ * Apply a stash while restoring the original staged/unstaged split via
+ * `--index`. Faithfully reinstates what was staged at stash time; git
+ * errors (surfaced to the user) if the index can no longer be replayed,
+ * in which case plain `applyStash` is the fallback.
+ */
+function applyStashKeepIndex(git, stash) {
+    return runAction$3(() => git.raw(['stash', 'apply', '--index', stash.ref]), `Applied ${stash.ref} (index restored)`);
+}
+/**
+ * Create a new branch from a stash's base commit, apply the stash onto
+ * it, and drop the stash on success — `git stash branch`. The canonical
+ * recovery when a stash no longer applies cleanly onto the current
+ * branch (the branch starts at the exact commit the stash was made on).
+ */
+function stashBranch(git, stash, branchName) {
+    const trimmed = branchName.trim();
+    if (!trimmed) {
+        return Promise.resolve({ ok: false, message: 'Cancelled: empty branch name.' });
+    }
+    return runAction$3(() => git.raw(['stash', 'branch', trimmed, stash.ref]), `Created branch ${trimmed} from ${stash.ref}`);
+}
+/**
+ * Rename a stash. Git has no native rename, so: drop the original entry,
+ * then re-store the SAME commit under the new message.
+ *
+ * Order matters — and it's the OPPOSITE of what you'd guess. `git stash
+ * store` SILENTLY NO-OPS when the commit is already referenced in the
+ * stash reflog (verified empirically), so storing first does nothing and
+ * a follow-up drop removes the wrong entry. Dropping first removes the
+ * reflog reference (the commit object survives), so the subsequent
+ * `store` actually re-adds it — landing at `stash@{0}` with the new
+ * message. The commit is captured by hash beforehand, so the drop→store
+ * window can't lose it.
+ */
+function renameStash(git, stash, newMessage) {
+    const trimmed = newMessage.trim();
+    if (!trimmed) {
+        return Promise.resolve({ ok: false, message: 'Rename cancelled: empty message.' });
+    }
+    if (!stash.hash) {
+        return Promise.resolve({ ok: false, message: 'Cannot rename: stash commit hash unavailable.' });
+    }
+    // Preserve git's `On <branch>: <subject>` convention so the renamed
+    // stash keeps its origin-branch context. The list + inspector parse the
+    // branch out of that prefix (`parseStashSubject`); a bare message would
+    // render `on <unknown>`. Falls back to the bare message when the branch
+    // is unknown so we never store a misleading `On <unknown>:`.
+    const branch = stash.branch && stash.branch !== '<unknown>' ? stash.branch : '';
+    const storedMessage = branch ? `On ${branch}: ${trimmed}` : trimmed;
+    return runAction$3(async () => {
+        await git.raw(['stash', 'drop', stash.ref]);
+        await git.raw(['stash', 'store', '-m', storedMessage, stash.hash]);
+    }, `Renamed ${stash.ref} → ${trimmed}`);
+}
+/**
+ * Re-store a previously dropped stash by its commit hash — the undo for
+ * a `dropStash`. The dropped stash's commit stays in the object database
+ * until git gc, so storing it back recreates the entry (at `stash@{0}`).
+ */
+function restoreStash(git, hash, message) {
+    if (!hash) {
+        return Promise.resolve({ ok: false, message: 'Nothing to restore.' });
+    }
+    return runAction$3(() => git.raw(['stash', 'store', '-m', message || 'restored stash', hash]), 'Restored dropped stash');
 }
 function applyStash(git, stash) {
     return runAction$3(() => git.raw(['stash', 'apply', stash.ref]), `Applied ${stash.ref}`);
@@ -31580,13 +32415,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 {
@@ -31831,6 +32667,28 @@ function unstageAllFiles(git, files) {
     }
     return runAction(() => git.raw(['restore', '--staged', '--', ...files.map((file) => file.path)]), `Unstaged ${files.length} ${files.length === 1 ? 'file' : 'files'}`);
 }
+/**
+ * Stage everything in the worktree — modifications, new files, and
+ * deletions — in one shot (`git add -A`). The `A` hotkey + the `:`
+ * palette's "stage all" both route here.
+ */
+function stageAll(git) {
+    return runAction(() => git.raw(['add', '-A']), 'Staged all changes');
+}
+/**
+ * Stage files matching one or more git pathspecs (`git add -- <spec…>`).
+ * Powers the typed "stage…" prompt (`+`): the user types a path, a
+ * directory, a glob like `*.ts`, or a space-separated list, and git's
+ * own pathspec matching does the rest. Args are passed directly (no
+ * shell), so the globs are interpreted by git, not the shell.
+ */
+function stagePathspec(git, pathspec) {
+    const specs = pathspec.trim().split(/\s+/).filter(Boolean);
+    if (specs.length === 0) {
+        return Promise.resolve({ ok: false, message: 'Enter a pathspec to stage (e.g. . or src/ or *.ts).' });
+    }
+    return runAction(() => git.raw(['add', '--', ...specs]), `Staged ${specs.join(' ')}`);
+}
 
 function hunkHeader(hunk) {
     return `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`;
@@ -32407,7 +33265,7 @@ function buildLoadedHashSet(commits) {
  * 5a.7 of #890. Two-row layout introduced post-0.54.2; per-kind
  * colors + glyphs added in the same pass.
  */
-function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFrame = 0) {
+function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFrame = 0, singlePane = false) {
     const { Box, Text } = components;
     // Sidebar item count drives the per-tab footer hints — when items are
     // present the footer surfaces in-sidebar ops (checkout / apply / pop /
@@ -32421,6 +33279,24 @@ function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFr
             default: return undefined;
         }
     })();
+    // The single-pane pane switcher only makes sense in the plain
+    // per-pane states. While an overlay or filter owns the screen the
+    // visible pane is forced (split-plan → main; help / palette / theme /
+    // gitignore / input prompt / confirmation / chord → inspector) or
+    // input is captured, and Tab does something else — so the switcher
+    // would point at a pane that isn't on screen. Suppress it then. Mirror
+    // of the runtime's `forcedPane` derivation in `app.ts`.
+    const overlayForcesPane = Boolean(state.splitPlan ||
+        state.showHelp ||
+        state.showViewKeys ||
+        state.showCommandPalette ||
+        state.showThemePicker ||
+        state.gitignorePicker ||
+        state.inputPrompt ||
+        state.pendingConfirmationId ||
+        state.pendingMutationConfirmation ||
+        state.pendingKey ||
+        state.filterMode);
     const hints = getLogInkFooterHints({
         activeView: state.activeView,
         diffSource: state.diffSource,
@@ -32434,6 +33310,12 @@ function renderFooter$1(h, components, state, context, theme, idleTip, spinnerFr
         sidebarItemCount,
         compareBaseSet: Boolean(state.compareBase),
         splitPlanStatus: state.splitPlan?.status,
+        singlePane: singlePane && !overlayForcesPane,
+        // Peeking (#1135 v2) is a single-pane glance with focus on the
+        // sidebar; the footer shows `v/esc → main` instead of the switcher.
+        // Suppressed under an overlay (which owns the footer) just like the
+        // switcher.
+        peeking: Boolean(state.peekReturnFocus) && singlePane && !overlayForcesPane,
     });
     // Real status messages always win; idle tips only fill the slot when it
     // would otherwise be empty.
@@ -32929,7 +33811,10 @@ function sidebarTabCount(tab, context) {
  * Header chip builder. Turns the workstation's title-bar state into an
  * ordered list of small visually-distinct chips:
  *
- *   coco · gfargo/coco · ⎇ main · ✓ clean · ⊘ no PR · [NORMAL]
+ *   coco · gfargo/coco · ⎇ main · ✓ clean · [NORMAL]
+ *
+ * The PR chip is appended only when a pull request exists (#1133); there
+ * is no "no PR" placeholder chip.
  *
  * Pre-refactor the title bar concatenated every segment into a single
  * Text span, which made the eye read the whole thing as one run of
@@ -33025,10 +33910,11 @@ function buildHeaderChips(input) {
             bold: true,
         });
     }
-    // PR state. When present, the chip uses the PR-state glyph + a short
-    // label ("PR #1234 OPEN" / "PR #1234 DRAFT"). When absent, a muted
-    // "no PR" chip so users know the system DID look (vs. the bar just
-    // being blank).
+    // PR state. Shown only when a PR actually exists — the chip uses the
+    // PR-state glyph + a short label ("PR #1234 OPEN" / "PR #1234 DRAFT").
+    // The old always-on "no PR" chip spent a permanent header segment to
+    // report a negative default state on every screen; dropping it keeps
+    // the state cluster about what *is* true (TUI audit).
     if (input.pullRequest) {
         const prGlyph = getPullRequestStateGlyph({ ...input.pullRequest, isDraft: Boolean(input.pullRequest.isDraft) }, theme);
         const stateLabel = input.pullRequest.isDraft
@@ -33045,15 +33931,6 @@ function buildHeaderChips(input) {
             bold: false,
         });
     }
-    else {
-        chips.push({
-            id: 'pr',
-            label: theme.ascii ? '- no PR' : '⊘ no PR',
-            color: theme.colors.muted,
-            dim: true,
-            bold: false,
-        });
-    }
     // View breadcrumb. Rendered only when there's content (`coco ui`
     // root view → no breadcrumb chip; pushed into a sub-view → chip
     // appears). Comes AFTER PR so the "state" group (app/repo/branch/
@@ -33124,7 +34001,10 @@ function measureHeaderChipsWidth(chips) {
  * Title-bar renderer. Surfaces the workstation's identity + navigation
  * state as a row of small visually-distinct chips:
  *
- *   coco · gfargo/coco · ⎇ main · ✓ clean · ⊘ no PR · [NORMAL]
+ *   coco · gfargo/coco · ⎇ main · ✓ clean · [NORMAL]
+ *
+ * The PR chip is appended only when a pull request exists (e.g.
+ * `· ⊠ PR #1234 OPEN`); there's no "no PR" placeholder chip.
  *
  * Per-chip color/glyph treatment lets the user scan in chunks ("what
  * app, what repo, what branch, how clean, what PR state, what mode")
@@ -33564,70 +34444,10 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         return `${marker} ${worktree.branch || worktree.path} ${wstate}`;
     }, 'tab-worktrees', visibleListCount);
 }
-/**
- * Single-letter glyph for a sidebar tab in rail mode. Letters always
- * carry the meaning so this stays useful under ASCII; the rail is too
- * narrow to fit the full tab label. Pairs with `sidebarTabCount` for
- * the trailing count.
- */
-function sidebarTabRailGlyph(tab) {
-    switch (tab) {
-        case 'status':
-            return 'S';
-        case 'branches':
-            return 'B';
-        case 'tags':
-            return 'T';
-        case 'stashes':
-            return '$';
-        case 'worktrees':
-            return 'W';
-        default:
-            return '·';
-    }
-}
-/**
- * Rail-mode sidebar — shown on terminals < 100 columns when the
- * sidebar does not hold focus. Five vertically stacked tab glyphs
- * with optional counts; the active tab is bracketed. Pressing Tab to
- * focus the sidebar pops it back to the full accordion (the layout
- * un-rails it on focus, this renderer is never called in that case).
- */
-function renderSidebarRail$1(h, components, state, context, width, theme, focused, tabs) {
-    const { Box, Text } = components;
-    return h(Box, {
-        borderColor: focusBorderColor(theme, focused),
-        borderStyle: theme.borderStyle,
-        flexDirection: 'column',
-        width,
-        paddingX: 1,
-    }, h(Text, { bold: true, dimColor: !focused }, 'Repo'), h(Text, { dimColor: true }, '────'), ...tabs.map((tab) => {
-        const isActive = tab === state.sidebarTab;
-        const glyph = sidebarTabRailGlyph(tab);
-        const count = sidebarTabCount(tab, context);
-        // Count fits in 2 cells (rail content area is ~4 cells); 99+
-        // collapses to `+` so we never overflow.
-        const countText = count === undefined
-            ? ''
-            : count > 99
-                ? '+'
-                : String(count);
-        const body = isActive ? `[${glyph}]` : ` ${glyph} `;
-        const text = countText ? `${body}${countText}` : body;
-        return h(Text, {
-            key: `rail-${tab}`,
-            bold: isActive,
-            dimColor: !isActive,
-        }, text);
-    }));
-}
-function renderSidebar$1(h, components, state, context, contextStatus, width, bodyRows, theme, railed = false) {
+function renderSidebar$1(h, components, state, context, contextStatus, width, bodyRows, theme) {
     const { Box, Text } = components;
     const focused = state.focus === 'sidebar';
     const tabs = getLogInkSidebarTabs();
-    if (railed) {
-        return renderSidebarRail$1(h, components, state, context, width, theme, focused, tabs);
-    }
     // Accordion layout — every tab's title is visible on its own line, but
     // only the active tab expands its content underneath. Switching tabs
     // (1-5 / [/]) collapses the previous and expands the next.
@@ -33686,7 +34506,8 @@ function renderSidebar$1(h, components, state, context, contextStatus, width, bo
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderBisectSurface(h, components, state, context, contextStatus, candidateDetail, candidateLoading, bodyRows, width, theme) {
+function renderBisectSurface(ctx, candidateDetail, candidateLoading) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'bisect');
@@ -34010,7 +34831,8 @@ function formatLogInkGitHubNoRemote({ resource, }) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderBranchesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderBranchesSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const branches = context.branches;
@@ -34156,7 +34978,8 @@ function formatCacheAge(generatedAt, now) {
     const day = Math.floor(hr / 24);
     return `${day}d ago`;
 }
-function renderChangelogSurface(h, components, state, _context, _contextStatus, bodyRows, width, theme) {
+function renderChangelogSurface(ctx) {
+    const { h, components, state, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const view = state.changelogView;
@@ -34348,7 +35171,8 @@ function renderStreamingPreviewLines(h, components, preview, width, theme) {
         }, `${prefix}${line}`);
     });
 }
-function renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme, spinnerFrame = 0) {
+function renderComposeSurface(ctx, spinnerFrame = 0) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const compose = state.commitCompose;
     const focused = state.focus === 'commits';
@@ -34369,8 +35193,16 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
     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.
@@ -34390,6 +35222,52 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
     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,
@@ -34397,20 +35275,7 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
         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
@@ -34461,7 +35326,8 @@ function renderComposeSurface(h, components, state, context, contextStatus, body
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.3
  * of #890. No behavior change.
  */
-function renderConflictsSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderConflictsSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'operation');
@@ -34930,6 +35796,50 @@ function renderDiffLine(h, Text, line, theme, syntaxSpans, maxCells, key) {
     return h(Text, { key }, h(Text, { key: `${key}-m`, color: markerColor }, marker), ...children);
 }
 
+/** The hunk index owning `absLine`, or -1 for pre-hunk header/label rows. */
+function hunkIndexForLine(absLine, hunkOffsets) {
+    let index = -1;
+    for (let k = 0; k < hunkOffsets.length; k++) {
+        if (hunkOffsets[k] <= absLine)
+            index = k;
+        else
+            break;
+    }
+    return index;
+}
+function renderWorktreeDiffBody(h, components, params) {
+    const { Box, Text } = components;
+    const { lines, offset, visibleRows, width, theme, syntaxSpans, hunkOffsets, hunks, selectedIndex, keyPrefix } = params;
+    const headerSet = new Set(hunkOffsets);
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const added = theme.noColor ? undefined : theme.colors.gitAdded;
+    const codeWidth = Math.max(8, width - 5); // 2 chrome + 1 gutter + slack
+    const visible = lines.slice(offset, offset + visibleRows);
+    return visible.map((line, i) => {
+        const abs = offset + i;
+        const key = `${keyPrefix}-${abs}`;
+        const hunkIndex = hunkIndexForLine(abs, hunkOffsets);
+        const hunk = hunkIndex >= 0 ? hunks[hunkIndex] : undefined;
+        const isSelected = hunkIndex >= 0 && hunkIndex === selectedIndex;
+        const isStaged = hunk?.state === 'staged';
+        const bar = isSelected ? '▎' : ' ';
+        // `@@` header row — badge + (dim) hunk position, emphasized when selected.
+        if (headerSet.has(abs)) {
+            const badge = theme.ascii ? (isStaged ? '[x] ' : '[ ] ') : (isStaged ? '● ' : '○ ');
+            const badgeColor = theme.noColor ? undefined : isStaged ? added : theme.colors.muted;
+            return h(Box, { key, flexDirection: 'row' }, h(Text, { color: accent }, bar), h(Text, { color: badgeColor, bold: isSelected }, badge), h(Text, { bold: isSelected, color: isSelected ? accent : (theme.noColor ? undefined : theme.colors.muted) }, truncateCells(line, codeWidth)));
+        }
+        // Body / context / pre-hunk lines.
+        // A staged hunk that ISN'T selected renders dim ("done", out of
+        // focus); the selected hunk and unstaged hunks keep full diff +
+        // syntax coloring via renderDiffLine so the focus stays vivid.
+        const content = isStaged && !isSelected && hunkIndex >= 0
+            ? h(Text, { key: `${key}-c`, dimColor: true }, truncateCells(line, codeWidth))
+            : renderDiffLine(h, Text, line, theme, syntaxSpans, codeWidth, `${key}-c`);
+        return h(Box, { key, flexDirection: 'row' }, h(Text, { color: accent }, bar), content);
+    });
+}
+
 /**
  * Diff surface — the unified or side-by-side diff view. Four sources
  * route through here, disambiguated by `state.diffSource`:
@@ -34952,7 +35862,9 @@ function renderDiffLine(h, Text, line, theme, syntaxSpans, maxCells, key) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.4
  * of #890. No behavior change.
  */
-function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme, syntaxSpans) {
+function renderDiffSurface(ctx, diff) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
+    const { worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, syntaxSpans, } = diff;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -35152,7 +36064,22 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
     }
     const diffLines = worktreeDiff?.lines || [];
     const selectedHunk = worktreeHunks?.hunks[state.selectedWorktreeHunkIndex];
+    const totalHunks = worktreeHunks?.hunks.length ?? 0;
+    const stagedHunks = worktreeHunks?.hunks.filter((hunk) => hunk.state === 'staged').length ?? 0;
     const visibleDiffLines = diffLines.slice(state.worktreeDiffOffset, state.worktreeDiffOffset + visibleRows);
+    // Hunk-position line: badge + selected hunk's state + a staged/total
+    // progress count, so the user always sees how far through staging they
+    // are. Untracked/new files have no hunks — point them at whole-file
+    // staging instead of a dead-end "no hunks" message.
+    const hunkHeaderLine = worktreeHunksLoading
+        ? 'Hunks loading…'
+        : worktreeDiff?.untracked
+            ? (theme.ascii ? 'New file — press space to stage it whole.' : '✚ New file — press space to stage it whole.')
+            : totalHunks
+                ? `Hunk ${state.selectedWorktreeHunkIndex + 1}/${totalHunks} · ${selectedHunk?.state === 'staged'
+                    ? (theme.ascii ? '[x] staged' : '● staged')
+                    : (theme.ascii ? '[ ] unstaged' : '○ unstaged')} · ${stagedHunks}/${totalHunks} staged`
+                : 'No stageable hunks for this file.';
     const headerLines = isLogInkContextKeyLoading(contextStatus, 'worktree')
         ? ['Loading file context...']
         : worktreeDiffLoading
@@ -35161,11 +36088,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
                 ? [
                     // File path is already shown in the panel title bar (right) —
                     // no redundant "Selected file:" line here.
-                    worktreeHunksLoading
-                        ? 'Hunks loading...'
-                        : worktreeHunks?.hunks.length
-                            ? `Hunk ${state.selectedWorktreeHunkIndex + 1}/${worktreeHunks.hunks.length} ${selectedHunk?.state || ''}`
-                            : 'No stageable hunks for this file.',
+                    hunkHeaderLine,
                     `Lines ${Math.min(state.worktreeDiffOffset + 1, diffLines.length || 1)}-${Math.min(state.worktreeDiffOffset + visibleDiffLines.length, diffLines.length)}/${diffLines.length}`,
                     '',
                 ]
@@ -35180,11 +36103,26 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         flexShrink: 0,
         paddingX: 1,
         width,
-    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Diff', focused)), h(Text, { dimColor: true }, worktreeFile ? worktreeFile.path : 'no file')), ...headerLines.map((line, index) => h(Text, {
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Diff', focused)), 
+    // Use the path of the file actually being diffed (the grouped/visible
+    // selection feeds the loaded diff) — `worktreeFile` indexes the raw,
+    // ungrouped file list and can name a different file than the diff body.
+    h(Text, { dimColor: true }, worktreeDiff?.filePath || worktreeFile?.path || 'no file')), ...headerLines.map((line, index) => h(Text, {
         key: `diff-surface-header-${index}`,
         dimColor: index > 0,
     }, truncateCells(line, 140))), ...(showDiffLines
-        ? visibleDiffLines.map((line, index) => renderDiffLine(h, Text, line, theme, syntaxSpans, 140, `diff-surface-line-${state.worktreeDiffOffset + index}`))
+        ? renderWorktreeDiffBody(h, components, {
+            lines: diffLines,
+            offset: state.worktreeDiffOffset,
+            visibleRows,
+            width,
+            theme,
+            syntaxSpans,
+            hunkOffsets: worktreeDiff?.hunkOffsets || [],
+            hunks: worktreeHunks?.hunks || [],
+            selectedIndex: state.selectedWorktreeHunkIndex,
+            keyPrefix: 'diff-surface-line',
+        })
         : []));
 }
 
@@ -36368,7 +37306,8 @@ function renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focu
         height: innerHeight,
     }, h(Text, { color: accent, bold: true }, `${spinner}  ${op.label}`), h(Text, undefined, ''), h(Text, { color: accent }, track), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Talking to the remote — history refreshes automatically.')));
 }
-function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
+function renderHistoryPanel(ctx, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
+    const { h, components, state, context, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     // Remote op in flight (fetch / pull / push) → swap the commit list
@@ -36674,6 +37613,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).
@@ -37070,7 +38057,8 @@ function matchesIssueFilter(issue, filter) {
         ...(issue.assignees || []),
     ], filter);
 }
-function renderIssuesTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderIssuesTriageSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const overview = context.issueList;
@@ -37352,7 +38340,8 @@ function formatPullRequestStateLine(pr) {
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.2
  * of #890. No behavior change.
  */
-function renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderPullRequestSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'pullRequest');
@@ -37525,7 +38514,8 @@ function matchesPullRequestFilter(pr, filter) {
         ...(pr.assignees || []),
     ], filter);
 }
-function renderPullRequestTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderPullRequestTriageSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const overview = context.pullRequestList;
@@ -37641,7 +38631,8 @@ function renderPullRequestTriageSurface(h, components, state, context, contextSt
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderReflogSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderReflogSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'reflog');
@@ -37712,7 +38703,8 @@ function renderReflogSurface(h, components, state, context, contextStatus, bodyR
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderStashSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'stashes');
@@ -37730,6 +38722,11 @@ function renderStashSurface(h, components, state, context, contextStatus, bodyRo
         : `${stashes.length}/${allStashes.length} stashes${filterLabel}`;
     const emptyLabel = formatLogInkStashEmpty({ filter: state.filter });
     const loadingLabel = formatLogInkLoading({ resource: 'stashes' });
+    const now = getRenderNow();
+    // Available width for a row: box width minus the 2-cell horizontal
+    // padding. Truncate to it (with a small floor) instead of a magic 140
+    // so the richer meta degrades gracefully on narrow terminals.
+    const rowWidth = Math.max(20, width - 2);
     const lines = loading
         ? [h(Text, { key: 'stash-loading', dimColor: true }, loadingLabel)]
         : stashes.length === 0
@@ -37738,11 +38735,25 @@ function renderStashSurface(h, components, state, context, contextStatus, bodyRo
                 const index = startIndex + offset;
                 const isSelected = index === selected;
                 const cursor = isSelected ? '>' : ' ';
+                // Surface the metadata the StashEntry already carries — origin
+                // branch, file count, and relative age — between the ref and the
+                // message, so the list answers "which stash is this?" without an
+                // Enter→diff round trip.
+                const age = formatCompactRelativeDate(stash.date, now);
+                const fileCount = stash.files.length;
+                const meta = [
+                    stash.branch ? `on ${stash.branch}` : '',
+                    fileCount > 0 ? `${fileCount} file${fileCount === 1 ? '' : 's'}` : '',
+                    age,
+                ].filter(Boolean).join(' · ');
+                const rowText = meta
+                    ? `${cursor} ${stash.ref.padEnd(11)} ${meta}  ${stash.message}`
+                    : `${cursor} ${stash.ref.padEnd(11)} ${stash.message}`;
                 return h(Text, {
                     key: `stash-${index}`,
                     bold: isSelected,
                     dimColor: !isSelected,
-                }, truncateCells(`${cursor} ${stash.ref.padEnd(12)} ${stash.message}`, 140));
+                }, truncateCells(rowText, rowWidth));
             });
     const stashHasMoreAbove = startIndex > 0 && stashes.length > 0;
     const stashHasMoreBelow = startIndex + listRows < stashes.length;
@@ -37802,7 +38813,8 @@ function formatStatusFilterMask(mask) {
         active.push('untracked');
     return active.join(' + ') || 'none';
 }
-function renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderStatusSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -37949,7 +38961,8 @@ function flagColor(flag, theme) {
         return theme.colors.danger;
     return undefined;
 }
-function renderSubmodulesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderSubmodulesSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'submodules');
@@ -38088,7 +39101,8 @@ 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(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderTagsSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'tags');
@@ -38170,7 +39184,8 @@ function renderTagsSurface(h, components, state, context, contextStatus, bodyRow
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.1
  * of #890. No behavior change.
  */
-function renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+function renderWorktreesSurface(ctx) {
+    const { h, components, state, context, contextStatus, bodyRows, width, theme } = ctx;
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const loading = isLogInkContextKeyLoading(contextStatus, 'worktreeList');
@@ -38234,7 +39249,12 @@ function renderWorktreesSurface(h, components, state, context, contextStatus, bo
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.7
  * of #890. No behavior change.
  */
-function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, density, rowMode, dateBucketingEnabled, syntaxSpans) {
+function renderMainPanel(surface, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, hasMoreCommits, loadingMoreCommits, spinnerFrame, density, rowMode, dateBucketingEnabled, syntaxSpans) {
+    // The universal render values now arrive bundled (#1136); only the
+    // few raw values the dispatcher itself touches (split-plan overlay,
+    // activeView switch) are destructured here. Surfaces receive `surface`
+    // directly plus their own slices.
+    const { h, components, state, bodyRows, width, theme } = surface;
     // Split-plan overlay (#907 polish): renders in the MAIN panel (not
     // detail) when active, because the content — multiple commit groups
     // with file lists, rationale, hunks — needs the full center width
@@ -38246,51 +39266,66 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
         return renderSplitPlanOverlay(h, components, state, width, bodyRows, theme, true, spinnerFrame);
     }
     if (state.activeView === 'status') {
-        return renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderStatusSurface(surface);
     }
     if (state.activeView === 'diff') {
-        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme, syntaxSpans);
+        const diffData = {
+            worktreeDiff,
+            worktreeDiffLoading,
+            worktreeHunks,
+            worktreeHunksLoading,
+            filePreview,
+            filePreviewLoading,
+            commitDiffHunkOffsets,
+            selectedDetailFile,
+            stashDiffLines,
+            stashDiffLoading,
+            compareDiffLines,
+            compareDiffLoading,
+            syntaxSpans,
+        };
+        return renderDiffSurface(surface, diffData);
     }
     if (state.activeView === 'compose') {
-        return renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme, spinnerFrame);
+        return renderComposeSurface(surface, spinnerFrame);
     }
     if (state.activeView === 'branches') {
-        return renderBranchesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderBranchesSurface(surface);
     }
     if (state.activeView === 'tags') {
-        return renderTagsSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderTagsSurface(surface);
     }
     if (state.activeView === 'reflog') {
-        return renderReflogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderReflogSurface(surface);
     }
     if (state.activeView === 'bisect') {
-        return renderBisectSurface(h, components, state, context, contextStatus, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme);
+        return renderBisectSurface(surface, bisectCandidateDetail, bisectCandidateLoading);
     }
     if (state.activeView === 'stash') {
-        return renderStashSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderStashSurface(surface);
     }
     if (state.activeView === 'worktrees') {
-        return renderWorktreesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderWorktreesSurface(surface);
     }
     if (state.activeView === 'submodules') {
-        return renderSubmodulesSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderSubmodulesSurface(surface);
     }
     if (state.activeView === 'pull-request') {
-        return renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderPullRequestSurface(surface);
     }
     if (state.activeView === 'pull-request-triage') {
-        return renderPullRequestTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderPullRequestTriageSurface(surface);
     }
     if (state.activeView === 'issues') {
-        return renderIssuesTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderIssuesTriageSurface(surface);
     }
     if (state.activeView === 'conflicts') {
-        return renderConflictsSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderConflictsSurface(surface);
     }
     if (state.activeView === 'changelog') {
-        return renderChangelogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+        return renderChangelogSurface(surface);
     }
-    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
+    return renderHistoryPanel(surface, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
 }
 
 /**
@@ -39163,21 +40198,16 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
     const bodyVisualLines = bodyHasContent
         ? compose.body.split('\n').flatMap((line) => wrapCells(line, bodyTextWidth)).slice(0, 12)
         : ['<empty>'];
-    const summaryWrapped = wrapCells(`${compose.summary || '<empty>'}${summaryCursor}`, bodyTextWidth);
-    const summaryFirst = `${compose.field === 'summary' && compose.editing ? '>' : ' '} Summary: ${summaryWrapped[0] || ''}`;
-    const summaryRest = summaryWrapped.slice(1).map((line) => `           ${line}`);
-    const headerLines = [
-        statusLine,
-        '',
-        summaryFirst,
-        ...summaryRest,
-        `${compose.field === 'body' && compose.editing ? '>' : ' '} Body:`,
-        ...bodyVisualLines.map((line, index) => {
-            const isLast = index === bodyVisualLines.length - 1;
-            return `  ${line}${bodyCursor && isLast ? bodyCursor : ''}`;
-        }),
-        '',
-    ];
+    const hasSummary = Boolean(compose.summary);
+    const summaryMarker = compose.field === 'summary' && compose.editing ? '>' : ' ';
+    const bodyMarker = compose.field === 'body' && compose.editing ? '>' : ' ';
+    // The generated subject is the thing the user is looking for — render
+    // it bold + accent so it pops out of the inspector instead of blending
+    // into the dim label/body text. The `Summary:` label stays dim.
+    const summaryLabel = `${summaryMarker} Summary: `;
+    const summaryColor = hasSummary && !theme.noColor ? theme.colors.accent : undefined;
+    const summaryValueWidth = Math.max(4, width - 4 - cellWidth(summaryLabel));
+    const summaryWrapped = wrapCells(`${compose.summary || '<empty>'}${summaryCursor}`, summaryValueWidth);
     const trailerLines = [
         ...(compose.message ? ['', compose.message] : []),
         ...(compose.details || []).map((line) => `  ${line}`),
@@ -39191,10 +40221,26 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
         flexDirection: 'column',
         width,
         paddingX: 1,
-    }, h(Text, { bold: true }, panelTitle('Commit', focused)), ...headerLines.map((line, index) => h(Text, {
-        key: `commit-header-${index}`,
-        dimColor: index < 2 || line.startsWith('  ') || line === '<empty>',
-    }, truncateCells(line, width - 4))), 
+    }, h(Text, { bold: true }, panelTitle('Commit', focused)), h(Text, { key: 'commit-status', dimColor: true }, truncateCells(statusLine, width - 4)), h(Text, { key: 'commit-spacer-1' }, ''), 
+    // Summary: dim label + the subject value emphasized so it's easy to spot.
+    h(Text, { key: 'commit-summary' }, h(Text, { dimColor: true }, summaryLabel), h(Text, {
+        bold: hasSummary,
+        color: summaryColor,
+        dimColor: !hasSummary,
+    }, summaryWrapped[0] || '<empty>')), ...summaryWrapped.slice(1).map((line, index) => h(Text, {
+        key: `commit-summary-rest-${index}`,
+        bold: true,
+        color: summaryColor,
+    }, truncateCells(`${' '.repeat(cellWidth(summaryLabel))}${line}`, width - 4))), h(Text, {
+        key: 'commit-body-label',
+        dimColor: !(compose.field === 'body' && compose.editing),
+    }, truncateCells(`${bodyMarker} Body:`, width - 4)), ...bodyVisualLines.map((line, index) => {
+        const isLast = index === bodyVisualLines.length - 1;
+        return h(Text, {
+            key: `commit-body-${index}`,
+            dimColor: true,
+        }, truncateCells(`  ${line}${bodyCursor && isLast ? bodyCursor : ''}`, width - 4));
+    }), h(Text, { key: 'commit-spacer-2' }, ''), 
     // Loading indicator + commit result/details stay inline with the body
     // (they describe what just happened to the fields above). The action
     // hint ("e edit | c commit | I AI draft") moves to the bottom of the
@@ -39285,44 +40331,20 @@ function renderPullRequestTriagePreviewPanel(h, components, state, context, cont
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.7
  * of #890. No behavior change.
  */
-/**
- * Rail-mode inspector — shown on terminals < 100 columns when the
- * detail panel does not hold focus. The full inspector (commit body,
- * file list, actions) does not survive truncation to ~4 content cells
- * so we collapse to a stack with the panel label and the selected
- * commit's shortHash. Focus pops the panel back to its expanded
- * widths via the layout, so this renderer is only reached at rest.
- *
- * Help / overlay states are still handled by their own renderers
- * above; this short-circuit only kicks in for the regular "view the
- * commit" cases.
- */
-function renderInspectorRail(h, components, state, detail, width, theme, focused) {
-    const { Box, Text } = components;
-    // Prefer the loaded detail's hash (canonical) but fall back to the
-    // selected list row's shortHash so the rail isn't blank on the
-    // first render before getCommitDetail resolves.
-    const selectedRow = getSelectedInkCommit(state);
-    const hashText = detail?.hash.slice(0, 4)
-        ?? selectedRow?.shortHash.slice(0, 4)
-        ?? '····';
-    return h(Box, {
-        borderColor: focusBorderColor(theme, focused),
-        borderStyle: theme.borderStyle,
-        flexDirection: 'column',
-        width,
-        paddingX: 1,
-    }, h(Text, { bold: true, dimColor: !focused }, panelTitle('Insp', focused)), h(Text, { dimColor: true }, '────'), h(Text, { color: theme.noColor ? undefined : theme.colors.accent }, hashText));
-}
-function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, railed = false, bodyRows = 0) {
+function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, bodyRows = 0) {
     const focused = state.focus === 'detail';
     // Overlays (help / palette / input / confirmation / chord) take
-    // precedence over rail because they always claim the panel's width
-    // via the help-overlay layout branch — and railing those would
-    // defeat their whole purpose (the user is reading them).
+    // precedence over every per-view surface because they claim the
+    // panel's full width via the help-overlay layout branch.
     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);
     }
@@ -39351,15 +40373,6 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.pendingKey && !state.splitPlan) {
         return renderChordOverlay(h, components, state, width, theme, focused);
     }
-    // Rail mode applies only after every overlay above has had its say
-    // — those would all be unreadable at 4 cells of content. The layout
-    // also clears `railed` whenever the inspector takes focus, so we
-    // can safely short-circuit the per-view dispatch here without
-    // worrying about hiding the panel from a user who's actively
-    // reading it.
-    if (railed) {
-        return renderInspectorRail(h, components, state, detail, width, theme, focused);
-    }
     // The synthetic "(+) new commit" row routes the inspector through the
     // worktree summary so the user sees what's staged / unstaged at a glance
     // — same surface as the compose view's right panel.
@@ -39409,6 +40422,43 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     return renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, focused);
 }
 
+/**
+ * Runtime React Context for the workstation (#1136).
+ *
+ * The render layer currently drills `state` / `dispatch` / `theme` /
+ * `layout` / `context` through every `render*Surface` signature, so
+ * adding a feature repeatedly means threading one more value through
+ * `app → mainPanel → render<View>Surface`. This Context is the single
+ * place those five values live; surfaces read what they need from it
+ * instead of receiving 10–15 positional props.
+ *
+ * Why a factory (`getLogInkRuntimeContext(React)`) instead of a plain
+ * module-level `React.createContext(...)`: the workstation never
+ * statically imports React. `ink` + `react` are ESM-only and loaded via
+ * dynamicImport at boot (see `inkRuntime.ts`), so the rest of the
+ * codebase compiles without bundling them. The Context object must be
+ * built from that same runtime React instance — the one that renders
+ * the tree and the one a consumer's `useContext` reads from have to be
+ * identical. There is exactly one React instance per process, so we
+ * lazily create the Context on first use and cache it; `LogInkApp`'s
+ * provider and (in later PRs) the surface consumers all share the one
+ * identity.
+ */
+let cachedContext = null;
+/**
+ * Lazily create (and thereafter return) the process-wide
+ * `LogInkRuntimeContext`, bound to the runtime React instance. Pass the
+ * same `React` the tree is rendered with — `LogInkApp` uses `deps.React`;
+ * tests use the statically-imported `react`.
+ */
+function getLogInkRuntimeContext(React) {
+    if (!cachedContext) {
+        cachedContext = React.createContext(null);
+        cachedContext.displayName = 'LogInkRuntimeContext';
+    }
+    return cachedContext;
+}
+
 /**
  * Resolve + scaffold the coco config files the workstation can open in
  * `$EDITOR` (the `gk` / `gK` chords and their command-palette entries).
@@ -39892,6 +40942,10 @@ function LogInkApp(deps) {
     const loadingMoreCommitsRef = React.useRef(false);
     const loadMoreRequestRef = React.useRef(0);
     const mountedRef = React.useRef(true);
+    // Last dropped stash {hash, message}, captured before `drop-stash` runs
+    // so `undo-drop-stash` can re-store it. The dropped commit survives in
+    // the object DB until gc, so the hash is enough to bring it back.
+    const lastDroppedStashRef = React.useRef(null);
     // P4.3 — idle tip rotation. tickIndex 0 ⇒ no tip; the hook bumps it after
     // a grace window of empty statusMessage and then on a steady cadence, so
     // the footer surfaces a different hint every interval until the user does
@@ -40196,6 +41250,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
@@ -41058,7 +42116,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,
@@ -41135,11 +42200,15 @@ function LogInkApp(deps) {
                 dispatch({ type: 'setStatus', value: 'AI draft ready for editing', kind: 'success' });
                 return;
             }
+            // Humanize provider errors (rate limit / auth / context / network)
+            // into a short actionable line; success-but-no-draft keeps its
+            // message as-is.
+            const composeMessage = result.ok ? result.message : humanizeAiError(result.message);
             dispatch({
                 type: 'commitCompose',
-                action: { type: 'setResult', message: result.message, details: result.details },
+                action: { type: 'setResult', message: composeMessage, details: result.details },
             });
-            dispatch({ type: 'setStatus', value: result.message });
+            dispatch({ type: 'setStatus', value: composeMessage, kind: result.ok ? undefined : 'error' });
         }
         catch (error) {
             // Audit finding #3: defensive recovery for unexpected throws
@@ -42110,8 +43179,20 @@ function LogInkApp(deps) {
                 const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
                 if (!stash)
                     return { ok: false, message: 'No stash selected' };
+                // Remember the dropped commit so `u` can undo it.
+                if (stash.hash)
+                    lastDroppedStashRef.current = { hash: stash.hash, message: stash.message };
                 return dropStash(git, stash);
             },
+            'undo-drop-stash': async () => {
+                const dropped = lastDroppedStashRef.current;
+                if (!dropped)
+                    return { ok: false, message: 'Nothing to undo — no stash dropped this session' };
+                const result = await restoreStash(git, dropped.hash, dropped.message);
+                if (result.ok)
+                    lastDroppedStashRef.current = null;
+                return result;
+            },
             'apply-stash': async () => {
                 const all = context.stashes?.stashes || [];
                 const visible = state.filter
@@ -42122,6 +43203,16 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No stash selected' };
                 return applyStash(git, stash);
             },
+            'apply-stash-index': async () => {
+                const all = context.stashes?.stashes || [];
+                const visible = state.filter
+                    ? all.filter((s) => matchesPromotedFilter([s.ref, s.message], state.filter))
+                    : all;
+                const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
+                if (!stash)
+                    return { ok: false, message: 'No stash selected' };
+                return applyStashKeepIndex(git, stash);
+            },
             'pop-stash': async () => {
                 const all = context.stashes?.stashes || [];
                 const visible = state.filter
@@ -42132,6 +43223,26 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No stash selected' };
                 return popStash(git, stash);
             },
+            'rename-stash': async () => {
+                const all = context.stashes?.stashes || [];
+                const visible = state.filter
+                    ? all.filter((s) => matchesPromotedFilter([s.ref, s.message], state.filter))
+                    : all;
+                const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
+                if (!stash)
+                    return { ok: false, message: 'No stash selected' };
+                return renameStash(git, stash, payload ?? '');
+            },
+            'stash-branch': async () => {
+                const all = context.stashes?.stashes || [];
+                const visible = state.filter
+                    ? all.filter((s) => matchesPromotedFilter([s.ref, s.message], state.filter))
+                    : all;
+                const stash = visible[Math.min(state.selectedStashIndex, visible.length - 1)];
+                if (!stash)
+                    return { ok: false, message: 'No stash selected' };
+                return stashBranch(git, stash, payload ?? '');
+            },
             'bisect-good': async () => {
                 if (!context.bisect?.active)
                     return { ok: false, message: 'No bisect in progress' };
@@ -42542,11 +43653,12 @@ function LogInkApp(deps) {
                 return deleteRemoteTag(git, tag.name);
             },
             'create-stash': async () => {
-                const message = payload?.trim();
-                if (!message)
-                    return { ok: false, message: 'Stash message required' };
-                return createStash(git, message);
+                // Empty is allowed — createStash turns it into a quick WIP stash
+                // (git's own `WIP on <branch>` subject). Naming is optional.
+                return createStash(git, payload ?? '');
             },
+            'stash-staged': async () => createStash(git, payload ?? '', { stagedOnly: true }),
+            'stash-keep-index': async () => createStash(git, payload ?? '', { keepIndex: true }),
             // #783 — full PR action panel handlers. Each wraps the matching
             // pullRequestActions verb. Strategy / body arrives via `payload`
             // — input prompts validate before they reach here, but the
@@ -42794,6 +43906,8 @@ function LogInkApp(deps) {
                 const files = applyStatusFilterMask(context.worktree?.files || [], state.statusFilterMask).filter((file) => file.state === 'untracked');
                 return stageAllFiles(git, files);
             },
+            'stage-all': async () => stageAll(git),
+            'stage-pathspec': async () => stagePathspec(git, payload || ''),
         };
         const handler = handlers[id];
         if (!handler) {
@@ -42824,6 +43938,16 @@ function LogInkApp(deps) {
                 'checkout-branch',
                 'continue-operation',
                 'pull-current-branch',
+                // Fetch / pull / push bring in new commits and move
+                // remote-tracking refs (origin/main, ahead/behind) — refresh the
+                // graph so they appear instead of staying pinned to the pre-sync
+                // state. (A successful push advances the local origin/<branch>
+                // ref, so the chip should hop to the pushed commit.)
+                'fetch-remotes',
+                'fetch-selected-branch',
+                'pull-selected-branch',
+                'push-current-branch',
+                'push-selected-branch',
                 'cherry-pick-commit',
                 'revert-commit',
                 'reset-hard-to-commit',
@@ -42878,6 +44002,11 @@ function LogInkApp(deps) {
             if (result?.ok && id === 'add-to-gitignore') {
                 await refreshWorktreeContext();
             }
+            // Stage-all / stage-pathspec change staged/unstaged counts — refresh
+            // the worktree so the status list + compose summary reflect it.
+            if (result?.ok && (id === 'stage-all' || id === 'stage-pathspec')) {
+                await refreshWorktreeContext();
+            }
             if (result?.ok && id === 'drop-stash') {
                 // Explicit worktree refresh in case the dropped stash carried
                 // untracked-file state that's now collected.
@@ -43461,6 +44590,11 @@ function LogInkApp(deps) {
             ? findStashFileForOffset(stashDiffFiles, state.diffPreviewOffset)?.path
             : undefined;
         getLogInkInputEvents(state, inputValue, key, {
+            // Narrow terminals show one pane at a time (#1135) — gates the `v`
+            // peek key. Derived the same way the layout does, since `layout`
+            // is computed later in the render path (not in this callback).
+            singlePane: (windowSize.columns || process.stdout.columns || LOG_INK_DEFAULT_COLUMNS) <
+                LAYOUT_SINGLE_PANE_BELOW,
             detailFileCount: detail?.files.length,
             previewLineCount: diffPreviewLineCount,
             worktreeDiffLineCount: worktreeDiff?.lines.length,
@@ -43585,7 +44719,14 @@ function LogInkApp(deps) {
                 exit();
             }
             else if (event.type === 'refreshContext') {
+                // The user-initiated refresh (`r`) refreshes BOTH the metadata
+                // context (branches/tags/worktree) AND the commit rows. Without
+                // the row re-fetch the history graph stays pinned to whatever
+                // commits existed at boot — new commits (made in another
+                // terminal, or remote commits brought in by a fetch) never
+                // appear until relaunch, which reads as "the history is stuck."
                 void refreshContext();
+                void refreshHistoryRows();
             }
             else if (event.type === 'toggleSelectedFileStage') {
                 void toggleSelectedFileStage();
@@ -43684,6 +44825,25 @@ function LogInkApp(deps) {
             }
         });
     });
+    // In single-pane mode (narrow terminals) only one pane renders, so an
+    // active overlay must pull its own pane into view rather than stay
+    // hidden behind whatever pane focus points at. The split-plan overlay
+    // lives in the main panel; every other overlay (help / palette / theme
+    // / gitignore / input prompt / confirmation / chord) renders in the
+    // inspector. Ignored above the single-pane breakpoint (all panes show).
+    const forcedPane = state.splitPlan
+        ? 'main'
+        : state.showHelp ||
+            state.showViewKeys ||
+            state.showCommandPalette ||
+            state.showThemePicker ||
+            state.gitignorePicker ||
+            state.inputPrompt ||
+            state.pendingConfirmationId ||
+            state.pendingMutationConfirmation ||
+            state.pendingKey
+            ? 'inspector'
+            : undefined;
     // Layout depends on focus (sidebar grows when focused), so it's
     // computed here — after state is in scope but before the render path.
     const layout = getLogInkLayout({
@@ -43692,7 +44852,22 @@ function LogInkApp(deps) {
         sidebarFocused: state.focus === 'sidebar',
         inspectorFocused: state.focus === 'detail',
         helpOverlayActive: state.showHelp,
+        forcedPane,
     });
+    // Runtime Context provider (#1136). Bundles the five most-drilled
+    // values so surfaces can read them from context instead of receiving
+    // them as positional props. No consumers yet — this PR only installs
+    // the provider at the root; the surface families migrate in later PRs.
+    // A Context.Provider renders its children transparently (no host
+    // output), so wrapping the tree is behavior-preserving.
+    const RuntimeContext = getLogInkRuntimeContext(React);
+    const runtimeContextValue = {
+        state,
+        dispatch,
+        theme,
+        layout,
+        context,
+    };
     if (layout.tooSmall) {
         return h(Box, {
             flexDirection: 'column',
@@ -43706,7 +44881,35 @@ function LogInkApp(deps) {
     if (showOnboarding) {
         return renderOnboardingOverlay(h, { Box, Text }, layout.rows, layout.columns, theme, appLabel);
     }
-    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader$1(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme, layout.sidebarRailed), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, layout.density, layout.historyRowMode, Boolean(dateBucketingEnabled), diffSyntaxSpans), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.inspectorRailed, layout.bodyRows)), renderFooter$1(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame));
+    // 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 mainSurface = {
+        h,
+        components: { Box, Text },
+        state,
+        context,
+        contextStatus,
+        bodyRows: layout.bodyRows,
+        width: layout.mainPanelWidth,
+        theme,
+    };
+    const mainPanel = () => renderMainPanel(mainSurface, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, hasMoreCommits, loadingMoreCommits, spinnerFrame, layout.density, layout.historyRowMode, Boolean(dateBucketingEnabled), diffSyntaxSpans);
+    const detailPanel = () => renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.bodyRows);
+    // Single-pane mode (narrow terminals): exactly one full-width pane,
+    // chosen by `layout.visiblePane`; Tab cycles which one. Above the
+    // breakpoint all three tile side by side as before.
+    const bodyPanels = layout.singlePane
+        ? [
+            layout.visiblePane === 'sidebar'
+                ? sidebarPanel()
+                : layout.visiblePane === 'inspector'
+                    ? detailPanel()
+                    : mainPanel(),
+        ]
+        : [sidebarPanel(), mainPanel(), detailPanel()];
+    return h(RuntimeContext.Provider, { value: runtimeContextValue }, h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader$1(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, ...bodyPanels), renderFooter$1(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame, layout.singlePane)));
 }
 
 /**
@@ -44444,6 +45647,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({
@@ -44523,8 +45727,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 });
@@ -45112,8 +46315,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 });
@@ -45826,6 +47028,54 @@ async function getWorkspacePullRequestCounts(repoPaths, options = {}) {
     return { authenticated: true, counts };
 }
 
+/**
+ * Clone a remote repository into a local path — the runtime side of the
+ * workspace surface's `c` (clone) flow.
+ *
+ * `deriveRepoName` is pure (and tested) so the UI can pre-fill the
+ * destination as `<cwd>/<name>` the moment a URL is typed; `cloneRepo`
+ * does the filesystem-touching work and reports a friendly result.
+ */
+/**
+ * Infer the repository folder name from a clone URL or SSH spec:
+ *   git@github.com:gfargo/coco.git  → coco
+ *   https://github.com/gfargo/coco  → coco
+ *   https://example.com/a/b/c.git/  → c
+ * Falls back to `repo` when nothing usable can be parsed.
+ */
+function deriveRepoName(url) {
+    const trimmed = url.trim().replace(/\/+$/, '').replace(/\.git$/i, '');
+    if (!trimmed)
+        return 'repo';
+    // Split on both `/` and `:` so `host:owner/name` SSH specs work.
+    const segment = trimmed.split(/[/:]/).filter(Boolean).pop() || '';
+    return segment || 'repo';
+}
+/**
+ * Clone `url` into `targetPath`. Refuses to clobber an existing path so
+ * a typo never overwrites a directory. Network / auth failures surface
+ * git's own message (trimmed to one line).
+ */
+async function cloneRepo(url, targetPath) {
+    const remote = url.trim();
+    const dest = targetPath.trim();
+    if (!remote)
+        return { ok: false, message: 'Enter a remote URL to clone.' };
+    if (!dest)
+        return { ok: false, message: 'Enter a destination path.' };
+    if (fs__namespace.existsSync(dest)) {
+        return { ok: false, message: `${dest} already exists — choose another path.` };
+    }
+    try {
+        await simpleGit.simpleGit().clone(remote, dest);
+        return { ok: true, message: `Cloned into ${dest}` };
+    }
+    catch (error) {
+        const raw = error instanceof Error ? error.message : String(error);
+        return { ok: false, message: `Clone failed: ${raw.split('\n')[0]}` };
+    }
+}
+
 function resolveStoreDir(subdir) {
     const xdg = process.env.XDG_CACHE_HOME;
     const root = xdg && xdg.trim().length > 0 ? xdg : path__namespace$1.join(os__namespace$1.homedir(), '.cache');
@@ -46068,6 +47318,7 @@ function createWorkspaceState(init) {
         showThemePicker: false,
         themePickerFilter: '',
         themePickerIndex: 0,
+        helpScrollOffset: 0,
         knownRepoPaths: init.knownRepoPaths ?? [],
         pullRequestFetching: [],
     };
@@ -46233,10 +47484,17 @@ function applyWorkspaceAction(state, action) {
             return { ...state, status: action.status };
         }
         case 'toggle-help': {
-            return { ...state, showHelp: !state.showHelp, showOnboarding: false };
+            // Always reopen at the top — picking up the last scroll position
+            // is more surprising than predictable for a reference overlay.
+            return { ...state, showHelp: !state.showHelp, helpScrollOffset: 0, showOnboarding: false };
         }
         case 'close-help': {
-            return { ...state, showHelp: false };
+            return { ...state, showHelp: false, helpScrollOffset: 0 };
+        }
+        case 'scroll-help': {
+            // Floor-clamp at 0 only; the renderer ceiling-clamps against the
+            // real content height so `j` past the end sticks at the last row.
+            return { ...state, helpScrollOffset: Math.max(0, state.helpScrollOffset + action.delta) };
         }
         case 'toggle-theme-picker': {
             return {
@@ -46566,6 +47824,7 @@ function buildWorkspaceListWindow(state, options = { rows: 20 }) {
     const all = buildWorkspaceListRows(state, {
         width: options.width,
         spinnerTick: options.spinnerTick,
+        now: options.now,
     });
     const visibleCount = Math.max(1, options.rows);
     if (all.length <= visibleCount) {
@@ -46689,10 +47948,11 @@ function buildWorkspaceHeaderChips(state, options = { focusLabel: 'List' }) {
 // The contextual slot drops bindings users can find via the help
 // overlay (arrow keys, tab); the global slot is the safety net so
 // `? help` and `q quit` never disappear.
-const LIST_CONTEXTUAL = ['s sort', '/ filter', 'r/R refresh', 'a add', 'd remove'];
+const LIST_CONTEXTUAL = ['s sort', '/ filter', 'r/R refresh', 'a add', 'c clone', 'd remove'];
 const SIDEBAR_CONTEXTUAL = ['↑/↓ cycle tab', 'enter open'];
 const FILTER_CONTEXTUAL = ['type to filter', 'enter apply', 'esc cancel'];
 const ADD_REPO_CONTEXTUAL = ['type path', 'tab to complete', 'enter to add', 'esc to cancel'];
+const CLONE_REPO_CONTEXTUAL = ['enter URL', 'enter → destination', 'enter to clone', 'esc to cancel'];
 const CONFIRM_DELETE_CONTEXTUAL = ['y confirm', 'any other key cancels'];
 const GLOBAL_HINTS = ['? help', 'q quit'];
 function contextualHintsFor(focus) {
@@ -46703,6 +47963,8 @@ function contextualHintsFor(focus) {
             return FILTER_CONTEXTUAL;
         case 'add-repo':
             return ADD_REPO_CONTEXTUAL;
+        case 'clone-repo':
+            return CLONE_REPO_CONTEXTUAL;
         case 'confirm-delete':
             return CONFIRM_DELETE_CONTEXTUAL;
         case 'list':
@@ -46717,6 +47979,7 @@ function buildWorkspaceFooter(state) {
     // is open and showing them would be misleading.
     const isModal = state.focus === 'filter' ||
         state.focus === 'add-repo' ||
+        state.focus === 'clone-repo' ||
         state.focus === 'confirm-delete';
     const global = isModal ? [] : GLOBAL_HINTS;
     const allHints = [...contextual, ...global];
@@ -46778,6 +48041,7 @@ function buildWorkspaceHelpSections() {
                 { glyph: '⟳', keys: 'r', description: 'Refresh all repos (discovery + PR counts)' },
                 { glyph: '⟲', keys: 'R', description: 'Refresh just the cursored repo (faster)' },
                 { glyph: '＋', keys: 'a', description: 'Add a repo via path prompt (tab-completes)' },
+                { glyph: '⬇', keys: 'c', description: 'Clone a remote repo (defaults into the launch directory)' },
                 { glyph: '✕', keys: 'd', description: 'Remove the cursored repo from the known-repos store' },
             ],
         },
@@ -46795,7 +48059,7 @@ function buildWorkspaceOnboarding(state) {
             : undefined,
         populatedHint: empty
             ? undefined
-            : 'Press `enter` to open a repo · `?` for the full keymap · `a` to add a repo by path.',
+            : 'Press `enter` to open a repo · `a` to add by path · `c` to clone · `?` for the full keymap.',
     };
 }
 
@@ -47091,6 +48355,7 @@ function renderListBody(deps, width, height) {
         width,
         rows: listRows,
         spinnerTick: deps.spinnerTick,
+        now: deps.now,
     });
     const visibleRepos = selectVisibleRepos(state);
     const filterChip = state.filter
@@ -47126,7 +48391,7 @@ function renderListBody(deps, width, height) {
 function renderHelpRow(deps, row, glyphWidth, keysWidth, key) {
     const { React, ink, theme } = deps;
     const { Box, Text } = ink;
-    return React.createElement(Box, { key, flexDirection: 'row' }, React.createElement(Box, { width: glyphWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.accent, bold: true }, ` ${row.glyph ?? ' '} `)), React.createElement(Box, { width: keysWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.success, bold: true }, row.keys)), React.createElement(Text, null, row.description));
+    return React.createElement(Box, { key, flexShrink: 0, flexDirection: 'row' }, React.createElement(Box, { width: glyphWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.accent, bold: true }, ` ${row.glyph ?? ' '} `)), React.createElement(Box, { width: keysWidth, flexShrink: 0 }, React.createElement(Text, { color: theme.noColor ? undefined : theme.colors.success, bold: true }, row.keys)), React.createElement(Text, null, row.description));
 }
 function renderHelpOverlay(deps) {
     if (!deps.state.showHelp) {
@@ -47139,34 +48404,68 @@ function renderHelpOverlay(deps) {
     // Columns: glyph cell (4 cells) · keys (padded to longest) · description.
     const glyphWidth = 4;
     const keysWidth = Math.max(14, allRows.reduce((acc, row) => Math.max(acc, row.keys.length), 0) + 4);
-    const children = [];
-    // Title bar — accent-tinged, matches the chip-style header on the
-    // main surface so the help reads as the same app, just a different
-    // panel.
-    children.push(React.createElement(Box, { key: 'title', flexDirection: 'row', justifyContent: 'space-between' }, React.createElement(Box, { key: 'title-left', flexDirection: 'row' }, React.createElement(Text, { bold: true, color: theme.noColor ? undefined : theme.colors.accent }, ' ?  coco workspace'), React.createElement(Text, { dimColor: true }, '  keymap · '), React.createElement(Text, { dimColor: true }, `${allRows.length} bindings`)), React.createElement(Text, { dimColor: true }, 'esc / ? to close ')));
-    children.push(React.createElement(Text, { key: 'title-sep', dimColor: true }, ''));
-    // Sections — each gets a title in accent, optional subtitle dim,
-    // then its rows, then a blank line.
+    // Body lines — every scrollable row below the pinned title. Built as
+    // a flat list (section title → optional subtitle → rows → inter-section
+    // spacer) so we can window it against the available height. Each entry
+    // is `flexShrink: 0` so Ink never crushes rows on top of each other
+    // when the keymap is taller than the panel (which used to collapse the
+    // title and the first category onto the same line).
+    const body = [];
     sections.forEach((section, sIndex) => {
-        children.push(React.createElement(Text, {
+        body.push(React.createElement(Text, {
             key: `section-${sIndex}-title`,
             bold: true,
             color: theme.noColor ? undefined : theme.colors.muted,
         }, section.title.toUpperCase()));
         if (section.subtitle) {
-            children.push(React.createElement(Text, { key: `section-${sIndex}-subtitle`, dimColor: true }, ` ${section.subtitle}`));
+            body.push(React.createElement(Text, { key: `section-${sIndex}-subtitle`, dimColor: true }, ` ${section.subtitle}`));
         }
         section.rows.forEach((row, rIndex) => {
-            children.push(renderHelpRow(deps, row, glyphWidth, keysWidth, `row-${sIndex}-${rIndex}`));
+            body.push(renderHelpRow(deps, row, glyphWidth, keysWidth, `row-${sIndex}-${rIndex}`));
         });
         if (sIndex < sections.length - 1) {
-            children.push(React.createElement(Text, { key: `section-${sIndex}-spacer` }, ''));
+            body.push(React.createElement(Text, { key: `section-${sIndex}-spacer` }, ''));
         }
     });
+    // Vertical budget: the overlay shares the column with the header
+    // (3 rows) and footer (FOOTER_HEIGHT). Its own chrome eats the border
+    // (2), the pinned title (1) and the title/body separator (1). Whatever
+    // is left is the window we slide the body through.
+    const HEADER_ROWS = 3;
+    const overlayChromeRows = 4;
+    const visibleRows = Math.max(4, deps.rows - HEADER_ROWS - FOOTER_HEIGHT - overlayChromeRows);
+    // Ceiling-clamp the offset here (the reducer only floors at 0) so
+    // scrolling past the end sticks at the last row instead of revealing
+    // blank space.
+    const maxOffset = Math.max(0, body.length - visibleRows);
+    const offset = Math.min(deps.state.helpScrollOffset, maxOffset);
+    const children = [];
+    // Title bar — accent-tinged, matches the chip-style header on the
+    // main surface so the help reads as the same app, just a different
+    // panel. Pinned above the scrolling body.
+    children.push(React.createElement(Box, { key: 'title', flexShrink: 0, flexDirection: 'row', justifyContent: 'space-between' }, React.createElement(Box, { key: 'title-left', flexDirection: 'row' }, React.createElement(Text, { bold: true, color: theme.noColor ? undefined : theme.colors.accent }, ' ?  coco workspace'), React.createElement(Text, { dimColor: true }, '  keymap · '), React.createElement(Text, { dimColor: true }, `${allRows.length} bindings`)), React.createElement(Text, { dimColor: true }, 'esc / ? to close ')));
+    children.push(React.createElement(Text, { key: 'title-sep', dimColor: true }, ''));
+    // "more above" / "more below" hints each consume a window row so they
+    // don't push body content off-screen. Mirrors the `coco ui` overlay.
+    let windowSize = visibleRows;
+    const hasMoreAbove = offset > 0;
+    if (hasMoreAbove) {
+        windowSize -= 1;
+        children.push(React.createElement(Text, { key: 'more-above', dimColor: true }, ' ↑ more above (j/k or ↑/↓ to scroll)'));
+    }
+    const hasMoreBelow = offset + windowSize < body.length;
+    if (hasMoreBelow) {
+        windowSize -= 1;
+    }
+    children.push(...body.slice(offset, offset + windowSize));
+    if (hasMoreBelow) {
+        children.push(React.createElement(Text, { key: 'more-below', dimColor: true }, ' ↓ more below (j/k or ↑/↓ to scroll)'));
+    }
     return React.createElement(Box, {
         borderColor: focusBorderColor(theme, true),
         borderStyle: theme.borderStyle,
         flexDirection: 'column',
+        flexShrink: 0,
         paddingX: 1,
     }, ...children);
 }
@@ -47217,6 +48516,29 @@ function renderAddRepoPrompt(deps) {
         ? React.createElement(Text, { color: toneColor('dim', theme) }, completionLine)
         : null);
 }
+function renderCloneRepoPrompt(deps) {
+    if (deps.state.focus !== 'clone-repo') {
+        return null;
+    }
+    const { React, ink, theme, cloneUrl, cloneTarget, cloneField, cloneCompletion, cloning } = deps;
+    const { Box, Text } = ink;
+    const urlActive = cloneField === 'url' && !cloning;
+    const targetActive = cloneField === 'target' && !cloning;
+    const completionLine = cloneCompletion.completions.slice(0, 8).join('  ');
+    const hint = cloning
+        ? 'Cloning… this can take a moment for large repos.'
+        : cloneField === 'url'
+            ? 'Paste a remote URL (https or git@…), then enter for the destination.'
+            : 'Edit the destination · tab to complete · enter to clone · esc to cancel';
+    return React.createElement(Box, {
+        borderColor: focusBorderColor(theme, true),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        paddingX: 1,
+    }, React.createElement(Text, { bold: true }, 'Clone a repository'), React.createElement(Text, { color: urlActive ? undefined : toneColor('dim', theme) }, `  URL:  ${cloneUrl}${urlActive ? '_' : ''}`), React.createElement(Text, { color: targetActive ? undefined : toneColor('dim', theme) }, `  Into: ${cloneTarget}${targetActive ? '_' : ''}`), React.createElement(Text, { dimColor: true }, hint), completionLine && targetActive
+        ? React.createElement(Text, { color: toneColor('dim', theme) }, completionLine)
+        : null);
+}
 const FOOTER_HEIGHT = 4; // 2 borders + hint row + status row
 function renderFooter(deps) {
     const { React, ink, state, theme } = deps;
@@ -47258,8 +48580,10 @@ function computeBodyHeight(deps) {
     const FOOTER_ROWS = FOOTER_HEIGHT;
     const onboardingRows = buildWorkspaceOnboarding(deps.state).show ? 5 : 0;
     const addRepoRows = deps.state.focus === 'add-repo' ? 5 : 0;
+    // Clone modal is one row taller (URL + Into + hint + completion).
+    const cloneRows = deps.state.focus === 'clone-repo' ? 6 : 0;
     const confirmRows = deps.state.focus === 'confirm-delete' ? 5 : 0;
-    const reserved = HEADER_ROWS + FOOTER_ROWS + onboardingRows + addRepoRows + confirmRows;
+    const reserved = HEADER_ROWS + FOOTER_ROWS + onboardingRows + addRepoRows + cloneRows + confirmRows;
     return Math.max(8, deps.rows - reserved);
 }
 function renderWorkspaceApp(deps) {
@@ -47281,7 +48605,7 @@ function renderWorkspaceApp(deps) {
         return React.createElement(Box, { flexDirection: 'column', height: rootHeight }, renderHeader(deps), renderThemePickerOverlay(React.createElement, { Box: ink.Box, Text: ink.Text }, deps.state.themePickerFilter, deps.state.themePickerIndex, bodyWidth, deps.theme, true), renderFooter(deps));
     }
     const bodyHeight = computeBodyHeight(deps);
-    return React.createElement(Box, { flexDirection: 'column', height: rootHeight }, renderHeader(deps), React.createElement(Box, { flexDirection: 'row', height: bodyHeight }, renderSidebar(deps, bodyHeight), renderListBody(deps, bodyWidth - sidebarWidthFor(deps) - 2, bodyHeight)), renderOnboardingBanner(deps), renderAddRepoPrompt(deps), renderConfirmDelete(deps), renderFooter(deps));
+    return React.createElement(Box, { flexDirection: 'column', height: rootHeight }, renderHeader(deps), React.createElement(Box, { flexDirection: 'row', height: bodyHeight }, renderSidebar(deps, bodyHeight), renderListBody(deps, bodyWidth - sidebarWidthFor(deps) - 2, bodyHeight)), renderOnboardingBanner(deps), renderAddRepoPrompt(deps), renderCloneRepoPrompt(deps), renderConfirmDelete(deps), renderFooter(deps));
 }
 
 /**
@@ -47318,6 +48642,21 @@ function resolveWorkspaceInput(input, key, state) {
         if (key.escape || input === '?' || input === 'q') {
             return { kind: 'action', action: { type: 'close-help' } };
         }
+        // The keymap is taller than the panel on short terminals — let
+        // j/k/↑/↓ and ctrl+d/u scroll the windowed body. Mirrors the
+        // `coco ui` help overlay.
+        if (key.downArrow || input === 'j') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: 1 } };
+        }
+        if (key.upArrow || input === 'k') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: -1 } };
+        }
+        if (key.ctrl && input === 'd') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: 10 } };
+        }
+        if (key.ctrl && input === 'u') {
+            return { kind: 'action', action: { type: 'scroll-help', delta: -10 } };
+        }
         return { kind: 'noop' };
     }
     // Theme picker is modal (like `coco ui`'s gC): type to filter, ↑/↓ to
@@ -47368,6 +48707,14 @@ function resolveWorkspaceInput(input, key, state) {
         // can drive the path-completion prompt.
         return { kind: 'noop' };
     }
+    if (state.focus === 'clone-repo') {
+        if (key.escape) {
+            return { kind: 'action', action: { type: 'set-focus', focus: 'list' } };
+        }
+        // Enter/Tab/printable keys drive the URL + destination prompt in the
+        // runtime (it owns the two-field state + path completion).
+        return { kind: 'noop' };
+    }
     // Confirm-delete is modal: only `y` confirms, anything else cancels.
     if (state.focus === 'confirm-delete') {
         if (input === 'y' || input === 'Y') {
@@ -47462,6 +48809,9 @@ function resolveWorkspaceInput(input, key, state) {
     if (input === 'a') {
         return { kind: 'add-repo' };
     }
+    if (input === 'c') {
+        return { kind: 'clone-repo' };
+    }
     if (input === 'd') {
         return { kind: 'request-delete' };
     }
@@ -48016,6 +49366,19 @@ function WorkspaceInkApp(props) {
     const [filterDraft, setFilterDraft] = React.useState('');
     const [addRepoDraft, setAddRepoDraft] = React.useState('~/');
     const [addRepoCompletion, setAddRepoCompletion] = React.useState(() => completePath('~/'));
+    // Clone-repo modal (`c`). Two fields: the remote URL and the
+    // destination path. `cloneField` tracks which is active; `cloneTarget`
+    // auto-derives `<cwd>/<repo-name>` from the URL until the user edits it
+    // (`cloneTargetEdited`). `cloning` blocks input + shows a spinner while
+    // `git clone` runs. The boot cwd is captured once at mount so it stays
+    // the directory the workspace launched in even after drill-in.
+    const bootCwdRef = React.useRef(process.cwd());
+    const [cloneUrl, setCloneUrl] = React.useState('');
+    const [cloneTarget, setCloneTarget] = React.useState('');
+    const [cloneField, setCloneField] = React.useState('url');
+    const [cloneTargetEdited, setCloneTargetEdited] = React.useState(false);
+    const [cloneCompletion, setCloneCompletion] = React.useState(() => completePath('~/'));
+    const [cloning, setCloning] = React.useState(false);
     // Tick counter for the per-row PR-fetch spinner. Bumped on a
     // setInterval that only runs while at least one row is mid-fetch
     // (see effect below) so idle workspaces don't burn CPU on animation
@@ -48065,6 +49428,18 @@ function WorkspaceInkApp(props) {
     addRepoDraftRef.current = addRepoDraft;
     const addRepoCompletionRef = React.useRef(addRepoCompletion);
     addRepoCompletionRef.current = addRepoCompletion;
+    const cloneUrlRef = React.useRef(cloneUrl);
+    cloneUrlRef.current = cloneUrl;
+    const cloneTargetRef = React.useRef(cloneTarget);
+    cloneTargetRef.current = cloneTarget;
+    const cloneFieldRef = React.useRef(cloneField);
+    cloneFieldRef.current = cloneField;
+    const cloneTargetEditedRef = React.useRef(cloneTargetEdited);
+    cloneTargetEditedRef.current = cloneTargetEdited;
+    const cloneCompletionRef = React.useRef(cloneCompletion);
+    cloneCompletionRef.current = cloneCompletion;
+    const cloningRef = React.useRef(cloning);
+    cloningRef.current = cloning;
     // Background discovery + PR-count refresh on mount.
     React.useEffect(() => {
         let cancelled = false;
@@ -48297,6 +49672,60 @@ function WorkspaceInkApp(props) {
             });
         }
     }, [addRepoDraft, dispatch, props]);
+    // Default destination for a clone URL: `<bootCwd>/<repo-name>`.
+    const cloneTargetFor = React.useCallback((url) => {
+        return path__namespace$1.join(bootCwdRef.current, deriveRepoName(url));
+    }, []);
+    const openClone = React.useCallback(() => {
+        setCloneUrl('');
+        setCloneTarget('');
+        setCloneField('url');
+        setCloneTargetEdited(false);
+        setCloneCompletion(completePath(`${bootCwdRef.current}/`));
+        dispatch({ type: 'set-focus', focus: 'clone-repo' });
+    }, [dispatch]);
+    const commitClone = React.useCallback(async () => {
+        const url = cloneUrlRef.current.trim();
+        const target = expandHomePrefix(cloneTargetRef.current.trim().replace(/\/+$/, ''));
+        if (!url) {
+            dispatch({ type: 'set-status', status: 'Enter a remote URL.' });
+            return;
+        }
+        if (!target) {
+            dispatch({ type: 'set-status', status: 'Enter a destination path.' });
+            return;
+        }
+        setCloning(true);
+        dispatch({ type: 'set-status', status: `Cloning ${deriveRepoName(url)}…` });
+        const result = await cloneRepo(url, target);
+        if (unmountedRef.current)
+            return;
+        setCloning(false);
+        if (!result.ok) {
+            // Keep the modal open so the user can fix the URL / path and retry.
+            dispatch({ type: 'set-status', status: result.message });
+            return;
+        }
+        const updated = appendKnownRepo(target);
+        dispatch({ type: 'replace-known-repos', paths: updated });
+        dispatch({ type: 'set-focus', focus: 'list' });
+        dispatch({ type: 'set-status', status: result.message });
+        dispatch({ type: 'set-loading', loading: true });
+        try {
+            const merged = mergeKnownRepos(props.knownRepos, readKnownRepos());
+            const overview = await props.loadOverview(props.roots, merged);
+            writeCachedWorkspace(props.roots, overview);
+            dispatch({ type: 'replace-overview', overview });
+            dispatch({ type: 'anchor-cursor-by-path', path: target });
+        }
+        catch (err) {
+            dispatch({ type: 'set-loading', loading: false });
+            dispatch({
+                type: 'set-status',
+                status: err instanceof Error ? err.message : 'Refresh failed.',
+            });
+        }
+    }, [dispatch, props]);
     // Callback refs so the stable input handler can reach the latest
     // closure without taking them in deps.
     const commitAddRepoRef = React.useRef(commitAddRepo);
@@ -48309,6 +49738,10 @@ function WorkspaceInkApp(props) {
     refreshRowRef.current = refreshRow;
     const openAddRepoRef = React.useRef(openAddRepo);
     openAddRepoRef.current = openAddRepo;
+    const openCloneRef = React.useRef(openClone);
+    openCloneRef.current = openClone;
+    const commitCloneRef = React.useRef(commitClone);
+    commitCloneRef.current = commitClone;
     const requestDeleteRef = React.useRef(requestDelete);
     requestDeleteRef.current = requestDelete;
     const confirmDeleteRef = React.useRef(confirmDelete);
@@ -48391,6 +49824,73 @@ function WorkspaceInkApp(props) {
             }
             return;
         }
+        if (state.focus === 'clone-repo') {
+            // While the clone is running, swallow everything except Esc
+            // (which is a no-op here — the clone is already in flight).
+            if (cloningRef.current)
+                return;
+            if (key.escape) {
+                dispatch({ type: 'set-focus', focus: 'list' });
+                return;
+            }
+            const field = cloneFieldRef.current;
+            const url = cloneUrlRef.current;
+            const target = cloneTargetRef.current;
+            const targetEdited = cloneTargetEditedRef.current;
+            if (key.return) {
+                if (field === 'url') {
+                    if (!url.trim()) {
+                        dispatch({ type: 'set-status', status: 'Enter a remote URL.' });
+                        return;
+                    }
+                    // Advance to the (pre-filled, editable) destination field.
+                    const derived = targetEdited ? target : cloneTargetFor(url);
+                    setCloneTarget(derived);
+                    setCloneCompletion(completePath(derived));
+                    setCloneField('target');
+                    return;
+                }
+                void commitCloneRef.current();
+                return;
+            }
+            if (key.tab && field === 'target') {
+                const next = applyTabCompletion(target, cloneCompletionRef.current);
+                setCloneTarget(next);
+                setCloneTargetEdited(true);
+                setCloneCompletion(completePath(next));
+                return;
+            }
+            if (key.backspace || key.delete) {
+                if (field === 'url') {
+                    const next = url.slice(0, -1);
+                    setCloneUrl(next);
+                    if (!targetEdited)
+                        setCloneTarget(next ? cloneTargetFor(next) : '');
+                }
+                else {
+                    const next = target.slice(0, -1);
+                    setCloneTarget(next);
+                    setCloneTargetEdited(true);
+                    setCloneCompletion(completePath(next || '~/'));
+                }
+                return;
+            }
+            if (rawInput && !key.ctrl && !key.meta) {
+                if (field === 'url') {
+                    const next = url + rawInput;
+                    setCloneUrl(next);
+                    if (!targetEdited)
+                        setCloneTarget(cloneTargetFor(next));
+                }
+                else {
+                    const next = target + rawInput;
+                    setCloneTarget(next);
+                    setCloneTargetEdited(true);
+                    setCloneCompletion(completePath(next));
+                }
+            }
+            return;
+        }
         // Ctrl+C → quit, since we disabled Ink's built-in ctrl+c exit.
         // Handled here (rather than in the pure resolver) because the
         // resolver doesn't have a notion of "raw key with ctrl flag" for
@@ -48431,6 +49931,9 @@ function WorkspaceInkApp(props) {
             case 'add-repo':
                 openAddRepoRef.current();
                 break;
+            case 'clone-repo':
+                openCloneRef.current();
+                break;
             case 'request-delete':
                 requestDeleteRef.current();
                 break;
@@ -48480,6 +49983,11 @@ function WorkspaceInkApp(props) {
         filterDraft,
         addRepoDraft,
         addRepoCompletion,
+        cloneUrl,
+        cloneTarget,
+        cloneField,
+        cloneCompletion,
+        cloning,
         columns,
         rows,
         spinnerTick,