git-coco 0.58.0 → 0.59.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.58.0";
+const BUILD_VERSION = "0.59.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -1164,6 +1164,11 @@ const schema$1 = {
                             "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
+                        },
+                        "syntaxHighlight": {
+                            "type": "boolean",
+                            "description": "Syntax-highlight code in the diff view using tree-sitter (TypeScript / TSX / JavaScript today). On by default. Highlighting degrades gracefully — unsupported languages, non-ASCII lines, and parse failures fall back to the plain add/remove coloring — so the only reason to disable it is preference or a very low-color terminal. Set to `false` to opt out.",
+                            "default": true
                         }
                     },
                     "additionalProperties": false,
@@ -2162,6 +2167,31 @@ const schema$1 = {
                 },
                 "warning": {
                     "type": "string"
+                },
+                "syntaxKeyword": {
+                    "type": "string",
+                    "description": "Optional syntax-highlight token colors for the diff view (#1117 follow-up). All optional: when a slot is unset the resolver (`resolveSyntaxColor`) falls back to a sensible ANSI default, so themes get highlighting for free and only need to define these to customize. `noColor` themes skip syntax coloring entirely."
+                },
+                "syntaxString": {
+                    "type": "string"
+                },
+                "syntaxComment": {
+                    "type": "string"
+                },
+                "syntaxNumber": {
+                    "type": "string"
+                },
+                "syntaxType": {
+                    "type": "string"
+                },
+                "syntaxFunction": {
+                    "type": "string"
+                },
+                "syntaxConstant": {
+                    "type": "string"
+                },
+                "syntaxProperty": {
+                    "type": "string"
                 }
             },
             "additionalProperties": false
@@ -21726,6 +21756,69 @@ function isLogInkContextKeyLoading(status, key) {
     return status[key] === 'loading';
 }
 
