git-coco 0.50.0 → 0.51.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.50.0";
+const BUILD_VERSION = "0.51.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -145,11 +145,11 @@ function removeUndefined(obj) {
     return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
 }
 
-const dynamicImport$2 = new Function('specifier', 'return import(specifier)');
+const dynamicImport$1 = new Function('specifier', 'return import(specifier)');
 let promptsPromise;
 function loadInquirerPrompts() {
     if (!promptsPromise) {
-        promptsPromise = dynamicImport$2('@inquirer/prompts');
+        promptsPromise = dynamicImport$1('@inquirer/prompts');
     }
     return promptsPromise;
 }
@@ -1140,6 +1140,11 @@ const schema$1 = {
                         "idleTips": {
                             "type": "boolean",
                             "description": "Rotate short usage tips through the status line when the TUI has been idle for >10s. Off by default so power users aren't distracted."
+                        },
+                        "dateBucketing": {
+                            "type": "boolean",
+                            "description": "Group adjacent commits in the history surface under shared section headers (`── Today ──`, `── Yesterday ──`, `── April 2026 ──`) and drop the per-row date column in favor of the headers. On by default because the bucketed view gives stronger temporal orientation at a glance and the freed cells go to the commit subject. Flip off if you prefer a date column on every row.\n\nBucketing automatically suppresses itself while a search filter is active (results aren't chronological), regardless of this setting.",
+                            "default": true
                         }
                     },
                     "additionalProperties": false,
@@ -1596,6 +1601,9 @@ const schema$1 = {
                 "commit": {
                     "$ref": "#/definitions/LLMModel"
                 },
+                "commitSplit": {
+                    "$ref": "#/definitions/LLMModel"
+                },
                 "changelog": {
                     "$ref": "#/definitions/LLMModel"
                 },
@@ -2505,9 +2513,10 @@ const CACHE_SUBCOMMANDS = [
     'parsers',
     'prefetch',
     'clear-parsers',
+    'clear-github',
 ];
-const command$8 = 'cache <subcommand> [languages..]';
-const builder$8 = (yargs) => {
+const command$a = 'cache <subcommand> [languages..]';
+const builder$a = (yargs) => {
     return yargs
         .positional('subcommand', {
         describe: 'Cache action to run',
@@ -2519,7 +2528,7 @@ const builder$8 = (yargs) => {
         type: 'string',
         array: true,
     })
-        .usage(getCommandUsageHeader(command$8));
+        .usage(getCommandUsageHeader(command$a));
 };
 
 /**
@@ -2969,15 +2978,15 @@ async function runPrefetchFromEnv(options) {
  * cache file under ~500 KB on a typical repo (each entry is a
  * sha256 hash + 200-500-byte summary).
  */
-const CACHE_SCHEMA_VERSION$1 = 1;
-const CACHE_DIR_NAME$1 = 'diff-summaries';
+const CACHE_SCHEMA_VERSION$2 = 1;
+const CACHE_DIR_NAME$2 = 'diff-summaries';
 const CACHE_ENTRY_HARD_CAP = 500;
-function resolveCacheDir$4() {
+function resolveCacheDir$5() {
     const xdg = process.env.XDG_CACHE_HOME;
     if (xdg && xdg.trim().length > 0) {
-        return path__namespace$1.join(xdg, 'coco', CACHE_DIR_NAME$1);
+        return path__namespace$1.join(xdg, 'coco', CACHE_DIR_NAME$2);
     }
-    return path__namespace$1.join(os__namespace$1.homedir(), '.cache', 'coco', CACHE_DIR_NAME$1);
+    return path__namespace$1.join(os__namespace$1.homedir(), '.cache', 'coco', CACHE_DIR_NAME$2);
 }
 function repoKey$3(repoPath) {
     // sha256 here is a non-security cache-key derivation — deterministic
@@ -2987,7 +2996,7 @@ function repoKey$3(repoPath) {
     return crypto__namespace.createHash('sha256').update(repoPath).digest('hex').slice(0, 16);
 }
 function getDiffSummaryCachePath(repoPath) {
-    return path__namespace$1.join(resolveCacheDir$4(), `summaries.${repoKey$3(repoPath)}.json`);
+    return path__namespace$1.join(resolveCacheDir$5(), `summaries.${repoKey$3(repoPath)}.json`);
 }
 /**
  * Build the cache key for a (diff, model, prompt) tuple. sha256
@@ -3004,7 +3013,7 @@ function readEnvelope(filePath) {
     try {
         const raw = fs__namespace$1.readFileSync(filePath, 'utf8');
         const parsed = JSON.parse(raw);
-        if (parsed.version !== CACHE_SCHEMA_VERSION$1)
+        if (parsed.version !== CACHE_SCHEMA_VERSION$2)
             return undefined;
         if (!parsed.entries || typeof parsed.entries !== 'object')
             return undefined;
@@ -3026,7 +3035,7 @@ function readDiffSummary(repoPath, key) {
 function writeDiffSummary(repoPath, key, entry) {
     const filePath = getDiffSummaryCachePath(repoPath);
     const existing = readEnvelope(filePath) || {
-        version: CACHE_SCHEMA_VERSION$1,
+        version: CACHE_SCHEMA_VERSION$2,
         savedAt: new Date().toISOString(),
         entries: {},
     };
@@ -3095,6 +3104,132 @@ function clearDiffSummaryCache(repoPath) {
     }
 }
 
+/**
+ * Disk-backed cache for `coco issues` / `coco prs` list fetches
+ * (#882 phase 2). Triage is bursty — a user runs `coco issues` a
+ * dozen times in a few minutes, then doesn't touch it for hours —
+ * so a short TTL (default 5 minutes) buys a lot of latency back
+ * without serving stale data outside that window.
+ *
+ * Best-effort, same as `overviewCache.ts`: read failures fall back
+ * to "no cache" (the fetcher does a fresh `gh` call), write failures
+ * are swallowed silently (next call just re-fetches). The cache is
+ * never load-bearing — `gh` is always the source of truth.
+ *
+ * Keying: `{kind}.{repoHash}.{filterHash}.json` where:
+ *   - `kind` is `'issues'` or `'prs'` so the two surfaces don't
+ *     collide.
+ *   - `repoHash` is a stable short hash of the absolute repo path
+ *     (same scheme as `overviewCache.ts`).
+ *   - `filterHash` is a stable short hash of the canonicalized
+ *     filter object so different `--state` / `--assignee` / `--label`
+ *     combinations cache independently.
+ *
+ * No PII in filenames; no auth context is hashed; no
+ * collision-resistance against an adversary is required.
+ */
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
+const CACHE_SCHEMA_VERSION$1 = 1;
+const CACHE_DIR_NAME$1 = 'github';
+function resolveCacheDir$4() {
+    const xdg = process.env.XDG_CACHE_HOME;
+    if (xdg && xdg.trim().length > 0) {
+        return path__namespace$1.join(xdg, 'coco', CACHE_DIR_NAME$1);
+    }
+    return path__namespace$1.join(os__namespace$1.homedir(), '.cache', 'coco', CACHE_DIR_NAME$1);
+}
+function shortHash$1(input) {
+    // sha1 here is a non-security cache-key derivation — we just need a
+    // deterministic short identifier so two repos / filters at different
+    // values never collide in the cache directory. No PII or auth
+    // context is hashed and no collision-resistance against an adversary
+    // is required.
+    // DevSkim: ignore DS126858
+    return crypto__namespace.createHash('sha1').update(input).digest('hex').slice(0, 16);
+}
+/**
+ * Canonicalize the filter object into a stable string before hashing.
+ * Sorts keys + drops undefined entries so equivalent filters
+ * (`{state: 'open'}` and `{state: 'open', limit: undefined}`) hash to
+ * the same key and share cached data.
+ */
+function canonicalizeFilter(filter) {
+    const entries = Object.entries(filter)
+        .filter(([, value]) => value !== undefined && value !== null && value !== '')
+        .sort(([a], [b]) => a.localeCompare(b));
+    return JSON.stringify(entries);
+}
+function getCachePath(kind, repoPath, filter) {
+    const repoHash = shortHash$1(repoPath);
+    const filterHash = shortHash$1(canonicalizeFilter(filter));
+    return path__namespace$1.join(resolveCacheDir$4(), `${kind}.${repoHash}.${filterHash}.json`);
+}
+function readCachedList(kind, repoPath, filter, ttlMs = DEFAULT_CACHE_TTL_MS) {
+    try {
+        const raw = fs__namespace$1.readFileSync(getCachePath(kind, repoPath, filter), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== CACHE_SCHEMA_VERSION$1)
+            return undefined;
+        if (!parsed.payload || parsed.payload.kind !== kind)
+            return undefined;
+        if (!Array.isArray(parsed.payload.items))
+            return undefined;
+        const savedAt = new Date(parsed.savedAt);
+        if (Number.isNaN(savedAt.getTime()))
+            return undefined;
+        const ageMs = Date.now() - savedAt.getTime();
+        return {
+            payload: parsed.payload,
+            savedAt,
+            ageMs,
+            fresh: ageMs < ttlMs,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeCachedList(repoPath, filter, payload) {
+    const file = getCachePath(payload.kind, repoPath, filter);
+    const envelope = {
+        version: CACHE_SCHEMA_VERSION$1,
+        savedAt: new Date().toISOString(),
+        payload,
+    };
+    try {
+        fs__namespace$1.mkdirSync(path__namespace$1.dirname(file), { recursive: true });
+        fs__namespace$1.writeFileSync(file, JSON.stringify(envelope));
+    }
+    catch {
+        // Best-effort persistence; swallow.
+    }
+}
+/**
+ * Drop every cached file under the github cache directory. Used by
+ * `--no-cache` / explicit purge commands. Best-effort: ENOENT on a
+ * never-populated cache directory is treated as success.
+ */
+function clearGitHubListCache() {
+    const dir = resolveCacheDir$4();
+    let removed = 0;
+    try {
+        const entries = fs__namespace$1.readdirSync(dir);
+        for (const entry of entries) {
+            try {
+                fs__namespace$1.unlinkSync(path__namespace$1.join(dir, entry));
+                removed++;
+            }
+            catch {
+                // Skip individual file failures; keep counting the rest.
+            }
+        }
+    }
+    catch {
+        // Directory missing → nothing to clear, treat as success.
+    }
+    return { removed };
+}
+
 /**
  * Retrieves a SimpleGit instance for a repository.
  *
@@ -3267,7 +3402,7 @@ async function promptLanguageSelection(logger) {
     });
     return picked;
 }
-const handler$8 = async (argv, logger) => {
+const handler$a = async (argv, logger) => {
     const subcommand = argv.subcommand;
     const positionalLanguages = (argv.languages || [])
         .map((s) => s.trim())
@@ -3344,6 +3479,16 @@ const handler$8 = async (argv, logger) => {
         }
         return;
     }
+    if (subcommand === 'clear-github') {
+        const result = clearGitHubListCache();
+        if (result.removed === 0) {
+            logger.log(chalk.dim('No GitHub triage cache to clear.'));
+            return;
+        }
+        logger.log(chalk.green(`✓ cleared ${result.removed} cached GitHub triage list${result.removed === 1 ? '' : 's'}`));
+        logger.log(chalk.dim('Cleared from ~/.cache/coco/github/'));
+        return;
+    }
     if (subcommand === 'clear-parsers') {
         const languages = listManifestLanguages();
         let cleared = 0;
@@ -3362,15 +3507,15 @@ const handler$8 = async (argv, logger) => {
         return;
     }
     logger.log(chalk.red(`Unknown cache subcommand: ${subcommand}`));
-    logger.log(chalk.dim('Use one of: clear, info, parsers, prefetch, clear-parsers'));
+    logger.log(chalk.dim('Use one of: clear, info, parsers, prefetch, clear-parsers, clear-github'));
     process.exitCode = 1;
 };
 
 var cache = {
-    command: command$8,
+    command: command$a,
     desc: 'Manage the diff-summary cache (clear, info)',
-    builder: builder$8,
-    handler: commandExecutor(handler$8),
+    builder: builder$a,
+    handler: commandExecutor(handler$a),
 };
 
 var util;
@@ -7159,11 +7304,11 @@ const ChangelogResponseSchema = objectType({
     title: stringType(),
     content: stringType(),
 });
-const command$7 = 'changelog';
+const command$9 = 'changelog';
 /**
  * Command line options via yargs
  */
-const options$7 = {
+const options$9 = {
     range: {
         type: 'string',
         alias: 'r',
@@ -7210,8 +7355,8 @@ const options$7 = {
         description: 'Toggle interactive mode',
     },
 };
-const builder$7 = (yargs) => {
-    return yargs.options(options$7).usage(getCommandUsageHeader(command$7));
+const builder$9 = (yargs) => {
+    return yargs.options(options$9).usage(getCommandUsageHeader(command$9));
 };
 
 /**
@@ -7415,6 +7560,12 @@ const OPENAI_DYNAMIC_DEFAULTS = {
     cost: {
         summarize: 'gpt-4.1-nano',
         commit: 'gpt-4.1-mini',
+        // `commitSplit` floors at mini even in cost mode. The split
+        // planner emits structured JSON with strict cross-group
+        // constraints (files appear exactly once, hunks fully cover or
+        // not at all). Nano-class models fail those constraints often
+        // enough that the cost win is eaten by the 3-retry budget.
+        commitSplit: 'gpt-4.1-mini',
         changelog: 'gpt-4.1-mini',
         review: 'gpt-4.1-mini',
         recap: 'gpt-4.1-nano',
@@ -7424,6 +7575,7 @@ const OPENAI_DYNAMIC_DEFAULTS = {
     balanced: {
         summarize: 'gpt-4.1-mini',
         commit: 'gpt-4.1-mini',
+        commitSplit: 'gpt-4.1',
         changelog: 'gpt-4.1',
         review: 'gpt-4.1',
         recap: 'gpt-4.1-mini',
@@ -7433,6 +7585,7 @@ const OPENAI_DYNAMIC_DEFAULTS = {
     quality: {
         summarize: 'gpt-4.1-mini',
         commit: 'gpt-4.1',
+        commitSplit: 'gpt-4.1',
         changelog: 'gpt-4.1',
         review: 'gpt-4.1',
         recap: 'gpt-4.1',
@@ -7444,6 +7597,8 @@ const ANTHROPIC_DYNAMIC_DEFAULTS = {
     cost: {
         summarize: 'claude-3-5-haiku-latest',
         commit: 'claude-3-5-haiku-latest',
+        // Floor at sonnet — see note on OpenAI commitSplit above.
+        commitSplit: 'claude-3-5-sonnet-latest',
         changelog: 'claude-3-5-sonnet-latest',
         review: 'claude-3-5-sonnet-latest',
         recap: 'claude-3-5-haiku-latest',
@@ -7453,6 +7608,7 @@ const ANTHROPIC_DYNAMIC_DEFAULTS = {
     balanced: {
         summarize: 'claude-3-5-haiku-latest',
         commit: 'claude-3-5-sonnet-latest',
+        commitSplit: 'claude-3-7-sonnet-latest',
         changelog: 'claude-3-5-sonnet-latest',
         review: 'claude-3-7-sonnet-latest',
         recap: 'claude-3-5-sonnet-latest',
@@ -7462,6 +7618,7 @@ const ANTHROPIC_DYNAMIC_DEFAULTS = {
     quality: {
         summarize: 'claude-3-5-sonnet-latest',
         commit: 'claude-3-7-sonnet-latest',
+        commitSplit: 'claude-sonnet-4-0',
         changelog: 'claude-3-7-sonnet-latest',
         review: 'claude-sonnet-4-0',
         recap: 'claude-3-7-sonnet-latest',
@@ -7473,6 +7630,8 @@ const OLLAMA_DYNAMIC_DEFAULTS = {
     cost: {
         summarize: 'llama3.2:3b',
         commit: 'llama3.1:8b',
+        // Floor at the coder-tuned 14b — see note on OpenAI commitSplit above.
+        commitSplit: 'qwen2.5-coder:14b',
         changelog: 'llama3.1:8b',
         review: 'qwen2.5-coder:7b',
         recap: 'llama3.2:3b',
@@ -7482,6 +7641,7 @@ const OLLAMA_DYNAMIC_DEFAULTS = {
     balanced: {
         summarize: 'llama3.1:8b',
         commit: 'qwen2.5-coder:14b',
+        commitSplit: 'qwen2.5-coder:32b',
         changelog: 'qwen2.5-coder:14b',
         review: 'qwen2.5-coder:32b',
         recap: 'llama3.1:8b',
@@ -7491,6 +7651,7 @@ const OLLAMA_DYNAMIC_DEFAULTS = {
     quality: {
         summarize: 'qwen2.5-coder:14b',
         commit: 'qwen2.5-coder:32b',
+        commitSplit: 'qwen2.5-coder:32b',
         changelog: 'qwen2.5-coder:32b',
         review: 'qwen2.5-coder:32b',
         recap: 'qwen2.5-coder:14b',
@@ -7506,6 +7667,7 @@ const DYNAMIC_DEFAULTS = {
 const DYNAMIC_MODEL_TASKS = [
     'summarize',
     'commit',
+    'commitSplit',
     'changelog',
     'review',
     'recap',
@@ -9219,7 +9381,9 @@ function summarizeRustStructuralDiff(fileDiff) {
  * on every diff — the regex fallback is the correct steady state
  * in that case.
  */
-const dynamicImport$1 = new Function('specifier', 'return import(specifier)');
+async function loadTreeSitterModule() {
+    return import('web-tree-sitter');
+}
 /**
  * Locate the bundled .wasm files. Tries the dist layout first (the
  * common case for installed packages), then falls back to the
@@ -9300,7 +9464,7 @@ async function ensureRuntime() {
             return undefined;
         let mod;
         try {
-            mod = await dynamicImport$1('web-tree-sitter');
+            mod = await loadTreeSitterModule();
         }
         catch {
             return undefined;
@@ -14051,7 +14215,7 @@ async function processInWaves(items, processor, maxConcurrent = 6) {
     }
     return results;
 }
-const handler$7 = async (argv, logger) => {
+const handler$9 = async (argv, logger) => {
     const git = applyRepoFlag(argv);
     const config = loadConfig(argv);
     const key = getApiKeyForModel(config);
@@ -14276,11 +14440,11 @@ const handler$7 = async (argv, logger) => {
 };
 
 var changelog = {
-    command: command$7,
+    command: command$9,
     desc: 'Generate a changelog from current or target branch, provided commit range, or since the last tag.',
-    builder: builder$7,
-    handler: commandExecutor(handler$7),
-    options: options$7,
+    builder: builder$9,
+    handler: commandExecutor(handler$9),
+    options: options$9,
 };
 
 const conventionalTypeRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?!?:/;
@@ -14297,11 +14461,11 @@ const ConventionalCommitMessageResponseSchema = objectType({
     body: stringType().describe("Body of the commit message")
     // .max(280, "Body must be 280 characters or less"),
 }).describe("Object with Conventional Commit message 'title' and 'body' adhering to Conventional Commits specification");
-const command$6 = 'commit';
+const command$8 = 'commit';
 /**
  * Command line options via yargs
  */
-const options$6 = {
+const options$8 = {
     i: {
         alias: 'interactive',
         description: 'Toggle interactive mode',
@@ -14373,8 +14537,8 @@ const options$6 = {
         default: false,
     },
 };
-const builder$6 = (yargs) => {
-    return yargs.options(options$6).usage(getCommandUsageHeader(command$6));
+const builder$8 = (yargs) => {
+    return yargs.options(options$8).usage(getCommandUsageHeader(command$8));
 };
 
 /**
@@ -14988,6 +15152,73 @@ function formatPlanValidationIssuesError(issues) {
         .filter(Boolean)
         .join('; ');
 }
+/**
+ * Salvage a plan that lists the same file in `files[]` of more than
+ * one group. Weaker models (e.g. `gpt-4.1-nano`) hit this often when
+ * the staged set has many files — they re-assert files across groups
+ * even though the prompt forbids it.
+ *
+ * Recovery: walk groups in plan order, keep the FIRST occurrence of
+ * each file path, drop subsequent occurrences. Plan-order is used
+ * because the LLM tends to put the most thematically-correct
+ * assignment in the first group it considered the file for; later
+ * appearances are usually accidental re-emissions.
+ *
+ * If dropping a duplicate leaves a group with empty `files[]` AND
+ * empty `hunks[]`, `dropEmptyGroups` (run last) filters it out so
+ * the apply path never sees a group with nothing to commit.
+ *
+ * Returns a NEW plan object — original is not mutated.
+ */
+function rescueDuplicateFiles(plan) {
+    const seen = new Set();
+    let mutated = false;
+    const rescuedGroups = plan.groups.map((group) => {
+        const keptFiles = [];
+        for (const file of group.files || []) {
+            if (seen.has(file)) {
+                mutated = true;
+                continue;
+            }
+            seen.add(file);
+            keptFiles.push(file);
+        }
+        return { ...group, files: keptFiles };
+    });
+    if (!mutated)
+        return plan;
+    return { ...plan, groups: rescuedGroups };
+}
+/**
+ * Salvage a plan that lists the same hunk ID in `hunks[]` of more
+ * than one group. Same failure mode as duplicate files but for the
+ * hunk-level assignments.
+ *
+ * Recovery: keep the FIRST occurrence of each hunk ID across groups
+ * (plan order), drop subsequent ones. `dropEmptyGroups` handles any
+ * group left fully empty.
+ *
+ * Returns a NEW plan object — original is not mutated.
+ */
+function rescueDuplicateHunks(plan) {
+    const seen = new Set();
+    let mutated = false;
+    const rescuedGroups = plan.groups.map((group) => {
+        const keptHunks = [];
+        for (const hunkId of group.hunks || []) {
+            if (seen.has(hunkId)) {
+                mutated = true;
+                continue;
+            }
+            seen.add(hunkId);
+            keptHunks.push(hunkId);
+        }
+        return { ...group, hunks: keptHunks };
+    });
+    if (!mutated)
+        return plan;
+    return { ...plan, groups: rescuedGroups };
+}
 /**
  * Salvage a plan that references hunk IDs not in the inventory by
  * promoting those hunks to file-level assignments. The LLM commonly
@@ -15251,31 +15482,39 @@ async function generateValidatedCommitSplitPlan({ llm, prompt, variables, staged
         });
         // Rescue passes. Run in order — order matters:
         //
-        //   1. rescuePhantomHunks (#918): LLM commonly emits "file::hunk-1"
+        //   1. rescueDuplicateFiles / rescueDuplicateHunks: weak models
+        //      (e.g. gpt-4.1-nano) repeatedly re-assert the same file or
+        //      hunk across multiple groups. Keep the first occurrence,
+        //      drop the rest. Run FIRST so downstream rescues see a
+        //      deduplicated plan and don't re-process redundant entries.
+        //
+        //   2. rescuePhantomHunks (#918): LLM commonly emits "file::hunk-1"
         //      against an empty inventory (all staged files are new).
         //      Promote those to file-level assignments.
         //
-        //   2. rescueMixedFiles (#919): LLM commonly puts a file in
+        //   3. rescueMixedFiles (#919): LLM commonly puts a file in
         //      `files[]` of group A AND uses its hunks in `hunks[]` of
         //      group B. Drop the hunks (the file-level claim is more
         //      specific). Must run AFTER phantom-hunk rescue because the
         //      rescue itself can create mixed-files situations.
         //
-        //   3. rescueMissingFiles (#921): LLM occasionally forgets a
+        //   4. rescueMissingFiles (#921): LLM occasionally forgets a
         //      staged file across every group. Append a synthetic "misc"
         //      group so the plan covers every staged file.
         //
-        //   4. dropEmptyGroups: rescueMixedFiles can leave a group with
-        //      empty files[] AND empty hunks[] when it had only hunks
-        //      that got dropped. Apply-time, an empty group means
-        //      `git commit` with nothing staged, which throws and
-        //      aborts mid-loop after the up-front `git reset` has
-        //      already wiped the index. Filter the empty groups out
-        //      LAST so the apply path can't hit them.
+        //   5. dropEmptyGroups: earlier rescues can leave a group with
+        //      empty files[] AND empty hunks[] when their only contents
+        //      got dropped. Apply-time, an empty group means `git commit`
+        //      with nothing staged, which throws and aborts mid-loop
+        //      after the up-front `git reset` has already wiped the
+        //      index. Filter the empty groups out LAST so the apply path
+        //      can't hit them.
         //
         // All rescues are no-ops when there's nothing to rescue, so
         // running them unconditionally costs nothing on healthy plans.
-        const phantomRescued = rescuePhantomHunks(rawPlan, staged, hunkInventory);
+        const dedupedFiles = rescueDuplicateFiles(rawPlan);
+        const dedupedHunks = rescueDuplicateHunks(dedupedFiles);
+        const phantomRescued = rescuePhantomHunks(dedupedHunks, staged, hunkInventory);
         const mixedRescued = rescueMixedFiles(phantomRescued, hunkInventory);
         const missingRescued = rescueMissingFiles(mixedRescued, staged, hunkInventory);
         const plan = dropEmptyGroups(missingRescued);
@@ -15624,7 +15863,7 @@ async function applyCommitSplitPlan({ plan, changes, hunkInventory, git, logger,
  * and apply would risk drift (small LLM nondeterminism, staged-state
  * changes the user didn't intend, etc.).
  */
-async function prepareCommitSplitPlan({ argv, config, git, logger, tokenizer, llm, }) {
+async function prepareCommitSplitPlan({ argv, config, git, logger, tokenizer, llm, planLlm, planService, }) {
     const changes = await getChanges({
         git,
         options: {
@@ -15697,8 +15936,10 @@ async function prepareCommitSplitPlan({ argv, config, git, logger, tokenizer, ll
             // the conventional-commits ruleset (or generic style).
         }
     }
+    const resolvedPlanLlm = planLlm ?? llm;
+    const resolvedPlanModel = planService?.model ?? config.service.model;
     const { plan } = await generateValidatedCommitSplitPlan({
-        llm,
+        llm: resolvedPlanLlm,
         prompt: COMMIT_SPLIT_PROMPT,
         variables: {
             file_inventory: fileInventory,
@@ -15716,15 +15957,24 @@ async function prepareCommitSplitPlan({ argv, config, git, logger, tokenizer, ll
         metadata: {
             command: 'commit',
             provider: config.service.provider,
-            model: String(config.service.model),
+            model: String(resolvedPlanModel),
             conventional: useConventional,
         },
         maxAttempts: DEFAULT_MAX_PLAN_ATTEMPTS,
     });
     return { plan, context: { changes, hunkInventory } };
 }
-async function handleCommitSplit({ argv, config, git, logger, tokenizer, llm, }) {
-    const result = await prepareCommitSplitPlan({ argv, config, git, logger, tokenizer, llm });
+async function handleCommitSplit({ argv, config, git, logger, tokenizer, llm, planLlm, planService, }) {
+    const result = await prepareCommitSplitPlan({
+        argv,
+        config,
+        git,
+        logger,
+        tokenizer,
+        llm,
+        planLlm,
+        planService,
+    });
     if ('empty' in result) {
         return 'No staged changes found.';
     }
@@ -15743,13 +15993,14 @@ async function handleCommitSplit({ argv, config, git, logger, tokenizer, llm, })
     return formatCommitSplitPlan(plan);
 }
 
-const handler$6 = async (argv, logger) => {
+const handler$8 = async (argv, logger) => {
     const git = applyRepoFlag(argv);
     const config = loadConfig(argv);
     const key = getApiKeyForModel(config);
     const { provider } = getModelAndProviderFromConfig(config);
     const commitService = resolveDynamicService(config, 'commit');
     const summaryService = resolveDynamicService(config, 'summarize');
+    const splitService = resolveDynamicService(config, 'commitSplit');
     const model = commitService.model;
     if (config.service.authentication.type !== 'None' && !key) {
         logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
@@ -15758,6 +16009,12 @@ const handler$6 = async (argv, logger) => {
     const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
     const llm = getLlm(provider, model, { ...config, service: commitService });
     const summaryLlm = getLlm(provider, summaryService.model, { ...config, service: summaryService });
+    // The split planner uses a dedicated LLM because its output schema
+    // is far stricter than the regular commit-message path (every staged
+    // file claimed exactly once, no cross-group duplication, hunk-vs-
+    // file mode exclusivity). Weak models fail those constraints often
+    // enough that the `cost` preference floors `commitSplit` at mini.
+    const splitLlm = getLlm(provider, splitService.model, { ...config, service: splitService });
     const INTERACTIVE = argv.interactive || isInteractive(config);
     if (INTERACTIVE) {
         if (!config.hideCocoBanner) {
@@ -15776,6 +16033,7 @@ const handler$6 = async (argv, logger) => {
         color: 'green',
     });
     if (isCommitSplitCommand(argv)) {
+        logger.verbose(`→ split planner: ${provider} (${splitService.model})`, { color: 'green' });
         const splitResult = await handleCommitSplit({
             argv,
             config,
@@ -15783,6 +16041,8 @@ const handler$6 = async (argv, logger) => {
             logger,
             tokenizer,
             llm,
+            planLlm: splitLlm,
+            planService: splitService,
         });
         const splitMode = INTERACTIVE ? 'interactive' : (config.mode || 'stdout');
         await handleResult({
@@ -16208,23 +16468,23 @@ IMPORTANT RULES:
 };
 
 var commit = {
-    command: command$6,
+    command: command$8,
     desc: 'Summarize the staged changes in a commit message.',
-    builder: builder$6,
-    handler: commandExecutor(handler$6),
-    options: options$6,
+    builder: builder$8,
+    handler: commandExecutor(handler$8),
+    options: options$8,
 };
 
-const command$5 = 'doctor';
-const options$5 = {
+const command$7 = 'doctor';
+const options$7 = {
     fix: {
         description: 'Attempt to auto-fix detected issues and write the updated config',
         type: 'boolean',
         default: false,
     },
 };
-const builder$5 = (yargs) => {
-    return yargs.options(options$5).usage(getCommandUsageHeader(command$5));
+const builder$7 = (yargs) => {
+    return yargs.options(options$7).usage(getCommandUsageHeader(command$7));
 };
 
 /**
@@ -16503,7 +16763,7 @@ function formatSourceInfo(sources) {
     }
     return lines;
 }
-const handler$5 = async (argv, logger) => {
+const handler$7 = async (argv, logger) => {
     // Honor the global --repo flag so `coco doctor --repo <X>`
     // inspects X's config sources, not the launcher's cwd. The chdir
     // has to happen before loadConfig so `findUp` walks the targeted
@@ -16610,17 +16870,17 @@ const handler$5 = async (argv, logger) => {
 };
 
 var doctor = {
-    command: command$5,
+    command: command$7,
     desc: 'Check your coco configuration for common issues and suggest fixes',
-    builder: builder$5,
-    handler: commandExecutor(handler$5),
+    builder: builder$7,
+    handler: commandExecutor(handler$7),
 };
 
-const command$4 = 'init';
+const command$6 = 'init';
 /**
  * Command line options via yargs
  */
-const options$4 = {
+const options$6 = {
     scope: {
         type: 'string',
         description: 'configure coco for the current user or project?',
@@ -16632,8 +16892,8 @@ const options$4 = {
         default: false,
     },
 };
-const builder$4 = (yargs) => {
-    return yargs.options(options$4).usage(getCommandUsageHeader(command$4));
+const builder$6 = (yargs) => {
+    return yargs.options(options$6).usage(getCommandUsageHeader(command$6));
 };
 
 /**
@@ -16988,7 +17248,7 @@ const questions = {
     }),
 };
 
-const handler$4 = async (argv, logger) => {
+const handler$6 = async (argv, logger) => {
     // Honor the global --repo flag so `coco init --repo <X> --scope project`
     // writes the project config to X, not the launcher's cwd. The
     // chdir has to happen before getProjectConfigFilePath resolves
@@ -17172,15 +17432,417 @@ async function installCommitlintPackages(scope, logger) {
 }
 
 var init = {
-    command: command$4,
+    command: command$6,
     desc: 'install & configure coco globally or for the current project',
-    builder: builder$4,
-    handler: commandExecutor(handler$4),
-    options: options$4,
+    builder: builder$6,
+    handler: commandExecutor(handler$6),
+    options: options$6,
 };
 
-const command$3 = 'log';
-const options$3 = {
+const command$5 = 'issues';
+const options$5 = {
+    state: {
+        type: 'string',
+        choices: ['open', 'closed', 'all'],
+        description: 'Filter by issue state.',
+        default: 'open',
+    },
+    assignee: {
+        type: 'string',
+        description: 'Filter by assignee GitHub login (or `@me`).',
+    },
+    author: {
+        type: 'string',
+        description: 'Filter by author GitHub login.',
+    },
+    label: {
+        type: 'string',
+        description: 'Filter by label name (comma-separated for AND).',
+    },
+    search: {
+        type: 'string',
+        description: 'Free-form GitHub issue search query.',
+    },
+    mine: {
+        type: 'boolean',
+        description: 'Shorthand for `--assignee @me`.',
+        default: false,
+    },
+    limit: {
+        type: 'number',
+        description: 'Maximum rows to fetch. Defaults to `gh`\'s own default.',
+    },
+    json: {
+        type: 'boolean',
+        description: 'Print machine-readable JSON instead of a formatted table.',
+        default: false,
+    },
+    refresh: {
+        type: 'boolean',
+        description: 'Force fresh `gh` call (writes through to cache).',
+        default: false,
+    },
+    'no-cache': {
+        type: 'boolean',
+        description: 'Skip the disk cache entirely (no read, no write).',
+        default: false,
+    },
+};
+const builder$5 = (yargs) => {
+    return yargs.options(options$5).usage(getCommandUsageHeader(command$5));
+};
+
+const execFileAsync = util$1.promisify(child_process.execFile);
+function parseGitHubRemoteUrl$1(url) {
+    const trimmed = url.trim().replace(/\.git$/, '');
+    const sshMatch = trimmed.match(/^git@github\.com:([^/]+)\/(.+)$/);
+    const httpsMatch = trimmed.match(/^https:\/\/github\.com\/([^/]+)\/(.+)$/);
+    const match = sshMatch || httpsMatch;
+    if (!match) {
+        return undefined;
+    }
+    return {
+        owner: match[1],
+        name: match[2],
+    };
+}
+async function defaultGhRunner(args) {
+    const result = await execFileAsync('gh', args);
+    return result.stdout;
+}
+async function getGitHubRepository(git) {
+    const remotes = await git.getRemotes(true);
+    const remote = remotes.find((entry) => entry.name === 'origin') || remotes[0];
+    const url = remote?.refs.push || remote?.refs.fetch;
+    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.
+ */
+async function isGhAuthenticated(runner) {
+    try {
+        await runner(['auth', 'status', '--hostname', 'github.com']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Pad a (possibly already-colored) string to `width` visible columns.
+ * We can't naively `String#padEnd` after coloring because ANSI escape
+ * codes inflate `.length` past the visible width. The pattern here is
+ * "measure the plain string, color last" — every formatter below
+ * computes column widths from raw values and passes the visible
+ * length explicitly so `padToVisible` only needs to add spaces.
+ */
+function padToVisible(colored, visibleLength, width) {
+    if (visibleLength >= width)
+        return colored;
+    return colored + ' '.repeat(width - visibleLength);
+}
+const STATE_COLORS = {
+    OPEN: chalk.green,
+    CLOSED: chalk.red,
+    MERGED: chalk.magenta,
+};
+function colorState(state) {
+    const fn = STATE_COLORS[state.toUpperCase()] || chalk.dim;
+    return fn(state.toLowerCase());
+}
+function formatLabels(labels) {
+    if (!labels || labels.length === 0)
+        return '';
+    return chalk.dim(labels.map((l) => `[${l}]`).join(' '));
+}
+function formatReviewDecision(decision) {
+    if (!decision)
+        return ' ';
+    switch (decision) {
+        case 'APPROVED':
+            return chalk.green('✓');
+        case 'CHANGES_REQUESTED':
+            return chalk.red('✗');
+        case 'REVIEW_REQUIRED':
+            return chalk.yellow('?');
+        default:
+            return chalk.dim(decision.slice(0, 1));
+    }
+}
+function formatMergeable(mergeable, mergeStateStatus) {
+    if (mergeStateStatus === 'CLEAN')
+        return chalk.green('●');
+    if (mergeStateStatus === 'BLOCKED')
+        return chalk.yellow('●');
+    if (mergeStateStatus === 'DIRTY' || mergeable === 'CONFLICTING')
+        return chalk.red('●');
+    if (mergeStateStatus === 'BEHIND')
+        return chalk.cyan('●');
+    if (mergeStateStatus === 'UNSTABLE')
+        return chalk.yellow('●');
+    return chalk.dim('●');
+}
+function formatIssueList(items) {
+    if (items.length === 0) {
+        return chalk.dim('No issues match the current filter.');
+    }
+    const numberWidth = Math.max(...items.map((i) => `#${i.number}`.length));
+    const authorWidth = Math.max(...items.map((i) => (i.author ? i.author.length : 0)), 1);
+    const stateWidth = 6;
+    return items
+        .map((issue) => {
+        const numRaw = `#${issue.number}`;
+        const num = padToVisible(chalk.dim(numRaw), numRaw.length, numberWidth);
+        const stateRaw = issue.state.toLowerCase();
+        const state = padToVisible(colorState(issue.state), stateRaw.length, stateWidth);
+        const authorRaw = issue.author || '';
+        const author = padToVisible(chalk.cyan(authorRaw), authorRaw.length, authorWidth);
+        const comments = typeof issue.comments === 'number' && issue.comments > 0
+            ? chalk.dim(` ${issue.comments}c`)
+            : '';
+        const labels = formatLabels(issue.labels);
+        const parts = [num, state, author, issue.title];
+        if (labels)
+            parts.push(labels);
+        return parts.join('  ') + comments;
+    })
+        .join('\n');
+}
+function formatPullRequestList(items) {
+    if (items.length === 0) {
+        return chalk.dim('No pull requests match the current filter.');
+    }
+    const numberWidth = Math.max(...items.map((i) => `#${i.number}`.length));
+    const authorWidth = Math.max(...items.map((i) => (i.author ? i.author.length : 0)), 1);
+    const headWidth = Math.min(Math.max(...items.map((i) => i.headRefName.length), 1), 28);
+    const stateWidth = 6;
+    return items
+        .map((pr) => {
+        const numRaw = `#${pr.number}`;
+        const num = padToVisible(chalk.dim(numRaw), numRaw.length, numberWidth);
+        const stateRaw = pr.isDraft ? 'draft' : pr.state.toLowerCase();
+        const stateColored = pr.isDraft ? chalk.dim('draft') : colorState(pr.state);
+        const state = padToVisible(stateColored, stateRaw.length, stateWidth);
+        const mergeable = formatMergeable(pr.mergeable, pr.mergeStateStatus);
+        const review = formatReviewDecision(pr.reviewDecision);
+        const authorRaw = pr.author || '';
+        const author = padToVisible(chalk.cyan(authorRaw), authorRaw.length, authorWidth);
+        const branchTruncated = pr.headRefName.length > headWidth
+            ? pr.headRefName.slice(0, headWidth - 1) + '…'
+            : pr.headRefName;
+        const branch = padToVisible(chalk.dim(branchTruncated), branchTruncated.length, headWidth);
+        const labels = formatLabels(pr.labels);
+        const parts = [num, state, mergeable, review, author, branch, pr.title];
+        if (labels)
+            parts.push(labels);
+        return parts.join('  ');
+    })
+        .join('\n');
+}
+
+/**
+ * `gh issue list --json` field list. Centralized so any future
+ * re-fetch (refresh, cache invalidation) requests the same shape and
+ * the parser can rely on every field being present (even if optional).
+ */
+const ISSUE_LIST_JSON_FIELDS = [
+    'number',
+    'title',
+    'url',
+    'state',
+    'author',
+    'assignees',
+    'labels',
+    'comments',
+    'createdAt',
+    'updatedAt',
+].join(',');
+function parseIssueListItems(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return [];
+    const raw = JSON.parse(trimmed);
+    return raw.map((entry) => {
+        const author = entry.author && typeof entry.author === 'object' && 'login' in entry.author
+            ? String(entry.author.login)
+            : undefined;
+        const assignees = Array.isArray(entry.assignees)
+            ? entry.assignees
+                .map((a) => (a && 'login' in a ? String(a.login) : ''))
+                .filter(Boolean)
+            : undefined;
+        const labels = Array.isArray(entry.labels)
+            ? entry.labels
+                .map((l) => (l && 'name' in l ? String(l.name) : ''))
+                .filter(Boolean)
+            : undefined;
+        return {
+            number: entry.number,
+            title: String(entry.title || ''),
+            url: String(entry.url || ''),
+            state: String(entry.state || ''),
+            author,
+            assignees,
+            labels,
+            comments: typeof entry.comments === 'number' ? entry.comments : undefined,
+            createdAt: String(entry.createdAt || ''),
+            updatedAt: String(entry.updatedAt || ''),
+        };
+    });
+}
+function buildGhArgs$1(filter) {
+    const args = ['issue', 'list', '--json', ISSUE_LIST_JSON_FIELDS];
+    if (filter.state)
+        args.push('--state', filter.state);
+    if (filter.assignee)
+        args.push('--assignee', filter.assignee);
+    if (filter.author)
+        args.push('--author', filter.author);
+    if (filter.label)
+        args.push('--label', filter.label);
+    if (filter.search)
+        args.push('--search', filter.search);
+    if (typeof filter.limit === 'number')
+        args.push('--limit', String(filter.limit));
+    return args;
+}
+async function getIssueList(git, filter = {}, runner = defaultGhRunner) {
+    const repository = await getGitHubRepository(git);
+    if (!repository) {
+        return {
+            available: false,
+            authenticated: false,
+            filter,
+            message: 'No GitHub remote detected.',
+        };
+    }
+    if (!(await isGhAuthenticated(runner))) {
+        return {
+            available: true,
+            authenticated: false,
+            repository,
+            filter,
+            message: 'GitHub CLI is missing or not authenticated.',
+        };
+    }
+    try {
+        const output = await runner(buildGhArgs$1(filter));
+        return {
+            available: true,
+            authenticated: true,
+            repository,
+            filter,
+            issues: parseIssueListItems(output),
+        };
+    }
+    catch (error) {
+        return {
+            available: true,
+            authenticated: true,
+            repository,
+            filter,
+            message: error instanceof Error ? error.message : 'Failed to fetch issue list.',
+        };
+    }
+}
+
+const handler$5 = async (argv, logger) => {
+    const git = applyRepoFlag(argv);
+    // `applyRepoFlag` chdir'd to the repo path (or kept process.cwd
+    // when --repo was omitted), so the cache key derives from a stable
+    // absolute path either way.
+    const repoPath = process.cwd();
+    const filter = {
+        state: argv.state,
+        assignee: argv.mine ? '@me' : argv.assignee,
+        author: argv.author,
+        label: argv.label,
+        search: argv.search,
+        limit: argv.limit,
+    };
+    const cacheEnabled = !argv.noCache;
+    let issues;
+    let fromCache = false;
+    let cacheAgeMs;
+    // Repository metadata is needed for the header in both code paths
+    // (cache hit and fresh fetch). The cache hit path skips
+    // `getIssueList` entirely, so probe it directly here. Cheap — no
+    // network, just a single `git remote` parse.
+    const repository = await getGitHubRepository(git);
+    if (cacheEnabled && !argv.refresh) {
+        const cached = readCachedList('issues', repoPath, filter);
+        if (cached?.fresh) {
+            issues = cached.payload.items;
+            fromCache = true;
+            cacheAgeMs = cached.ageMs;
+        }
+    }
+    if (!issues) {
+        const overview = await getIssueList(git, filter);
+        if (!overview.available) {
+            logger.log(chalk.red(overview.message || 'No GitHub remote detected.'));
+            commandExit(1);
+            return;
+        }
+        if (!overview.authenticated) {
+            logger.log(chalk.yellow(overview.message || 'GitHub CLI is missing or not authenticated.'));
+            logger.log(chalk.dim('Install `gh` and run `gh auth login` to enable issue triage.'));
+            commandExit(1);
+            return;
+        }
+        if (overview.message) {
+            logger.log(chalk.red(overview.message));
+            commandExit(1);
+            return;
+        }
+        issues = overview.issues || [];
+        if (cacheEnabled) {
+            writeCachedList(repoPath, filter, { kind: 'issues', items: issues });
+        }
+    }
+    if (argv.json) {
+        logger.log(JSON.stringify(issues, null, 2));
+        return;
+    }
+    if (repository) {
+        const filterParts = [];
+        if (filter.state && filter.state !== 'open')
+            filterParts.push(`state=${filter.state}`);
+        if (filter.assignee)
+            filterParts.push(`assignee=${filter.assignee}`);
+        if (filter.author)
+            filterParts.push(`author=${filter.author}`);
+        if (filter.label)
+            filterParts.push(`label=${filter.label}`);
+        if (filter.search)
+            filterParts.push(`search=${JSON.stringify(filter.search)}`);
+        const suffix = filterParts.length ? chalk.dim(` (${filterParts.join(', ')})`) : '';
+        const cacheTag = fromCache && typeof cacheAgeMs === 'number'
+            ? chalk.dim(` · cached ${Math.round(cacheAgeMs / 1000)}s ago`)
+            : '';
+        logger.log(chalk.bold(`${repository.owner}/${repository.name}`) +
+            chalk.dim(` · ${issues.length} issue${issues.length === 1 ? '' : 's'}`) +
+            suffix +
+            cacheTag);
+        logger.log('');
+    }
+    logger.log(formatIssueList(issues));
+};
+
+var issues = {
+    command: command$5,
+    desc: 'List GitHub issues for the current repository (read-only triage)',
+    builder: builder$5,
+    handler: commandExecutor(handler$5),
+};
+
+const command$4 = 'log';
+const options$4 = {
     i: {
         description: 'Open the interactive terminal log UI',
         type: 'boolean',
@@ -17243,8 +17905,8 @@ const options$3 = {
         default: 'compact',
     },
 };
-const builder$3 = (yargs) => {
-    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
+const builder$4 = (yargs) => {
+    return yargs.options(options$4).usage(getCommandUsageHeader(command$4));
 };
 
 /**
@@ -17818,30 +18480,6 @@ async function getBranchOverview(git) {
     };
 }
 
-const execFileAsync = util$1.promisify(child_process.execFile);
-function parseGitHubRemoteUrl$1(url) {
-    const trimmed = url.trim().replace(/\.git$/, '');
-    const sshMatch = trimmed.match(/^git@github\.com:([^/]+)\/(.+)$/);
-    const httpsMatch = trimmed.match(/^https:\/\/github\.com\/([^/]+)\/(.+)$/);
-    const match = sshMatch || httpsMatch;
-    if (!match) {
-        return undefined;
-    }
-    return {
-        owner: match[1],
-        name: match[2],
-    };
-}
-async function defaultGhRunner(args) {
-    const result = await execFileAsync('gh', args);
-    return result.stdout;
-}
-async function getGitHubRepository(git) {
-    const remotes = await git.getRemotes(true);
-    const remote = remotes.find((entry) => entry.name === 'origin') || remotes[0];
-    const url = remote?.refs.push || remote?.refs.fetch;
-    return url ? parseGitHubRemoteUrl$1(url) : undefined;
-}
 function parsePullRequestInfo(output) {
     const trimmed = output.trim();
     if (!trimmed) {
@@ -17920,10 +18558,7 @@ async function getPullRequestOverview(git, runner = defaultGhRunner) {
             message: 'No GitHub remote detected.',
         };
     }
-    try {
-        await runner(['auth', 'status', '--hostname', 'github.com']);
-    }
-    catch {
+    if (!(await isGhAuthenticated(runner))) {
         return {
             available: true,
             authenticated: false,
@@ -19800,6 +20435,7 @@ async function runCommitSplitPlanWorkflow(input = {}) {
     const key = getApiKeyForModel(config);
     const { provider } = getModelAndProviderFromConfig(config);
     const commitService = resolveDynamicService(config, 'commit');
+    const splitService = resolveDynamicService(config, 'commitSplit');
     const model = commitService.model;
     if (config.service.authentication.type !== 'None' && !key) {
         return {
@@ -19810,6 +20446,10 @@ async function runCommitSplitPlanWorkflow(input = {}) {
     try {
         const tokenizer = await getTokenCounter(provider === 'openai' ? model : 'gpt-4o');
         const llm = getLlm(provider, model, { ...config, service: commitService });
+        const planLlm = getLlm(provider, splitService.model, {
+            ...config,
+            service: splitService,
+        });
         const result = await prepareCommitSplitPlan({
             argv,
             config,
@@ -19817,6 +20457,8 @@ async function runCommitSplitPlanWorkflow(input = {}) {
             logger,
             tokenizer,
             llm,
+            planLlm,
+            planService: splitService,
         });
         if ('empty' in result) {
             return {
@@ -19958,7 +20600,7 @@ async function runPullRequestBodyWorkflow(input = {}) {
     const argv = createChangelogArgv({ branch: baseBranch });
     let raw = '';
     try {
-        raw = await captureStdout(() => handler$7(argv, new Logger({
+        raw = await captureStdout(() => handler$9(argv, new Logger({
             verbose: true,
             silent: false,
         })));
@@ -20021,7 +20663,7 @@ async function runChangelogTextWorkflow(input = {}) {
     const argv = createChangelogArgv(input);
     let raw = '';
     try {
-        raw = await captureStdout(() => handler$7(argv, new Logger({
+        raw = await captureStdout(() => handler$9(argv, new Logger({
             verbose: true,
             silent: false,
         })));
@@ -20043,10 +20685,12 @@ async function runChangelogTextWorkflow(input = {}) {
 const LOG_INK_CONTEXT_KEYS = [
     'bisect',
     'branches',
+    'issueList',
     'lfs',
     'operation',
     'provider',
     'pullRequest',
+    'pullRequestList',
     'reflog',
     'stashes',
     'submodules',
@@ -20492,6 +21136,60 @@ function getLogInkWorkflowActions() {
             kind: 'normal',
             requiresConfirmation: false,
         },
+        // #882 phase 5 — triage-view destructive verbs. Each routed
+        // through the y-confirm path so single-keystroke `x` / `a` /
+        // `R` / `m` never silently rewrites publicly-visible state.
+        // The runner reads the cursored item from the filtered list
+        // at confirm-time — the cursor can't move while the
+        // confirmation overlay is up, so no stale-target risk.
+        {
+            id: 'triage-issue-close',
+            key: '',
+            label: 'Close issue',
+            description: 'Close the cursored issue on the triage list view.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'triage-issue-reopen',
+            key: '',
+            label: 'Reopen issue',
+            description: 'Reopen the cursored issue on the triage list view.',
+            kind: 'normal',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'triage-pr-merge',
+            key: '',
+            label: 'Merge pull request',
+            description: 'Merge the cursored pull request on the triage list view (prompts for merge / squash / rebase, then confirms).',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'triage-pr-close',
+            key: '',
+            label: 'Close pull request',
+            description: 'Close the cursored pull request on the triage list view without merging.',
+            kind: 'destructive',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'triage-pr-approve',
+            key: '',
+            label: 'Approve pull request',
+            description: 'Submit an approving review on the cursored pull request.',
+            kind: 'normal',
+            requiresConfirmation: true,
+        },
+        {
+            id: 'triage-pr-request-changes',
+            key: '',
+            label: 'Request changes on pull request',
+            description: 'Submit a change-request review on the cursored pull request (prompts for body, then confirms).',
+            kind: 'normal',
+            requiresConfirmation: true,
+        },
         {
             // Per-view-only: scoped to the history view in inkInput so `R`
             // doesn't fire elsewhere (it's also `R` for rename in branches
@@ -20887,6 +21585,20 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Push the dedicated pull-request action panel for the current branch.',
         contexts: ['normal'],
     },
+    {
+        id: 'navigatePullRequestTriage',
+        keys: ['gP'],
+        label: 'PR triage',
+        description: 'Push the multi-PR triage list view (#882). Capital P disambiguates from `gp` which targets the single-PR panel for the current branch.',
+        contexts: ['normal'],
+    },
+    {
+        id: 'navigateIssues',
+        keys: ['gi'],
+        label: 'issues',
+        description: 'Push the issue triage list view (#882).',
+        contexts: ['normal'],
+    },
     {
         id: 'navigateConflicts',
         keys: ['gx'],
@@ -21065,6 +21777,8 @@ const GLOBAL_BINDING_IDS = [
     'navigateStash',
     'navigateWorktrees',
     'navigatePullRequest',
+    'navigatePullRequestTriage',
+    'navigateIssues',
     'navigateConflicts',
     'navigateReflog',
     'navigateBisect',
@@ -21302,6 +22016,24 @@ function getLogInkFooterHints(options) {
             global: NORMAL_GLOBAL_HINTS,
         };
     }
+    if (options.activeView === 'issues') {
+        return {
+            // #882 phase 4-6 — read + additive mutations + destructive
+            // (gated through y-confirm) + filter cycling. AI summarize
+            // (`I`) deferred to a follow-up.
+            contextual: ['↑/↓ issues', 'f filter', 'O open', 'y yank URL', 'c comment', 'L label', 'A assign', 'x close*', 'X reopen', 'esc back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
+    if (options.activeView === 'pull-request-triage') {
+        return {
+            // #882 phase 4-6 — full PR action panel scoped to the triage
+            // list + filter cycling. AI summarize (`I`) deferred to a
+            // follow-up.
+            contextual: ['↑/↓ PRs', 'f filter', 'O open', 'y yank URL', 'c comment', 'L label', 'A assign', 'm merge*', 'x close*', 'a approve', 'R changes*', 'esc back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
     if (options.activeView === 'submodules') {
         return {
             contextual: ['↑/↓ entries', 'y yank path', 'Y yank sha', '/ filter', 'esc back'],
@@ -21482,6 +22214,109 @@ function filterLogInkPaletteCommands(commands, filter, recent) {
         .map((entry) => entry.command);
 }
 
+/**
+ * Canned filter presets for the issue / PR triage TUI views
+ * (#882 phase 6). Each preset compiles to the same shape the
+ * underlying list fetchers (`getIssueList` / `getPullRequestList`)
+ * already accept — there's no new `gh` surface area, just a
+ * curated set of common triage angles surfaced as a single
+ * keystroke (`f` cycles).
+ *
+ * The presets are deliberately *not* a 1:1 mirror across the two
+ * surfaces:
+ *
+ *   - Issues have no draft / mergeable concept, so `draft` /
+ *     `mergeable` are skipped on the issue list.
+ *   - PRs have a `merged` state distinct from `closed`; issues
+ *     don't.
+ *   - `mine` semantics differ subtly: for issues it tends to
+ *     mean "I'm the assignee" (issues are tasks people pick up);
+ *     for PRs it means "I'm the author" (PRs are work people
+ *     post). The presets bake those in so the user doesn't have
+ *     to think about it.
+ */
+/** Cycle order — must match the keystroke walk on `f`. */
+const ISSUE_FILTER_PRESETS = [
+    'open',
+    'closed',
+    'mine',
+    'assigned',
+];
+const PULL_REQUEST_FILTER_PRESETS = [
+    'open',
+    'draft',
+    'mine',
+    'assigned',
+    'closed',
+    'merged',
+];
+const ISSUE_FILTER_LABELS = {
+    open: 'open',
+    closed: 'closed',
+    mine: 'mine (assigned)',
+    assigned: 'assigned to me',
+};
+const PULL_REQUEST_FILTER_LABELS = {
+    open: 'open',
+    draft: 'draft',
+    mine: 'mine (authored)',
+    assigned: 'assigned to me',
+    closed: 'closed',
+    merged: 'merged',
+};
+/**
+ * Resolve a preset to the filter object the data fetcher accepts.
+ * Pure mapping — no `gh` calls. Kept separate from `getIssueList` /
+ * `getPullRequestList` so unit tests can assert the mapping
+ * independently from the fetch pipeline.
+ */
+function issueFilterForPreset(preset) {
+    switch (preset) {
+        case 'open':
+            return { state: 'open' };
+        case 'closed':
+            return { state: 'closed' };
+        case 'mine':
+            // Issues are tasks — "mine" is what *I'm working on*, i.e.
+            // assigned to me + still open. Same as `assigned` plus the
+            // open-state filter for ergonomic single-keystroke focus on
+            // the active backlog.
+            return { state: 'open', assignee: '@me' };
+        case 'assigned':
+            return { assignee: '@me' };
+    }
+}
+function pullRequestFilterForPreset(preset) {
+    switch (preset) {
+        case 'open':
+            return { state: 'open' };
+        case 'draft':
+            // gh's `--draft` flag implies `--state open`; surface that
+            // explicitly so the canonicalize step doesn't elide it.
+            return { state: 'open', draft: true };
+        case 'mine':
+            // PRs are work — "mine" is what *I authored*. Most useful
+            // when looking at one's own backlog of in-flight PRs.
+            return { state: 'open', author: '@me' };
+        case 'assigned':
+            return { assignee: '@me' };
+        case 'closed':
+            return { state: 'closed' };
+        case 'merged':
+            return { state: 'merged' };
+    }
+}
+function cycleIssueFilterPreset(current) {
+    const index = ISSUE_FILTER_PRESETS.indexOf(current);
+    const next = (index + 1) % ISSUE_FILTER_PRESETS.length;
+    return ISSUE_FILTER_PRESETS[next];
+}
+function cyclePullRequestFilterPreset(current) {
+    const index = PULL_REQUEST_FILTER_PRESETS.indexOf(current);
+    const next = (index + 1) % PULL_REQUEST_FILTER_PRESETS.length;
+    return PULL_REQUEST_FILTER_PRESETS[next];
+}
+
 /**
  * Sort modes for the promoted views (P4.2).
  *
@@ -21869,6 +22704,10 @@ function createLogInkState(rows, options = {}) {
         selectedConflictFileIndex: 0,
         selectedReflogIndex: 0,
         selectedSubmoduleIndex: 0,
+        selectedIssueIndex: 0,
+        selectedPullRequestTriageIndex: 0,
+        selectedIssueFilter: 'open',
+        selectedPullRequestFilter: 'open',
         repoStack: [{ label: options.repoLabel || 'root' }],
         branchSort: DEFAULT_BRANCH_SORT_MODE,
         tagSort: DEFAULT_TAG_SORT_MODE,
@@ -22131,6 +22970,36 @@ function applyLogInkAction(state, action) {
                 selectedSubmoduleIndex: clampIndex(state.selectedSubmoduleIndex + action.delta, action.count),
                 pendingKey: undefined,
             };
+        case 'moveIssue':
+            return {
+                ...state,
+                selectedIssueIndex: clampIndex(state.selectedIssueIndex + action.delta, action.count),
+                pendingKey: undefined,
+            };
+        case 'movePullRequestTriage':
+            return {
+                ...state,
+                selectedPullRequestTriageIndex: clampIndex(state.selectedPullRequestTriageIndex + action.delta, action.count),
+                pendingKey: undefined,
+            };
+        case 'cycleIssueFilter':
+            // Advance the preset, snap the cursor to the top of the
+            // (newly filtered) list — same UX rule as `cycleBranchSort`.
+            // The list refetches on preset change via the effect in
+            // app.ts, so the cursor at 0 lands on whatever was promoted.
+            return {
+                ...state,
+                selectedIssueFilter: cycleIssueFilterPreset(state.selectedIssueFilter),
+                selectedIssueIndex: 0,
+                pendingKey: undefined,
+            };
+        case 'cyclePullRequestTriageFilter':
+            return {
+                ...state,
+                selectedPullRequestFilter: cyclePullRequestFilterPreset(state.selectedPullRequestFilter),
+                selectedPullRequestTriageIndex: 0,
+                pendingKey: undefined,
+            };
         case 'moveWorktreeListEntry':
             return {
                 ...state,
@@ -22953,6 +23822,22 @@ function isReflogActionTarget(state) {
 function isSubmodulesActionTarget(state) {
     return state.activeView === 'submodules' && state.focus === 'commits';
 }
+/**
+ * Issue triage list (#882 phase 3). Same shape as the other promoted
+ * read-only views — j/k move the cursor when the commits pane is
+ * focused on the dedicated view.
+ */
+function isIssueActionTarget(state) {
+    return state.activeView === 'issues' && state.focus === 'commits';
+}
+/**
+ * Pull-request triage list (#882 phase 3). Distinct from the existing
+ * `pull-request` single-PR action panel — this is the multi-PR list
+ * surface and its cursor lives in `selectedPullRequestTriageIndex`.
+ */
+function isPullRequestTriageActionTarget(state) {
+    return state.activeView === 'pull-request-triage' && state.focus === 'commits';
+}
 function isWorktreeActionTarget(state) {
     return (state.activeView === 'worktrees' && state.focus === 'commits') ||
         (state.focus === 'sidebar' && state.sidebarTab === 'worktrees');
@@ -23102,6 +23987,10 @@ function getLogInkPaletteExecuteEvents(command, state) {
             return [action({ type: 'pushView', value: 'worktrees' })];
         case 'navigatePullRequest':
             return [action({ type: 'pushView', value: 'pull-request' })];
+        case 'navigatePullRequestTriage':
+            return [action({ type: 'pushView', value: 'pull-request-triage' })];
+        case 'navigateIssues':
+            return [action({ type: 'pushView', value: 'issues' })];
         case 'navigateConflicts':
             return [action({ type: 'pushView', value: 'conflicts' })];
         case 'navigateReflog':
@@ -23276,6 +24165,69 @@ function submitInputPrompt(state) {
             action({ type: 'closeInputPrompt' }),
         ];
     }
+    // #882 phase 4 — triage-view mutation prompts. Each kind routes to
+    // its by-number workflow id; the runner reads the cursored item
+    // from state + filtered list and runs the matching `gh` action.
+    if (state.inputPrompt.kind === 'triage-issue-comment') {
+        return [
+            { type: 'runWorkflowAction', id: 'triage-issue-comment', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'triage-issue-label') {
+        return [
+            { type: 'runWorkflowAction', id: 'triage-issue-label', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'triage-issue-assign') {
+        return [
+            { type: 'runWorkflowAction', id: 'triage-issue-assign', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'triage-pr-comment') {
+        return [
+            { type: 'runWorkflowAction', id: 'triage-pr-comment', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'triage-pr-label') {
+        return [
+            { type: 'runWorkflowAction', id: 'triage-pr-label', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'triage-pr-assign') {
+        return [
+            { type: 'runWorkflowAction', id: 'triage-pr-assign', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    // #882 phase 5 — destructive prompt submissions route through the
+    // y-confirm path (not directly to runWorkflowAction) so the user
+    // gets a final "are you sure?" before anything ships. The
+    // collected value (strategy / body) rides along as the
+    // confirmation payload.
+    if (state.inputPrompt.kind === 'triage-pr-merge-strategy') {
+        const strategy = value.toLowerCase();
+        if (strategy !== 'merge' && strategy !== 'squash' && strategy !== 'rebase') {
+            return [action({
+                    type: 'setStatus',
+                    value: `Unknown merge strategy: ${value}. Use merge, squash, or rebase.`,
+                })];
+        }
+        return [
+            action({ type: 'setPendingConfirmation', value: 'triage-pr-merge', payload: strategy }),
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
+    if (state.inputPrompt.kind === 'triage-pr-request-changes') {
+        return [
+            action({ type: 'setPendingConfirmation', value: 'triage-pr-request-changes', payload: value }),
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     if (state.inputPrompt.kind === 'pr-request-changes') {
         return [
             action({ type: 'setPendingConfirmation', value: 'request-changes-pr', payload: value }),
@@ -23698,6 +24650,23 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'setStatus', value: 'jumped to pull request' }),
         ];
     }
+    // `gP` chord (#882 phase 3): jump to the multi-PR triage list.
+    // Capital P disambiguates from `gp` (current-branch PR panel).
+    // Pleasingly symmetric with `gi` for issues — both lead to the
+    // read-only list views shipped in #882.
+    if (state.pendingKey === 'g' && inputValue === 'P') {
+        return [
+            action({ type: 'pushView', value: 'pull-request-triage' }),
+            action({ type: 'setStatus', value: 'jumped to PR triage' }),
+        ];
+    }
+    // `gi` chord (#882 phase 3): jump to the issue triage list.
+    if (state.pendingKey === 'g' && inputValue === 'i') {
+        return [
+            action({ type: 'pushView', value: 'issues' }),
+            action({ type: 'setStatus', value: 'jumped to issues' }),
+        ];
+    }
     if (state.pendingKey === 'g' && inputValue === 'x') {
         return [
             action({ type: 'pushView', value: 'conflicts' }),
@@ -24136,6 +25105,16 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (isSubmodulesActionTarget(state) && context.submoduleCount) {
             return [action({ type: 'moveSubmodule', delta: -1, count: context.submoduleCount })];
         }
+        if (isIssueActionTarget(state) && context.issueCount) {
+            return [action({ type: 'moveIssue', delta: -1, count: context.issueCount })];
+        }
+        if (isPullRequestTriageActionTarget(state) && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'movePullRequestTriage',
+                    delta: -1,
+                    count: context.pullRequestTriageCount,
+                })];
+        }
         if (isWorktreeActionTarget(state) && context.worktreeListCount) {
             return [action({ type: 'moveWorktreeListEntry', delta: -1, count: context.worktreeListCount })];
         }
@@ -24223,6 +25202,16 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (isSubmodulesActionTarget(state) && context.submoduleCount) {
             return [action({ type: 'moveSubmodule', delta: 1, count: context.submoduleCount })];
         }
+        if (isIssueActionTarget(state) && context.issueCount) {
+            return [action({ type: 'moveIssue', delta: 1, count: context.issueCount })];
+        }
+        if (isPullRequestTriageActionTarget(state) && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'movePullRequestTriage',
+                    delta: 1,
+                    count: context.pullRequestTriageCount,
+                })];
+        }
         if (isWorktreeActionTarget(state) && context.worktreeListCount) {
             return [action({ type: 'moveWorktreeListEntry', delta: 1, count: context.worktreeListCount })];
         }
@@ -24639,6 +25628,120 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
                 multiline: true,
             })];
     }
+    // #882 phase 4 — issue triage per-row actions. Scoped to the
+    // `'issues'` view + commits focus so the single-letter keys stay
+    // free elsewhere. Each prompts; submit dispatches the matching
+    // `triage-issue-*` workflow which routes through `gh issue` and
+    // invalidates both the in-memory + disk caches on success.
+    if (state.activeView === 'issues' && state.focus === 'commits') {
+        if (inputValue === 'O' && context.issueSelectedUrl) {
+            return [{ type: 'runWorkflowAction', id: 'triage-issue-open' }];
+        }
+        if (inputValue === 'c' && context.issueCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-issue-comment',
+                    label: 'Comment body (Enter newline · Ctrl+D submit)',
+                    multiline: true,
+                })];
+        }
+        if (inputValue === 'L' && context.issueCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-issue-label',
+                    label: 'Label name to add',
+                })];
+        }
+        if (inputValue === 'A' && context.issueCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-issue-assign',
+                    label: 'Assignee login (or @me)',
+                    initial: '@me',
+                })];
+        }
+        // #882 phase 5 — destructive issue mutations. Both gated through
+        // the y-confirm path. `x` closes (matches `pull-request` view's
+        // close binding); `X` reopens, useful to undo a stray close.
+        if (inputValue === 'x' && context.issueCount) {
+            return [action({ type: 'setPendingConfirmation', value: 'triage-issue-close' })];
+        }
+        if (inputValue === 'X' && context.issueCount) {
+            return [action({ type: 'setPendingConfirmation', value: 'triage-issue-reopen' })];
+        }
+        // #882 phase 6 — cycle the canned filter preset (open → closed
+        // → mine → assigned → open). The effect in app.ts watches
+        // `state.selectedIssueFilter` and refetches with the matching
+        // filter object, so the list updates without an explicit
+        // refresh keystroke.
+        if (inputValue === 'f') {
+            return [action({ type: 'cycleIssueFilter' })];
+        }
+    }
+    // #882 phase 4 — PR triage per-row actions. Same shape as the
+    // issue handlers above; distinct view id so the keys don't
+    // collide with the single-PR action panel (`pull-request`).
+    if (state.activeView === 'pull-request-triage' && state.focus === 'commits') {
+        if (inputValue === 'O' && context.pullRequestTriageSelectedUrl) {
+            return [{ type: 'runWorkflowAction', id: 'triage-pr-open' }];
+        }
+        if (inputValue === 'c' && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-pr-comment',
+                    label: 'Comment body (Enter newline · Ctrl+D submit)',
+                    multiline: true,
+                })];
+        }
+        if (inputValue === 'L' && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-pr-label',
+                    label: 'Label name to add',
+                })];
+        }
+        if (inputValue === 'A' && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-pr-assign',
+                    label: 'Assignee login (or @me)',
+                    initial: '@me',
+                })];
+        }
+        // #882 phase 5 — destructive PR mutations on the triage view.
+        // Mirror the single-PR action panel's keys (m / x / a / R) but
+        // route to the by-number workflows. `m` and `R` open input
+        // prompts first; submit lands the strategy / body as the
+        // confirmation payload, which the runner picks up after y.
+        if (inputValue === 'm' && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-pr-merge-strategy',
+                    label: 'Merge strategy (merge / squash / rebase)',
+                })];
+        }
+        if (inputValue === 'x' && context.pullRequestTriageCount) {
+            return [action({ type: 'setPendingConfirmation', value: 'triage-pr-close' })];
+        }
+        if (inputValue === 'a' && context.pullRequestTriageCount) {
+            return [action({ type: 'setPendingConfirmation', value: 'triage-pr-approve' })];
+        }
+        if (inputValue === 'R' && context.pullRequestTriageCount) {
+            return [action({
+                    type: 'openInputPrompt',
+                    kind: 'triage-pr-request-changes',
+                    label: 'Request changes — review body (Enter newline · Ctrl+D submit)',
+                    multiline: true,
+                })];
+        }
+        // #882 phase 6 — cycle the canned filter preset (open → draft
+        // → mine → assigned → closed → merged → open). The effect in
+        // app.ts watches `state.selectedPullRequestFilter` and refetches
+        // with the matching filter object.
+        if (inputValue === 'f') {
+            return [action({ type: 'cyclePullRequestTriageFilter' })];
+        }
+    }
     // Global stash hotkey: `S` opens a stash-message prompt and
     // `createStash` runs once submitted. Available everywhere there's
     // not a more modal handler in front of it.
@@ -24889,6 +25992,17 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         if (isSubmodulesActionTarget(state) && context.submoduleCount) {
             return [{ type: 'yankFromActiveView', short }];
         }
+        // #882 phase 4 — triage views: y yanks the cursored issue / PR
+        // URL so the user can paste it into a chat / PR description
+        // without dropping back to the browser. Y is a no-op on these
+        // views — there's no compact alternate identifier worth a
+        // second key.
+        if (isIssueActionTarget(state) && context.issueSelectedUrl) {
+            return [{ type: 'yankFromActiveView' }];
+        }
+        if (isPullRequestTriageActionTarget(state) && context.pullRequestTriageSelectedUrl) {
+            return [{ type: 'yankFromActiveView' }];
+        }
     }
     // Enter on a stash row pushes the diff view scoped to that stash.
     // The runtime loads `git stash show -p <ref>` once the view is
@@ -25398,9 +26512,56 @@ const LOG_INK_DEFAULT_ROWS = 40;
  * gives both views their own air.
  */
 const INSPECTOR_TABBED_BELOW_ROWS = 28;
+/**
+ * Density-tier breakpoints in columns. Picked so the three legacy
+ * panels (sidebar ~24-32 + inspector ~20-32 + main) still leave the
+ * history panel with at least ~40 usable cells before we start
+ * collapsing chrome:
+ *
+ *   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
+ */
+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.
+ */
+const LAYOUT_RAIL_PANEL_WIDTH = 8;
+const SIDEBAR_AT_REST_BY_TIER = {
+    rail: { min: 22, max: 28, fraction: 0.24 }, // unused — rail collapses to LAYOUT_RAIL_PANEL_WIDTH
+    tight: { min: 22, max: 28, fraction: 0.24 },
+    normal: { min: 22, max: 30, fraction: 0.22 },
+    wide: { min: 28, max: 48, fraction: 0.24 },
+};
+function calcSidebarAtRestWidth(columns, density) {
+    const config = SIDEBAR_AT_REST_BY_TIER[density];
+    return Math.max(config.min, Math.min(config.max, Math.floor(columns * config.fraction)));
+}
 function getLogInkLayout(input) {
     const columns = input.columns || LOG_INK_DEFAULT_COLUMNS;
     const rows = input.rows || LOG_INK_DEFAULT_ROWS;
+    const density = columns >= LAYOUT_NORMAL_BELOW
+        ? 'wide'
+        : columns >= LAYOUT_TIGHT_BELOW
+            ? 'normal'
+            : 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;
     // 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
@@ -25411,17 +26572,30 @@ function getLogInkLayout(input) {
     // hotkey descriptions render in full instead of truncating to
     // "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.
     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)))
-            : Math.max(20, Math.min(32, Math.floor(columns * 0.22)));
-    // Sidebar at rest: 22-34 cells (~24% of width). Focused: 32-50 cells
-    // (~36% of width). The transition is instant per render — focus tab to
-    // expand, focus away to collapse.
+            : inspectorRailed
+                ? LAYOUT_RAIL_PANEL_WIDTH
+                : 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.
     const sidebarWidth = input.sidebarFocused
         ? Math.max(32, Math.min(50, Math.floor(columns * 0.36)))
-        : Math.max(22, Math.min(34, Math.floor(columns * 0.24)));
+        : sidebarRailed
+            ? LAYOUT_RAIL_PANEL_WIDTH
+            : calcSidebarAtRestWidth(columns, density);
     return {
         bodyRows: Math.max(8, rows - 5),
         columns,
@@ -25431,6 +26605,10 @@ function getLogInkLayout(input) {
         sidebarWidth,
         tooSmall: columns < LOG_INK_MIN_COLUMNS || rows < LOG_INK_MIN_ROWS,
         inspectorTabbed: rows < INSPECTOR_TABBED_BELOW_ROWS,
+        density,
+        sidebarRailed,
+        inspectorRailed,
+        historyRowMode: density === 'rail' ? 'stacked' : 'single',
     };
 }
 
@@ -26140,6 +27318,382 @@ function stageConflictResolved(git, path) {
     return runAction$1(() => git.raw(['add', '--', path]), `Staged ${path} (marked resolved)`);
 }
 
+/**
+ * Per-item issue detail fetcher (#882 inspector hydration). The list
+ * payload from `gh issue list` deliberately omits bodies and
+ * comments to keep the list fetch cheap; this module fills those in
+ * on demand when the user rests the cursor on a specific issue.
+ *
+ * Called from the workstation runtime with a debounced timer so
+ * rapid j/k navigation doesn't spam `gh`. Results land in a
+ * `Map<number, IssueDetail>` cache on `LogInkContext` keyed by
+ * issue number, so cursoring back to a previously-fetched item
+ * shows instantly.
+ */
+/**
+ * `gh issue view <#> --json` field list. Kept separate from the
+ * list-view field list since the detail view only needs the
+ * fields that the list payload doesn't already carry.
+ */
+const ISSUE_DETAIL_JSON_FIELDS = ['number', 'body', 'comments'].join(',');
+function parseIssueComments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => {
+        const raw = entry;
+        const author = raw.author && typeof raw.author === 'object' && 'login' in raw.author
+            ? String(raw.author.login)
+            : undefined;
+        return {
+            author,
+            body: typeof raw.body === 'string' ? raw.body : '',
+            createdAt: typeof raw.createdAt === 'string' ? raw.createdAt : '',
+        };
+    });
+}
+function parseIssueDetail(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return undefined;
+    const raw = JSON.parse(trimmed);
+    if (typeof raw.number !== 'number')
+        return undefined;
+    return {
+        number: raw.number,
+        body: typeof raw.body === 'string' ? raw.body : '',
+        comments: parseIssueComments(raw.comments),
+    };
+}
+async function getIssueDetail(issueNumber, runner = defaultGhRunner) {
+    try {
+        const output = await runner([
+            'issue',
+            'view',
+            String(issueNumber),
+            '--json',
+            ISSUE_DETAIL_JSON_FIELDS,
+        ]);
+        const detail = parseIssueDetail(output);
+        if (!detail) {
+            return { ok: false, message: `Empty response from gh for issue #${issueNumber}` };
+        }
+        return { ok: true, detail };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+
+/**
+ * Low-risk issue mutations driven from the issue-triage TUI (#882
+ * phase 4). Mirrors `pullRequestActions.ts`'s shape — each function
+ * wraps a single `gh issue <verb>` invocation through the shared
+ * runner indirection so tests can mock the shell-out cleanly.
+ *
+ * "Low risk" here means: reversible by re-invoking with the
+ * opposite flag (`--add-label` ↔ `--remove-label`), or strictly
+ * additive (comment). The destructive verbs (`close`, `reopen`,
+ * `delete`) land in phase 5 alongside the PR-level destructive
+ * mutations, all gated through the y-confirm path.
+ */
+async function runGhAction$1(runner, args, successMessage) {
+    try {
+        return successMessage(await runner(args));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error.message,
+        };
+    }
+}
+function commentIssue(issueNumber, body, runner = defaultGhRunner) {
+    if (!body.trim()) {
+        return Promise.resolve({ ok: false, message: 'Comment body required' });
+    }
+    return runGhAction$1(runner, ['issue', 'comment', String(issueNumber), '--body', body], (output) => ({
+        ok: true,
+        message: output.trim() || `Commented on issue #${issueNumber}`,
+    }));
+}
+function addIssueLabel(issueNumber, label, runner = defaultGhRunner) {
+    if (!label.trim()) {
+        return Promise.resolve({ ok: false, message: 'Label name required' });
+    }
+    return runGhAction$1(runner, ['issue', 'edit', String(issueNumber), '--add-label', label], () => ({
+        ok: true,
+        message: `Added label '${label}' to issue #${issueNumber}`,
+    }));
+}
+function addIssueAssignee(issueNumber, assignee, runner = defaultGhRunner) {
+    if (!assignee.trim()) {
+        return Promise.resolve({ ok: false, message: 'Assignee login required' });
+    }
+    return runGhAction$1(runner, ['issue', 'edit', String(issueNumber), '--add-assignee', assignee], () => ({
+        ok: true,
+        message: `Assigned ${assignee} to issue #${issueNumber}`,
+    }));
+}
+/**
+ * Destructive issue verbs (#882 phase 5). Both routed through the
+ * y-confirm path in the workstation; the action functions themselves
+ * make no extra guarantee — every gh-side error surfaces via the
+ * standard `runGhAction` error wrapper.
+ */
+function closeIssue(issueNumber, runner = defaultGhRunner) {
+    return runGhAction$1(runner, ['issue', 'close', String(issueNumber)], (output) => ({
+        ok: true,
+        message: output.trim() || `Closed issue #${issueNumber}`,
+    }));
+}
+function reopenIssue(issueNumber, runner = defaultGhRunner) {
+    return runGhAction$1(runner, ['issue', 'reopen', String(issueNumber)], (output) => ({
+        ok: true,
+        message: output.trim() || `Reopened issue #${issueNumber}`,
+    }));
+}
+
+/**
+ * Per-item PR detail fetcher (#882 inspector hydration). Mirrors
+ * `issueDetailData.ts`'s shape — pulls body, comments, reviews,
+ * and the status-check rollup on demand when the user rests the
+ * cursor on a PR row.
+ *
+ * Distinct from the existing `pullRequestData.ts` which fetches
+ * the CURRENT BRANCH's PR via `gh pr view` (no number arg). This
+ * fetcher takes an explicit PR number so the triage view can
+ * hydrate any cursored PR, not just the one matching the current
+ * branch.
+ */
+/**
+ * `gh pr view <#> --json` field list. Subset of what
+ * `pullRequestData.ts`'s `PULL_REQUEST_VIEW_JSON_FIELDS` includes —
+ * the triage list payload already carries the structural metadata
+ * (state, isDraft, branches, labels, etc.), so the detail fetch
+ * only needs the heavy/expensive fields that the list omits.
+ */
+const PULL_REQUEST_DETAIL_JSON_FIELDS = [
+    'number',
+    'body',
+    'comments',
+    'reviews',
+    'statusCheckRollup',
+].join(',');
+function parseComments(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => {
+        const raw = entry;
+        const author = raw.author && typeof raw.author === 'object' && 'login' in raw.author
+            ? String(raw.author.login)
+            : undefined;
+        return {
+            author,
+            body: typeof raw.body === 'string' ? raw.body : '',
+            createdAt: typeof raw.createdAt === 'string' ? raw.createdAt : '',
+        };
+    });
+}
+function parseReviews(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((entry) => {
+        const raw = entry;
+        const author = raw.author && typeof raw.author === 'object' && 'login' in raw.author
+            ? String(raw.author.login)
+            : undefined;
+        return {
+            author,
+            state: typeof raw.state === 'string' ? raw.state : '',
+            body: typeof raw.body === 'string' ? raw.body : '',
+            submittedAt: typeof raw.submittedAt === 'string' ? raw.submittedAt : '',
+        };
+    })
+        // gh occasionally returns review entries without an author when the
+        // reviewer's account is deleted. Those are unactionable noise here;
+        // strip them so the inspector doesn't render anonymous rows.
+        .filter((review) => review.author || review.body);
+}
+function parseStatusCheckRollup(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => {
+        const raw = entry;
+        return {
+            name: String(raw.name || raw.context || 'check'),
+            status: typeof raw.status === 'string' ? raw.status : undefined,
+            conclusion: typeof raw.conclusion === 'string' ? raw.conclusion : undefined,
+        };
+    });
+}
+function parsePullRequestDetail(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return undefined;
+    const raw = JSON.parse(trimmed);
+    if (typeof raw.number !== 'number')
+        return undefined;
+    return {
+        number: raw.number,
+        body: typeof raw.body === 'string' ? raw.body : '',
+        comments: parseComments(raw.comments),
+        reviews: parseReviews(raw.reviews),
+        statusCheckRollup: parseStatusCheckRollup(raw.statusCheckRollup),
+    };
+}
+async function getPullRequestDetail(pullRequestNumber, runner = defaultGhRunner) {
+    try {
+        const output = await runner([
+            'pr',
+            'view',
+            String(pullRequestNumber),
+            '--json',
+            PULL_REQUEST_DETAIL_JSON_FIELDS,
+        ]);
+        const detail = parsePullRequestDetail(output);
+        if (!detail) {
+            return {
+                ok: false,
+                message: `Empty response from gh for pull request #${pullRequestNumber}`,
+            };
+        }
+        return { ok: true, detail };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+
+/**
+ * `gh pr list --json` field list. Trimmer than `pullRequestData.ts`'s
+ * single-PR field set — the triage list view doesn't need bodies,
+ * statusCheckRollup, or per-review breakdowns (those live in the
+ * inspector that opens when the user picks a row).
+ */
+const PULL_REQUEST_LIST_JSON_FIELDS = [
+    'number',
+    'title',
+    'url',
+    'state',
+    'isDraft',
+    'headRefName',
+    'baseRefName',
+    'author',
+    'assignees',
+    'labels',
+    'reviewDecision',
+    'mergeable',
+    'mergeStateStatus',
+    'createdAt',
+    'updatedAt',
+].join(',');
+function parsePullRequestListItems(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return [];
+    const raw = JSON.parse(trimmed);
+    return raw.map((entry) => {
+        const author = entry.author && typeof entry.author === 'object' && 'login' in entry.author
+            ? String(entry.author.login)
+            : undefined;
+        const assignees = Array.isArray(entry.assignees)
+            ? entry.assignees
+                .map((a) => (a && 'login' in a ? String(a.login) : ''))
+                .filter(Boolean)
+            : undefined;
+        const labels = Array.isArray(entry.labels)
+            ? entry.labels
+                .map((l) => (l && 'name' in l ? String(l.name) : ''))
+                .filter(Boolean)
+            : undefined;
+        return {
+            number: entry.number,
+            title: String(entry.title || ''),
+            url: String(entry.url || ''),
+            state: String(entry.state || ''),
+            isDraft: Boolean(entry.isDraft),
+            headRefName: String(entry.headRefName || ''),
+            baseRefName: String(entry.baseRefName || ''),
+            author,
+            assignees,
+            labels,
+            reviewDecision: typeof entry.reviewDecision === 'string' ? entry.reviewDecision : undefined,
+            mergeable: typeof entry.mergeable === 'string' ? entry.mergeable : undefined,
+            mergeStateStatus: typeof entry.mergeStateStatus === 'string' ? entry.mergeStateStatus : undefined,
+            createdAt: String(entry.createdAt || ''),
+            updatedAt: String(entry.updatedAt || ''),
+        };
+    });
+}
+function buildGhArgs(filter) {
+    const args = ['pr', 'list', '--json', PULL_REQUEST_LIST_JSON_FIELDS];
+    if (filter.state)
+        args.push('--state', filter.state);
+    if (filter.assignee)
+        args.push('--assignee', filter.assignee);
+    if (filter.author)
+        args.push('--author', filter.author);
+    if (filter.label)
+        args.push('--label', filter.label);
+    if (filter.search)
+        args.push('--search', filter.search);
+    if (filter.draft)
+        args.push('--draft');
+    if (filter.base)
+        args.push('--base', filter.base);
+    if (filter.head)
+        args.push('--head', filter.head);
+    if (typeof filter.limit === 'number')
+        args.push('--limit', String(filter.limit));
+    return args;
+}
+async function getPullRequestList(git, filter = {}, runner = defaultGhRunner) {
+    const repository = await getGitHubRepository(git);
+    if (!repository) {
+        return {
+            available: false,
+            authenticated: false,
+            filter,
+            message: 'No GitHub remote detected.',
+        };
+    }
+    if (!(await isGhAuthenticated(runner))) {
+        return {
+            available: true,
+            authenticated: false,
+            repository,
+            filter,
+            message: 'GitHub CLI is missing or not authenticated.',
+        };
+    }
+    try {
+        const output = await runner(buildGhArgs(filter));
+        return {
+            available: true,
+            authenticated: true,
+            repository,
+            filter,
+            pullRequests: parsePullRequestListItems(output),
+        };
+    }
+    catch (error) {
+        return {
+            available: true,
+            authenticated: true,
+            repository,
+            filter,
+            message: error instanceof Error ? error.message : 'Failed to fetch pull request list.',
+        };
+    }
+}
+
 function parseCreatedPullRequestUrl(output) {
     return output
         .split('\n')
@@ -26240,6 +27794,77 @@ function commentPullRequest(body, runner = defaultGhRunner) {
         message: output.trim() || 'Comment added',
     }));
 }
+/**
+ * Triage-view variants (#882 phase 4). Same shape as
+ * `commentPullRequest` above but target a specific PR by number,
+ * which is what the multi-PR triage list needs (the cursor isn't
+ * necessarily on the current branch's PR). Kept as siblings rather
+ * than overloads so the single-PR call sites stay untouched and
+ * the API stays readable at the call site (no need to pass
+ * `undefined` to skip the number arg).
+ */
+function commentPullRequestByNumber(pullRequestNumber, body, runner = defaultGhRunner) {
+    if (!body.trim()) {
+        return Promise.resolve({ ok: false, message: 'Comment body required' });
+    }
+    return runGhAction(runner, ['pr', 'comment', String(pullRequestNumber), '--body', body], (output) => ({
+        ok: true,
+        message: output.trim() || `Commented on pull request #${pullRequestNumber}`,
+    }));
+}
+function addPullRequestLabel(pullRequestNumber, label, runner = defaultGhRunner) {
+    if (!label.trim()) {
+        return Promise.resolve({ ok: false, message: 'Label name required' });
+    }
+    return runGhAction(runner, ['pr', 'edit', String(pullRequestNumber), '--add-label', label], () => ({
+        ok: true,
+        message: `Added label '${label}' to pull request #${pullRequestNumber}`,
+    }));
+}
+function addPullRequestAssignee(pullRequestNumber, assignee, runner = defaultGhRunner) {
+    if (!assignee.trim()) {
+        return Promise.resolve({ ok: false, message: 'Assignee login required' });
+    }
+    return runGhAction(runner, ['pr', 'edit', String(pullRequestNumber), '--add-assignee', assignee], () => ({
+        ok: true,
+        message: `Assigned ${assignee} to pull request #${pullRequestNumber}`,
+    }));
+}
+/**
+ * Destructive PR verbs targeting a specific number (#882 phase 5).
+ * Siblings of the existing current-branch functions above; both
+ * variants delegate to the same `runGhAction` wrapper so error
+ * shaping stays uniform.
+ */
+function mergePullRequestByNumber(pullRequestNumber, strategy, runner = defaultGhRunner) {
+    return runGhAction(runner, ['pr', 'merge', String(pullRequestNumber), `--${strategy}`], (output) => ({
+        ok: true,
+        message: output.trim() ||
+            `Merged pull request #${pullRequestNumber} with ${strategy}`,
+    }));
+}
+function closePullRequestByNumber(pullRequestNumber, runner = defaultGhRunner) {
+    return runGhAction(runner, ['pr', 'close', String(pullRequestNumber)], (output) => ({
+        ok: true,
+        message: output.trim() || `Closed pull request #${pullRequestNumber}`,
+    }));
+}
+function approvePullRequestByNumber(pullRequestNumber, runner = defaultGhRunner) {
+    return runGhAction(runner, ['pr', 'review', String(pullRequestNumber), '--approve'], (output) => ({
+        ok: true,
+        message: output.trim() || `Approved pull request #${pullRequestNumber}`,
+    }));
+}
+function requestChangesPullRequestByNumber(pullRequestNumber, body, runner = defaultGhRunner) {
+    if (!body.trim()) {
+        return Promise.resolve({ ok: false, message: 'Review body required for change-request' });
+    }
+    return runGhAction(runner, ['pr', 'review', String(pullRequestNumber), '--request-changes', '--body', body], (output) => ({
+        ok: true,
+        message: output.trim() ||
+            `Requested changes on pull request #${pullRequestNumber}`,
+    }));
+}
 
 async function runAction(action, successMessage) {
     try {
@@ -27549,10 +29174,70 @@ function renderActiveSidebarContent(h, Text, tab, state, context, contextStatus,
         return `${marker} ${worktree.branch || worktree.path} ${wstate}`;
     }, 'tab-worktrees', visibleListCount);
 }
-function renderSidebar(h, components, state, context, contextStatus, width, bodyRows, theme) {
+/**
+ * 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(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(h, components, state, context, contextStatus, width, bodyRows, theme, railed = false) {
     const { Box, Text } = components;
     const focused = state.focus === 'sidebar';
     const tabs = getLogInkSidebarTabs();
+    if (railed) {
+        return renderSidebarRail(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.
@@ -27839,6 +29524,34 @@ function formatLogInkSubmodulesEmpty({ filter }) {
     }
     return 'No submodules registered. Add one with `git submodule add <url> <path>` from the shell.';
 }
+function formatLogInkIssuesEmpty({ filter }) {
+    if (filter.trim()) {
+        return `No issues match filter '${filter}'. Press ctrl+u to clear.`;
+    }
+    return 'No issues match the current GitHub filter (default: open issues).';
+}
+function formatLogInkPullRequestTriageEmpty({ filter, }) {
+    if (filter.trim()) {
+        return `No pull requests match filter '${filter}'. Press ctrl+u to clear.`;
+    }
+    return 'No pull requests match the current GitHub filter (default: open PRs).';
+}
+/**
+ * Surface-level fallback when the GitHub CLI is missing or not
+ * authenticated. The triage views (#882) all share this empty-state
+ * copy — the underlying problem is the same regardless of which
+ * surface the user is on, and the recovery is identical.
+ */
+function formatLogInkGitHubUnauthenticated({ resource, }) {
+    return `${resource} require the GitHub CLI. Install \`gh\` and run \`gh auth login\` to enable triage.`;
+}
+/**
+ * Surface-level fallback when the repo has no GitHub remote. Same
+ * shared message across the triage surfaces.
+ */
+function formatLogInkGitHubNoRemote({ resource, }) {
+    return `${resource} require a GitHub remote (origin or fallback). None detected for this repo.`;
+}
 
 /**
  * Branches surface — promoted view listing local branches with sort,
@@ -28729,6 +30442,179 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         : []));
 }
 
+/**
+ * Strip refs that are already represented by a branch tip chip so the
+ * trailing `[ref] [ref]` list doesn't repeat what the chip is already
+ * showing. The chip carries the primary branch name; the trailing
+ * list keeps everything else — including remote-tracking variants
+ * (`origin/X`) and `origin/HEAD` — because those convey "remote is
+ * also at this commit" info the chip alone doesn't.
+ *
+ * Removes:
+ *   - exact match of the chipped name (`main`, `feat/foo`)
+ *   - `HEAD -> <name>` for the chipped name
+ *   - bare `HEAD` when the chip is the HEAD branch (only paranoia;
+ *     git typically emits `HEAD -> name` not both, but a detached
+ *     fixup commit may have produced both)
+ */
+function filterChippedRefs(refs, chip) {
+    if (!chip)
+        return refs;
+    const headDecoration = `HEAD -> ${chip.name}`;
+    return refs.filter((ref) => {
+        if (ref === chip.name)
+            return false;
+        if (ref === headDecoration)
+            return false;
+        if (chip.isHead && ref === 'HEAD')
+            return false;
+        return true;
+    });
+}
+function getBranchTipChip(refs) {
+    for (const ref of refs) {
+        if (ref.startsWith('HEAD -> ')) {
+            const name = ref.slice('HEAD -> '.length).trim();
+            if (name)
+                return { name, isHead: true };
+        }
+    }
+    for (const ref of refs) {
+        if (ref === 'HEAD' ||
+            ref.startsWith('HEAD -> ') ||
+            ref.startsWith('tag: ') ||
+            ref.includes('/')) {
+            continue;
+        }
+        if (ref.trim())
+            return { name: ref.trim(), isHead: false };
+    }
+    for (const ref of refs) {
+        if (ref.startsWith('tag: ') || ref === 'HEAD' || ref.startsWith('HEAD -> ')) {
+            continue;
+        }
+        if (ref.includes('/') && ref.trim()) {
+            return { name: ref.trim(), isHead: false };
+        }
+    }
+    return undefined;
+}
+
+const PREFIX_PATTERN = /^([a-z]+)(\(([^)]+)\))?(!)?:\s+/;
+function parseConventionalCommitPrefix(message) {
+    const match = PREFIX_PATTERN.exec(message);
+    if (!match)
+        return undefined;
+    const [whole, type, , scope, breakingMarker] = match;
+    return {
+        prefix: whole,
+        rest: message.slice(whole.length),
+        type,
+        scope: scope || undefined,
+        breaking: Boolean(breakingMarker),
+    };
+}
+/**
+ * Pick the theme color used to paint a conventional-commit prefix.
+ *
+ * Rough mapping intent:
+ *   - feat                       → success  (new capability, growth)
+ *   - fix                        → warning  (was a problem; eye-catch)
+ *   - docs / refactor / perf     → info / accent (intent-bearing change)
+ *   - test / style / build / ci  → muted    (mechanical / housekeeping)
+ *   - chore                      → muted
+ *   - revert                     → danger   (signals "this undid something")
+ *
+ * Unknown types fall through to `accent` so a project-specific
+ * convention (`wip:`, `release:`, etc.) still reads as the typed
+ * prefix rather than blending into the subject. Returns `undefined`
+ * under `theme.noColor` so the prefix stays plain — the textual
+ * `feat:` carries the meaning by itself.
+ *
+ * Breaking changes (`!:`) override the type color with `danger` so
+ * the row reads as "stop and look at this" regardless of which type
+ * it is.
+ */
+function getConventionalCommitColor(parsed, theme) {
+    if (theme.noColor)
+        return undefined;
+    if (parsed.breaking)
+        return theme.colors.danger;
+    switch (parsed.type) {
+        case 'feat':
+            return theme.colors.success;
+        case 'fix':
+            return theme.colors.warning;
+        case 'docs':
+        case 'refactor':
+        case 'perf':
+            return theme.colors.info;
+        case 'test':
+        case 'style':
+        case 'build':
+        case 'ci':
+        case 'chore':
+            return theme.colors.muted;
+        case 'revert':
+            return theme.colors.danger;
+        default:
+            return theme.colors.accent;
+    }
+}
+
+/**
+ * Date formatting helpers for the Ink TUI surfaces.
+ *
+ * The branch list already ships its own "X ago" formatter
+ * (`formatBranchLastTouched` in iconography.ts) sized for a sidebar
+ * row with room to breathe. The history surface needs a tighter
+ * variant: the date column is fixed-width and competes with the
+ * commit message for cells, so a 2-3 character form is the budget.
+ *
+ * Inputs match what `git log --date=short` produces:
+ * `YYYY-MM-DD`. Caller passes `now` so tests can pin the reference
+ * instant.
+ *
+ * Outputs (rounded toward the nearest unit, no `ago` suffix):
+ *   - `today` for same UTC day
+ *   - `1d` … `13d` for 1-13 days
+ *   - `2w` … `8w` for 2-8 weeks
+ *   - `2mo` … `11mo` for 2-11 months
+ *   - `2y`+ for older
+ *   - `''` for malformed inputs (caller renders nothing)
+ *
+ * Day comparison is in UTC so a commit dated "yesterday" never reads
+ * "today" depending on the operator's timezone.
+ */
+function formatCompactRelativeDate(iso, now) {
+    if (!iso)
+        return '';
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
+    if (!match)
+        return '';
+    const year = Number.parseInt(match[1], 10);
+    const month = Number.parseInt(match[2], 10);
+    const day = Number.parseInt(match[3], 10);
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day))
+        return '';
+    const commitUtc = Date.UTC(year, month - 1, day);
+    const nowUtc = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+    const oneDay = 24 * 60 * 60 * 1000;
+    const days = Math.floor((nowUtc - commitUtc) / oneDay);
+    if (days <= 0)
+        return 'today';
+    if (days < 14)
+        return `${days}d`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 9)
+        return `${weeks}w`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo`;
+    const years = Math.floor(days / 365);
+    return `${years}y`;
+}
+
 /**
  * The chars `git log --graph` emits for branch topology — `*`, `|`, `\`,
  * `/`, `_`, ` `. ASCII-only output is bulletproof for legacy terminals
@@ -28978,6 +30864,54 @@ function getLaneColor(laneId, theme) {
     return palette[laneId % palette.length];
 }
 
+const MONTH_NAMES = [
+    'January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December',
+];
+function getDateBucket(iso, now) {
+    if (!iso)
+        return { key: 'unknown', label: 'Unknown date' };
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(iso);
+    if (!match)
+        return { key: 'unknown', label: 'Unknown date' };
+    const year = Number.parseInt(match[1], 10);
+    const month = Number.parseInt(match[2], 10);
+    const day = Number.parseInt(match[3], 10);
+    if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) {
+        return { key: 'unknown', label: 'Unknown date' };
+    }
+    const commitUtc = Date.UTC(year, month - 1, day);
+    const nowUtc = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+    const oneDay = 24 * 60 * 60 * 1000;
+    const days = Math.floor((nowUtc - commitUtc) / oneDay);
+    // Future-dated commits (clock skew, bad commit dates) collapse to
+    // today rather than confusing the user with an "in the future"
+    // bucket.
+    if (days <= 0)
+        return { key: 'today', label: 'Today' };
+    if (days === 1)
+        return { key: 'yesterday', label: 'Yesterday' };
+    if (days < 7)
+        return { key: 'this-week', label: 'This week' };
+    if (days < 14)
+        return { key: 'last-week', label: 'Last week' };
+    // Inside the same calendar month → one "earlier this month" bucket
+    // so the user sees a single section rather than per-day groupings
+    // for a commit-heavy week.
+    if (year === now.getUTCFullYear() && month - 1 === now.getUTCMonth()) {
+        return { key: 'earlier-this-month', label: 'Earlier this month' };
+    }
+    // Older months use the calendar-month label so the bucket reads
+    // naturally even years back (`April 2024`). The key embeds the
+    // year+month so different months stay in distinct buckets without
+    // colliding on month name alone.
+    const monthLabel = MONTH_NAMES[month - 1] ?? `Month ${month}`;
+    return {
+        key: `month-${match[1]}-${match[2]}`,
+        label: `${monthLabel} ${year}`,
+    };
+}
+
 /**
  * Pick the commit glyph based on parent count + HEAD-ness so the
  * renderer can flag merges and the current head visually. HEAD wins
@@ -29006,9 +30940,8 @@ function commitKey(commit) {
 function graphWidth(items) {
     return Math.max(1, ...items.map((item) => item.graph.length));
 }
-function toCompactItems(state, visibleCount) {
-    const start = clampWindowStart(state.selectedIndex, state.filteredCommits.length, visibleCount);
-    return state.filteredCommits.slice(start, start + visibleCount).map((commit, offset) => ({
+function makeCompactCommitItem(commit, selected) {
+    return {
         type: 'commit',
         commit,
         graph: '*',
@@ -29017,24 +30950,197 @@ function toCompactItems(state, visibleCount) {
         // glance. Lane id stays undefined so the segment renders muted —
         // matching the legacy compact appearance, just with a richer glyph.
         laneSegments: [{ text: commitGlyphFor(commit), laneId: undefined }],
-        selected: start + offset === state.selectedIndex,
-    }));
+        selected,
+    };
+}
+function bucketHeaderItem(label) {
+    return { type: 'bucket-header', graph: '', label };
+}
+function toCompactItems(state, visibleCount, bucketingNow) {
+    const start = clampWindowStart(state.selectedIndex, state.filteredCommits.length, visibleCount);
+    const slice = state.filteredCommits.slice(start, start + visibleCount);
+    if (!bucketingNow) {
+        return slice.map((commit, offset) => makeCompactCommitItem(commit, start + offset === state.selectedIndex));
+    }
+    // With bucketing on: emit a sticky header above the first visible
+    // commit and an additional header each time the bucket changes. The
+    // header occupies one row from the visibleCount budget every time
+    // it fires, so the visible commit count drops slightly in exchange
+    // for always-on temporal orientation.
+    const items = [];
+    let prevBucket = undefined;
+    for (let offset = 0; offset < slice.length && items.length < visibleCount; offset += 1) {
+        const commit = slice[offset];
+        const bucket = getDateBucket(commit.date, bucketingNow);
+        if (bucket.key !== prevBucket) {
+            items.push(bucketHeaderItem(bucket.label));
+            prevBucket = bucket.key;
+            if (items.length >= visibleCount)
+                break;
+        }
+        items.push(makeCompactCommitItem(commit, start + offset === state.selectedIndex));
+    }
+    return items;
 }
 function isSelectedCommit(row, selected) {
     return row.type === 'commit' && selected ? commitKey(row) === commitKey(selected) : false;
 }
-function toFullGraphItems(state, visibleCount) {
+/**
+ * Build the vertical-only graph string that follows a commit row when
+ * `withSpacers` is enabled. Every commit-cell glyph (`*`) is rewritten
+ * to a lane bar (`|`) so the synthetic row continues every open lane
+ * without re-rendering the commit dot. All other graph chars pass
+ * through unchanged, so a commit graph like `* | |` becomes `| | |`.
+ */
+function buildSpacerGraph(commitGraph) {
+    return commitGraph.replace(/\*/g, '|');
+}
+/**
+ * Walk `state.rows` and inject a synthetic spacer entry after every
+ * commit row when `withSpacers` is true. The spacer is a graph-only
+ * row that renders as `|` per active lane so consecutive commits have
+ * a clear vertical rhythm without losing topology continuity.
+ *
+ * The spacer is suppressed in two cases where it would create visible
+ * "tearing" on the graph column:
+ *
+ *   1. The next row is git's own graph-only topology row (`|\` /
+ *      `|/` / `| |`). That row already provides vertical breathing
+ *      AND draws the lane transition; sandwiching our spacer between
+ *      the commit and the transition produces an extra all-pipes row
+ *      that reads as misalignment.
+ *
+ *   2. The current commit's graph contains a backslash or forward
+ *      slash (the compressed forms git uses for `*\` / `*` followed
+ *      by slash, when it draws the fork on the same row as the
+ *      commit). The spacer's commit-glyph → lane-bar rewrite would
+ *      leave the diagonal intact, rendering a second corner glyph
+ *      immediately below the merge — a duplicate that looks like a
+ *      glyph stutter.
+ *
+ * When `withSpacers` is false the list is identity-mapped from
+ * source rows, preserving the legacy zero-padding behavior for any
+ * caller that wants raw git topology (filters, tests, etc.).
+ */
+function commitGraphIsSimple(graph) {
+    return !/[\\/]/.test(graph);
+}
+function expandRowsWithSpacers(rows, withSpacers) {
+    const out = [];
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i];
+        out.push({ kind: 'source', row });
+        if (!withSpacers || row.type !== 'commit')
+            continue;
+        if (!commitGraphIsSimple(row.graph || '*'))
+            continue;
+        const next = rows[i + 1];
+        if (next && next.type === 'graph')
+            continue;
+        out.push({ kind: 'spacer', sourceCommit: row });
+    }
+    return out;
+}
+/**
+ * Walk an already-expanded row list and inject `bucket-header`
+ * entries immediately before each commit whose date bucket differs
+ * from the previous commit's. The very first commit always gets a
+ * header so the user lands inside a labeled section regardless of
+ * where the scroll window starts. Non-commit entries (spacers, git
+ * topology rows) pass through unchanged.
+ */
+function injectBucketHeaders(rows, now) {
+    const out = [];
+    let prevBucket = undefined;
+    for (const entry of rows) {
+        if (entry.kind === 'source' && entry.row.type === 'commit') {
+            const bucket = getDateBucket(entry.row.date, now);
+            if (bucket.key !== prevBucket) {
+                out.push({ kind: 'bucket-header', label: bucket.label });
+                prevBucket = bucket.key;
+            }
+        }
+        out.push(entry);
+    }
+    return out;
+}
+/**
+ * Find the most recent bucket header at or above `start` so a slice
+ * that begins mid-bucket can still surface its section label. Used
+ * for the "sticky header" behavior — when the window scrolls past
+ * the natural header position, prepend the header to the slice so
+ * the user always sees which bucket they're in. Returns the label
+ * to prepend, or `undefined` when no prepend is needed (either
+ * `expanded[start]` is already a header, or there is no earlier
+ * header in the list).
+ */
+function findStickyBucketLabel(expanded, start) {
+    if (start < expanded.length && expanded[start].kind === 'bucket-header')
+        return undefined;
+    for (let i = start - 1; i >= 0; i -= 1) {
+        const entry = expanded[i];
+        if (entry.kind === 'bucket-header')
+            return entry.label;
+    }
+    return undefined;
+}
+function toFullGraphItems(state, visibleCount, options = {
+    withSpacers: false,
+    bucketingNow: undefined,
+}) {
     const selected = state.filteredCommits[state.selectedIndex];
-    const selectedRowIndex = state.rows.findIndex((row) => isSelectedCommit(row, selected));
-    const start = clampWindowStart(selectedRowIndex >= 0 ? selectedRowIndex : 0, state.rows.length, visibleCount);
+    const withSpacers = expandRowsWithSpacers(state.rows, options.withSpacers);
+    const expanded = options.bucketingNow
+        ? injectBucketHeaders(withSpacers, options.bucketingNow)
+        : withSpacers;
+    const selectedExpandedIndex = expanded.findIndex((entry) => entry.kind === 'source' && isSelectedCommit(entry.row, selected));
+    const start = clampWindowStart(selectedExpandedIndex >= 0 ? selectedExpandedIndex : 0, expanded.length, visibleCount);
     // Lane tracking is order-dependent — fast-forward the tracker through
     // every row above the visible window so lane ids stay stable as the
     // user scrolls. Without this, scrolling would re-color lanes from a
-    // fresh tracker each time.
+    // fresh tracker each time. Spacers contribute their vertical-only
+    // graph to the prefix so the tracker sees a no-op advance and lane
+    // state stays consistent at the window boundary. Bucket headers
+    // skip the tracker entirely since they have no graph string.
     const tracker = createLaneTrackerState();
-    const allGraphs = state.rows.map((row) => (row.type === 'commit' ? row.graph || '*' : row.graph));
-    advanceTrackerThrough(allGraphs, tracker, start);
-    return state.rows.slice(start, start + visibleCount).map((row) => {
+    const prefixGraphs = [];
+    for (let k = 0; k < start; k += 1) {
+        const entry = expanded[k];
+        if (entry.kind === 'bucket-header')
+            continue;
+        if (entry.kind === 'spacer') {
+            prefixGraphs.push(buildSpacerGraph(entry.sourceCommit.graph || '*'));
+            continue;
+        }
+        prefixGraphs.push(entry.row.type === 'commit' ? entry.row.graph || '*' : entry.row.graph);
+    }
+    advanceTrackerThrough(prefixGraphs, tracker, prefixGraphs.length);
+    // Sticky header — if the slice would start partway into a bucket
+    // (most commonly when scrolling), prepend the bucket label so the
+    // user keeps temporal context. The prepend costs one row from the
+    // visible budget, so the slice itself shrinks by 1.
+    const stickyLabel = options.bucketingNow
+        ? findStickyBucketLabel(expanded, start)
+        : undefined;
+    const sliceCount = stickyLabel ? visibleCount - 1 : visibleCount;
+    const sliced = expanded.slice(start, start + sliceCount);
+    const finalEntries = stickyLabel
+        ? [{ kind: 'bucket-header', label: stickyLabel }, ...sliced]
+        : sliced;
+    return finalEntries.map((entry) => {
+        if (entry.kind === 'bucket-header') {
+            return bucketHeaderItem(entry.label);
+        }
+        if (entry.kind === 'spacer') {
+            const graph = buildSpacerGraph(entry.sourceCommit.graph || '*');
+            return {
+                type: 'graph',
+                graph,
+                laneSegments: renderGraphRowSegments(graph, tracker, { ascii: false }),
+                spacer: true,
+            };
+        }
+        const { row } = entry;
         if (row.type === 'graph') {
             return {
                 type: 'graph',
@@ -29053,10 +31159,18 @@ function toFullGraphItems(state, visibleCount) {
         };
     });
 }
-function getVisibleLogInkHistory(state, visibleCount) {
+function getVisibleLogInkHistory(state, visibleCount, options = {}) {
+    // Bucketing only makes sense for chronologically ordered output —
+    // an active search filter shuffles commits by relevance, so the
+    // adjacent-bucket invariant breaks down and the divider would
+    // read as noise.
+    const bucketingNow = state.filter ? undefined : options.dateBucketingNow;
     const items = state.fullGraph && !state.filter
-        ? toFullGraphItems(state, visibleCount)
-        : toCompactItems(state, visibleCount);
+        ? toFullGraphItems(state, visibleCount, {
+            withSpacers: Boolean(options.fullGraphSpacing),
+            bucketingNow,
+        })
+        : toCompactItems(state, visibleCount, bucketingNow);
     return {
         graphWidth: graphWidth(items),
         items,
@@ -29082,6 +31196,96 @@ function formatInkRefLabels(refs) {
  * `formatHistoryFetchArgs`) lived in inkRuntime.ts only to support
  * this surface; they migrate together.
  */
+/**
+ * How the date column should render for a given density tier:
+ *   - wide   → absolute `YYYY-MM-DD`
+ *   - normal → compact relative form (`2d`, `3w`, `2mo`)
+ *   - tight  → hidden entirely (column dropped)
+ *   - rail   → caller picks `rowMode='stacked'`; this fn isn't consulted
+ *
+ * Compact mode (the user toggling away from the full graph) forces
+ * the tight behavior regardless of density. Compact is the "scan
+ * mode" — the date is the first thing the user is willing to drop in
+ * exchange for more visible commits per screen.
+ *
+ * When `bucketed` is true the surface is rendering section dividers
+ * (`── Today ──`) above commits, so the per-row date column would be
+ * redundant. We drop it entirely and let the message column expand.
+ */
+function pickDateText(commit, density, fullGraph, bucketed, now) {
+    if (bucketed)
+        return '';
+    if (!fullGraph)
+        return '';
+    if (density === 'wide')
+        return commit.date;
+    if (density === 'normal')
+        return formatCompactRelativeDate(commit.date, now);
+    return '';
+}
+/**
+ * Maximum cells the chip body (between the brackets) is allowed to
+ * occupy. Anything longer is truncated with an ellipsis so a
+ * `[origin/claude/issues-prs-cache]` chip — 32 cells of chrome —
+ * doesn't eat the whole subject column on a narrow terminal. Picked
+ * empirically: 20 cells fits common branch shapes (`feat/foo`,
+ * `claude/graph-fidelity`, `main`) without truncation.
+ */
+const BRANCH_CHIP_MAX_NAME_WIDTH = 20;
+/**
+ * Render a pill-style chip for a branch tip — colored background
+ * with the branch name reverse-printed inside, so the chip reads as
+ * a distinct visual category (block) rather than colored text (which
+ * collides with `docs:`/`refactor:`/`perf:` conventional-commit
+ * prefixes that also use `info`). Current branch (HEAD -> X) uses
+ * success-green; other branch tips use info-blue.
+ *
+ * Implementation: `inverse: true` + `color: <accent>` is the
+ * portable way to render "colored background with terminal-default
+ * foreground" — it adapts to dark vs light terminals without
+ * hardcoding a black/white fg. Tags are never chipped; they stay in
+ * the trailing ref list. The chip emits its own trailing space so
+ * callers concatenate it directly into the row without a separator.
+ *
+ * Selection styling is opt-out: when the row is selected, the outer
+ * `inverse: true` + selection background already covers everything,
+ * and a second `inverse` on the chip would flip it back to plain. We
+ * drop the pill styling for selected rows and let the row's own
+ * inverse highlight carry through cleanly.
+ *
+ * Returns the rendered node alongside its cell width AND the chip
+ * descriptor so the caller can pass it to `filterChippedRefs` and
+ * avoid emitting the same branch a second time in the trailing list.
+ */
+function renderBranchTipChip(h, Text, commit, theme, key, selected) {
+    const chip = getBranchTipChip(commit.refs);
+    if (!chip)
+        return { node: null, width: 0, chip };
+    const truncated = truncateCells(chip.name, BRANCH_CHIP_MAX_NAME_WIDTH);
+    // Inner pill body is `name`; the trailing space sits OUTSIDE the
+    // colored block so the bg doesn't bleed into the message column.
+    // The brackets are gone — the colored block is its own visual
+    // affordance and the brackets would add 2 cells of chrome that
+    // duplicate the affordance.
+    const body = ` ${truncated} `;
+    // Selected row OR noColor mode → drop pill styling. Selected rows
+    // get the row-level inverse highlight; noColor terminals fall
+    // back to bracketed text so the chip still parses visually.
+    if (selected || theme.noColor) {
+        const fallbackLabel = `[${truncated}] `;
+        return {
+            node: h(Text, { key, bold: chip.isHead }, fallbackLabel),
+            width: cellWidth(fallbackLabel),
+            chip,
+        };
+    }
+    const accent = chip.isHead ? theme.colors.success : theme.colors.info;
+    return {
+        node: h(Text, {}, h(Text, { key, inverse: true, color: accent, bold: chip.isHead }, body), h(Text, { key: `${key}-pad` }, ' ')),
+        width: cellWidth(body) + 1,
+        chip,
+    };
+}
 function formatHistoryFetchArgs(args) {
     const parts = [];
     if (args.author)
@@ -29090,6 +31294,36 @@ function formatHistoryFetchArgs(args) {
         parts.push(`-- ${args.path}`);
     return parts.join(' ') || 'none';
 }
+/**
+ * Render a commit subject with the conventional-commit prefix
+ * (`feat:`, `fix(scope)!:`, …) painted in a type-specific color so
+ * the eye can bucket commits by type while scanning.
+ *
+ * Truncation lives at the message level above this helper — the
+ * caller has already shortened `text` to the available room. We just
+ * split on the parsed prefix length and emit two spans. If the
+ * shortened text is too narrow to include the full prefix (e.g. a
+ * tight panel that cut into `feat`), we fall back to a single plain
+ * span so the partial prefix doesn't read as a malformed colored
+ * fragment.
+ *
+ * Returns the spans flat so the caller can splat them into the row's
+ * outer Text alongside other segments without an extra wrapper.
+ */
+function renderTypedSubject(h, Text, text, theme, key) {
+    const parsed = parseConventionalCommitPrefix(text);
+    if (!parsed) {
+        return [h(Text, { key: `${key}-msg` }, text)];
+    }
+    if (text.length < parsed.prefix.length) {
+        return [h(Text, { key: `${key}-msg` }, text)];
+    }
+    const color = getConventionalCommitColor(parsed, theme);
+    return [
+        h(Text, { key: `${key}-type`, color, bold: parsed.breaking }, parsed.prefix),
+        h(Text, { key: `${key}-rest` }, text.slice(parsed.prefix.length)),
+    ];
+}
 /**
  * Render `LaneSegment[]` as a flat list of Text spans, one per lane
  * (#791 stage 2). Each segment paints in its lane's palette color so
@@ -29135,8 +31369,7 @@ function renderLaneSegmentSpans(h, Text, segments, theme, padTo, keyPrefix, opti
  * Truncation is per-segment so the variable-length message field gets
  * the leftover budget after fixed segments are accounted for.
  */
-function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, theme, index, panelWidth, laneSegments, isRecent = false) {
-    const refs = formatInkRefLabels(commit.refs);
+function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, theme, index, panelWidth, density, fullGraph, bucketed, now, laneSegments, isRecent = false) {
     // Total cells available to the row content. Earlier revisions used a
     // hardcoded 140 here, which let row content overflow whenever the
     // panel was narrower than that — Ink would wrap onto a second visual
@@ -29144,7 +31377,19 @@ function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, th
     // continuation rather than its own commit (#830). Subtracting 4
     // accounts for the panel's left + right border + 1-cell padding.
     const totalWidth = Math.max(20, panelWidth - 4);
-    const fixedWidth = graphWidth + 1 + commit.shortHash.length + 1 + commit.date.length + 1;
+    const dateText = pickDateText(commit, density, fullGraph, bucketed, now);
+    const dateSegmentWidth = dateText ? dateText.length + 1 : 0;
+    // Branch chip prefix — only renders in full-graph mode so compact
+    // (scan) mode stays minimal. Chip occupies cells immediately after
+    // the shortHash and before the message; truncation math reserves
+    // its width before sizing the message column. Trailing refs filter
+    // out whatever the chip already shows so the row doesn't print
+    // `[main] feat: x [HEAD -> main]` with the same info on both ends.
+    const chip = fullGraph
+        ? renderBranchTipChip(h, Text, commit, theme, `${commit.hash}-${index}-chip`, selected)
+        : { node: null, width: 0, chip: undefined };
+    const refs = formatInkRefLabels(filterChippedRefs(commit.refs, chip.chip));
+    const fixedWidth = graphWidth + 1 + commit.shortHash.length + 1 + dateSegmentWidth + chip.width;
     // Refs trail the message and shrink first when the row is narrow:
     // the user can always see the full ref list in the inspector, so
     // the headline subject keeps priority over decoration.
@@ -29182,7 +31427,81 @@ function renderCommitHistoryRow(h, Text, commit, graph, graphWidth, selected, th
         // the primary cue but boldness makes the row read as "this is
         // worth looking at" even without color.
         bold: selected || isRecent,
-    }, commit.shortHash), ' ', h(Text, { dimColor: true }, commit.date), ' ', h(Text, undefined, message), refsTrunc ? h(Text, { color: accent }, refsTrunc) : null);
+    }, commit.shortHash), ' ', 
+    // Date column drops out entirely at `tight` density — no spacer
+    // either, so the message column slides left into the freed cells.
+    dateText
+        ? h(Text, { key: `${commit.hash}-${index}-date`, dimColor: true }, dateText, ' ')
+        : null, 
+    // Branch chip prefix (full-graph mode only) lands right before the
+    // message so the eye reads "branch · subject" as a unit.
+    chip.node, ...renderTypedSubject(h, Text, message, theme, `${commit.hash}-${index}-subj`), refsTrunc ? h(Text, { color: accent }, refsTrunc) : null);
+}
+/**
+ * Stacked variant used at `rowMode='stacked'` (rail tier). Each
+ * commit takes two lines so the message never has to share its row
+ * with the date / refs / hash on a sub-90-cell terminal:
+ *   line 1: graph · shortHash · subject
+ *   line 2: dim padding · date · refs
+ *
+ * Selection styling lives on the line-1 outer span; the secondary
+ * line stays dim regardless of selection so it doesn't pull the eye
+ * away from the subject.
+ */
+function renderStackedCommitHistoryRow(h, Text, Box, commit, graph, graphWidth, selected, theme, index, panelWidth, fullGraph, now, laneSegments, isRecent = false) {
+    const totalWidth = Math.max(20, panelWidth - 4);
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const muted = theme.noColor ? undefined : theme.colors.muted;
+    const selectedBg = selected && !theme.noColor ? theme.colors.selection : undefined;
+    // Line 1 — subject row. Mostly mirrors the single-line layout but
+    // skips the date and refs so the message has the whole tail to
+    // itself. Branch chip rides between the hash and the subject the
+    // same way as the single-line variant, but only in full-graph mode.
+    const recentMarkerWidth = isRecent ? 2 : 0;
+    const chip = fullGraph
+        ? renderBranchTipChip(h, Text, commit, theme, `${commit.hash}-${index}-stk-chip`, selected)
+        : { node: null, width: 0, chip: undefined };
+    const lineOneFixed = graphWidth + 1 + commit.shortHash.length + 1 + recentMarkerWidth + chip.width;
+    const subject = truncateCells(commit.message, Math.max(8, totalWidth - lineOneFixed));
+    const graphChildren = laneSegments && !theme.ascii
+        ? renderLaneSegmentSpans(h, Text, laneSegments, theme, graphWidth, `cs${index}`)
+        : [h(Text, { color: muted, dimColor: theme.noColor }, substituteGraphChars(graph.padEnd(graphWidth), { ascii: theme.ascii }))];
+    const lineOne = h(Text, {
+        key: `${commit.hash}-${index}-l1`,
+        backgroundColor: selectedBg,
+        inverse: selected,
+    }, ...graphChildren, ' ', isRecent
+        ? h(Text, { color: accent, bold: true }, theme.ascii ? '* ' : '▎ ')
+        : null, h(Text, { color: accent, bold: selected || isRecent }, commit.shortHash), ' ', chip.node, ...renderTypedSubject(h, Text, subject, theme, `${commit.hash}-${index}-stk-subj`));
+    // Line 2 — metadata row, padded to align with the start of the
+    // shortHash on line 1 so the eye still groups them as one commit.
+    // Selection background does not extend here so we don't get a thick
+    // double-row highlight on a tight terminal. Trailing refs are
+    // filtered against the chip so we don't repeat the branch tip both
+    // as a leading chip and a trailing label.
+    const indent = ' '.repeat(graphWidth + 1);
+    const dateText = formatCompactRelativeDate(commit.date, now);
+    const refs = formatInkRefLabels(filterChippedRefs(commit.refs, chip.chip));
+    const metaRoom = Math.max(8, totalWidth - indent.length - (dateText ? dateText.length + 1 : 0));
+    const refsTrunc = refs ? truncateCells(refs, metaRoom) : '';
+    // If both pieces are empty (date unparseable + no refs), show a
+    // bullet so the row's structure still reads as two-line and the
+    // user doesn't think they hit a render bug.
+    const metaContent = dateText || refsTrunc
+        ? [
+            dateText ? h(Text, { key: `${commit.hash}-${index}-l2-date` }, dateText) : null,
+            dateText && refsTrunc ? h(Text, { key: `${commit.hash}-${index}-l2-sep` }, ' ') : null,
+            refsTrunc ? h(Text, { key: `${commit.hash}-${index}-l2-refs` }, refsTrunc) : null,
+        ].filter(Boolean)
+        : [h(Text, { key: `${commit.hash}-${index}-l2-empty` }, '·')];
+    const lineTwo = h(Text, {
+        key: `${commit.hash}-${index}-l2`,
+        dimColor: true,
+    }, indent, ...metaContent);
+    return h(Box, {
+        key: `${commit.hash}-${index}-stack`,
+        flexDirection: 'column',
+    }, lineOne, lineTwo);
 }
 /**
  * Render the synthetic "(+) new commit" affordance shown above the real
@@ -29211,7 +31530,7 @@ function renderPendingCommitRow(h, Text, worktree, selected, theme) {
         backgroundColor: selected && !theme.noColor ? theme.colors.selection : undefined,
     }, truncateCells(label, 140));
 }
-function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits) {
+function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = new Date()) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -29227,8 +31546,26 @@ function renderHistoryPanel(h, components, state, context, bodyRows, width, them
     const showPendingRow = worktreeDirty &&
         !state.filter &&
         state.selectedIndex === 0;
-    const listRows = Math.max(3, bodyRows - (showPendingRow ? 5 : 4));
-    const visible = getVisibleLogInkHistory(state, listRows);
+    // Stacked rows take two terminal lines each, so the visible item
+    // budget is halved before the pending-row / chrome subtraction.
+    // Full-graph mode injects a spacer row after every commit for
+    // comfortable rhythm — the data-layer items still count 1 per row,
+    // so the listRows budget passes straight through; the spacer rows
+    // just consume some of that budget instead of additional commits.
+    // Date bucketing is the new way the surface communicates "when" —
+    // headers replace the per-row date column whenever the result set
+    // is chronological (no active filter) AND the user has bucketing
+    // enabled in `logTui.dateBucketing`. The filter check is the second
+    // guardrail: even with bucketing enabled, an active search filter
+    // shuffles commits by relevance so the adjacent-bucket invariant
+    // breaks down and the dividers would read as noise.
+    const fullGraphSpacing = state.fullGraph && !state.filter;
+    const dateBucketingNow = !dateBucketingEnabled || state.filter ? undefined : now;
+    const chromeRows = showPendingRow ? 5 : 4;
+    const listRows = rowMode === 'stacked'
+        ? Math.max(2, Math.floor((bodyRows - chromeRows) / 2))
+        : Math.max(3, bodyRows - chromeRows);
+    const visible = getVisibleLogInkHistory(state, listRows, { fullGraphSpacing, dateBucketingNow });
     const loadState = loadingMoreCommits
         ? 'loading older commits'
         : hasMoreCommits
@@ -29263,23 +31600,51 @@ function renderHistoryPanel(h, components, state, context, bodyRows, width, them
                 totalCommits: state.commits.length,
             }))
         : visible.items.map((item, index) => {
+            if (item.type === 'bucket-header') {
+                // Section divider — `── Today ────────────`. The label is
+                // bold to anchor the eye, the surrounding rule is dim so
+                // the divider reads as chrome rather than competing with
+                // commit content. Rule fills the panel's interior width
+                // (minus border + padding); the label rides inside it.
+                const contentWidth = Math.max(10, width - 4);
+                const labelCells = cellWidth(item.label) + 2; // pad the label with surrounding spaces
+                const ruleAfter = Math.max(0, contentWidth - 3 - labelCells);
+                return h(Text, {
+                    key: `bucket-${index}-${item.label}`,
+                    dimColor: true,
+                }, h(Text, undefined, '── '), h(Text, { bold: true }, item.label), h(Text, undefined, ' '), h(Text, undefined, '─'.repeat(ruleAfter)));
+            }
             if (item.type === 'graph') {
-                // Graph-only rows are git's lane-closure scaffolding (`|/`,
-                // `|\`, etc.) — they're real topology but visually they look
-                // like blank rows that the user might wonder if they
-                // accidentally skipped a commit on (#831). Render dim-on-dim
-                // so they retreat as connectors rather than competing with
-                // commit rows for the eye's attention.
+                // Graph-only rows split into two visual categories:
+                //
+                //   - git's own lane-closure scaffolding (`|/`, `|\`, etc.)
+                //     stays dim-on-dim so it reads as connector chrome that
+                //     recedes behind the commits it joins (#831). The eye
+                //     should never confuse a fork/close row for a commit
+                //     somebody accidentally skipped.
+                //
+                //   - synthetic spacers we inject between linear commits
+                //     (`spacer: true`) render at FULL lane brightness so the
+                //     trunk lane bar visibly connects consecutive commits.
+                //     They are explicitly NOT scaffolding — they exist to
+                //     make linear-history rhythm read as one continuous lane.
+                const isSpacer = item.spacer === true;
                 if (item.laneSegments && !theme.ascii) {
-                    return h(Text, { key: `graph-${index}-${item.graph}`, dimColor: true }, ...renderLaneSegmentSpans(h, Text, item.laneSegments, theme, visible.graphWidth, `g${index}`, { forceDim: true }));
+                    return h(Text, {
+                        key: `graph-${index}-${item.graph}`,
+                        dimColor: !isSpacer,
+                    }, ...renderLaneSegmentSpans(h, Text, item.laneSegments, theme, visible.graphWidth, `g${index}`, { forceDim: !isSpacer }));
                 }
                 return h(Text, {
                     key: `graph-${index}-${item.graph}`,
                     color: theme.noColor ? undefined : theme.colors.muted,
-                    dimColor: true,
+                    dimColor: !isSpacer,
                 }, truncateCells(substituteGraphChars(item.graph.padEnd(visible.graphWidth), { ascii: theme.ascii }), Math.max(8, width - 4)));
             }
-            return renderCommitHistoryRow(h, Text, item.commit, item.graph, visible.graphWidth, Boolean(item.selected) && !realSelectionSuppressed, theme, index, width, item.laneSegments, recentCommitsSet.has(item.commit.hash));
+            if (rowMode === 'stacked') {
+                return renderStackedCommitHistoryRow(h, Text, Box, item.commit, item.graph, visible.graphWidth, Boolean(item.selected) && !realSelectionSuppressed, theme, index, width, state.fullGraph, now, item.laneSegments, recentCommitsSet.has(item.commit.hash));
+            }
+            return renderCommitHistoryRow(h, Text, item.commit, item.graph, visible.graphWidth, Boolean(item.selected) && !realSelectionSuppressed, theme, index, width, density, state.fullGraph, Boolean(dateBucketingNow), now, item.laneSegments, recentCommitsSet.has(item.commit.hash));
         }));
 }
 
@@ -29654,6 +32019,138 @@ function wrapErrorMessage(message, maxWidth) {
     return lines;
 }
 
+/**
+ * Issues triage surface (#882 phase 3). Read-only list view rendered
+ * in the main panel when `state.activeView === 'issues'`. Mirrors the
+ * branches / tags surface pattern: pure renderer, no hooks, no async.
+ * Data flows in via `context.issueList`; the cursor position lives at
+ * `state.selectedIssueIndex`.
+ *
+ * Per-row actions (assign, label, comment, close) and AI summarize
+ * land in phase 4-6. This phase ships navigation only.
+ */
+function stateColor$1(theme, state) {
+    if (theme.noColor)
+        return undefined;
+    switch (state.toUpperCase()) {
+        case 'OPEN':
+            return theme.colors.success;
+        case 'CLOSED':
+            return theme.colors.danger;
+        default:
+            return theme.colors.muted;
+    }
+}
+function matchesIssueFilter(issue, filter) {
+    if (!filter)
+        return true;
+    return matchesPromotedFilter([
+        `#${issue.number}`,
+        issue.title,
+        issue.author || '',
+        ...(issue.labels || []),
+        ...(issue.assignees || []),
+    ], filter);
+}
+function renderIssuesTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const overview = context.issueList;
+    const loading = isLogInkContextKeyLoading(contextStatus, 'issueList');
+    // Resolve the "what should the panel say" headline first, then fan
+    // out to the row body. The chrome (border + title + headerRight) is
+    // identical across loading / unavailable / unauthenticated / empty
+    // / populated states; only the body changes.
+    let headerRight = '';
+    let bodyLines = [];
+    if (loading || !overview) {
+        headerRight = 'loading issues';
+        bodyLines = [
+            h(Text, { key: 'issues-loading', dimColor: true }, formatLogInkLoading({ resource: 'issues' })),
+        ];
+    }
+    else if (!overview.available) {
+        headerRight = 'unavailable';
+        bodyLines = [
+            h(Text, { key: 'issues-no-remote', dimColor: true }, formatLogInkGitHubNoRemote({ resource: 'Issues' })),
+        ];
+    }
+    else if (!overview.authenticated) {
+        headerRight = 'gh not authenticated';
+        bodyLines = [
+            h(Text, { key: 'issues-unauth', dimColor: true }, formatLogInkGitHubUnauthenticated({ resource: 'Issues' })),
+        ];
+    }
+    else if (overview.message && !overview.issues) {
+        headerRight = 'error';
+        bodyLines = [
+            h(Text, { key: 'issues-error', dimColor: true, color: theme.noColor ? undefined : theme.colors.danger }, overview.message),
+        ];
+    }
+    else {
+        const all = overview.issues || [];
+        const visible = state.filter
+            ? all.filter((issue) => matchesIssueFilter(issue, state.filter))
+            : all;
+        const selected = Math.max(0, Math.min(state.selectedIssueIndex, Math.max(0, visible.length - 1)));
+        const listRows = Math.max(4, bodyRows - 4);
+        const startIndex = Math.max(0, selected - Math.floor(listRows / 2));
+        const windowed = visible.slice(startIndex, startIndex + listRows);
+        const filterLabel = state.filter ? ` | filter: ${state.filter}` : '';
+        const presetLabel = `▼ ${ISSUE_FILTER_LABELS[state.selectedIssueFilter]}`;
+        const repoLabel = overview.repository
+            ? `${overview.repository.owner}/${overview.repository.name}`
+            : '';
+        headerRight = `${repoLabel ? `${repoLabel} · ` : ''}${visible.length}/${all.length} | ${presetLabel}${filterLabel}`;
+        if (visible.length === 0) {
+            bodyLines = [
+                h(Text, { key: 'issues-empty', dimColor: true }, formatLogInkIssuesEmpty({ filter: state.filter })),
+            ];
+        }
+        else {
+            // Column widths derived from the visible window so columns stay
+            // aligned without one outlier title pushing the rest sideways.
+            // Capped to keep the title column from being squeezed out on
+            // narrow terminals.
+            const numberColWidth = Math.min(6, Math.max(...windowed.map((i) => `#${i.number}`.length), 3));
+            const authorColWidth = Math.min(16, Math.max(...windowed.map((i) => (i.author || '').length), 4));
+            bodyLines = windowed.map((issue, offset) => {
+                const index = startIndex + offset;
+                const isSelected = index === selected;
+                const cursor = isSelected ? '>' : ' ';
+                const numStr = `#${issue.number}`.padEnd(numberColWidth);
+                const stateStr = issue.state.toLowerCase().padEnd(6);
+                const authorStr = (issue.author || '').padEnd(authorColWidth);
+                const commentsStr = typeof issue.comments === 'number' && issue.comments > 0
+                    ? ` ${issue.comments}c`
+                    : '';
+                // The title column gets whatever is left after the prefix
+                // columns. Truncate so the row stays a single visual line.
+                const head = `${cursor} `;
+                const prefix = `${numStr}  ${stateStr}  ${authorStr}  `;
+                const titleBudget = Math.max(8, width - 4 - head.length - prefix.length - commentsStr.length);
+                const titleStr = truncateCells(issue.title, titleBudget);
+                const labelStr = (issue.labels || []).length
+                    ? ` [${(issue.labels || []).join(' ')}]`
+                    : '';
+                return h(Text, {
+                    key: `issue-${index}`,
+                    bold: isSelected,
+                    dimColor: !isSelected,
+                }, head, h(Text, { dimColor: true }, numStr + '  '), h(Text, { color: stateColor$1(theme, issue.state), dimColor: !isSelected }, stateStr + '  '), h(Text, { color: theme.noColor ? undefined : theme.colors.accent, dimColor: !isSelected }, authorStr + '  '), titleStr, h(Text, { dimColor: true }, labelStr), h(Text, { dimColor: true }, commentsStr));
+            });
+        }
+    }
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Issues', focused)), h(Text, { dimColor: true }, headerRight)), ...bodyLines);
+}
+
 /**
  * Normalize gh's two parallel signals (`status` for in-flight check
  * runs, `conclusion` for completed runs and status contexts) into a
@@ -29918,6 +32415,205 @@ function renderPullRequestSurface(h, components, state, context, contextStatus,
         : []));
 }
 
+/**
+ * Pull-request triage surface (#882 phase 3). Read-only list view
+ * rendered in the main panel when `state.activeView ===
+ * 'pull-request-triage'`. Distinct from the existing single-PR action
+ * panel (`'pull-request'`, chord `gp`) — this is the multi-PR list
+ * surface (chord `gP`).
+ *
+ * Pure renderer; data flows in via `context.pullRequestList`. Per-row
+ * actions (merge, approve, request-changes, close, comment) and AI
+ * summarize land in phase 4-6.
+ */
+function stateColor(theme, state, isDraft) {
+    if (theme.noColor)
+        return undefined;
+    if (isDraft)
+        return theme.colors.muted;
+    switch (state.toUpperCase()) {
+        case 'OPEN':
+            return theme.colors.success;
+        case 'CLOSED':
+            return theme.colors.danger;
+        case 'MERGED':
+            return theme.colors.accent;
+        default:
+            return theme.colors.muted;
+    }
+}
+function reviewGlyph(decision) {
+    switch (decision) {
+        case 'APPROVED':
+            return '✓';
+        case 'CHANGES_REQUESTED':
+            return '✗';
+        case 'REVIEW_REQUIRED':
+            return '?';
+        default:
+            return ' ';
+    }
+}
+function mergeableGlyph(mergeStateStatus, mergeable) {
+    if (mergeStateStatus === 'CLEAN')
+        return '●';
+    if (mergeStateStatus === 'BLOCKED')
+        return '●';
+    if (mergeStateStatus === 'DIRTY' || mergeable === 'CONFLICTING')
+        return '●';
+    if (mergeStateStatus === 'BEHIND')
+        return '●';
+    if (mergeStateStatus === 'UNSTABLE')
+        return '●';
+    return '·';
+}
+function mergeableColor(theme, mergeStateStatus, mergeable) {
+    if (theme.noColor)
+        return undefined;
+    if (mergeStateStatus === 'CLEAN')
+        return theme.colors.success;
+    if (mergeStateStatus === 'BLOCKED' || mergeStateStatus === 'UNSTABLE')
+        return theme.colors.warning;
+    if (mergeStateStatus === 'DIRTY' || mergeable === 'CONFLICTING')
+        return theme.colors.danger;
+    if (mergeStateStatus === 'BEHIND')
+        return theme.colors.accent;
+    return theme.colors.muted;
+}
+function reviewColor(theme, decision) {
+    if (theme.noColor)
+        return undefined;
+    switch (decision) {
+        case 'APPROVED':
+            return theme.colors.success;
+        case 'CHANGES_REQUESTED':
+            return theme.colors.danger;
+        case 'REVIEW_REQUIRED':
+            return theme.colors.warning;
+        default:
+            return theme.colors.muted;
+    }
+}
+function matchesPullRequestFilter(pr, filter) {
+    if (!filter)
+        return true;
+    return matchesPromotedFilter([
+        `#${pr.number}`,
+        pr.title,
+        pr.author || '',
+        pr.headRefName,
+        pr.baseRefName,
+        ...(pr.labels || []),
+        ...(pr.assignees || []),
+    ], filter);
+}
+function renderPullRequestTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const overview = context.pullRequestList;
+    const loading = isLogInkContextKeyLoading(contextStatus, 'pullRequestList');
+    let headerRight = '';
+    let bodyLines = [];
+    if (loading || !overview) {
+        headerRight = 'loading pull requests';
+        bodyLines = [
+            h(Text, { key: 'pr-triage-loading', dimColor: true }, formatLogInkLoading({ resource: 'pull requests' })),
+        ];
+    }
+    else if (!overview.available) {
+        headerRight = 'unavailable';
+        bodyLines = [
+            h(Text, { key: 'pr-triage-no-remote', dimColor: true }, formatLogInkGitHubNoRemote({ resource: 'Pull requests' })),
+        ];
+    }
+    else if (!overview.authenticated) {
+        headerRight = 'gh not authenticated';
+        bodyLines = [
+            h(Text, { key: 'pr-triage-unauth', dimColor: true }, formatLogInkGitHubUnauthenticated({ resource: 'Pull requests' })),
+        ];
+    }
+    else if (overview.message && !overview.pullRequests) {
+        headerRight = 'error';
+        bodyLines = [
+            h(Text, {
+                key: 'pr-triage-error',
+                dimColor: true,
+                color: theme.noColor ? undefined : theme.colors.danger,
+            }, overview.message),
+        ];
+    }
+    else {
+        const all = overview.pullRequests || [];
+        const visible = state.filter
+            ? all.filter((pr) => matchesPullRequestFilter(pr, state.filter))
+            : all;
+        const selected = Math.max(0, Math.min(state.selectedPullRequestTriageIndex, Math.max(0, visible.length - 1)));
+        const listRows = Math.max(4, bodyRows - 4);
+        const startIndex = Math.max(0, selected - Math.floor(listRows / 2));
+        const windowed = visible.slice(startIndex, startIndex + listRows);
+        const filterLabel = state.filter ? ` | filter: ${state.filter}` : '';
+        const presetLabel = `▼ ${PULL_REQUEST_FILTER_LABELS[state.selectedPullRequestFilter]}`;
+        const repoLabel = overview.repository
+            ? `${overview.repository.owner}/${overview.repository.name}`
+            : '';
+        headerRight = `${repoLabel ? `${repoLabel} · ` : ''}${visible.length}/${all.length} | ${presetLabel}${filterLabel}`;
+        if (visible.length === 0) {
+            bodyLines = [
+                h(Text, { key: 'pr-triage-empty', dimColor: true }, formatLogInkPullRequestTriageEmpty({ filter: state.filter })),
+            ];
+        }
+        else {
+            const numberColWidth = Math.min(6, Math.max(...windowed.map((p) => `#${p.number}`.length), 3));
+            const authorColWidth = Math.min(16, Math.max(...windowed.map((p) => (p.author || '').length), 4));
+            const branchColWidth = Math.min(24, Math.max(...windowed.map((p) => p.headRefName.length), 6));
+            bodyLines = windowed.map((pr, offset) => {
+                const index = startIndex + offset;
+                const isSelected = index === selected;
+                const cursor = isSelected ? '>' : ' ';
+                const numStr = `#${pr.number}`.padEnd(numberColWidth);
+                const stateLabel = pr.isDraft ? 'draft' : pr.state.toLowerCase();
+                const stateStr = stateLabel.padEnd(6);
+                const mergeStr = mergeableGlyph(pr.mergeStateStatus, pr.mergeable);
+                const reviewStr = reviewGlyph(pr.reviewDecision);
+                const authorStr = (pr.author || '').padEnd(authorColWidth);
+                const branchStr = truncateCells(pr.headRefName, branchColWidth).padEnd(branchColWidth);
+                const labelStr = (pr.labels || []).length
+                    ? ` [${(pr.labels || []).join(' ')}]`
+                    : '';
+                const head = `${cursor} `;
+                const prefix = `${numStr}  ${stateStr}  ${mergeStr}  ${reviewStr}  ${authorStr}  ${branchStr}  `;
+                const titleBudget = Math.max(8, width - 4 - head.length - prefix.length);
+                const titleStr = truncateCells(pr.title, titleBudget);
+                return h(Text, {
+                    key: `pr-triage-${index}`,
+                    bold: isSelected,
+                    dimColor: !isSelected,
+                }, head, h(Text, { dimColor: true }, numStr + '  '), h(Text, {
+                    color: stateColor(theme, pr.state, pr.isDraft),
+                    dimColor: !isSelected,
+                }, stateStr + '  '), h(Text, {
+                    color: mergeableColor(theme, pr.mergeStateStatus, pr.mergeable),
+                    dimColor: !isSelected,
+                }, mergeStr + '  '), h(Text, {
+                    color: reviewColor(theme, pr.reviewDecision),
+                    dimColor: !isSelected,
+                }, reviewStr + '  '), h(Text, {
+                    color: theme.noColor ? undefined : theme.colors.accent,
+                    dimColor: !isSelected,
+                }, authorStr + '  '), h(Text, { dimColor: true }, branchStr + '  '), titleStr, h(Text, { dimColor: true }, labelStr));
+            });
+        }
+    }
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        flexShrink: 0,
+        paddingX: 1,
+        width,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Pull requests', focused)), h(Text, { dimColor: true }, headerRight)), ...bodyLines);
+}
+
 /**
  * Reflog surface (#781). Renders `git reflog` chronologically — every
  * HEAD movement (commit, checkout, merge, reset, …) with relative time,
@@ -30497,7 +33193,7 @@ 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) {
+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) {
     // 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
@@ -30541,13 +33237,19 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     if (state.activeView === 'pull-request') {
         return renderPullRequestSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
+    if (state.activeView === 'pull-request-triage') {
+        return renderPullRequestTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+    }
+    if (state.activeView === 'issues') {
+        return renderIssuesTriageSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
+    }
     if (state.activeView === 'conflicts') {
         return renderConflictsSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
     if (state.activeView === 'changelog') {
         return renderChangelogSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
-    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits);
+    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled);
 }
 
 /**
@@ -30645,6 +33347,230 @@ function formatStashPreview(stash, options = {}) {
     }
     return out;
 }
+/* ------------------------- detail-section helpers ----------------------- */
+/**
+ * Render the first `maxLines` non-empty lines of an issue / PR body
+ * as preview lines. Returns an empty array when the body itself is
+ * empty (or whitespace only) so callers can `out.push(...body(...))`
+ * without an extra guard. Trailer appears only when content was
+ * actually truncated.
+ */
+function bodyExcerptLines(body, maxLines) {
+    if (!body.trim())
+        return [];
+    const lines = body.replace(/\r\n/g, '\n').split('\n');
+    // Drop leading blanks so the excerpt opens on the first real line
+    // rather than rendering an awkward "blank line, then body".
+    while (lines.length > 0 && !lines[0].trim())
+        lines.shift();
+    const shown = lines.slice(0, maxLines);
+    const truncated = lines.length > maxLines;
+    const out = [
+        heading('Body'),
+        ...shown.map((l) => line(l)),
+    ];
+    if (truncated) {
+        out.push(dim(`… ${lines.length - maxLines} more line(s)`));
+    }
+    return out;
+}
+function shortenLine(value, maxLength) {
+    const flattened = value.replace(/\s+/g, ' ').trim();
+    if (flattened.length <= maxLength)
+        return flattened;
+    return `${flattened.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+function commentsSection(comments, maxShown) {
+    if (comments.length === 0)
+        return [];
+    const recent = comments.slice(-3);
+    const out = [heading(`Comments (${comments.length})`)];
+    for (const comment of recent) {
+        const who = comment.author || 'anonymous';
+        out.push(line(`@${who}: ${shortenLine(comment.body, 80)}`));
+    }
+    if (comments.length > recent.length) {
+        out.push(dim(`… ${comments.length - recent.length} earlier comment(s)`));
+    }
+    return out;
+}
+function reviewsSection(reviews) {
+    if (reviews.length === 0)
+        return [];
+    const out = [heading(`Reviews (${reviews.length})`)];
+    for (const review of reviews) {
+        const who = review.author || 'anonymous';
+        const stateLabel = (review.state || 'commented').toLowerCase().replace(/_/g, ' ');
+        const inlineBody = review.body ? ` — ${shortenLine(review.body, 60)}` : '';
+        out.push(line(`@${who} (${stateLabel})${inlineBody}`));
+    }
+    return out;
+}
+function statusChecksSection(checks) {
+    if (checks.length === 0)
+        return [];
+    const grouped = {
+        success: 0,
+        failure: 0,
+        pending: 0,
+        other: 0,
+    };
+    for (const check of checks) {
+        const result = check.conclusion?.toLowerCase() ?? check.status?.toLowerCase() ?? '';
+        if (result === 'success')
+            grouped.success++;
+        else if (result === 'failure' || result === 'cancelled' || result === 'timed_out')
+            grouped.failure++;
+        else if (result === 'pending' || result === 'queued' || result === 'in_progress')
+            grouped.pending++;
+        else
+            grouped.other++;
+    }
+    const parts = [];
+    if (grouped.success)
+        parts.push(`${grouped.success} pass`);
+    if (grouped.failure)
+        parts.push(`${grouped.failure} fail`);
+    if (grouped.pending)
+        parts.push(`${grouped.pending} pending`);
+    if (grouped.other)
+        parts.push(`${grouped.other} other`);
+    return [
+        heading(`Checks (${checks.length})`),
+        line(parts.join(' · ')),
+    ];
+}
+/* -------------------------------- issue -------------------------------- */
+/**
+ * Format an issue triage entry into preview lines (#882 phase 3,
+ * body + comments added in the inspector-hydration follow-up).
+ * The list payload from `gh issue list --json` carries metadata
+ * only; the optional `detail` argument is filled by the runtime's
+ * debounced hydration effect when the cursor rests on a row, and
+ * unlocks the body / comments sections.
+ */
+function formatIssueTriagePreview(issue, detail) {
+    if (!issue) {
+        return [dim('Select an issue to preview.')];
+    }
+    const out = [
+        heading(`#${issue.number} · ${issue.title}`),
+        blank(),
+        line(`State:    ${issue.state.toLowerCase()}`),
+    ];
+    if (issue.author)
+        out.push(line(`Author:   ${issue.author}`));
+    if (issue.assignees && issue.assignees.length > 0) {
+        out.push(line(`Assigned: ${issue.assignees.join(', ')}`));
+    }
+    if (issue.labels && issue.labels.length > 0) {
+        out.push(line(`Labels:   ${issue.labels.join(', ')}`));
+    }
+    if (typeof issue.comments === 'number') {
+        out.push(line(`Comments: ${issue.comments}`));
+    }
+    out.push(blank());
+    if (issue.createdAt)
+        out.push(line(`Created:  ${issue.createdAt}`));
+    if (issue.updatedAt)
+        out.push(line(`Updated:  ${issue.updatedAt}`));
+    out.push(blank());
+    out.push(dim(issue.url));
+    // Hydrated sections (body + recent comments). Inserted only when
+    // the runtime has finished the per-cursor-rest detail fetch and
+    // populated the cache.
+    if (detail) {
+        const body = bodyExcerptLines(detail.body, 6);
+        if (body.length > 0) {
+            out.push(blank());
+            out.push(...body);
+        }
+        const comments = commentsSection(detail.comments);
+        if (comments.length > 0) {
+            out.push(blank());
+            out.push(...comments);
+        }
+    }
+    else if (typeof issue.comments === 'number' && issue.comments > 0) {
+        // Pre-hydration affordance — tell the user the body / comments
+        // section is coming, so a 250ms wait doesn't look like a bug.
+        out.push(blank());
+        out.push(dim('Loading body + comments…'));
+    }
+    return out;
+}
+/* ----------------------------- pull request ---------------------------- */
+/**
+ * Format a pull-request triage entry into preview lines (#882 phase 3,
+ * body / comments / reviews / checks added in the inspector-hydration
+ * follow-up). Optional `detail` argument is filled by the runtime's
+ * debounced hydration effect when the cursor rests on a row.
+ */
+function formatPullRequestTriagePreview(pr, detail) {
+    if (!pr) {
+        return [dim('Select a pull request to preview.')];
+    }
+    const out = [
+        heading(`#${pr.number} · ${pr.title}`),
+        blank(),
+        line(`State:     ${pr.isDraft ? 'draft' : pr.state.toLowerCase()}`),
+    ];
+    if (pr.author)
+        out.push(line(`Author:    ${pr.author}`));
+    out.push(line(`Branches:  ${pr.headRefName} → ${pr.baseRefName}`));
+    if (pr.mergeable || pr.mergeStateStatus) {
+        const merge = [pr.mergeable, pr.mergeStateStatus].filter(Boolean).join(' / ');
+        out.push(line(`Mergeable: ${merge.toLowerCase()}`));
+    }
+    if (pr.reviewDecision) {
+        out.push(line(`Review:    ${pr.reviewDecision.toLowerCase().replace(/_/g, ' ')}`));
+    }
+    if (pr.assignees && pr.assignees.length > 0) {
+        out.push(line(`Assigned:  ${pr.assignees.join(', ')}`));
+    }
+    if (pr.labels && pr.labels.length > 0) {
+        out.push(line(`Labels:    ${pr.labels.join(', ')}`));
+    }
+    out.push(blank());
+    if (pr.createdAt)
+        out.push(line(`Created:   ${pr.createdAt}`));
+    if (pr.updatedAt)
+        out.push(line(`Updated:   ${pr.updatedAt}`));
+    out.push(blank());
+    out.push(dim(pr.url));
+    // Hydrated sections — body, status checks, reviews, comments.
+    // Status checks come BEFORE reviews because failing CI is usually
+    // what a triager wants to see first; reviews come second because
+    // they're the human-judgment layer on top.
+    if (detail) {
+        const body = bodyExcerptLines(detail.body, 6);
+        if (body.length > 0) {
+            out.push(blank());
+            out.push(...body);
+        }
+        const checks = statusChecksSection(detail.statusCheckRollup);
+        if (checks.length > 0) {
+            out.push(blank());
+            out.push(...checks);
+        }
+        const reviews = reviewsSection(detail.reviews);
+        if (reviews.length > 0) {
+            out.push(blank());
+            out.push(...reviews);
+        }
+        const comments = commentsSection(detail.comments);
+        if (comments.length > 0) {
+            out.push(blank());
+            out.push(...comments);
+        }
+    }
+    else {
+        // Pre-hydration affordance — same as the issue preview.
+        out.push(blank());
+        out.push(dim('Loading body + reviews + comments…'));
+    }
+    return out;
+}
 
 /**
  * Detail / inspector / preview surface family.
@@ -30683,6 +33609,15 @@ function formatStashPreview(stash, options = {}) {
  * minimum from `getLogInkLayout`) so an overflowing label never wraps and
  * collides with the next row.
  */
+/**
+ * Format the file-count portion of the inspector stats line. Pluralize
+ * "files" only when the count is not 1 so `1 file +12/-22` reads
+ * naturally instead of `1 files`.
+ */
+function formatCommitStatLine(stats) {
+    const label = stats.filesChanged === 1 ? 'file' : 'files';
+    return `${stats.filesChanged} ${label}  +${stats.insertions}/-${stats.deletions}`;
+}
 function renderInspectorActionsSection(h, Text, context, width, theme, options = {}) {
     const actions = getInspectorActions(context);
     if (!actions.length)
@@ -30857,7 +33792,7 @@ function renderHistoryInspector(h, components, state, context, _contextStatus, d
             cursorActive: focused && state.inspectorTab === 'actions',
         }));
     }
-    const statLine = `${detail.stats.filesChanged} files  +${detail.stats.insertions}/-${detail.stats.deletions}`;
+    const statLine = formatCommitStatLine(detail.stats);
     // P5.1 — link the commit hash and each ref out to GitHub when we know
     // the remote. OSC 8 escapes embed inline; supportsHyperlinks() decides
     // whether to wrap or fall through to plain text.
@@ -30977,7 +33912,7 @@ function renderCommitDiffDetail(h, components, state, detail, loading, width, th
             dimColor: index > 1,
         }, truncateCells(line, width - 4))));
     }
-    const statLine = `${detail.stats.filesChanged} files  +${detail.stats.insertions}/-${detail.stats.deletions}`;
+    const statLine = formatCommitStatLine(detail.stats);
     const headerLines = [
         detail.message,
         '',
@@ -31206,6 +34141,64 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
         ? null
         : h(Text, { key: 'commit-state', dimColor: true }, truncateCells(stateLine, width - 4)));
 }
+/**
+ * Issue triage preview pane (#882 phase 3). Mirrors the branch / tag /
+ * stash preview pattern — `renderPreviewPanel` chrome, formatter pulls
+ * the cursored item via `state.selectedIssueIndex`. Shown when
+ * `state.activeView === 'issues'`.
+ */
+function renderIssueTriagePreviewPanel(h, components, state, context, contextStatus, width, theme, focused) {
+    const { Box, Text } = components;
+    if (isLogInkContextKeyLoading(contextStatus, 'issueList')) {
+        return renderPreviewPanel(h, { Box, Text }, 'Issue preview', [{ text: formatLogInkLoading({ resource: 'issues' }), emphasis: 'dim' }], width, theme, focused);
+    }
+    const all = context.issueList?.issues || [];
+    const visible = state.filter
+        ? all.filter((issue) => matchesPromotedFilter([
+            `#${issue.number}`,
+            issue.title,
+            issue.author || '',
+            ...(issue.labels || []),
+            ...(issue.assignees || []),
+        ], state.filter))
+        : all;
+    const index = Math.max(0, Math.min(state.selectedIssueIndex, Math.max(0, visible.length - 1)));
+    const issue = visible[index];
+    const detail = issue
+        ? context.issueDetailByNumber?.get(issue.number)
+        : undefined;
+    return renderPreviewPanel(h, { Box, Text }, 'Issue preview', formatIssueTriagePreview(issue, detail), width, theme, focused);
+}
+/**
+ * Pull-request triage preview pane (#882 phase 3). Shown when
+ * `state.activeView === 'pull-request-triage'`. Distinct from the
+ * single-PR action panel's right pane (which renders the full
+ * inspector with status checks, reviews, and action keys).
+ */
+function renderPullRequestTriagePreviewPanel(h, components, state, context, contextStatus, width, theme, focused) {
+    const { Box, Text } = components;
+    if (isLogInkContextKeyLoading(contextStatus, 'pullRequestList')) {
+        return renderPreviewPanel(h, { Box, Text }, 'Pull request preview', [{ text: formatLogInkLoading({ resource: 'pull requests' }), emphasis: 'dim' }], width, theme, focused);
+    }
+    const all = context.pullRequestList?.pullRequests || [];
+    const visible = state.filter
+        ? all.filter((pr) => matchesPromotedFilter([
+            `#${pr.number}`,
+            pr.title,
+            pr.author || '',
+            pr.headRefName,
+            pr.baseRefName,
+            ...(pr.labels || []),
+            ...(pr.assignees || []),
+        ], state.filter))
+        : all;
+    const index = Math.max(0, Math.min(state.selectedPullRequestTriageIndex, Math.max(0, visible.length - 1)));
+    const pr = visible[index];
+    const detail = pr
+        ? context.pullRequestDetailByNumber?.get(pr.number)
+        : undefined;
+    return renderPreviewPanel(h, { Box, Text }, 'Pull request preview', formatPullRequestTriagePreview(pr, detail), width, theme, focused);
+}
 
 /**
  * Detail-panel dispatcher. Routes to the right detail / overlay
@@ -31221,8 +34214,41 @@ function renderCommitPanel(h, components, state, context, contextStatus, width,
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.7
  * of #890. No behavior change.
  */
-function renderDetailPanel(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme) {
+/**
+ * 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) {
     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).
     if (state.showHelp) {
         return renderHelpPanel(h, components, state, width, theme, focused);
     }
@@ -31248,6 +34274,15 @@ 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.
@@ -31288,6 +34323,12 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.activeView === 'submodules') {
         return renderSubmodulePreviewPanel(h, components, state, context, contextStatus, width, theme, focused);
     }
+    if (state.activeView === 'issues') {
+        return renderIssueTriagePreviewPanel(h, components, state, context, contextStatus, width, theme, focused);
+    }
+    if (state.activeView === 'pull-request-triage') {
+        return renderPullRequestTriagePreviewPanel(h, components, state, context, contextStatus, width, theme, focused);
+    }
     return renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, focused);
 }
 
@@ -31508,7 +34549,7 @@ function enrichFilterActionWithRectification(action, state, context) {
     }
 }
 function LogInkApp(deps) {
-    const { appLabel, clipboardRunner, git, idleTipsEnabled, ink, initialView, loadRows, logArgv, React, resumeRef, rows, theme } = deps;
+    const { appLabel, clipboardRunner, dateBucketingEnabled, git, idleTipsEnabled, ink, initialView, loadRows, logArgv, React, resumeRef, rows, theme } = deps;
     const { Box, Text, useApp, useInput, useWindowSize } = ink;
     const h = React.createElement;
     const { exit } = useApp();
@@ -31702,6 +34743,35 @@ function LogInkApp(deps) {
             return all;
         return all.filter((entry) => matchesPromotedFilter([entry.name, entry.path, entry.trackingBranch || '', entry.url || ''], state.filter));
     }, [context.submodules?.entries, state.filter]);
+    // Issues + PR triage filtered lists (#882 phase 3). Same memo
+    // pattern as the other promoted views — collapses per-keystroke
+    // filter work to one pass per (data, filter) change.
+    const filteredIssueList = React.useMemo(() => {
+        const all = context.issueList?.issues || [];
+        if (!state.filter)
+            return all;
+        return all.filter((issue) => matchesPromotedFilter([
+            `#${issue.number}`,
+            issue.title,
+            issue.author || '',
+            ...(issue.labels || []),
+            ...(issue.assignees || []),
+        ], state.filter));
+    }, [context.issueList?.issues, state.filter]);
+    const filteredPullRequestTriageList = React.useMemo(() => {
+        const all = context.pullRequestList?.pullRequests || [];
+        if (!state.filter)
+            return all;
+        return all.filter((pr) => matchesPromotedFilter([
+            `#${pr.number}`,
+            pr.title,
+            pr.author || '',
+            pr.headRefName,
+            pr.baseRefName,
+            ...(pr.labels || []),
+            ...(pr.assignees || []),
+        ], state.filter));
+    }, [context.pullRequestList?.pullRequests, state.filter]);
     const dispatch = React.useCallback((action) => {
         setState((current) => applyLogInkAction(current, action));
     }, []);
@@ -32085,6 +35155,149 @@ function LogInkApp(deps) {
             active = false;
         };
     }, [git, state.activeView, context.pullRequest]);
+    // Lazy-load the issue triage list (#882 phase 3, filter-aware
+    // since phase 6). Fires on entry to the view AND on filter
+    // preset changes (`f` cycles the preset; the dep on
+    // `state.selectedIssueFilter` triggers the refetch). The
+    // existing `context.issueList` guard collapses to a no-op when
+    // the preset hasn't changed and data is already loaded.
+    React.useEffect(() => {
+        if (state.activeView !== 'issues')
+            return;
+        if (context.issueList)
+            return;
+        let active = true;
+        setContextStatus((current) => updateLogInkContextStatus(current, 'issueList', 'loading'));
+        const filter = issueFilterForPreset(state.selectedIssueFilter);
+        void safe(getIssueList(git, filter)).then((value) => {
+            if (!active)
+                return;
+            setContext((current) => ({
+                ...current,
+                issueList: value,
+            }));
+            setContextStatus((current) => updateLogInkContextStatus(current, 'issueList', 'ready'));
+        });
+        return () => {
+            active = false;
+        };
+    }, [git, state.activeView, context.issueList, state.selectedIssueFilter]);
+    // Filter cycling: when the preset changes, drop the cached list
+    // so the effect above re-fires with the new filter. Done as a
+    // separate effect (rather than folded into the cycle reducer)
+    // because the reducer is pure — fs / network side-effects live
+    // in `useEffect`.
+    React.useEffect(() => {
+        if (state.activeView !== 'issues')
+            return;
+        setContext((current) => (current.issueList ? { ...current, issueList: undefined } : current));
+        setContextStatus((current) => updateLogInkContextStatus(current, 'issueList', 'idle'));
+        // We deliberately depend ONLY on the preset — not on
+        // activeView — so re-entering the view doesn't re-fire and
+        // discard the just-loaded data. The activeView guard above
+        // keeps us from clearing data while the user is on a
+        // different surface.
+    }, [state.selectedIssueFilter]);
+    // Lazy-load the PR triage list (#882 phase 3, filter-aware
+    // since phase 6). Same pattern as the issue effect above.
+    React.useEffect(() => {
+        if (state.activeView !== 'pull-request-triage')
+            return;
+        if (context.pullRequestList)
+            return;
+        let active = true;
+        setContextStatus((current) => updateLogInkContextStatus(current, 'pullRequestList', 'loading'));
+        const filter = pullRequestFilterForPreset(state.selectedPullRequestFilter);
+        void safe(getPullRequestList(git, filter)).then((value) => {
+            if (!active)
+                return;
+            setContext((current) => ({
+                ...current,
+                pullRequestList: value,
+            }));
+            setContextStatus((current) => updateLogInkContextStatus(current, 'pullRequestList', 'ready'));
+        });
+        return () => {
+            active = false;
+        };
+    }, [git, state.activeView, context.pullRequestList, state.selectedPullRequestFilter]);
+    React.useEffect(() => {
+        if (state.activeView !== 'pull-request-triage')
+            return;
+        setContext((current) => current.pullRequestList ? { ...current, pullRequestList: undefined } : current);
+        setContextStatus((current) => updateLogInkContextStatus(current, 'pullRequestList', 'idle'));
+    }, [state.selectedPullRequestFilter]);
+    // Per-item inspector hydration (#882 follow-up to phase 6). When
+    // the user rests the cursor on an issue / PR row for ~250ms, fetch
+    // the body + comments (+ reviews + status checks for PRs) and
+    // cache the result keyed by number. Cursoring back to a previously-
+    // fetched item shows the cached entry instantly; rapid j/k
+    // navigation never fires a `gh` call because the debounce timer
+    // resets on every cursor move.
+    //
+    // The cache lives on `context.{issueDetailByNumber,
+    // pullRequestDetailByNumber}` so it survives the per-keystroke
+    // re-renders. It's intentionally Maps — `new Map(prev).set(k, v)`
+    // keeps the immutable update story simple, and entries persist
+    // until either the list is invalidated (post-mutation) or the
+    // process exits.
+    const DETAIL_HYDRATION_DELAY_MS = 250;
+    React.useEffect(() => {
+        if (state.activeView !== 'issues')
+            return;
+        const cursored = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+        if (!cursored)
+            return;
+        if (context.issueDetailByNumber?.has(cursored.number))
+            return;
+        let active = true;
+        const timer = setTimeout(async () => {
+            const result = await getIssueDetail(cursored.number);
+            if (!active || !result.ok)
+                return;
+            setContext((current) => ({
+                ...current,
+                issueDetailByNumber: new Map(current.issueDetailByNumber || []).set(result.detail.number, result.detail),
+            }));
+        }, DETAIL_HYDRATION_DELAY_MS);
+        return () => {
+            active = false;
+            clearTimeout(timer);
+        };
+    }, [
+        state.activeView,
+        state.selectedIssueIndex,
+        filteredIssueList,
+        context.issueDetailByNumber,
+    ]);
+    React.useEffect(() => {
+        if (state.activeView !== 'pull-request-triage')
+            return;
+        const cursored = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+        if (!cursored)
+            return;
+        if (context.pullRequestDetailByNumber?.has(cursored.number))
+            return;
+        let active = true;
+        const timer = setTimeout(async () => {
+            const result = await getPullRequestDetail(cursored.number);
+            if (!active || !result.ok)
+                return;
+            setContext((current) => ({
+                ...current,
+                pullRequestDetailByNumber: new Map(current.pullRequestDetailByNumber || []).set(result.detail.number, result.detail),
+            }));
+        }, DETAIL_HYDRATION_DELAY_MS);
+        return () => {
+            active = false;
+            clearTimeout(timer);
+        };
+    }, [
+        state.activeView,
+        state.selectedPullRequestTriageIndex,
+        filteredPullRequestTriageList,
+        context.pullRequestDetailByNumber,
+    ]);
     React.useEffect(() => {
         let active = true;
         async function loadDetail() {
@@ -33031,6 +36244,56 @@ function LogInkApp(deps) {
             const effectiveTarget = expectedTarget || target;
             return applyHunkPatch(git, patchText, { target: effectiveTarget });
         };
+        // #882 phase 4 — post-mutation cache invalidation for the
+        // issue / PR triage views. Each helper does two things:
+        //   1. Clears the in-memory `context.issueList` /
+        //      `context.pullRequestList` entry so the view's `useEffect`
+        //      retriggers on the next render and the user sees their
+        //      change reflected immediately.
+        //   2. Wipes the disk cache so a follow-up `coco issues` /
+        //      `coco prs` CLI call doesn't serve stale data from the
+        //      5-minute TTL window. Sledgehammer rather than scalpel —
+        //      clearing per (repo, filter) tuple would require more
+        //      bookkeeping than the cache is worth.
+        const invalidateIssueListCaches = (issueNumber) => {
+            setContext((current) => {
+                const next = { ...current, issueList: undefined };
+                // Drop only the mutated issue's detail entry so other
+                // hydrated entries survive — they're still accurate. When
+                // no number is given (rare), wipe the whole detail map.
+                if (current.issueDetailByNumber) {
+                    if (typeof issueNumber === 'number') {
+                        const trimmed = new Map(current.issueDetailByNumber);
+                        trimmed.delete(issueNumber);
+                        next.issueDetailByNumber = trimmed;
+                    }
+                    else {
+                        next.issueDetailByNumber = undefined;
+                    }
+                }
+                return next;
+            });
+            setContextStatus((current) => updateLogInkContextStatus(current, 'issueList', 'idle'));
+            clearGitHubListCache();
+        };
+        const invalidatePullRequestListCaches = (pullRequestNumber) => {
+            setContext((current) => {
+                const next = { ...current, pullRequestList: undefined };
+                if (current.pullRequestDetailByNumber) {
+                    if (typeof pullRequestNumber === 'number') {
+                        const trimmed = new Map(current.pullRequestDetailByNumber);
+                        trimmed.delete(pullRequestNumber);
+                        next.pullRequestDetailByNumber = trimmed;
+                    }
+                    else {
+                        next.pullRequestDetailByNumber = undefined;
+                    }
+                }
+                return next;
+            });
+            setContextStatus((current) => updateLogInkContextStatus(current, 'pullRequestList', 'idle'));
+            clearGitHubListCache();
+        };
         const handlers = {
             'create-branch': async () => {
                 const name = payload?.trim();
@@ -33548,6 +36811,181 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'Comment body required' };
                 return commentPullRequest(body);
             },
+            // #882 phase 4 — triage-view low-risk mutations. Each picks
+            // the cursored item from the *filtered* list (matching what
+            // the user sees on screen), runs the corresponding `gh` action,
+            // and on success clears both the in-memory context entry and
+            // the disk cache so the next view entry refetches. Comment
+            // is additive; label / assign are toggleable via re-invocation
+            // with --remove-* (deferred to phase 5 as part of the y-confirm
+            // suite). Open / yank don't mutate so they skip the
+            // invalidation step entirely.
+            'triage-issue-open': async () => {
+                const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+                if (!issue)
+                    return { ok: false, message: 'No issue under cursor' };
+                try {
+                    await defaultOpenUrlRunner(issue.url);
+                    return { ok: true, message: `Opened ${issue.url}` };
+                }
+                catch (error) {
+                    return { ok: false, message: error.message };
+                }
+            },
+            'triage-issue-comment': async () => {
+                const body = payload?.trim();
+                if (!body)
+                    return { ok: false, message: 'Comment body required' };
+                const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+                if (!issue)
+                    return { ok: false, message: 'No issue under cursor' };
+                const result = await commentIssue(issue.number, body);
+                if (result.ok)
+                    invalidateIssueListCaches(issue.number);
+                return result;
+            },
+            'triage-issue-label': async () => {
+                const label = payload?.trim();
+                if (!label)
+                    return { ok: false, message: 'Label name required' };
+                const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+                if (!issue)
+                    return { ok: false, message: 'No issue under cursor' };
+                const result = await addIssueLabel(issue.number, label);
+                if (result.ok)
+                    invalidateIssueListCaches(issue.number);
+                return result;
+            },
+            'triage-issue-assign': async () => {
+                const assignee = payload?.trim();
+                if (!assignee)
+                    return { ok: false, message: 'Assignee login required' };
+                const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+                if (!issue)
+                    return { ok: false, message: 'No issue under cursor' };
+                const result = await addIssueAssignee(issue.number, assignee);
+                if (result.ok)
+                    invalidateIssueListCaches(issue.number);
+                return result;
+            },
+            'triage-pr-open': async () => {
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                try {
+                    await defaultOpenUrlRunner(pr.url);
+                    return { ok: true, message: `Opened ${pr.url}` };
+                }
+                catch (error) {
+                    return { ok: false, message: error.message };
+                }
+            },
+            'triage-pr-comment': async () => {
+                const body = payload?.trim();
+                if (!body)
+                    return { ok: false, message: 'Comment body required' };
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await commentPullRequestByNumber(pr.number, body);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
+            'triage-pr-label': async () => {
+                const label = payload?.trim();
+                if (!label)
+                    return { ok: false, message: 'Label name required' };
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await addPullRequestLabel(pr.number, label);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
+            'triage-pr-assign': async () => {
+                const assignee = payload?.trim();
+                if (!assignee)
+                    return { ok: false, message: 'Assignee login required' };
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await addPullRequestAssignee(pr.number, assignee);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
+            // #882 phase 5 — destructive triage mutations. Each is gated
+            // through the y-confirm path so the user sees a prompt before
+            // anything ships. The runner reads the cursored item from the
+            // filtered list at confirm-time; the cursor can't move while
+            // the confirmation overlay is up so there's no stale-target
+            // window. Cache invalidation matches the phase-4 pattern.
+            'triage-issue-close': async () => {
+                const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+                if (!issue)
+                    return { ok: false, message: 'No issue under cursor' };
+                const result = await closeIssue(issue.number);
+                if (result.ok)
+                    invalidateIssueListCaches(issue.number);
+                return result;
+            },
+            'triage-issue-reopen': async () => {
+                const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+                if (!issue)
+                    return { ok: false, message: 'No issue under cursor' };
+                const result = await reopenIssue(issue.number);
+                if (result.ok)
+                    invalidateIssueListCaches(issue.number);
+                return result;
+            },
+            'triage-pr-merge': async () => {
+                const strategy = payload?.trim();
+                if (!strategy || !isPullRequestMergeStrategy(strategy)) {
+                    return {
+                        ok: false,
+                        message: `Unknown merge strategy: ${strategy}. Use merge, squash, or rebase.`,
+                    };
+                }
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await mergePullRequestByNumber(pr.number, strategy);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
+            'triage-pr-close': async () => {
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await closePullRequestByNumber(pr.number);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
+            'triage-pr-approve': async () => {
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await approvePullRequestByNumber(pr.number);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
+            'triage-pr-request-changes': async () => {
+                const body = payload?.trim();
+                if (!body)
+                    return { ok: false, message: 'Review body required for change-request' };
+                const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+                if (!pr)
+                    return { ok: false, message: 'No pull request under cursor' };
+                const result = await requestChangesPullRequestByNumber(pr.number, body);
+                if (result.ok)
+                    invalidatePullRequestListCaches(pr.number);
+                return result;
+            },
             // Status surface group-level batch ops (#791 follow-up). The
             // input handler dispatches these when the user presses Enter on a
             // group header. We re-derive the file list from the live
@@ -33703,6 +37141,29 @@ function LogInkApp(deps) {
                 }
             }
         }
+        else if (view === 'issues') {
+            // #882 phase 4 — y yanks the cursored issue's URL so the user
+            // can paste it into Slack / a PR description / etc. without
+            // dropping back to the browser. Short form (`Y`) is a no-op
+            // here — there's no compact identifier worth a second key.
+            const issue = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))];
+            if (issue) {
+                value = issue.url;
+                label = `issue #${issue.number} URL`;
+            }
+        }
+        else if (view === 'pull-request-triage') {
+            // #882 phase 4 — same URL-yank pattern for the multi-PR list.
+            // Distinct from `pull-request` (single, current-branch); that
+            // view falls through to the generic "Nothing to yank" path
+            // below since the action panel already exposes O for browser
+            // open.
+            const pr = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))];
+            if (pr) {
+                value = pr.url;
+                label = `pull request #${pr.number} URL`;
+            }
+        }
         else if (view === 'bisect') {
             // #879 item 3 — yank the first-bad commit sha from the
             // completion panel. The headline answer is what the user
@@ -33773,6 +37234,8 @@ function LogInkApp(deps) {
         context.submodules,
         context.tags,
         dispatch,
+        filteredIssueList,
+        filteredPullRequestTriageList,
         selected,
         selectedDetailFile,
         stashDiffLines,
@@ -33785,6 +37248,8 @@ function LogInkApp(deps) {
         state.filteredCommits,
         state.selectedBranchIndex,
         state.selectedIndex,
+        state.selectedIssueIndex,
+        state.selectedPullRequestTriageIndex,
         state.selectedStashIndex,
         state.selectedSubmoduleIndex,
         state.selectedTagIndex,
@@ -34005,6 +37470,10 @@ function LogInkApp(deps) {
         const reflogSelectedHash = filteredReflogList[Math.min(state.selectedReflogIndex, Math.max(0, filteredReflogList.length - 1))]?.hash;
         const submoduleVisibleCount = filteredSubmoduleList.length;
         filteredSubmoduleList[Math.min(state.selectedSubmoduleIndex, Math.max(0, filteredSubmoduleList.length - 1))]?.path;
+        const issueVisibleCount = filteredIssueList.length;
+        const issueSelectedUrl = filteredIssueList[Math.min(state.selectedIssueIndex, Math.max(0, filteredIssueList.length - 1))]?.url;
+        const pullRequestTriageVisibleCount = filteredPullRequestTriageList.length;
+        const pullRequestTriageSelectedUrl = filteredPullRequestTriageList[Math.min(state.selectedPullRequestTriageIndex, Math.max(0, filteredPullRequestTriageList.length - 1))]?.url;
         const worktreeVisibleCount = filteredWorktreeList.length;
         // When the diff view is showing a stash patch, swap the previewLineCount
         // to the stash diff length so the existing pageDetailPreview path
@@ -34036,6 +37505,10 @@ function LogInkApp(deps) {
             reflogCount: reflogVisibleCount,
             reflogSelectedHash,
             submoduleCount: submoduleVisibleCount,
+            issueCount: issueVisibleCount,
+            issueSelectedUrl,
+            pullRequestTriageCount: pullRequestTriageVisibleCount,
+            pullRequestTriageSelectedUrl,
             stashSelectedRef,
             stashDiffFileOffsets: stashDiffFileOffsets.length ? stashDiffFileOffsets : undefined,
             stashDiffSelectedPath,
@@ -34203,7 +37676,7 @@ 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(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme), 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), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme)), renderFooter(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame));
+    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar(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)), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.inspectorRailed)), renderFooter(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame));
 }
 
 /**
@@ -34512,6 +37985,9 @@ async function startInkInteractiveLog(git, rows, streams = {}, options = {}) {
         appLabel: options.appLabel || 'coco log',
         git,
         idleTipsEnabled: Boolean(options.idleTips),
+        // Resolve undefined → true so the default flips on automatically.
+        // An explicit `false` from config opts out.
+        dateBucketingEnabled: options.dateBucketing !== false,
         ink,
         initialView: options.initialView || 'history',
         logArgv: options.logArgv,
@@ -34676,6 +38152,7 @@ async function startCocoUiFromLogArgv(logArgv, options = {}) {
     await startInkInteractiveLog(git, initialRows, {}, {
         appLabel: 'coco',
         idleTips: config.logTui?.idleTips,
+        dateBucketing: config.logTui?.dateBucketing,
         initialView: 'history',
         loadRows,
         logArgv,
@@ -34697,13 +38174,14 @@ async function startCocoUi(argv) {
     await startInkInteractiveLog(git, cachedRows || [], {}, {
         appLabel: 'coco',
         idleTips: config.logTui?.idleTips,
+        dateBucketing: config.logTui?.dateBucketing,
         initialView: argv.view || 'history',
         loadRows: withCacheWrite(repoPath, () => getLogRows(git, logArgv)),
         logArgv,
         theme: createUiTheme(config, argv),
     });
 }
-const handler$3 = async (argv) => {
+const handler$4 = async (argv) => {
     await startCocoUi(argv);
 };
 
@@ -34796,7 +38274,7 @@ function formatCommitDetail(detail, format) {
     ].join('\n');
 }
 
-const handler$2 = async (argv) => {
+const handler$3 = async (argv) => {
     // `--repo <dir>` (alias `--cwd`) — apply the global flag via the
     // shared helper. After this returns, `process.cwd()` and the git
     // instance are both bound to the targeted repo.
@@ -34831,11 +38309,169 @@ const handler$2 = async (argv) => {
 };
 
 var log = {
-    command: command$3,
+    command: command$4,
     desc: 'Explore commit history with a branch graph, filters, and commit details.',
+    builder: builder$4,
+    handler: commandExecutor(handler$3),
+    options: options$4,
+};
+
+const command$3 = 'prs';
+const options$3 = {
+    state: {
+        type: 'string',
+        choices: ['open', 'closed', 'merged', 'all'],
+        description: 'Filter by PR state.',
+        default: 'open',
+    },
+    assignee: {
+        type: 'string',
+        description: 'Filter by assignee GitHub login (or `@me`).',
+    },
+    author: {
+        type: 'string',
+        description: 'Filter by author GitHub login.',
+    },
+    label: {
+        type: 'string',
+        description: 'Filter by label name (comma-separated for AND).',
+    },
+    search: {
+        type: 'string',
+        description: 'Free-form GitHub PR search query.',
+    },
+    base: {
+        type: 'string',
+        description: 'Filter to PRs targeting a specific base branch.',
+    },
+    head: {
+        type: 'string',
+        description: 'Filter to PRs originating from a specific head branch.',
+    },
+    draft: {
+        type: 'boolean',
+        description: 'Limit to draft PRs only.',
+        default: false,
+    },
+    mine: {
+        type: 'boolean',
+        description: 'Shorthand for `--assignee @me`.',
+        default: false,
+    },
+    limit: {
+        type: 'number',
+        description: 'Maximum rows to fetch. Defaults to `gh`\'s own default.',
+    },
+    json: {
+        type: 'boolean',
+        description: 'Print machine-readable JSON instead of a formatted table.',
+        default: false,
+    },
+    refresh: {
+        type: 'boolean',
+        description: 'Force fresh `gh` call (writes through to cache).',
+        default: false,
+    },
+    'no-cache': {
+        type: 'boolean',
+        description: 'Skip the disk cache entirely (no read, no write).',
+        default: false,
+    },
+};
+const builder$3 = (yargs) => {
+    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
+};
+
+const handler$2 = async (argv, logger) => {
+    const git = applyRepoFlag(argv);
+    const repoPath = process.cwd();
+    const filter = {
+        state: argv.state,
+        assignee: argv.mine ? '@me' : argv.assignee,
+        author: argv.author,
+        label: argv.label,
+        search: argv.search,
+        base: argv.base,
+        head: argv.head,
+        draft: argv.draft,
+        limit: argv.limit,
+    };
+    const cacheEnabled = !argv.noCache;
+    let prs;
+    let fromCache = false;
+    let cacheAgeMs;
+    const repository = await getGitHubRepository(git);
+    if (cacheEnabled && !argv.refresh) {
+        const cached = readCachedList('prs', repoPath, filter);
+        if (cached?.fresh) {
+            prs = cached.payload.items;
+            fromCache = true;
+            cacheAgeMs = cached.ageMs;
+        }
+    }
+    if (!prs) {
+        const overview = await getPullRequestList(git, filter);
+        if (!overview.available) {
+            logger.log(chalk.red(overview.message || 'No GitHub remote detected.'));
+            commandExit(1);
+            return;
+        }
+        if (!overview.authenticated) {
+            logger.log(chalk.yellow(overview.message || 'GitHub CLI is missing or not authenticated.'));
+            logger.log(chalk.dim('Install `gh` and run `gh auth login` to enable PR triage.'));
+            commandExit(1);
+            return;
+        }
+        if (overview.message) {
+            logger.log(chalk.red(overview.message));
+            commandExit(1);
+            return;
+        }
+        prs = overview.pullRequests || [];
+        if (cacheEnabled) {
+            writeCachedList(repoPath, filter, { kind: 'prs', items: prs });
+        }
+    }
+    if (argv.json) {
+        logger.log(JSON.stringify(prs, null, 2));
+        return;
+    }
+    if (repository) {
+        const filterParts = [];
+        if (filter.state && filter.state !== 'open')
+            filterParts.push(`state=${filter.state}`);
+        if (filter.assignee)
+            filterParts.push(`assignee=${filter.assignee}`);
+        if (filter.author)
+            filterParts.push(`author=${filter.author}`);
+        if (filter.label)
+            filterParts.push(`label=${filter.label}`);
+        if (filter.search)
+            filterParts.push(`search=${JSON.stringify(filter.search)}`);
+        if (filter.base)
+            filterParts.push(`base=${filter.base}`);
+        if (filter.head)
+            filterParts.push(`head=${filter.head}`);
+        if (filter.draft)
+            filterParts.push('draft');
+        const suffix = filterParts.length ? chalk.dim(` (${filterParts.join(', ')})`) : '';
+        const cacheTag = fromCache && typeof cacheAgeMs === 'number'
+            ? chalk.dim(` · cached ${Math.round(cacheAgeMs / 1000)}s ago`)
+            : '';
+        logger.log(chalk.bold(`${repository.owner}/${repository.name}`) +
+            chalk.dim(` · ${prs.length} pull request${prs.length === 1 ? '' : 's'}`) +
+            suffix +
+            cacheTag);
+        logger.log('');
+    }
+    logger.log(formatPullRequestList(prs));
+};
+
+var prs = {
+    command: command$3,
+    desc: 'List GitHub pull requests for the current repository (read-only triage)',
     builder: builder$3,
     handler: commandExecutor(handler$2),
-    options: options$3,
 };
 
 const RecapLlmResponseSchema = objectType({
@@ -35737,7 +39373,7 @@ var ui = {
     command,
     desc: 'Open the Coco Git workstation TUI.',
     builder,
-    handler: commandExecutor(handler$3),
+    handler: commandExecutor(handler$4),
     options,
 };
 
@@ -35768,6 +39404,8 @@ y.command(doctor.command, doctor.desc, doctor.builder, doctor.handler);
 y.command(log.command, log.desc, log.builder, log.handler);
 y.command(ui.command, ui.desc, ui.builder, ui.handler);
 y.command(cache.command, cache.desc, cache.builder, cache.handler);
+y.command(issues.command, issues.desc, issues.builder, issues.handler);
+y.command(prs.command, prs.desc, prs.builder, prs.handler);
 async function main() {
     await runPrefetchFromEnv();
     y.help().parse(process.argv.slice(2));
@@ -36231,7 +39869,9 @@ exports.changelog = changelog;
 exports.commit = commit;
 exports.doctor = doctor;
 exports.init = init;
+exports.issues = issues;
 exports.log = log;
+exports.prs = prs;
 exports.recap = recap;
 exports.types = types;
 exports.ui = ui;