+/**
+ * Derive a short menu of sensible `.gitignore` patterns from the path of
+ * the cursored worktree file (the "add to .gitignore" quick-pick, `i` on
+ * the status view).
+ *
+ * The goal is to turn the common asks — "ignore exactly this", "ignore
+ * everything with this extension", "ignore this whole folder" — into
+ * one-keystroke choices, while always offering a `Custom pattern…` escape
+ * hatch that opens a free-text prompt for anything the menu doesn't cover
+ * (negations, globs, anchored paths, etc.).
+ *
+ * Pure / synchronous so it's trivially unit-testable and reusable from the
+ * reducer, the input handler, and the overlay renderer without pulling in
+ * `fs`.
+ */
+/**
+ * Build the option list for a repo-relative path. Git reports untracked
+ * directories with a trailing slash (`.www/`), which is how we tell a
+ * directory from a file. Duplicate patterns are collapsed (e.g. a
+ * top-level dir whose anchored and bare forms would otherwise repeat).
+ */
+function deriveGitignoreOptions(rawPath) {
+    const input = rawPath.trim();
+    const options = [];
+    const seen = new Set();
+    const add = (pattern, label) => {
+        if (!pattern || seen.has(pattern))
+            return;
+        seen.add(pattern);
+        options.push({ pattern, label, custom: false });
+    };
+    if (input) {
+        const isDir = input.endsWith('/');
+        const clean = input.replace(/\/+$/, '');
+        const segments = clean.split('/').filter(Boolean);
+        const base = segments[segments.length - 1] || clean;
+        const parent = segments.slice(0, -1).join('/');
+        if (isDir) {
+            // Anchored to the repo root vs. matching any folder of that name.
+            add(`/${clean}/`, `This folder only (/${clean}/)`);
+            add(`${base}/`, `Any “${base}/” folder`);
+        }
+        else {
+            add(input, `This file only (${input})`);
+            const dot = base.lastIndexOf('.');
+            if (dot > 0 && dot < base.length - 1) {
+                const ext = base.slice(dot);
+                add(`*${ext}`, `All ${ext} files (*${ext})`);
+            }
+            if (parent) {
+                add(`${parent}/`, `Its folder (${parent}/)`);
+            }
+            add(base, `Any file named “${base}”`);
+        }
+    }
+    options.push({
+        pattern: input,
+        label: 'Custom pattern…',
+        custom: true,
+    });
+    return options;
+}
+
 /**
  * Extract a single hunk from a unified-patch diff so it can be fed to
  * `git apply` (or `git apply --cached`) for a hunk-level cherry-pick.
@@ -22865,6 +22958,27 @@ const LOG_INK_KEY_BINDINGS = [
         description: 'Browse, live-preview, and apply a color theme.',
         contexts: ['normal'],
     },
+    {
+        id: 'openProjectConfig',
+        keys: ['gk'],
+        label: 'project config',
+        description: 'Open this repo’s .coco.json in $EDITOR (creates a starter file if missing).',
+        contexts: ['normal'],
+    },
+    {
+        id: 'openGlobalConfig',
+        keys: ['gK'],
+        label: 'global config',
+        description: 'Open ~/.config/coco/config.json in $EDITOR (creates a starter file if missing).',
+        contexts: ['normal'],
+    },
+    {
+        id: 'gitignoreFile',
+        keys: ['i'],
+        label: 'gitignore',
+        description: 'Add the cursored file or folder to .gitignore (pick a pattern).',
+        contexts: ['status'],
+    },
     {
         id: 'viewChangelog',
         keys: ['L'],
@@ -22955,6 +23069,9 @@ const BINDING_CATEGORY_BY_ID = {
     help: 'essentials',
     commandPalette: 'essentials',
     themePicker: 'view',
+    openProjectConfig: 'view',
+    openGlobalConfig: 'view',
+    gitignoreFile: 'mutate',
     quit: 'essentials',
     refresh: 'essentials',
     navigateBack: 'essentials',
@@ -23277,7 +23394,7 @@ function getLogInkFooterHints(options) {
     }
     if (options.activeView === 'status') {
         return {
-            contextual: ['↑/↓ files', 'enter diff', 'space stage', 'z revert', 'e/c compose', 'y yank'],
+            contextual: ['↑/↓ files', 'enter diff', 'space stage', 'z revert', 'i ignore', 'e/c compose', 'y yank'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -25322,6 +25439,11 @@ function applyLogInkAction(state, action) {
                 bootLoading: action.value,
                 pendingKey: undefined,
             };
+        case 'setRemoteOp':
+            return {
+                ...state,
+                remoteOp: action.value,
+            };
         case 'moveTag':
             return {
                 ...state,
@@ -25858,6 +25980,29 @@ function applyLogInkAction(state, action) {
                 themePickerIndex: 0,
                 pendingKey: undefined,
             };
+        case 'openGitignorePicker':
+            return {
+                ...state,
+                gitignorePicker: { file: action.file, index: 0 },
+                pendingKey: undefined,
+            };
+        case 'closeGitignorePicker':
+            return {
+                ...state,
+                gitignorePicker: undefined,
+                pendingKey: undefined,
+            };
+        case 'moveGitignorePicker':
+            return state.gitignorePicker
+                ? {
+                    ...state,
+                    gitignorePicker: {
+                        ...state.gitignorePicker,
+                        index: clampIndex(state.gitignorePicker.index + action.delta, action.count),
+                    },
+                    pendingKey: undefined,
+                }
+                : state;
         case 'setChangelogLoading':
             return {
                 ...state,
@@ -26595,6 +26740,14 @@ function getLogInkPaletteExecuteEvents(command, state) {
             // Palette closes on execute (toggleCommandPalette runs first), then
             // this opens the theme picker.
             return [action({ type: 'toggleThemePicker' })];
+        case 'openProjectConfig':
+            return [{ type: 'openConfigInEditor', scope: 'project' }];
+        case 'openGlobalConfig':
+            return [{ type: 'openConfigInEditor', scope: 'global' }];
+        case 'gitignoreFile':
+            // Runtime resolves the cursored worktree file and opens the picker
+            // (no-ops with a warning when there's no file under the cursor).
+            return [{ type: 'openGitignorePicker' }];
         case 'workflowDeleteBranch':
         case 'workflowDeleteTag':
         case 'workflowDropStash':
@@ -26688,6 +26841,12 @@ function submitInputPrompt(state) {
     if (!value) {
         return [action({ type: 'setStatus', value: 'enter a value or press esc to cancel', kind: 'warning' })];
     }
+    if (state.inputPrompt.kind === 'gitignore-pattern') {
+        return [
+            { type: 'runWorkflowAction', id: 'add-to-gitignore', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     if (state.inputPrompt.kind === 'reset-mode') {
         const mode = value.toLowerCase();
         if (mode !== 'soft' && mode !== 'mixed' && mode !== 'hard') {
@@ -27166,6 +27325,45 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         }
         return [];
     }
+    if (state.gitignorePicker) {
+        const options = deriveGitignoreOptions(state.gitignorePicker.file);
+        if (key.escape) {
+            return [action({ type: 'closeGitignorePicker' })];
+        }
+        if (key.upArrow || (key.ctrl && inputValue === 'p')) {
+            return [action({ type: 'moveGitignorePicker', delta: -1, count: options.length })];
+        }
+        if (key.downArrow || (key.ctrl && inputValue === 'n')) {
+            return [action({ type: 'moveGitignorePicker', delta: 1, count: options.length })];
+        }
+        if (key.return) {
+            const selected = options[Math.max(0, Math.min(state.gitignorePicker.index, options.length - 1))];
+            if (!selected) {
+                return [action({ type: 'closeGitignorePicker' })];
+            }
+            if (selected.custom) {
+                // Hand off to a free-text prompt seeded with the file path so
+                // the user can type any valid gitignore pattern (negations,
+                // globs, anchored paths) the derived options don't cover.
+                return [
+                    action({ type: 'closeGitignorePicker' }),
+                    action({
+                        type: 'openInputPrompt',
+                        kind: 'gitignore-pattern',
+                        label: `.gitignore pattern (e.g. ${selected.pattern || '*.log'})`,
+                        initial: selected.pattern,
+                    }),
+                ];
+            }
+            return [
+                action({ type: 'closeGitignorePicker' }),
+                { type: 'runWorkflowAction', id: 'add-to-gitignore', payload: selected.pattern },
+            ];
+        }
+        // Consume everything else so the underlying status view keys don't
+        // leak through while the picker owns the screen.
+        return [];
+    }
     if (state.showCommandPalette) {
         const filtered = filterLogInkPaletteCommands(getLogInkPaletteCommands(), state.paletteFilter, state.paletteRecent);
         if (key.escape) {
@@ -27443,6 +27641,20 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             action({ type: 'toggleThemePicker' }),
         ];
     }
+    // gk — open this repo's project config (.coco.json) in $EDITOR.
+    if (state.pendingKey === 'g' && inputValue === 'k') {
+        return [
+            action({ type: 'setPendingKey', value: undefined }),
+            { type: 'openConfigInEditor', scope: 'project' },
+        ];
+    }
+    // gK — open the global config (~/.config/coco/config.json) in $EDITOR.
+    if (state.pendingKey === 'g' && inputValue === 'K') {
+        return [
+            action({ type: 'setPendingKey', value: undefined }),
+            { type: 'openConfigInEditor', scope: 'global' },
+        ];
+    }
     // #784 — bisect view action keys. Scoped to `state.activeView ===
     // 'bisect' && state.focus === 'commits'` so the single-letter keys
     // stay free everywhere else. `g` and `b` collide with the global
@@ -28524,6 +28736,13 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'o' && state.activeView === 'status' && context.worktreeFileCount && context.worktreeSelectedPath) {
         return [{ type: 'openFileInEditor', path: context.worktreeSelectedPath }];
     }
+    // `i` opens the "add to .gitignore" picker for the cursored worktree
+    // file. The runtime resolves the path + opens the picker (the bare
+    // event carries no path — same selection-resolution pattern as the
+    // revert / stage events).
+    if (inputValue === 'i' && state.activeView === 'status' && context.worktreeFileCount && context.worktreeSelectedPath) {
+        return [{ type: 'openGitignorePicker' }];
+    }
     if (inputValue === 'o' && state.activeView === 'diff' && state.diffSource === 'worktree' && context.worktreeSelectedPath) {
         return [{ type: 'openFileInEditor', path: context.worktreeSelectedPath }];
     }
@@ -29981,6 +30200,35 @@ async function runAction$5(action, successMessage) {
         };
     }
 }
+/** Configured remote names (best-effort; `[]` if the call fails). */
+async function listRemotes(git) {
+    try {
+        return (await git.getRemotes()).map((remote) => remote.name).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Remote to push a not-yet-tracked branch to: `origin` when it exists,
+ * else the first configured remote, else `undefined` (no remotes).
+ */
+async function resolveDefaultRemote(git) {
+    const remotes = await listRemotes(git);
+    if (remotes.length === 0)
+        return undefined;
+    return remotes.includes('origin') ? 'origin' : remotes[0];
+}
+/** Whether the remote-tracking ref `refs/remotes/<remote>/<branch>` exists locally. */
+async function remoteBranchExists(git, remote, branch) {
+    try {
+        await git.raw(['show-ref', '--verify', '--quiet', `refs/remotes/${remote}/${branch}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function checkoutBranch(git, branch) {
     const refs = getBranchActionRefs(branch);
     if (branch.type === 'remote') {
@@ -30015,11 +30263,58 @@ function fetchRemotes(git) {
 function pullCurrentBranch(git) {
     return runAction$5(() => git.raw(['pull', '--ff-only']), 'Pulled current branch');
 }
-function pushCurrentBranch(git) {
-    return runAction$5(() => git.raw(['push']), 'Pushed current branch');
-}
-function setUpstream(git, localBranch, upstreamBranch) {
-    return runAction$5(() => git.raw(['branch', '--set-upstream-to', upstreamBranch, localBranch]), `Set ${localBranch} upstream to ${upstreamBranch}`);
+async function pushCurrentBranch(git) {
+    const hasUpstream = await git
+        .raw(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'])
+        .then(() => true)
+        .catch(() => false);
+    if (hasUpstream) {
+        return runAction$5(() => git.raw(['push']), 'Pushed current branch');
+    }
+    // No upstream yet — push with `-u` to create the remote branch AND set
+    // tracking, instead of failing with git's bare "has no upstream" error.
+    const remote = await resolveDefaultRemote(git);
+    if (!remote) {
+        return { ok: false, message: 'No upstream and no remote configured — add one with `git remote add origin <url>`.' };
+    }
+    const current = (await git.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+    return runAction$5(() => git.raw(['push', '-u', remote, current]), `Pushed ${current} and set upstream to ${remote}/${current}`);
+}
+/**
+ * Set (or create) the upstream for a local branch from a user-typed target.
+ *
+ * The target may be a bare branch name (`main` → `<default-remote>/main`) or
+ * a `remote/branch` ref (`origin/main`). If that remote-tracking branch
+ * already exists, we just link to it (`git branch --set-upstream-to`). If it
+ * does NOT exist yet — the common "I just created this branch" case — we
+ * `git push -u` to create the remote branch and set tracking in one step.
+ * The old behavior ran `--set-upstream-to <bare-name>`, which silently
+ * resolved `main` to the *local* branch and left push still complaining.
+ */
+async function setUpstream(git, localBranch, target) {
+    const cleaned = target.trim();
+    if (!cleaned)
+        return { ok: false, message: 'Upstream ref required' };
+    const remotes = await listRemotes(git);
+    const slash = cleaned.indexOf('/');
+    let remote;
+    let remoteBranch;
+    if (slash > 0 && remotes.includes(cleaned.slice(0, slash))) {
+        remote = cleaned.slice(0, slash);
+        remoteBranch = cleaned.slice(slash + 1);
+    }
+    else {
+        remote = remotes.includes('origin') ? 'origin' : remotes[0];
+        remoteBranch = cleaned;
+    }
+    if (!remote) {
+        return { ok: false, message: 'No remote configured — add one with `git remote add origin <url>` first.' };
+    }
+    if (await remoteBranchExists(git, remote, remoteBranch)) {
+        return runAction$5(() => git.raw(['branch', '--set-upstream-to', `${remote}/${remoteBranch}`, localBranch]), `Set ${localBranch} to track ${remote}/${remoteBranch}`);
+    }
+    // Remote branch doesn't exist yet — push it and set upstream in one step.
+    return runAction$5(() => git.raw(['push', '-u', remote, `${localBranch}:${remoteBranch}`]), `Pushed ${localBranch} → ${remote}/${remoteBranch} and set upstream`);
 }
 /**
  * Push an arbitrary local branch (need not be the current branch) to
@@ -30030,18 +30325,21 @@ function setUpstream(git, localBranch, upstreamBranch) {
  * Pairs with `pushCurrentBranch` (no-arg variant); the workstation
  * dispatcher picks one or the other based on where the cursor is.
  */
-function pushBranch(git, branch) {
+async function pushBranch(git, branch) {
     if (branch.type !== 'local') {
-        return Promise.resolve({
-            ok: false,
-            message: 'Only local branches can be pushed.',
-        });
+        return { ok: false, message: 'Only local branches can be pushed.' };
     }
     if (!branch.upstream || !branch.remote) {
-        return Promise.resolve({
-            ok: false,
-            message: `${branch.shortName} has no upstream — checkout the branch and run \`git push -u <remote> ${branch.shortName}\` first.`,
-        });
+        // No upstream yet — push with `-u` to create the remote branch AND set
+        // tracking, rather than refusing and sending the user to the shell.
+        const remote = await resolveDefaultRemote(git);
+        if (!remote) {
+            return {
+                ok: false,
+                message: `${branch.shortName} has no upstream and no remote is configured — add one with \`git remote add origin <url>\`.`,
+            };
+        }
+        return runAction$5(() => git.raw(['push', '-u', remote, branch.shortName]), `Pushed ${branch.shortName} and set upstream to ${remote}/${branch.shortName}`);
     }
     return runAction$5(() => git.raw(['push', branch.remote, branch.shortName]), `Pushed ${branch.shortName} to ${branch.upstream}`);
 }
@@ -30122,6 +30420,493 @@ function pullBranch(git, branch, currentBranchName) {
     ]), `Fast-forwarded ${branch.shortName} to ${branch.upstream}`);
 }
 
+/**
+ * Append a pattern to the repository's `.gitignore` (the runtime side of
+ * the "add to .gitignore" quick-pick, `i` on the status view).
+ *
+ * Kept separate from the pure pattern-derivation helper
+ * (`workstation/chrome/gitignore.ts`) because this touches the filesystem
+ * and resolves the repo root via git — neither of which the UI layer
+ * should pull in.
+ */
+/**
+ * Append `pattern` to `<repoRoot>/.gitignore`, creating the file if it
+ * doesn't exist. No-ops (reporting success) when the exact pattern is
+ * already present so re-running is safe. Handles the missing-trailing-
+ * newline case so we never glue the new entry onto the previous line.
+ */
+async function addToGitignore(git, pattern) {
+    const entry = pattern.trim();
+    if (!entry) {
+        return { ok: false, message: 'No pattern to add.' };
+    }
+    let root;
+    try {
+        root = (await git.revparse(['--show-toplevel'])).trim();
+    }
+    catch {
+        return { ok: false, message: 'Could not resolve the repository root.' };
+    }
+    if (!root) {
+        return { ok: false, message: 'Could not resolve the repository root.' };
+    }
+    const file = path__namespace.join(root, '.gitignore');
+    let existing = '';
+    try {
+        existing = await fs.promises.readFile(file, 'utf8');
+    }
+    catch {
+        // No .gitignore yet — we'll create it.
+        existing = '';
+    }
+    // Already ignored (exact line match, ignoring surrounding whitespace)?
+    const alreadyPresent = existing
+        .split('\n')
+        .some((line) => line.trim() === entry);
+    if (alreadyPresent) {
+        return { ok: true, message: `${entry} is already in .gitignore` };
+    }
+    const needsLeadingNewline = existing.length > 0 && !existing.endsWith('\n');
+    const addition = `${needsLeadingNewline ? '\n' : ''}${entry}\n`;
+    try {
+        await fs.promises.appendFile(file, addition, 'utf8');
+    }
+    catch (error) {
+        return { ok: false, message: error.message };
+    }
+    return { ok: true, message: `Added ${entry} to .gitignore` };
+}
+
+/**
+ * Embedded tree-sitter highlight queries (one per language).
+ *
+ * We ship our own compact queries rather than reading the upstream
+ * `queries/highlights.scm` from the grammar packages because those are
+ * dev-only / not present in a published install, and they lean on
+ * `#match?` / `#is-not? local` predicates that web-tree-sitter's
+ * `Query.captures()` does NOT evaluate for us — including them would
+ * mis-tag every identifier. These subsets are **predicate-free** (so
+ * every capture is unconditionally correct) and use only grammar-valid
+ * node/token names (so the query compiles — verified against the real
+ * grammars), distilled from each language's upstream `highlights.scm`.
+ *
+ * The TS query serves both `typescript` and `tsx` (tsx is a superset).
+ */
+const TS_HIGHLIGHT_QUERY = `
+; Comments
+(comment) @comment
+
+; Strings
+[
+  (string)
+  (template_string)
+] @string
+(regex) @string
+
+; Numbers
+(number) @number
+
+; Types
+(type_identifier) @type
+(predefined_type) @type
+
+; Literals
+[
+  (true)
+  (false)
+  (null)
+  (undefined)
+] @constant
+(this) @keyword
+(super) @keyword
+
+; Properties
+(property_identifier) @property
+
+; Function definitions and calls (field-name patterns — no predicates)
+(function_declaration
+  name: (identifier) @function)
+(function_expression
+  name: (identifier) @function)
+(method_definition
+  name: (property_identifier) @function)
+(call_expression
+  function: (identifier) @function)
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function))
+(variable_declarator
+  name: (identifier) @function
+  value: [(function_expression) (arrow_function)])
+
+; Keywords (anonymous tokens — all valid in the TS/TSX grammars)
+[
+  "abstract"
+  "declare"
+  "enum"
+  "implements"
+  "interface"
+  "keyof"
+  "namespace"
+  "private"
+  "protected"
+  "public"
+  "type"
+  "readonly"
+  "override"
+  "satisfies"
+  "as"
+  "async"
+  "await"
+  "break"
+  "case"
+  "catch"
+  "class"
+  "const"
+  "continue"
+  "debugger"
+  "default"
+  "delete"
+  "do"
+  "else"
+  "export"
+  "extends"
+  "finally"
+  "for"
+  "from"
+  "function"
+  "get"
+  "if"
+  "import"
+  "in"
+  "instanceof"
+  "let"
+  "new"
+  "of"
+  "return"
+  "set"
+  "static"
+  "switch"
+  "throw"
+  "try"
+  "typeof"
+  "var"
+  "void"
+  "while"
+  "with"
+  "yield"
+] @keyword
+`.trim();
+/** Python (validated against tree-sitter-python 0.23.6). */
+const PYTHON_HIGHLIGHT_QUERY = `
+(comment) @comment
+(string) @string
+(integer) @number
+(float) @number
+(type) @type
+(function_definition
+  name: (identifier) @function)
+(class_definition
+  name: (identifier) @type)
+(call
+  function: (identifier) @function)
+[ (true) (false) (none) ] @constant
+[
+  "def" "class" "return" "pass" "if" "elif" "else" "for" "while"
+  "import" "from" "as" "with" "try" "except" "finally" "raise"
+  "lambda" "yield" "global" "nonlocal" "assert" "del" "in" "not"
+  "and" "or" "is" "await" "async"
+] @keyword
+`.trim();
+/** Rust (validated against tree-sitter-rust 0.24.0). */
+const RUST_HIGHLIGHT_QUERY = `
+[ (line_comment) (block_comment) ] @comment
+[ (string_literal) (char_literal) (raw_string_literal) ] @string
+(integer_literal) @number
+(float_literal) @number
+[ (primitive_type) (type_identifier) ] @type
+(function_item
+  name: (identifier) @function)
+(call_expression
+  function: (identifier) @function)
+(boolean_literal) @constant
+[
+  "fn" "let" "const" "static" "if" "else" "match" "for" "while"
+  "loop" "return" "break" "continue" "struct" "enum" "trait" "impl"
+  "use" "mod" "pub" "as" "where" "in" "unsafe" "async" "await"
+  "dyn" "type"
+] @keyword
+`.trim();
+/** Go (validated against tree-sitter-go 0.25.0). */
+const GO_HIGHLIGHT_QUERY = `
+(comment) @comment
+[ (interpreted_string_literal) (raw_string_literal) (rune_literal) ] @string
+(int_literal) @number
+(float_literal) @number
+(type_identifier) @type
+(function_declaration
+  name: (identifier) @function)
+(method_declaration
+  name: (field_identifier) @function)
+(call_expression
+  function: (identifier) @function)
+(call_expression
+  function: (selector_expression
+    field: (field_identifier) @function))
+[ (true) (false) (nil) (iota) ] @constant
+[
+  "func" "var" "const" "type" "struct" "interface" "map" "chan"
+  "package" "import" "return" "if" "else" "for" "range" "switch"
+  "case" "default" "break" "continue" "go" "defer" "select"
+  "fallthrough" "goto"
+] @keyword
+`.trim();
+/** Highlight query keyed by tree-sitter language id. */
+const HIGHLIGHT_QUERIES = {
+    typescript: TS_HIGHLIGHT_QUERY,
+    tsx: TS_HIGHLIGHT_QUERY,
+    python: PYTHON_HIGHLIGHT_QUERY,
+    rust: RUST_HIGHLIGHT_QUERY,
+    go: GO_HIGHLIGHT_QUERY,
+};
+
+/**
+ * Map a tree-sitter capture name to a normalized token type. Captures
+ * are dotted (`a.b.c`); we key off the leading segment and fold the rest
+ * in. Anything we don't have a color for collapses to `plain` (rendered
+ * in the default foreground), so unmapped captures degrade gracefully.
+ */
+function captureToToken(capture) {
+    const base = capture.split('.')[0];
+    switch (base) {
+        case 'keyword':
+            return 'keyword';
+        case 'string':
+            return 'string';
+        case 'comment':
+            return 'comment';
+        case 'number':
+            return 'number';
+        case 'type':
+            return 'type';
+        case 'function':
+        case 'method':
+        case 'constructor':
+            return 'function';
+        case 'property':
+            return 'property';
+        case 'constant':
+            return 'constant';
+        default:
+            return 'plain';
+    }
+}
+
+/**
+ * Tree-sitter syntax highlighter for the diff view.
+ *
+ * Reuses the existing tree-sitter runtime (`getTreeSitterParser`) — same
+ * lazy init, same bundled `typescript` / `tsx` grammars (offline-safe),
+ * same "return undefined when .wasm is unavailable" contract. On top of
+ * that we build one `Query` per language from our embedded highlight
+ * query and tokenize code **per line**.
+ *
+ * Per-line (rather than whole-file) tokenization keeps this uniform
+ * across every diff source — stash / compare / commit / worktree all
+ * hand us diff lines, never reconstructed files — and tree-sitter's
+ * error tolerance means a single statement still yields good captures.
+ * Results are cached by (language, line) so re-renders and repeated
+ * lines are free.
+ *
+ * Everything degrades to "no spans" (the caller renders the plain
+ * single-color line): missing grammar, query compile failure, parse
+ * error, non-ASCII text (byte/char offset skew), or an over-long line.
+ */
+// Longest extension first so `.d.ts` / `.mts` win over `.ts`.
+//
+// NOTE: typescript + tsx grammars are bundled (offline). python / rust /
+// go grammars download on demand and are only available once cached
+// (prefetched) — `getTreeSitterParser` returns undefined otherwise, so
+// those diffs render plain until the grammar is present. Same
+// availability model the structural parsers already use.
+const EXT_LANGUAGE = [
+    ['.tsx', 'tsx'],
+    ['.jsx', 'tsx'],
+    ['.mts', 'typescript'],
+    ['.cts', 'typescript'],
+    ['.mjs', 'tsx'],
+    ['.cjs', 'tsx'],
+    ['.ts', 'typescript'],
+    ['.js', 'tsx'],
+    ['.py', 'python'],
+    ['.pyi', 'python'],
+    ['.rs', 'rust'],
+    ['.go', 'go'],
+];
+/** Map a file path to a highlight language, or undefined when unsupported. */
+function detectSyntaxLanguage(filePath) {
+    const lower = filePath.toLowerCase();
+    for (const [ext, language] of EXT_LANGUAGE) {
+        if (lower.endsWith(ext))
+            return language;
+    }
+    return undefined;
+}
+// Printable ASCII (+ tab). Outside this range tree-sitter's byte offsets
+// diverge from JS string char offsets, which would misalign spans — so
+// we skip those lines entirely (rendered plain).
+const ASCII_ONLY = /^[\t\x20-\x7E]*$/;
+const MAX_LINE_LENGTH = 2000;
+// `null` marks "tried and failed" so we don't retry the grammar/query
+// load on every line.
+const queryCache = new Map();
+const spanCache = new Map();
+async function getQuery(language) {
+    if (queryCache.has(language)) {
+        return queryCache.get(language) ?? undefined;
+    }
+    const querySource = HIGHLIGHT_QUERIES[language];
+    const loaded = querySource ? await getTreeSitterParser(language) : undefined;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const grammar = loaded?.parser?.language;
+    if (!loaded || !grammar || !querySource) {
+        queryCache.set(language, null);
+        return undefined;
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await import('web-tree-sitter'));
+        const QueryCtor = mod.Query;
+        const query = new QueryCtor(grammar, querySource);
+        queryCache.set(language, query);
+        return query;
+    }
+    catch {
+        queryCache.set(language, null);
+        return undefined;
+    }
+}
+function buildSpans(text, captures) {
+    const n = text.length;
+    const charType = new Array(n);
+    // Paint widest captures first so narrower/inner captures override them
+    // — yields clean, non-overlapping spans without nesting bookkeeping.
+    const ordered = [...captures].sort((a, b) => (b.node.endIndex - b.node.startIndex) - (a.node.endIndex - a.node.startIndex));
+    for (const capture of ordered) {
+        const token = captureToToken(capture.name);
+        if (token === 'plain')
+            continue;
+        const start = Math.max(0, capture.node.startIndex);
+        const end = Math.min(n, capture.node.endIndex);
+        for (let i = start; i < end; i++)
+            charType[i] = token;
+    }
+    // Coalesce runs of equal token type (gaps → 'plain').
+    const spans = [];
+    let i = 0;
+    while (i < n) {
+        const token = charType[i] ?? 'plain';
+        let j = i + 1;
+        while (j < n && (charType[j] ?? 'plain') === token)
+            j++;
+        spans.push({ start: i, end: j, token });
+        i = j;
+    }
+    return spans;
+}
+/**
+ * Tokenize a single line of code into non-overlapping spans covering the
+ * whole string (plain runs included). Returns `[]` when the line can't
+ * be highlighted (no grammar, parse error, non-ASCII, too long) so the
+ * caller falls back to its plain single-color rendering.
+ */
+async function highlightLine(language, text) {
+    if (!text)
+        return [];
+    if (text.length > MAX_LINE_LENGTH || !ASCII_ONLY.test(text))
+        return [];
+    const key = `${language}${text}`;
+    const cached = spanCache.get(key);
+    if (cached)
+        return cached;
+    const query = await getQuery(language);
+    const loaded = await getTreeSitterParser(language);
+    if (!query || !loaded) {
+        spanCache.set(key, []);
+        return [];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let tree;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        tree = loaded.parser.parse(text);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const captures = query.captures(tree.rootNode);
+        const spans = buildSpans(text, captures);
+        spanCache.set(key, spans);
+        return spans;
+    }
+    catch {
+        spanCache.set(key, []);
+        return [];
+    }
+    finally {
+        tree?.delete?.();
+    }
+}
+/**
+ * Tokenize the code lines of a unified diff. Strips the leading
+ * `+` / `-` / ` ` marker before highlighting (headers and `@@` lines are
+ * skipped — they're not code), and returns a map keyed by the
+ * marker-stripped line text so the renderer can look spans up directly.
+ * Lines that yield no spans are omitted (renderer falls back to plain).
+ */
+/**
+ * Pick the unique, marker-stripped code lines out of a unified diff:
+ * only `+` / `-` / ` ` rows are code; `diff`/`index`/`@@`/`+++`/`---`
+ * headers are skipped. Pure + exported so the selection is testable
+ * without a grammar.
+ */
+function selectDiffCodeLines(lines) {
+    const seen = new Set();
+    // Hunk-aware: a `+`/`-`/` ` line is code only INSIDE a hunk. This is
+    // what distinguishes a real added line from the `+++ b/file` /
+    // `--- a/file` file headers (which precede the first `@@` and also
+    // start with `+`/`-`). Same stateful rule the split-diff parser uses.
+    let inHunk = false;
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (!inHunk)
+            continue;
+        const marker = line[0];
+        if (marker !== '+' && marker !== '-' && marker !== ' ') {
+            // A non-diff line (blank-separator label, next file's `diff --git`)
+            // ends the current hunk until the next `@@`.
+            inHunk = false;
+            continue;
+        }
+        seen.add(line.slice(1));
+    }
+    return [...seen];
+}
+async function highlightDiffCode(filePath, lines) {
+    const result = new Map();
+    const language = detectSyntaxLanguage(filePath);
+    if (!language)
+        return result;
+    for (const code of selectDiffCodeLines(lines)) {
+        const spans = await highlightLine(language, code);
+        if (spans.length)
+            result.set(code, spans);
+    }
+    return result;
+}
+
 async function runAction$4(action, successMessage) {
     try {
         await action();
@@ -33843,11 +34628,50 @@ function flushChangeBlock(removals, additions, rows) {
     removals.length = 0;
     additions.length = 0;
 }
-function buildSplitDiffRows(unifiedLines) {
-    const rows = [];
+/**
+ * Replay the hunk parser over `unifiedLines[0..upTo)` (exclusive) and
+ * return the parse state at that boundary. Used by the split renderer
+ * to seed `buildSplitDiffRows` with the correct in-hunk flag and
+ * line-number cursors when it windows the diff to a scroll offset that
+ * starts partway through a hunk. Counting mirrors `buildSplitDiffRows`
+ * exactly so the seeded line numbers stay continuous across the cut.
+ */
+function computeDiffContext(unifiedLines, upTo) {
     let oldLineNo = 0;
     let newLineNo = 0;
     let inHunk = false;
+    const bound = Math.max(0, Math.min(upTo, unifiedLines.length));
+    for (let i = 0; i < bound; i++) {
+        const raw = unifiedLines[i];
+        if (raw.startsWith('@@')) {
+            const [oldStart, newStart] = parseHunkHeader(raw);
+            oldLineNo = oldStart;
+            newLineNo = newStart;
+            inHunk = true;
+            continue;
+        }
+        if (!inHunk || isDiffHeader(raw)) {
+            continue;
+        }
+        if (raw.startsWith('-')) {
+            oldLineNo += 1;
+            continue;
+        }
+        if (raw.startsWith('+')) {
+            newLineNo += 1;
+            continue;
+        }
+        // Context line (or `\ No newline` marker) advances both cursors.
+        oldLineNo += 1;
+        newLineNo += 1;
+    }
+    return { inHunk, oldLineNo, newLineNo };
+}
+function buildSplitDiffRows(unifiedLines, seed) {
+    const rows = [];
+    let oldLineNo = seed?.oldLineNo ?? 0;
+    let newLineNo = seed?.newLineNo ?? 0;
+    let inHunk = seed?.inHunk ?? false;
     const removals = [];
     const additions = [];
     const flushHeader = (text) => {
@@ -33908,6 +34732,32 @@ function buildSplitDiffRows(unifiedLines) {
     return rows;
 }
 
+function resolveSyntaxColor(token, theme) {
+    if (theme.noColor)
+        return undefined;
+    const c = theme.colors;
+    switch (token) {
+        case 'keyword':
+            return c.syntaxKeyword ?? 'magenta';
+        case 'string':
+            return c.syntaxString ?? 'green';
+        case 'comment':
+            return c.syntaxComment ?? 'gray';
+        case 'number':
+            return c.syntaxNumber ?? 'yellow';
+        case 'type':
+            return c.syntaxType ?? 'cyan';
+        case 'function':
+            return c.syntaxFunction ?? 'blue';
+        case 'constant':
+            return c.syntaxConstant ?? 'yellow';
+        case 'property':
+            return c.syntaxProperty ?? undefined;
+        default:
+            return undefined;
+    }
+}
+
 /**
  * Split-diff rendering helpers (#785) — shared between the diff
  * surface and any future surface that wants side-by-side diff layout.
@@ -33979,30 +34829,107 @@ function formatSplitDiffCell(side, columnWidth) {
     return `${lineNo} ${truncateCells(text, textRoom)}`.padEnd(columnWidth);
 }
 /**
- * Render the split-diff body as a list of two-column rows. The caller
- * is responsible for slicing the unified-line array to the visible
- * window — the helper just transforms that slice into Ink nodes.
+ * Render one split-diff column as an Ink node — syntax-highlighted when
+ * spans are available for the line, plain otherwise.
+ *
+ * Highlighted cells keep the 4-digit line-number gutter but color IT
+ * with the add/remove cue (green/red, dim for context) so the code body
+ * is free to carry its syntax colors — the split layout's position
+ * (old | new) plus the colored gutter still tells you what changed.
+ * Width is budgeted exactly like `formatSplitDiffCell` (gutter + 1 space
+ * + truncated code) so columns never drift.
+ */
+function renderSplitDiffCell(h, Text, side, columnWidth, theme, syntaxSpans, key) {
+    const text = side.text.replace(/\n$/, '');
+    const spans = side.kind === 'add' || side.kind === 'remove' || side.kind === 'context'
+        ? syntaxSpans?.get(text)
+        : undefined;
+    if (!spans || spans.length === 0) {
+        return h(Text, { key, ...splitDiffSideProps(side.kind, theme) }, formatSplitDiffCell(side, columnWidth));
+    }
+    const lineNo = side.lineNumber !== undefined ? String(side.lineNumber).padStart(4) : '    ';
+    const textRoom = Math.max(1, columnWidth - 5);
+    const gutterColor = side.kind === 'add'
+        ? theme.colors.gitAdded
+        : side.kind === 'remove'
+            ? theme.colors.gitDeleted
+            : undefined;
+    const children = [];
+    let used = 0;
+    for (const span of spans) {
+        if (used >= textRoom)
+            break;
+        const segment = truncateCells(text.slice(span.start, span.end), textRoom - used);
+        if (!segment)
+            continue;
+        used += cellWidth(segment);
+        children.push(h(Text, { key: `${key}-s${span.start}`, color: resolveSyntaxColor(span.token, theme) }, segment));
+    }
+    return h(Text, { key }, h(Text, { key: `${key}-g`, color: gutterColor, dimColor: !gutterColor }, `${lineNo} `), ...children);
+}
+/**
+ * Render the split-diff body as a list of two-column rows.
+ *
+ * Takes the FULL unified-line array plus the scroll offset + visible
+ * row budget, and windows it internally. The windowing has to live
+ * here (not the caller) because the parser is stateful: a window that
+ * starts partway through a hunk needs the hunk context (in-hunk flag +
+ * line-number cursors) that precedes it, or every visible line gets
+ * misclassified as a header and painted in the accent color (#1114).
+ * We compute that context from the lines before the window and seed
+ * the parser with it.
  */
-function renderSplitDiffBody(h, components, unifiedSlice, startOffset, width, theme, keyPrefix) {
+function renderSplitDiffBody(h, components, unifiedLines, startOffset, visibleRows, width, theme, keyPrefix, syntaxSpans) {
     const { Box, Text } = components;
-    const rows = buildSplitDiffRows(unifiedSlice);
+    const seed = computeDiffContext(unifiedLines, startOffset);
+    const unifiedSlice = unifiedLines.slice(startOffset, startOffset + visibleRows);
+    const rows = buildSplitDiffRows(unifiedSlice, seed);
     // Reserve 3 columns of gutter (1 left padding from the Box + 1 column
     // separator + 1 right padding) so neither side touches the border.
     const usable = Math.max(20, width - 4);
     const gutter = 1;
     const half = Math.max(10, Math.floor((usable - gutter) / 2));
     return rows.map((row, index) => {
-        const leftProps = splitDiffSideProps(row.left.kind, theme);
-        const rightProps = splitDiffSideProps(row.right.kind, theme);
-        const leftText = formatSplitDiffCell(row.left, half);
-        const rightText = formatSplitDiffCell(row.right, half);
+        const rowKey = `${keyPrefix}-${startOffset + index}`;
         return h(Box, {
-            key: `${keyPrefix}-${startOffset + index}`,
+            key: rowKey,
             flexDirection: 'row',
-        }, h(Box, { width: half, flexShrink: 0 }, h(Text, leftProps, leftText)), h(Box, { width: gutter, flexShrink: 0 }, h(Text, { dimColor: true }, ' ')), h(Box, { width: half, flexShrink: 0 }, h(Text, rightProps, rightText)));
+        }, h(Box, { width: half, flexShrink: 0 }, renderSplitDiffCell(h, Text, row.left, half, theme, syntaxSpans, `${rowKey}-l`)), h(Box, { width: gutter, flexShrink: 0 }, h(Text, { dimColor: true }, ' ')), h(Box, { width: half, flexShrink: 0 }, renderSplitDiffCell(h, Text, row.right, half, theme, syntaxSpans, `${rowKey}-r`)));
     });
 }
 
+/**
+ * @param syntaxSpans map of marker-stripped code line → token spans
+ *   (from `highlightDiffCode`), or undefined when highlighting is off.
+ * @param maxCells total cell budget for the whole line (marker + code).
+ */
+function renderDiffLine(h, Text, line, theme, syntaxSpans, maxCells, key) {
+    const spans = line ? syntaxSpans?.get(line.slice(1)) : undefined;
+    if (!spans || spans.length === 0) {
+        return h(Text, { key, ...diffLineProps(line, theme) }, truncateCells(line, maxCells));
+    }
+    const marker = line[0];
+    const markerColor = marker === '+'
+        ? theme.colors.gitAdded
+        : marker === '-'
+            ? theme.colors.gitDeleted
+            : undefined;
+    const code = line.slice(1);
+    const budget = Math.max(0, maxCells - 1); // reserve one cell for the marker
+    const children = [];
+    let used = 0;
+    for (const span of spans) {
+        if (used >= budget)
+            break;
+        const segment = truncateCells(code.slice(span.start, span.end), budget - used);
+        if (!segment)
+            continue;
+        used += cellWidth(segment);
+        children.push(h(Text, { key: `${key}-s${span.start}`, color: resolveSyntaxColor(span.token, theme) }, segment));
+    }
+    return h(Text, { key }, h(Text, { key: `${key}-m`, color: markerColor }, marker), ...children);
+}
+
 /**
  * Diff surface — the unified or side-by-side diff view. Four sources
  * route through here, disambiguated by `state.diffSource`:
@@ -34025,7 +34952,7 @@ function renderSplitDiffBody(h, components, unifiedSlice, startOffset, width, th
  * Extracted from `src/commands/log/inkRuntime.ts` as part of phase 5a.4
  * of #890. No behavior change.
  */
-function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme) {
+function renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme, syntaxSpans) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
     const worktree = context.worktree;
@@ -34079,7 +35006,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const stashBodyNodes = stashDiffLoading || !lines.length
             ? []
             : splitActive
-                ? renderSplitDiffBody(h, components, visibleLines, state.diffPreviewOffset, width, theme, 'stash-diff-split')
+                ? renderSplitDiffBody(h, components, lines, state.diffPreviewOffset, visibleRows, width, theme, 'stash-diff-split', syntaxSpans)
                 : visibleLines.map((line, index) => {
                     const absoluteIndex = state.diffPreviewOffset + index;
                     const headerFile = stashFileByStartLine.get(absoluteIndex);
@@ -34116,10 +35043,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
                                 : truncateCells(`${arrow}${headerFile.path}`, width - 4);
                         })());
                     }
-                    return h(Text, {
-                        key: `stash-diff-line-${absoluteIndex}`,
-                        ...diffLineProps(line, theme),
-                    }, truncateCells(line, width - 4));
+                    return renderDiffLine(h, Text, line, theme, syntaxSpans, width - 4, `stash-diff-line-${absoluteIndex}`);
                 });
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
@@ -34160,11 +35084,8 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const compareBodyNodes = compareDiffLoading || !lines.length || (lines.length === 1 && !lines[0])
             ? []
             : splitActive
-                ? renderSplitDiffBody(h, components, visibleLines, state.diffPreviewOffset, width, theme, 'compare-diff-split')
-                : visibleLines.map((line, index) => h(Text, {
-                    key: `compare-diff-line-${state.diffPreviewOffset + index}`,
-                    ...diffLineProps(line, theme),
-                }, truncateCells(line, width - 4)));
+                ? renderSplitDiffBody(h, components, lines, state.diffPreviewOffset, visibleRows, width, theme, 'compare-diff-split', syntaxSpans)
+                : visibleLines.map((line, index) => renderDiffLine(h, Text, line, theme, syntaxSpans, width - 4, `compare-diff-line-${state.diffPreviewOffset + index}`));
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
             borderStyle: theme.borderStyle,
@@ -34214,11 +35135,8 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         const commitBodyNodes = filePreviewLoading || !previewHunks.length
             ? []
             : splitActive
-                ? renderSplitDiffBody(h, components, visiblePreviewHunks, state.diffPreviewOffset, width, theme, 'commit-diff-split')
-                : visiblePreviewHunks.map((line, index) => h(Text, {
-                    key: `diff-surface-line-${state.diffPreviewOffset + index}`,
-                    ...diffLineProps(line, theme),
-                }, truncateCells(line, 140)));
+                ? renderSplitDiffBody(h, components, previewHunks, state.diffPreviewOffset, visibleRows, width, theme, 'commit-diff-split', syntaxSpans)
+                : visiblePreviewHunks.map((line, index) => renderDiffLine(h, Text, line, theme, syntaxSpans, 140, `diff-surface-line-${state.diffPreviewOffset + index}`));
         return h(Box, {
             borderColor: focusBorderColor(theme, focused),
             borderStyle: theme.borderStyle,
@@ -34264,10 +35182,7 @@ function renderDiffSurface(h, components, state, context, contextStatus, worktre
         key: `diff-surface-header-${index}`,
         dimColor: index > 0,
     }, truncateCells(line, 140))), ...(showDiffLines
-        ? visibleDiffLines.map((line, index) => h(Text, {
-            key: `diff-surface-line-${state.worktreeDiffOffset + index}`,
-            ...diffLineProps(line, theme),
-        }, truncateCells(line, 140)))
+        ? visibleDiffLines.map((line, index) => renderDiffLine(h, Text, line, theme, syntaxSpans, 140, `diff-surface-line-${state.worktreeDiffOffset + index}`))
         : []));
 }
 
@@ -35413,9 +36328,55 @@ 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, density, rowMode, dateBucketingEnabled = false, now = getRenderNow()) {
+/**
+ * Full-panel loader shown over the history surface while a remote
+ * operation (fetch / pull / push) is in flight. Same bordered frame
+ * and `Commits` title row as the real panel so the swap in/out is
+ * seamless: a centered spinner + label + a travelling arrow track
+ * give the user an unmistakable "we're talking to the remote" beat in
+ * place of a frozen, soon-to-abruptly-repaint commit list.
+ */
+function renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focused, spinnerFrame) {
+    const { Box, Text } = components;
+    const op = state.remoteOp;
+    if (!op) {
+        return h(Box, { width });
+    }
+    const spinner = pickSpinnerFrame(spinnerFrame);
+    // Directional glyph hints which way the bits are flowing.
+    const glyph = op.kind === 'push' ? '↑' : op.kind === 'pull' ? '↓' : '↕';
+    // A single glyph "travels" along a dotted track each tick so the
+    // motion reads even on terminals that render braille spinners poorly.
+    const trackWidth = 9;
+    const pos = Math.max(0, spinnerFrame) % trackWidth;
+    const track = Array.from({ length: trackWidth }, (_, i) => (i === pos ? glyph : '·')).join(' ');
+    const accent = theme.noColor ? undefined : theme.colors.accent;
+    const innerHeight = Math.max(3, bodyRows - 2);
+    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('Commits', focused)), h(Text, { dimColor: true }, `${op.kind} in progress`)), h(Box, {
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        height: innerHeight,
+    }, h(Text, { color: accent, bold: true }, `${spinner}  ${op.label}`), h(Text, undefined, ''), h(Text, { color: accent }, track), h(Text, undefined, ''), h(Text, { dimColor: true }, 'Talking to the remote — history refreshes automatically.')));
+}
+function renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled = false, now = getRenderNow(), spinnerFrame = 0) {
     const { Box, Text } = components;
     const focused = state.focus === 'commits';
+    // Remote op in flight (fetch / pull / push) → swap the commit list
+    // for a centered, animated loader. Keeping the same bordered panel
+    // (same width, same title row) means that when the op completes and
+    // `remoteOp` clears, the fresh rows paint in place without the panel
+    // jumping — smoothing over the "frozen list → sudden repaint" feel.
+    if (state.remoteOp) {
+        return renderRemoteOpLoader(h, components, state, width, bodyRows, theme, focused, spinnerFrame);
+    }
     const worktree = context.worktree;
     // Distinct remote names seen across the repo's remote-tracking
     // branches — `['origin']` for a typical fork, `['origin', 'upstream']`
@@ -35896,6 +36857,37 @@ function renderThemePickerOverlay(h, components, filter, index, width, theme, fo
         ? [h(Text, { key: 'theme-more-below', dimColor: true }, `  ↓ ${filtered.length - (startIndex + listRows)} more below`)]
         : []));
 }
+/**
+ * "Add to .gitignore" quick-pick overlay (`i` on the status view).
+ * Modeled on the theme picker but with a fixed, file-derived option list
+ * (no fuzzy filter — the menu is short): pick exact / by-extension /
+ * by-folder / by-name, or the `Custom pattern…` escape hatch which opens
+ * a free-text prompt. ↑/↓ to move, Enter to choose, Esc to cancel.
+ */
+function renderGitignorePickerOverlay(h, components, file, index, width, theme, focused) {
+    const { Box, Text } = components;
+    const options = deriveGitignoreOptions(file);
+    const selectedIndex = Math.max(0, Math.min(index, options.length - 1));
+    const hint = '↑/↓ select · enter add · esc cancel';
+    const itemLines = options.map((option, offset) => {
+        const isSelected = offset === selectedIndex;
+        const cursor = isSelected ? '>' : ' ';
+        const glyph = option.custom ? '✎ ' : '+ ';
+        return h(Text, {
+            key: `gitignore-opt-${offset}`,
+            bold: isSelected,
+            dimColor: !isSelected,
+            color: isSelected && !theme.noColor ? theme.colors.accent : undefined,
+        }, `${cursor} ${glyph}`, truncateCells(option.label, width - 8));
+    });
+    return h(Box, {
+        borderColor: focusBorderColor(theme, focused),
+        borderStyle: theme.borderStyle,
+        flexDirection: 'column',
+        width,
+        paddingX: 1,
+    }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Add to .gitignore', focused)), h(Text, { dimColor: true }, `${options.length} options`)), h(Text, { color: theme.colors.accent }, truncateCells(file || '(no file)', width - 4)), h(Text, { dimColor: true }, truncateCells(hint, width - 4)), h(Text, undefined, ''), ...itemLines);
+}
 /**
  * Split-plan overlay (#907) — renders the proposed commit groups for
  * the user to review before applying. Three phases driven by
@@ -37240,7 +38232,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, density, rowMode, dateBucketingEnabled) {
+function renderMainPanel(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, density, rowMode, dateBucketingEnabled, syntaxSpans) {
     // 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
@@ -37255,7 +38247,7 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
         return renderStatusSurface(h, components, state, context, contextStatus, bodyRows, width, theme);
     }
     if (state.activeView === 'diff') {
-        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme);
+        return renderDiffSurface(h, components, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bodyRows, width, theme, syntaxSpans);
     }
     if (state.activeView === 'compose') {
         return renderComposeSurface(h, components, state, context, contextStatus, bodyRows, width, theme, spinnerFrame);
@@ -37296,7 +38288,7 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     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, density, rowMode, dateBucketingEnabled);
+    return renderHistoryPanel(h, components, state, context, bodyRows, width, theme, hasMoreCommits, loadingMoreCommits, density, rowMode, dateBucketingEnabled, undefined, spinnerFrame);
 }
 
 /**
@@ -38335,6 +39327,9 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     if (state.showThemePicker) {
         return renderThemePickerOverlay(h, components, state.themePickerFilter, state.themePickerIndex, width, theme, focused);
     }
+    if (state.gitignorePicker) {
+        return renderGitignorePickerOverlay(h, components, state.gitignorePicker.file, state.gitignorePicker.index, width, theme, focused);
+    }
     if (state.inputPrompt) {
         return renderInputPromptPanel(h, components, state, width, theme, focused);
     }
@@ -38412,6 +39407,67 @@ function renderDetailPanel(h, components, state, context, contextStatus, detail,
     return renderHistoryInspector(h, components, state, context, contextStatus, detail, loading, filePreview, filePreviewLoading, width, tabbed, theme, focused);
 }
 
+/**
+ * Resolve + scaffold the coco config files the workstation can open in
+ * `$EDITOR` (the `gk` / `gK` chords and their command-palette entries).
+ *
+ * Two scopes:
+ *   - `global`  → `$XDG_CONFIG_HOME/coco/config.json` (default
+ *                 `~/.config/coco/config.json`) — applies to every repo.
+ *   - `project` → `.coco.json` (preferred) or the legacy
+ *                 `.coco.config.json` at the repo root — applies to the
+ *                 current repository only.
+ *
+ * When the chosen file doesn't exist yet we write a minimal templated
+ * starter (just the `$schema` link + a sample `logTui.theme.preset`) so
+ * the user lands in an editable, schema-aware file instead of an empty
+ * buffer or an error.
+ */
+/**
+ * Minimal starter config written when scaffolding a missing file. Keeps
+ * the `$schema` link (so editors offer completion/validation) and one
+ * illustrative key showing where settings live — small enough to not
+ * impose opinions, structured enough to be a useful starting point.
+ */
+const STARTER_CONFIG = `${JSON.stringify({
+    $schema: SCHEMA_PUBLIC_URL,
+    logTui: { theme: { preset: 'default' } },
+}, null, 2)}\n`;
+/** `$XDG_CONFIG_HOME/coco/config.json` (default `~/.config/coco/config.json`). */
+function getGlobalConfigPath() {
+    return getXdgConfigPath();
+}
+/**
+ * The project config path for `repoRoot`: the first existing of
+ * `.coco.json` / `.coco.config.json`, else `.coco.json` as the default
+ * to create.
+ */
+function getProjectConfigPath(repoRoot) {
+    for (const name of ['.coco.json', '.coco.config.json']) {
+        const candidate = path__namespace.join(repoRoot, name);
+        if (fs__namespace.existsSync(candidate))
+            return candidate;
+    }
+    return path__namespace.join(repoRoot, '.coco.json');
+}
+/** Resolve the config path for a scope. `project` needs the repo root. */
+function resolveConfigPath(scope, repoRoot) {
+    return scope === 'global' ? getGlobalConfigPath() : getProjectConfigPath(repoRoot);
+}
+/**
+ * Ensure `filePath` exists, scaffolding the starter template (and any
+ * missing parent directories) when it doesn't. Returns whether it was
+ * just created so the caller can surface a "Created …" message.
+ */
+function ensureConfigFile(filePath) {
+    if (fs__namespace.existsSync(filePath)) {
+        return { created: false };
+    }
+    fs__namespace.mkdirSync(path__namespace.dirname(filePath), { recursive: true });
+    fs__namespace.writeFileSync(filePath, STARTER_CONFIG);
+    return { created: true };
+}
+
 /**
  * `LogInkApp` — the workstation's root React component. Hosts all state
  * via `useState`/`useEffect`/`useMemo`/`useCallback` hooks; wires up the
@@ -38558,6 +39614,18 @@ function loadLogInkContextEntries(git) {
         },
     ];
 }
+// Workflow action ids that hit the network (fetch / pull / push) →
+// the loader copy shown over the history surface while they run. Any
+// id NOT in this map runs without the full-screen loader (local-only
+// mutations repaint fast enough that a loader would just flicker).
+const REMOTE_OP_LOADERS = {
+    'fetch-remotes': { kind: 'fetch', label: 'Fetching all remotes…' },
+    'pull-current-branch': { kind: 'pull', label: 'Pulling from origin…' },
+    'push-current-branch': { kind: 'push', label: 'Pushing to origin…' },
+    'fetch-selected-branch': { kind: 'fetch', label: 'Fetching branch from remote…' },
+    'pull-selected-branch': { kind: 'pull', label: 'Pulling branch from remote…' },
+    'push-selected-branch': { kind: 'push', label: 'Pushing branch to remote…' },
+};
 function predictNextFilter(action, currentFilter) {
     switch (action.type) {
         case 'appendFilter':
@@ -38629,7 +39697,7 @@ function enrichFilterActionWithRectification(action, state, context) {
     }
 }
 function LogInkApp(deps) {
-    const { appLabel, clipboardRunner, dateBucketingEnabled, git: rootGit, idleTipsEnabled, ink, initialView, loadRows, logArgv, React, resumeRef, rows, theme: baseTheme, themeConfig } = deps;
+    const { appLabel, clipboardRunner, dateBucketingEnabled, git: rootGit, idleTipsEnabled, ink, initialView, loadRows, logArgv, React, resumeRef, rows, syntaxHighlightEnabled, theme: baseTheme, themeConfig } = deps;
     const { Box, Text, useApp, useInput, useWindowSize } = ink;
     const h = React.createElement;
     // Theme picker (gC) — live preview + apply. `themePreviewPreset` follows
@@ -38800,6 +39868,11 @@ function LogInkApp(deps) {
     const [worktreeDiffLoading, setWorktreeDiffLoading] = React.useState(false);
     const [worktreeHunks, setWorktreeHunks] = React.useState(undefined);
     const [worktreeHunksLoading, setWorktreeHunksLoading] = React.useState(false);
+    // Syntax-highlight spans for the diff currently in view (#1117
+    // follow-up). Computed off the render path by the effect below;
+    // keyed by marker-stripped code line so the diff renderer looks
+    // spans up directly. `undefined` = no highlighting (renders plain).
+    const [diffSyntaxSpans, setDiffSyntaxSpans] = React.useState(undefined);
     // Stash diff explorer (Enter on a stash row): the runtime fetches
     // `git stash show -p <ref>` lazily once the diff view becomes active
     // with diffSource='stash'. Lines are stored as a flat string[] —
@@ -38864,6 +39937,7 @@ function LogInkApp(deps) {
         state.splitPlan?.status === 'applying' ||
         state.changelogView.status === 'loading' ||
         state.commitCompose.loading ||
+        Boolean(state.remoteOp) ||
         Boolean(state.statusLoading);
     React.useEffect(() => {
         if (!anyLoading) {
@@ -39830,6 +40904,53 @@ function LogInkApp(deps) {
         selectedWorktreeFile?.worktreeStatus,
         state.activeView,
     ]);
+    // Syntax-highlight the diff currently in view, off the render path
+    // (#1117 follow-up). Mirrors the worktree-diff effect: detect the
+    // active file + its diff lines (worktree or commit source), tokenize
+    // via tree-sitter, and store the per-line spans for the renderer.
+    // Stash / compare sources aren't highlighted yet (multi-file patch /
+    // no single path). Gated on the config flag + a color terminal.
+    React.useEffect(() => {
+        if (!syntaxHighlightEnabled || theme.noColor || state.activeView !== 'diff') {
+            setDiffSyntaxSpans(undefined);
+            return;
+        }
+        let filePath;
+        let lines;
+        if (state.diffSource === 'commit') {
+            filePath = selectedDetailFile?.path;
+            lines = filePreview?.hunks;
+        }
+        else if (worktreeDiff && !worktreeDiff.untracked) {
+            filePath = worktreeDiff.filePath;
+            lines = worktreeDiff.lines;
+        }
+        if (!filePath || !lines || lines.length === 0) {
+            setDiffSyntaxSpans(undefined);
+            return;
+        }
+        let active = true;
+        void highlightDiffCode(filePath, lines)
+            .then((map) => {
+            if (active)
+                setDiffSyntaxSpans(map.size > 0 ? map : undefined);
+        })
+            .catch(() => {
+            if (active)
+                setDiffSyntaxSpans(undefined);
+        });
+        return () => {
+            active = false;
+        };
+    }, [
+        syntaxHighlightEnabled,
+        theme.noColor,
+        state.activeView,
+        state.diffSource,
+        selectedDetailFile?.path,
+        filePreview,
+        worktreeDiff,
+    ]);
     const toggleSelectedFileStage = React.useCallback(async () => {
         if (!selectedWorktreeFile) {
             dispatch({ type: 'setStatus', value: 'no worktree file selected', kind: 'warning' });
@@ -40504,6 +41625,28 @@ function LogInkApp(deps) {
         // refresh so the file row reflects the new staged/unstaged state.
         void refreshWorktreeContext({ silent: true });
     }, [dispatch, refreshWorktreeContext, resumeRef]);
+    // Open the global or project coco config in $EDITOR (gk / gK + their
+    // command-palette entries). Scaffolds a templated starter when the file
+    // doesn't exist yet so the user never lands in an empty buffer or hits
+    // a "no such file" error.
+    const openConfigInEditor = React.useCallback((scope) => {
+        // `repoRootRef` is populated async from `git rev-parse --show-toplevel`;
+        // fall back to cwd so a freshly-launched session can still scaffold +
+        // open the project config before that resolves.
+        const repoRoot = repoRootRef.current || process.cwd();
+        const filePath = resolveConfigPath(scope, repoRoot);
+        try {
+            const { created } = ensureConfigFile(filePath);
+            if (created) {
+                dispatch({ type: 'setStatus', value: `Created ${scope} config at ${filePath}`, kind: 'success' });
+            }
+        }
+        catch (error) {
+            dispatch({ type: 'setStatus', value: `Could not create config: ${error.message}`, kind: 'error' });
+            return;
+        }
+        openInEditor(filePath);
+    }, [dispatch, openInEditor]);
     // `E` keystroke handler — open the current commit draft in $EDITOR
     // (or $VISUAL), then read the file back and update the compose state
     // with the saved content. Mirrors the suspend → spawn → resume
@@ -41359,6 +42502,7 @@ function LogInkApp(deps) {
                     return { ok: false, message: 'No branch selected' };
                 return pushBranch(git, branch);
             },
+            'add-to-gitignore': async () => addToGitignore(git, payload || ''),
             'rename-branch': async () => {
                 const newName = payload?.trim();
                 if (!newName)
@@ -41654,76 +42798,102 @@ function LogInkApp(deps) {
             dispatch({ type: 'setStatus', value: `Workflow action ${id} not yet wired`, kind: 'warning' });
             return;
         }
-        const result = await handler();
-        dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
-        // Refresh history rows AS WELL when the workflow could have
-        // changed the commits the user sees (#945 follow-up). The
-        // workflow IDs below all either create/rewrite local commits or
-        // change which branch's history is being viewed — without this
-        // the history pane shows stale data even after the operation
-        // succeeds. Cheap one-off `git log` call; doesn't fire on
-        // metadata-only mutations (delete-tag, set-upstream, etc.).
-        const historyMutatingIds = new Set([
-            'checkout-branch',
-            'continue-operation',
-            'pull-current-branch',
-            'cherry-pick-commit',
-            'revert-commit',
-            'reset-hard-to-commit',
-            'reset-soft-to-commit',
-            'reset-mixed-to-commit',
-            'interactive-rebase-to-commit',
-            'bisect-good',
-            'bisect-bad',
-            'bisect-skip',
-            'bisect-reset',
-        ]);
-        if (result?.ok && historyMutatingIds.has(id)) {
-            await refreshHistoryRows();
-        }
-        // Checkout-branch is the one workflow where we want a *visible*
-        // refresh so the user sees the branches sidebar repaint with the
-        // new current branch (per #806 follow-up). Snap the cursor to
-        // position 0 first so when the refresh completes and the new
-        // current branch lands at the top (per #809's pin-current rule),
-        // the cursor is already there waiting.
-        if (id === 'checkout-branch' && result?.ok) {
-            dispatch({ type: 'resetBranchSelection' });
-            await refreshContext();
+        // Remote network ops (fetch / pull / push) get a full-screen
+        // history loader while in flight so the commit list doesn't sit
+        // frozen and then abruptly repaint when the call returns. Cleared
+        // in `finally` *after* the post-op refresh below so the loader
+        // hands straight off to the freshly-fetched rows instead of
+        // flashing the stale list for a frame in between.
+        const remoteOp = REMOTE_OP_LOADERS[id];
+        if (remoteOp) {
+            dispatch({ type: 'setRemoteOp', value: remoteOp });
         }
-        else {
-            // Silent refresh so the deleted item disappears from the list
-            // without flickering the surfaces through a 'loading' phase.
-            await refreshContext({ silent: true });
-        }
-        // Stash workflow follow-up. Two distinct behaviours.
-        //
-        // **apply / pop**: the user brought stashed content back into the
-        // worktree, but the sidebar still has them on the stash view.
-        // Expected next move is "look at what landed in my worktree", so
-        // jump them to history view (where the worktree counts in the
-        // sidebar are visible) AND refresh worktree context explicitly so
-        // the staged / unstaged / untracked numbers reflect the changes.
-        //
-        // **drop**: the silent context refresh above already re-fetched
-        // the stash list, BUT users reported it feeling like nothing
-        // happened. Fix two things: refresh worktree alongside (drops can
-        // affect untracked files when the stash held `-u` state), and
-        // surface the new stash count on the status line so there's
-        // unambiguous feedback that the drop landed and the list shrank.
-        if (result?.ok && (id === 'apply-stash' || id === 'pop-stash')) {
-            dispatch({ type: 'pushView', value: 'history' });
-            await refreshWorktreeContext();
+        try {
+            const result = await handler();
+            dispatch({ type: 'setStatus', value: result?.message || 'Workflow action complete' });
+            // Refresh history rows AS WELL when the workflow could have
+            // changed the commits the user sees (#945 follow-up). The
+            // workflow IDs below all either create/rewrite local commits or
+            // change which branch's history is being viewed — without this
+            // the history pane shows stale data even after the operation
+            // succeeds. Cheap one-off `git log` call; doesn't fire on
+            // metadata-only mutations (delete-tag, set-upstream, etc.).
+            const historyMutatingIds = new Set([
+                'checkout-branch',
+                'continue-operation',
+                'pull-current-branch',
+                'cherry-pick-commit',
+                'revert-commit',
+                'reset-hard-to-commit',
+                'reset-soft-to-commit',
+                'reset-mixed-to-commit',
+                'interactive-rebase-to-commit',
+                'bisect-good',
+                'bisect-bad',
+                'bisect-skip',
+                'bisect-reset',
+            ]);
+            if (result?.ok && historyMutatingIds.has(id)) {
+                await refreshHistoryRows();
+            }
+            // Checkout-branch is the one workflow where we want a *visible*
+            // refresh so the user sees the branches sidebar repaint with the
+            // new current branch (per #806 follow-up). Snap the cursor to
+            // position 0 first so when the refresh completes and the new
+            // current branch lands at the top (per #809's pin-current rule),
+            // the cursor is already there waiting.
+            if (id === 'checkout-branch' && result?.ok) {
+                dispatch({ type: 'resetBranchSelection' });
+                await refreshContext();
+            }
+            else {
+                // Silent refresh so the deleted item disappears from the list
+                // without flickering the surfaces through a 'loading' phase.
+                await refreshContext({ silent: true });
+            }
+            // Stash workflow follow-up. Two distinct behaviours.
+            //
+            // **apply / pop**: the user brought stashed content back into the
+            // worktree, but the sidebar still has them on the stash view.
+            // Expected next move is "look at what landed in my worktree", so
+            // jump them to history view (where the worktree counts in the
+            // sidebar are visible) AND refresh worktree context explicitly so
+            // the staged / unstaged / untracked numbers reflect the changes.
+            //
+            // **drop**: the silent context refresh above already re-fetched
+            // the stash list, BUT users reported it feeling like nothing
+            // happened. Fix two things: refresh worktree alongside (drops can
+            // affect untracked files when the stash held `-u` state), and
+            // surface the new stash count on the status line so there's
+            // unambiguous feedback that the drop landed and the list shrank.
+            if (result?.ok && (id === 'apply-stash' || id === 'pop-stash')) {
+                dispatch({ type: 'pushView', value: 'history' });
+                await refreshWorktreeContext();
+            }
+            // Refresh the worktree so a now-ignored untracked file drops out of
+            // the status list immediately (the silent context refresh above
+            // doesn't always re-read the worktree file set).
+            if (result?.ok && id === 'add-to-gitignore') {
+                await refreshWorktreeContext();
+            }
+            if (result?.ok && id === 'drop-stash') {
+                // Explicit worktree refresh in case the dropped stash carried
+                // untracked-file state that's now collected.
+                await refreshWorktreeContext();
+                // The silent context refresh already replaced `context.stashes`;
+                // reading the count back here would be stale because closures
+                // capture the pre-refresh value. Status message stays generic
+                // ("Dropped stash@{N}") — the visible list shrinking is the
+                // unambiguous signal that the operation landed.
+            }
         }
-        if (result?.ok && id === 'drop-stash') {
-            // Explicit worktree refresh in case the dropped stash carried
-            // untracked-file state that's now collected.
-            await refreshWorktreeContext();
-            // The silent context refresh already replaced `context.stashes`;
-            // reading the count back here would be stale because closures
-            // capture the pre-refresh value. Status message stays generic
-            // ("Dropped stash@{N}") — the visible list shrinking is the
-            // unambiguous signal that the operation landed.
+        finally {
+            // Always clear the loader — even if a refresh threw — so a
+            // failed fetch/pull can't leave the history surface stuck behind
+            // the spinner.
+            if (remoteOp) {
+                dispatch({ type: 'setRemoteOp', value: undefined });
+            }
         }
     }, [context, dispatch, git, refreshContext, refreshHistoryRows, refreshWorktreeContext,
         state.branchSort, state.filter, state.selectedBranchIndex,
@@ -42475,9 +43645,22 @@ function LogInkApp(deps) {
             else if (event.type === 'openFileInEditor') {
                 openInEditor(event.path);
             }
+            else if (event.type === 'openConfigInEditor') {
+                openConfigInEditor(event.scope);
+            }
             else if (event.type === 'yankFromActiveView') {
                 void yankFromActiveView(event.short);
             }
+            else if (event.type === 'openGitignorePicker') {
+                // Resolve the cursored worktree file here (the runtime owns the
+                // selection→file mapping) and open the picker over its path.
+                if (selectedWorktreeFile?.path) {
+                    dispatch({ type: 'openGitignorePicker', file: selectedWorktreeFile.path });
+                }
+                else {
+                    dispatch({ type: 'setStatus', value: 'No file under the cursor to ignore.', kind: 'warning' });
+                }
+            }
             else if (event.type === 'applyThemePreset') {
                 // Apply for the session immediately, and best-effort persist to the
                 // global config so it sticks across launches. The picker has already
@@ -42521,7 +43704,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$1(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme, layout.sidebarRailed), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, layout.density, layout.historyRowMode, Boolean(dateBucketingEnabled)), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.inspectorRailed, layout.bodyRows)), renderFooter$1(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame));
+    return h(Box, { flexDirection: 'column', height: layout.rows }, renderHeader$1(h, { Box, Text }, state, context, contextStatus, layout.columns, theme, appLabel), h(Box, { flexDirection: 'row', height: layout.bodyRows }, renderSidebar$1(h, { Box, Text }, state, context, contextStatus, layout.sidebarWidth, layout.bodyRows, theme, layout.sidebarRailed), renderMainPanel(h, { Box, Text }, state, context, contextStatus, worktreeDiff, worktreeDiffLoading, worktreeHunks, worktreeHunksLoading, filePreview, filePreviewLoading, commitDiffHunkOffsets, selectedDetailFile, stashDiffLines, stashDiffLoading, compareDiffLines, compareDiffLoading, bisectCandidateDetail, bisectCandidateLoading, layout.bodyRows, layout.mainPanelWidth, theme, hasMoreCommits, loadingMoreCommits, spinnerFrame, layout.density, layout.historyRowMode, Boolean(dateBucketingEnabled), diffSyntaxSpans), renderDetailPanel(h, { Box, Text }, state, context, contextStatus, detail, detailLoading, filePreview, filePreviewLoading, layout.detailWidth, layout.inspectorTabbed, theme, layout.inspectorRailed, layout.bodyRows)), renderFooter$1(h, { Box, Text }, state, context, theme, idleTip, spinnerFrame));
 }
 
 /**
@@ -42692,6 +43875,8 @@ async function startInkInteractiveLog(git, rows, streams = {}, options = {}) {
         // Resolve undefined → true so the default flips on automatically.
         // An explicit `false` from config opts out.
         dateBucketingEnabled: options.dateBucketing !== false,
+        // Undefined → on; explicit `false` opts out.
+        syntaxHighlightEnabled: options.syntaxHighlight !== false,
         ink,
         initialView: options.initialView || 'history',
         logArgv: options.logArgv,
@@ -42899,6 +44084,7 @@ async function startCocoUiFromLogArgv(logArgv, options = {}) {
         appLabel: 'coco',
         idleTips: config.logTui?.idleTips,
         dateBucketing: config.logTui?.dateBucketing,
+        syntaxHighlight: config.logTui?.syntaxHighlight,
         initialView: 'history',
         loadRows,
         logArgv,
@@ -42921,6 +44107,7 @@ async function startCocoUi(argv) {
         appLabel: 'coco',
         idleTips: config.logTui?.idleTips,
         dateBucketing: config.logTui?.dateBucketing,
+        syntaxHighlight: config.logTui?.syntaxHighlight,
         initialView: argv.view || 'history',
         loadRows: withCacheWrite(repoPath, () => loadRowsWithStashes(git, logArgv)),
         logArgv,