git-coco 0.48.0 → 0.49.0

package/dist/index.esm.mjs

@@ -17,7 +17,9 @@ import ora from 'ora';
 import now from 'performance-now';
 import prettyMilliseconds from 'pretty-ms';
 import * as fs$1 from 'node:fs';
+import { mkdtempSync, writeFileSync, rmSync, readFileSync as readFileSync$1 } from 'node:fs';
 import * as os$1 from 'node:os';
+import { tmpdir as tmpdir$1 } from 'node:os';
 import * as path$1 from 'node:path';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatOllama } from '@langchain/ollama';
@@ -53,7 +55,7 @@ import { pathToFileURL } from 'url';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.48.0";
+const BUILD_VERSION = "0.49.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -15505,6 +15507,54 @@ async function getDefaultBranch(repository, runner) {
         return undefined;
     }
 }
+/**
+ * Local-only fallback for the default branch — used when no GitHub
+ * remote is configured, when `gh` isn't authenticated, or when
+ * `gh repo view` fails (e.g. private repo we can't access, offline).
+ *
+ * Detection order, picking the first that resolves:
+ *   1. `origin/HEAD` — the symbolic ref set by `git clone` pointing at
+ *      whatever the remote's default branch was at clone time. This is
+ *      the most authoritative local signal.
+ *   2. Conventional branch names checked against local refs in order:
+ *      `main`, `master`, `develop`, `trunk`.
+ *
+ * Returns `undefined` when nothing matches — caller surfaces that as
+ * "no default branch detected" without claiming any particular cause.
+ *
+ * Pure local-ref reads (no network) — safe to call on every overview
+ * load regardless of provider state.
+ */
+async function detectLocalDefaultBranch(git) {
+    // origin/HEAD — set by `git clone` to track the remote's HEAD. The
+    // symbolic-ref output is the full ref (refs/remotes/origin/main); we
+    // strip the prefix to get just the branch name. `--short` would do it
+    // too but isn't supported on older git, and the prefix is fixed-length.
+    try {
+        const ref = (await git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD'])).trim();
+        const match = ref.match(/^refs\/remotes\/origin\/(.+)$/);
+        if (match) {
+            return match[1];
+        }
+    }
+    catch {
+        // symbolic-ref returns non-zero when origin/HEAD doesn't exist —
+        // expected on fresh repos and `git init`-only working trees. Fall
+        // through to the conventional-name check.
+    }
+    // Conventional names — most repos follow one of these. `rev-parse
+    // --verify --quiet <ref>` returns 0 + hash on hit, non-zero on miss.
+    for (const candidate of ['main', 'master', 'develop', 'trunk']) {
+        try {
+            await git.raw(['rev-parse', '--verify', '--quiet', `refs/heads/${candidate}`]);
+            return candidate;
+        }
+        catch {
+            // Not present — try the next one.
+        }
+    }
+    return undefined;
+}
 async function getCurrentPullRequest(runner) {
     try {
         return parsePullRequestJson(await runner([
@@ -15519,9 +15569,14 @@ async function getCurrentPullRequest(runner) {
     }
 }
 async function getProviderOverview(git, runner = defaultGhRunner) {
-    const [remotes, currentBranchOutput] = await Promise.all([
+    const [remotes, currentBranchOutput, localDefaultBranch] = await Promise.all([
         git.getRemotes(true),
         git.raw(['branch', '--show-current']),
+        // Read local default-branch signal up-front in parallel — used as
+        // the fallback when gh is unavailable / unauthenticated / can't see
+        // the repo. Coco aims to be platform-agnostic + work offline; the
+        // GH-specific paths layer on top of this, they don't replace it.
+        detectLocalDefaultBranch(git),
     ]);
     const remote = remotes.find((entry) => entry.name === 'origin') || remotes[0];
     const remoteUrl = remote?.refs.push || remote?.refs.fetch;
@@ -15535,7 +15590,10 @@ async function getProviderOverview(git, runner = defaultGhRunner) {
     const currentBranch = currentBranchOutput.trim() || undefined;
     if (repository.provider !== 'github') {
         return {
-            repository,
+            repository: {
+                ...repository,
+                defaultBranch: localDefaultBranch,
+            },
             currentBranch,
             authenticated: false,
             message: repository.message || 'Unsupported remote provider.',
@@ -15546,20 +15604,27 @@ async function getProviderOverview(git, runner = defaultGhRunner) {
     }
     catch {
         return {
-            repository,
+            repository: {
+                ...repository,
+                defaultBranch: localDefaultBranch,
+            },
             currentBranch,
             authenticated: false,
             message: 'GitHub CLI is missing or not authenticated.',
         };
     }
-    const [defaultBranch, currentPullRequest] = await Promise.all([
+    const [providerDefaultBranch, currentPullRequest] = await Promise.all([
         getDefaultBranch(repository, runner),
         getCurrentPullRequest(runner),
     ]);
     return {
         repository: {
             ...repository,
-            defaultBranch,
+            // gh's answer wins when it has one — it knows the remote's
+            // current state, including custom default-branch settings the
+            // local refs can't reflect. Fall back to local detection when gh
+            // returns undefined (offline, private repo, transient failure).
+            defaultBranch: providerDefaultBranch || localDefaultBranch,
         },
         currentBranch,
         currentPullRequest,
@@ -16525,6 +16590,149 @@ async function runCommitDraftWorkflow(input = {}) {
     }
 }
 
+function createChangelogArgv(input) {
+    return {
+        $0: 'coco',
+        _: ['changelog'],
+        interactive: false,
+        verbose: true,
+        version: false,
+        help: false,
+        mode: 'stdout',
+        range: '',
+        branch: '',
+        tag: '',
+        sinceLastTag: false,
+        withDiff: false,
+        onlyDiff: false,
+        author: false,
+        ...input,
+    };
+}
+async function captureStdout(action) {
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    let output = '';
+    process.stdout.write = ((chunk, ...args) => {
+        output += typeof chunk === 'string' ? chunk : chunk.toString();
+        const callback = args.find((arg) => typeof arg === 'function');
+        callback?.();
+        return true;
+    });
+    try {
+        await action();
+        return output;
+    }
+    finally {
+        process.stdout.write = originalWrite;
+    }
+}
+/**
+ * Generate a pull-request body for the current branch by running
+ * `coco changelog --branch <base>` and parsing the title / content
+ * out of the captured stdout.
+ *
+ * The changelog handler emits `${title}\n\n${content}[\n\nPart of <ticket>]`
+ * (see `commands/changelog/handler.ts` line 306). We split on the first
+ * blank-line boundary so the caller gets a clean title + body pair to
+ * pre-fill the PR creation prompt with. Ticket footer (when present)
+ * stays in the body so the resulting PR keeps the reference.
+ *
+ * Captures the raw stdout (rather than going through `runChangelogAction`,
+ * which strips blank lines via its `compactOutputLines` filter) so the
+ * title-vs-body separator survives intact.
+ *
+ * Returns the standard LogAiActionResult plus extracted `title` / `body`
+ * fields. Falls back to undefined `title` / `body` when the changelog
+ * fails or produces no parseable output; the caller is expected to
+ * surface that as a prompt with empty fields rather than aborting.
+ */
+async function runPullRequestBodyWorkflow(input = {}) {
+    const baseBranch = input.baseBranch || 'main';
+    const argv = createChangelogArgv({ branch: baseBranch });
+    let raw = '';
+    try {
+        raw = await captureStdout(() => handler$7(argv, new Logger({
+            verbose: true,
+            silent: false,
+        })));
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error.message,
+        };
+    }
+    const text = raw.trim();
+    if (!text) {
+        return {
+            ok: false,
+            message: 'No changelog output produced — branch may have no commits ahead of base.',
+        };
+    }
+    // First blank-line boundary separates title from body. Falls back to
+    // "everything is the title" when no blank line is found — typical of
+    // very small changesets where the changelog content collapsed to one
+    // line.
+    const blankIdx = text.indexOf('\n\n');
+    const title = blankIdx > 0 ? text.slice(0, blankIdx).trim() : text.split('\n')[0].trim();
+    const body = blankIdx > 0 ? text.slice(blankIdx + 2).trim() : '';
+    // Keep the standard LogAiActionResult shape (message + telemetry
+    // details + editable text) so palette callers get a consistent
+    // surface. The captured telemetry lines are dropped here — the PR
+    // body should be the actionable content, not the LLM trace.
+    return {
+        ok: true,
+        message: title || 'Pull request body drafted.',
+        details: [],
+        editable: text,
+        title,
+        body,
+    };
+}
+/**
+ * Run `coco changelog` and return the raw captured stdout, intact —
+ * blank lines preserved, no telemetry stripping. Use this when you
+ * want to show or copy the changelog as the user would see it from
+ * the CLI (the chromed-up `runChangelogAction` collapses blank lines
+ * via `compactOutputLines` which is wrong for any UI that wants the
+ * full prose output).
+ *
+ * The argv defaults match `createChangelogArgv` — pass overrides via
+ * `input`. Common shapes:
+ *
+ *   - { branch: 'main' }           — commits on current branch vs main
+ *   - { sinceLastTag: true }       — since last tag
+ *   - { tag: 'v1.0.0' }            — since a specific tag
+ *   - { range: 'abc..def' }        — between two refs
+ *
+ * Returns:
+ *   - { ok: true, message, text } on success (message = first non-blank
+ *     line, useful for status surface; text = full raw output)
+ *   - { ok: false, message } on changelog handler error or empty output
+ */
+async function runChangelogTextWorkflow(input = {}) {
+    const argv = createChangelogArgv(input);
+    let raw = '';
+    try {
+        raw = await captureStdout(() => handler$7(argv, new Logger({
+            verbose: true,
+            silent: false,
+        })));
+    }
+    catch (error) {
+        return { ok: false, message: error.message };
+    }
+    const text = raw.trim();
+    if (!text) {
+        return {
+            ok: false,
+            message: 'No changelog output produced — branch may have no commits ahead of base.',
+        };
+    }
+    const firstLine = text.split('\n').find((line) => line.trim()) || 'Changelog generated.';
+    return { ok: true, message: firstLine, text };
+}
+
 const LOG_INK_CONTEXT_KEYS = [
     'bisect',
     'branches',
@@ -17402,7 +17610,14 @@ const LOG_INK_KEY_BINDINGS = [
         id: 'editCommit',
         keys: ['e'],
         label: 'edit commit',
-        description: 'Edit the manual commit summary or body.',
+        description: 'Edit the manual commit summary or body inline.',
+        contexts: ['commits'],
+    },
+    {
+        id: 'editCommitExternal',
+        keys: ['E'],
+        label: 'edit in $EDITOR',
+        description: 'Open the current commit draft in $EDITOR (or $VISUAL) for full editing, write-back on save.',
         contexts: ['commits'],
     },
     {
@@ -17645,7 +17860,7 @@ function getLogInkFooterHints(options) {
     }
     if (options.activeView === 'compose') {
         return {
-            contextual: ['e edit', 'c commit', 'I AI draft', 'gs hunks', 'esc back'],
+            contextual: ['e edit', 'E $EDITOR', 'c commit', 'I AI draft', 'gs hunks', 'esc back'],
             global: NORMAL_GLOBAL_HINTS,
         };
     }
@@ -17713,6 +17928,12 @@ function getLogInkFooterHints(options) {
             global: NORMAL_GLOBAL_HINTS,
         };
     }
+    if (options.activeView === 'changelog') {
+        return {
+            contextual: ['j/k scroll', 'pg up/dn', 'y yank', 'E $EDITOR', 'c PR', 'r regen', '< back'],
+            global: NORMAL_GLOBAL_HINTS,
+        };
+    }
     if (options.compareBaseSet) {
         // History view with a compare base set — Enter is overridden to
         // open the compare diff; show the override + the bail-out key.
@@ -17945,6 +18166,10 @@ function formatSortIndicator(mode, options = {}) {
     return `${options.ascii ? 'v' : '▼'} ${mode}`;
 }
 
+const DEFAULT_CHANGELOG_VIEW_STATE = {
+    status: 'idle',
+    scrollOffset: 0,
+};
 const DEFAULT_LOG_INK_STATUS_FILTER_MASK = {
     staged: true,
     unstaged: true,
@@ -18285,6 +18510,8 @@ function createLogInkState(rows, options = {}) {
         inspectorTab: 'inspector',
         inspectorActionIndex: 0,
         bootLoading: options.bootLoading ?? false,
+        changelogView: { ...DEFAULT_CHANGELOG_VIEW_STATE },
+        changelogCache: {},
     };
 }
 function getSelectedInkCommit(state) {
@@ -18908,6 +19135,105 @@ function applyLogInkAction(state, action) {
                 pendingKey: undefined,
             };
         }
+        case 'setChangelogLoading':
+            return {
+                ...state,
+                changelogView: {
+                    status: 'loading',
+                    branch: action.branch,
+                    baseLabel: action.baseLabel,
+                    scrollOffset: 0,
+                },
+                pendingKey: undefined,
+            };
+        case 'setChangelogReady': {
+            // Cache the result so re-entry (or `c` to PR) reuses it instead of
+            // re-running the LLM. Keyed by branch so a checkout naturally
+            // produces a fresh generation.
+            const cached = {
+                text: action.text,
+                baseLabel: action.baseLabel,
+                generatedAt: Date.now(),
+            };
+            return {
+                ...state,
+                changelogView: {
+                    status: 'ready',
+                    text: action.text,
+                    branch: action.branch,
+                    baseLabel: action.baseLabel,
+                    scrollOffset: 0,
+                },
+                changelogCache: {
+                    ...state.changelogCache,
+                    [action.branch]: cached,
+                },
+                pendingKey: undefined,
+            };
+        }
+        case 'setChangelogError':
+            return {
+                ...state,
+                changelogView: {
+                    status: 'error',
+                    branch: action.branch,
+                    baseLabel: action.baseLabel,
+                    error: action.error,
+                    scrollOffset: 0,
+                },
+                pendingKey: undefined,
+            };
+        case 'setChangelogText': {
+            // Used by the $EDITOR round-trip: user edits the cached text, we
+            // update the view AND the cache entry so subsequent re-entry
+            // reflects the edits. Branch key is taken from the current view
+            // (which is what the user just edited against).
+            if (state.changelogView.status !== 'ready' || !state.changelogView.branch) {
+                return state;
+            }
+            const branch = state.changelogView.branch;
+            const existing = state.changelogCache[branch];
+            return {
+                ...state,
+                changelogView: {
+                    ...state.changelogView,
+                    text: action.text,
+                },
+                changelogCache: {
+                    ...state.changelogCache,
+                    [branch]: {
+                        text: action.text,
+                        baseLabel: existing?.baseLabel || state.changelogView.baseLabel || '',
+                        // Updated-at timestamp reflects the edit. Not the original
+                        // generation time — `r` (regenerate) is the explicit knob
+                        // for "I want fresh LLM output, not my edits".
+                        generatedAt: Date.now(),
+                    },
+                },
+                pendingKey: undefined,
+            };
+        }
+        case 'pageChangelog':
+            return {
+                ...state,
+                changelogView: {
+                    ...state.changelogView,
+                    scrollOffset: clampIndex(state.changelogView.scrollOffset + action.delta, action.lineCount),
+                },
+                pendingKey: undefined,
+            };
+        case 'clearChangelogCache': {
+            // Targeted clear for a single branch, or wholesale wipe when
+            // `branch` is omitted. Wholesale used on session reset / config
+            // change; targeted reserved for future "this generation looks
+            // wrong, drop it" UX.
+            if (!action.branch) {
+                return { ...state, changelogCache: {}, pendingKey: undefined };
+            }
+            const next = { ...state.changelogCache };
+            delete next[action.branch];
+            return { ...state, changelogCache: next, pendingKey: undefined };
+        }
         default:
             return state;
     }
@@ -19449,6 +19775,17 @@ function submitInputPrompt(state) {
             action({ type: 'closeInputPrompt' }),
         ];
     }
+    if (state.inputPrompt.kind === 'create-pr') {
+        // Multi-line content: line 1 is the PR title, lines 2+ are the body
+        // (leading blank line tolerated). The generic empty-value guard
+        // above (line ~627) covers truly-empty submissions; the workflow
+        // handler in app.ts has the belt-and-suspenders title check for
+        // the "newline-then-body" edge.
+        return [
+            { type: 'runWorkflowAction', id: 'create-pr', payload: value },
+            action({ type: 'closeInputPrompt' }),
+        ];
+    }
     const id = state.inputPrompt.kind;
     return [
         { type: 'runWorkflowAction', id, payload: value },
@@ -19845,6 +20182,46 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
             return [action({ type: 'setPendingConfirmation', value: 'bisect-reset' })];
         }
     }
+    // Changelog view local keymap. Scoped to `activeView === 'changelog'`
+    // so the letters stay free everywhere else. Bindings:
+    //
+    //   j / k          → scroll line down / up (1 line)
+    //   pgdn / pgup    → scroll page down / up (10 lines)
+    //   y              → yank text to clipboard
+    //   E              → open in $EDITOR (companion to compose's `E` from #913)
+    //   c              → create-PR seeded with this changelog
+    //   r              → regenerate (skip cache, re-run LLM)
+    //
+    // Back-out is `<` / Esc handled by the global pop-view path lower
+    // down. The view only renders when `state.changelogView.status`
+    // is 'ready' — scroll keystrokes early-return when changelogLineCount
+    // is missing so they no-op gracefully during loading / error states.
+    if (state.activeView === 'changelog') {
+        if (inputValue === 'j' && context.changelogLineCount) {
+            return [action({ type: 'pageChangelog', delta: 1, lineCount: context.changelogLineCount })];
+        }
+        if (inputValue === 'k' && context.changelogLineCount) {
+            return [action({ type: 'pageChangelog', delta: -1, lineCount: context.changelogLineCount })];
+        }
+        if (key.pageDown && context.changelogLineCount) {
+            return [action({ type: 'pageChangelog', delta: 10, lineCount: context.changelogLineCount })];
+        }
+        if (key.pageUp && context.changelogLineCount) {
+            return [action({ type: 'pageChangelog', delta: -10, lineCount: context.changelogLineCount })];
+        }
+        if (inputValue === 'y') {
+            return [{ type: 'yankChangelog' }];
+        }
+        if (inputValue === 'E') {
+            return [{ type: 'openChangelogInEditor' }];
+        }
+        if (inputValue === 'c') {
+            return [{ type: 'startCreatePullRequest' }];
+        }
+        if (inputValue === 'r') {
+            return [{ type: 'regenerateChangelog' }];
+        }
+    }
     if (inputValue === 'g') {
         if (state.pendingKey === 'g') {
             return [
@@ -20629,6 +21006,34 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
     if (inputValue === 'C' && state.activeView === 'conflicts') {
         return [action({ type: 'setStatus', value: 'Resolve all conflicts before continuing' })];
     }
+    // Global `C` — create a pull request from the current branch. The
+    // runtime callback handles pre-flight (current branch resolution,
+    // provider check) and seeds the input prompt with a changelog-derived
+    // title + body before handing control back to the user for editing.
+    // Conflicts view handles `C` above (continue-operation). Compose view
+    // gets an explicit guard — claiming the keystroke with a status
+    // message — so users mid-draft don't fat-finger out of their commit
+    // into a PR-creation flow. Without this guard the keystroke would
+    // fall through to the generic workflow-by-key dispatch at the end of
+    // this function, which would fire `create-pr` to its handler.
+    if (inputValue === 'C' && state.activeView === 'compose') {
+        return [action({
+                type: 'setStatus',
+                value: 'Finish or cancel the commit draft before creating a PR.',
+            })];
+    }
+    if (inputValue === 'C' && state.activeView !== 'conflicts') {
+        return [{ type: 'startCreatePullRequest' }];
+    }
+    // Global `L` — generate the changelog for the current branch and
+    // push the dedicated `changelog` view. Scoped to history and branches
+    // — those are the natural "where am I, what landed here recently"
+    // entry points. Avoids polluting every view's global namespace; the
+    // changelog is reachable from anywhere via `g L` (added in keymap).
+    if (inputValue === 'L' &&
+        (state.activeView === 'history' || state.activeView === 'branches')) {
+        return [{ type: 'startChangelogView' }];
+    }
     // `c` on a stash diff cherry-picks the file under the cursor —
     // materializes that single path from the stash into the working tree
     // (`git checkout <stashRef> -- <path>`). Routed through the y-confirm
@@ -20812,6 +21217,24 @@ function getLogInkInputEvents(state, inputValue, key = {}, context = {}) {
         events.push(action({ type: 'commitCompose', action: { type: 'setEditing', value: true } }));
         return events;
     }
+    // Capital `E` — open the commit draft in $EDITOR (or $VISUAL). Companion
+    // to lowercase `e` which activates inline editing inside the panel:
+    // `e` for quick tweaks in-place, `E` for "I want the full power of my
+    // editor — syntax highlighting, multi-line nav, paste buffers, etc."
+    // The runtime callback handles the temp-file write, editor session,
+    // and read-back; the input handler emits a single event the
+    // dispatcher routes there. As with lowercase `e`, fires from status
+    // and diff views too (auto-pushes into compose first), since those
+    // are the natural entry points to commit-message work.
+    if (inputValue === 'E' &&
+        (state.activeView === 'status' || state.activeView === 'diff' || state.activeView === 'compose')) {
+        const events = [];
+        if (state.activeView !== 'compose') {
+            events.push(action({ type: 'pushView', value: 'compose' }));
+        }
+        events.push({ type: 'openComposeInEditor' });
+        return events;
+    }
     if (inputValue === 'c' &&
         (state.activeView === 'status' || state.activeView === 'diff' || state.activeView === 'compose')) {
         const events = [];
@@ -21876,6 +22299,12 @@ function stageConflictResolved(git, path) {
     return runAction$1(() => git.raw(['add', '--', path]), `Staged ${path} (marked resolved)`);
 }
 
+function parseCreatedPullRequestUrl(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trim())
+        .find((line) => line.startsWith('https://'));
+}
 async function runGhAction(runner, args, successMessage) {
     try {
         return successMessage(await runner(args));
@@ -21887,6 +22316,34 @@ async function runGhAction(runner, args, successMessage) {
         };
     }
 }
+function buildCreatePullRequestArgs(input) {
+    const args = [
+        'pr',
+        'create',
+        '--base',
+        input.base,
+        '--head',
+        input.head,
+        '--title',
+        input.title,
+        '--body',
+        input.body,
+    ];
+    if (input.draft) {
+        args.push('--draft');
+    }
+    return args;
+}
+function createPullRequest(input, runner = defaultGhRunner) {
+    return runGhAction(runner, buildCreatePullRequestArgs(input), (output) => {
+        const url = parseCreatedPullRequestUrl(output);
+        return {
+            ok: true,
+            message: url ? `Created pull request: ${url}` : 'Created pull request',
+            url,
+        };
+    });
+}
 function isPullRequestMergeStrategy(value) {
     return value === 'merge' || value === 'squash' || value === 'rebase';
 }
@@ -23492,6 +23949,121 @@ function renderBranchesSurface(h, components, state, context, contextStatus, bod
     }, h(Box, { justifyContent: 'space-between' }, h(Text, { bold: true }, panelTitle('Branches', focused)), h(Text, { dimColor: true }, headerRight)), ...renderPromotedFilterAffordance(h, Text, state, theme), ...lines);
 }
 
+/**
+ * Changelog surface — full-screen view that renders LLM-generated
+ * release notes for the current branch. Reached via `L` from history
+ * or branches; rendered as a real surface (not an input prompt) so the
+ * content gets proper scroll, editing, yank, and create-PR follow-ups.
+ *
+ * Replaces the input-prompt-in-sidebar implementation from #906 (PR
+ * feedback: cramped, no useful navigation, hotkeys invisible).
+ *
+ * Display states:
+ *   - loading : spinner + "generating changelog vs main…"
+ *   - ready   : full text with scroll, header showing branch + base +
+ *               cache age, footer hints driven by the keymap
+ *   - error   : error message + "press r to retry"
+ *
+ * View-local bindings (also reflected in footer hints + help):
+ *   - j/k          scroll line
+ *   - pgup/pgdn    scroll page
+ *   - y            yank to clipboard
+ *   - E            open in $EDITOR (write-back updates view + cache)
+ *   - c            create-PR seeded with this content
+ *   - r            regenerate (force-refresh, skip cache)
+ *   - </Esc        pop back to prior view
+ *
+ * Caching: state.changelogCache is keyed by branch name. Re-entering
+ * the view for the same branch hits the cache (no LLM call); switching
+ * branches naturally produces a fresh generation. `r` is the explicit
+ * "I want fresh output right now" knob.
+ */
+/**
+ * Pluralization-free relative-time string for cache age. Coarse on
+ * purpose — exact seconds don't help, but "5 minutes ago" vs "2 hours
+ * ago" tells the user whether the cached content might be stale.
+ */
+function formatCacheAge(generatedAt, now) {
+    const diffMs = Math.max(0, now - generatedAt);
+    const sec = Math.floor(diffMs / 1000);
+    if (sec < 5)
+        return 'just now';
+    if (sec < 60)
+        return `${sec}s ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const day = Math.floor(hr / 24);
+    return `${day}d ago`;
+}
+function renderChangelogSurface(h, components, state, _context, _contextStatus, bodyRows, width, theme) {
+    const { Box, Text } = components;
+    const focused = state.focus === 'commits';
+    const view = state.changelogView;
+    // Reserve rows for the header (1) + cache hint line (1) + 1 for
+    // borders. Body fills the rest. Min of 4 so even ultra-short terminals
+    // don't collapse to negative space.
+    const listRows = Math.max(4, bodyRows - 3);
+    const maxLineWidth = Math.max(20, width - 4);
+    const headerLeft = view.branch
+        ? `Changelog: ${view.branch}${view.baseLabel ? ` (${view.baseLabel})` : ''}`
+        : 'Changelog';
+    let headerRight = '';
+    let lines;
+    if (view.status === 'loading') {
+        headerRight = 'generating…';
+        lines = [
+            h(Text, { key: 'changelog-loading', dimColor: true }, `Generating changelog ${view.baseLabel ? `(${view.baseLabel})` : ''}…`),
+            h(Text, { key: 'changelog-loading-hint', dimColor: true }, ''),
+            h(Text, { key: 'changelog-loading-hint-2', dimColor: true }, 'Esc cancels and returns to the previous view.'),
+        ];
+    }
+    else if (view.status === 'error') {
+        headerRight = 'error';
+        lines = [
+            h(Text, { key: 'changelog-error', color: 'red' }, `Changelog generation failed.`),
+            h(Text, { key: 'changelog-error-msg', dimColor: true }, view.error || 'No additional detail.'),
+            h(Text, { key: 'changelog-error-hint', dimColor: true }, ''),
+            h(Text, { key: 'changelog-error-retry', dimColor: true }, 'Press `r` to retry, `<` / Esc to go back.'),
+        ];
+    }
+    else if (view.status === 'ready' && view.text) {
+        const allLines = view.text.split('\n');
+        const totalLines = allLines.length;
+        const scrollOffset = Math.min(view.scrollOffset, Math.max(0, totalLines - 1));
+        const visible = allLines.slice(scrollOffset, scrollOffset + listRows);
+        const cached = view.branch ? state.changelogCache[view.branch] : undefined;
+        const ageHint = cached ? formatCacheAge(cached.generatedAt, Date.now()) : 'just now';
+        headerRight = `${scrollOffset + 1}–${Math.min(totalLines, scrollOffset + listRows)} / ${totalLines} · ${ageHint}`;
+        lines = visible.length === 0
+            ? [h(Text, { key: 'changelog-empty', dimColor: true }, '(empty changelog)')]
+            : visible.map((line, offset) => h(Text, {
+                key: `changelog-line-${scrollOffset + offset}`,
+                dimColor: false,
+            }, truncateCells(line || ' ', maxLineWidth)));
+    }
+    else {
+        // 'idle' — view was pushed but loading hasn't started yet. Should
+        // be a single-frame transient; we render the same loading copy so
+        // there's no jarring "empty" frame.
+        headerRight = '';
+        lines = [
+            h(Text, { key: 'changelog-idle', dimColor: true }, 'Preparing changelog…'),
+        ];
+    }
+    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(headerLeft, focused)), h(Text, { dimColor: true }, headerRight)), ...lines);
+}
+
 /**
  * Compose surface — the in-TUI commit-message composer. Combines a
  * summary line, a body field, and a state-line footer; an inline
@@ -25495,6 +26067,9 @@ function renderMainPanel(h, components, state, context, contextStatus, worktreeD
     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);
 }
 
@@ -27349,6 +27924,292 @@ function LogInkApp(deps) {
         });
         dispatch({ type: 'setStatus', value: result.message });
     }, [dispatch]);
+    // `C` keystroke handler — start the create-pull-request flow. Resolves
+    // the head + base branches from the live context, runs
+    // `coco changelog --branch <base>` (via `runPullRequestBodyWorkflow`)
+    // to seed a title + body, then opens a multi-line input prompt
+    // pre-filled with that content for the user to edit before submission.
+    //
+    // On submit, the workflow handler `'create-pr'` parses the prompt
+    // value (line 1 = title, lines 2+ = body) and runs
+    // `createPullRequest({ base, head, title, body })`. If anything in the
+    // pre-flight goes sideways (no current branch, no provider, gh CLI
+    // missing) we surface the failure on the status line and skip the
+    // prompt entirely — better than opening a prompt the user can't
+    // actually submit successfully.
+    const startCreatePullRequest = React.useCallback(async () => {
+        const head = context.branches?.currentBranch || context.provider?.currentBranch;
+        if (!head) {
+            dispatch({ type: 'setStatus', value: 'No current branch to create a PR from.' });
+            return;
+        }
+        const defaultBranch = context.provider?.repository.defaultBranch;
+        if (!defaultBranch) {
+            dispatch({
+                type: 'setStatus',
+                value: 'No default branch detected. Set origin/HEAD or ensure main/master exists locally.',
+            });
+            return;
+        }
+        if (head === defaultBranch) {
+            dispatch({ type: 'setStatus', value: `Current branch is ${defaultBranch}; check out a feature branch first.` });
+            return;
+        }
+        if (context.pullRequest?.currentPullRequest || context.provider?.currentPullRequest) {
+            const existing = context.pullRequest?.currentPullRequest || context.provider?.currentPullRequest;
+            dispatch({
+                type: 'setStatus',
+                value: existing
+                    ? `PR #${existing.number} already open for ${head}. Use the PR view to manage it.`
+                    : `A pull request is already open for ${head}.`,
+            });
+            return;
+        }
+        dispatch({ type: 'setStatus', value: `generating PR body from changelog (vs ${defaultBranch})…` });
+        const body = await runPullRequestBodyWorkflow({ baseBranch: defaultBranch });
+        // Fallback shape when the changelog generation fails — open the
+        // prompt with empty title + body rather than aborting, so the user
+        // can still author the PR manually. The status line surfaces why
+        // we couldn't pre-fill.
+        const initialTitle = body.title || head.replace(/^(feat|fix|chore|docs|refactor|test)\//, '').replace(/[-_]/g, ' ');
+        const initialBody = body.body || '';
+        const initial = initialBody ? `${initialTitle}\n\n${initialBody}` : initialTitle;
+        if (!body.ok) {
+            dispatch({ type: 'setStatus', value: `PR body generation failed: ${body.message}. Edit manually.` });
+        }
+        else {
+            dispatch({ type: 'setStatus', value: 'PR body drafted — review and Ctrl+D to submit.' });
+        }
+        dispatch({
+            type: 'openInputPrompt',
+            kind: 'create-pr',
+            label: `Create PR: ${head} → ${defaultBranch}  (line 1 title · rest body · Enter newline · Ctrl+D submit)`,
+            initial,
+            multiline: true,
+        });
+    }, [
+        context.branches?.currentBranch,
+        context.provider?.currentBranch,
+        context.provider?.currentPullRequest,
+        context.provider?.repository.defaultBranch,
+        context.pullRequest?.currentPullRequest,
+        dispatch,
+    ]);
+    // Copy an arbitrary string to the system clipboard. Distinct from
+    // `yankFromActiveView` which derives the value from the current view
+    // — this one takes the value as an explicit event payload, used by
+    // the changelog view's `y` keystroke (and a candidate for future
+    // "copy this" surfaces). Surfaces a status confirming what landed
+    // in clipboard.
+    const yankText = React.useCallback(async (value, label) => {
+        const clipboard = clipboardRunner || defaultClipboardRunner;
+        if (!value) {
+            dispatch({ type: 'setStatus', value: `Nothing to copy — ${label} is empty.` });
+            return;
+        }
+        try {
+            await clipboard(value);
+            dispatch({ type: 'setStatus', value: `Copied ${label} to clipboard.` });
+        }
+        catch (error) {
+            dispatch({
+                type: 'setStatus',
+                value: `Copy failed (${label}): ${error.message}`,
+            });
+        }
+    }, [clipboardRunner, dispatch]);
+    // `L` keystroke handler — generate (or recall from cache) a changelog
+    // for the current branch and push the dedicated `changelog` surface
+    // to display it. The view renders the full text in the main panel
+    // (not cramped into an input prompt), with its own keymap for scroll,
+    // yank, $EDITOR, create-PR, and regenerate.
+    //
+    // Caching: `state.changelogCache` is keyed by branch name. On `L`,
+    // we check the cache first and reuse if hit (no LLM call); the user
+    // presses `r` from inside the view to force a regenerate. Switching
+    // branches naturally produces a fresh generation since the cache key
+    // changes.
+    //
+    // Surface lifecycle: we push the `changelog` view BEFORE awaiting the
+    // workflow, so the user sees a loading state instead of a blank
+    // history view while the LLM runs. On error, we keep the view pushed
+    // and render the error there (with `r` to retry) instead of bailing
+    // back to history with a status-line message that may scroll past.
+    const startChangelogView = React.useCallback(async (options = {}) => {
+        const head = context.branches?.currentBranch || context.provider?.currentBranch;
+        if (!head) {
+            dispatch({ type: 'setStatus', value: 'No current branch — check out a branch first.' });
+            return;
+        }
+        const defaultBranch = context.provider?.repository.defaultBranch;
+        // The changelog command will fall back to its own defaults when no
+        // branch arg is passed, but being explicit about the base is more
+        // honest about what the user is seeing. With the local default-
+        // branch fallback in providerData (#912), `defaultBranch` is
+        // populated even for non-GitHub / offline scenarios — we only fall
+        // through to `--since-last-tag` when truly nothing resolves.
+        const argv = defaultBranch && head !== defaultBranch
+            ? { branch: defaultBranch }
+            : { sinceLastTag: true };
+        const baseLabel = defaultBranch && head !== defaultBranch
+            ? `vs ${defaultBranch}`
+            : 'since last tag';
+        // Cache hit — skip the LLM, push view with ready content. The
+        // generated-at timestamp on the cache entry drives the "(cached, N
+        // ago)" hint in the header, so the user knows whether to press `r`.
+        const cached = !options.force ? state.changelogCache[head] : undefined;
+        if (cached) {
+            dispatch({ type: 'pushView', value: 'changelog' });
+            dispatch({
+                type: 'setChangelogReady',
+                branch: head,
+                baseLabel: cached.baseLabel,
+                text: cached.text,
+            });
+            dispatch({
+                type: 'setStatus',
+                value: `Changelog loaded from cache (${cached.baseLabel}). r to regenerate.`,
+            });
+            return;
+        }
+        // No cache (or force=true via `r`) — push view with loading state,
+        // then run the workflow.
+        dispatch({ type: 'pushView', value: 'changelog' });
+        dispatch({ type: 'setChangelogLoading', branch: head, baseLabel });
+        dispatch({ type: 'setStatus', value: `generating changelog (${baseLabel})…` });
+        const result = await runChangelogTextWorkflow(argv);
+        if (!result.ok || !result.text) {
+            dispatch({
+                type: 'setChangelogError',
+                branch: head,
+                baseLabel,
+                error: result.message,
+            });
+            dispatch({ type: 'setStatus', value: `Changelog failed: ${result.message}` });
+            return;
+        }
+        dispatch({
+            type: 'setChangelogReady',
+            branch: head,
+            baseLabel,
+            text: result.text,
+        });
+        dispatch({
+            type: 'setStatus',
+            value: 'Changelog ready — y yank · E $EDITOR · c PR · r regen · < back.',
+        });
+    }, [
+        context.branches?.currentBranch,
+        context.provider?.currentBranch,
+        context.provider?.repository.defaultBranch,
+        dispatch,
+        state.changelogCache,
+    ]);
+    // `r` keystroke inside the changelog view — re-run generation
+    // ignoring any cached result. Thin wrapper since the underlying
+    // logic in `startChangelogView` already supports the force path.
+    const regenerateChangelog = React.useCallback(() => {
+        void startChangelogView({ force: true });
+    }, [startChangelogView]);
+    // `y` keystroke inside the changelog view — yank the current text
+    // to the system clipboard. Pulled from view state rather than from
+    // wherever the cursor is (no per-row selection on this surface).
+    const yankChangelog = React.useCallback(() => {
+        const text = state.changelogView.text;
+        if (!text) {
+            dispatch({ type: 'setStatus', value: 'No changelog text to copy.' });
+            return;
+        }
+        void yankText(text, 'changelog');
+    }, [dispatch, state.changelogView.text, yankText]);
+    // `E` keystroke inside the changelog view — open the current text in
+    // $EDITOR / $VISUAL, read it back, update view + cache. Mirrors the
+    // compose `E` flow (#913) but on the changelog-view state slice.
+    // After save, `setChangelogText` updates both view and cache so the
+    // edits persist across view re-entry.
+    const openChangelogInEditor = React.useCallback(() => {
+        const current = state.changelogView.text;
+        if (current === undefined) {
+            dispatch({ type: 'setStatus', value: 'Changelog not loaded yet — wait for generation.' });
+            return;
+        }
+        let dir;
+        try {
+            dir = mkdtempSync(path$1.join(tmpdir$1(), 'coco-changelog-'));
+        }
+        catch (error) {
+            dispatch({
+                type: 'setStatus',
+                value: `Failed to create temp file for editor: ${error.message}`,
+            });
+            return;
+        }
+        const file = path$1.join(dir, 'CHANGELOG.md');
+        try {
+            writeFileSync(file, current, 'utf8');
+        }
+        catch (error) {
+            dispatch({
+                type: 'setStatus',
+                value: `Failed to seed temp file: ${error.message}`,
+            });
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        const editorEnv = process.env.VISUAL || process.env.EDITOR || 'vi';
+        const editorArgs = editorEnv.trim().split(/\s+/).filter(Boolean);
+        const editor = editorArgs[0] || 'vi';
+        const editorPrefixArgs = editorArgs.slice(1);
+        const out = process.stdout;
+        const stdin = process.stdin;
+        const ENTER_ALT = '\x1b[?1049h';
+        const EXIT_ALT = '\x1b[?1049l';
+        const SHOW_CURSOR = '\x1b[?25h';
+        const HIDE_CURSOR = '\x1b[?25l';
+        let editorOk = false;
+        try {
+            stdin.setRawMode?.(false);
+            out.write(`${SHOW_CURSOR}${EXIT_ALT}`);
+            const result = spawnSync(editor, [...editorPrefixArgs, file], { stdio: 'inherit' });
+            if (result.error) {
+                dispatch({ type: 'setStatus', value: `Failed to launch ${editor}: ${result.error.message}` });
+            }
+            else if (result.signal) {
+                dispatch({ type: 'setStatus', value: `${editor} interrupted by ${result.signal}` });
+            }
+            else if (typeof result.status === 'number' && result.status !== 0) {
+                dispatch({ type: 'setStatus', value: `${editor} exited with status ${result.status}` });
+            }
+            else {
+                editorOk = true;
+            }
+        }
+        finally {
+            out.write(`${ENTER_ALT}${HIDE_CURSOR}`);
+            stdin.setRawMode?.(true);
+            resumeRef?.current?.();
+        }
+        if (editorOk) {
+            try {
+                const content = readFileSync$1(file, 'utf8');
+                dispatch({ type: 'setChangelogText', text: content });
+                dispatch({ type: 'setStatus', value: 'Changelog updated from editor.' });
+            }
+            catch (error) {
+                dispatch({
+                    type: 'setStatus',
+                    value: `Failed to read back edited changelog: ${error.message}`,
+                });
+            }
+        }
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }, [dispatch, resumeRef, state.changelogView.text]);
     // Open a file in $EDITOR (or $VISUAL) by suspending Ink's hold on the
     // terminal, spawning the editor synchronously inheriting stdio, then
     // restoring the alt screen + raw mode and forcing a re-render. The
@@ -27407,6 +28268,116 @@ function LogInkApp(deps) {
         // refresh so the file row reflects the new staged/unstaged state.
         void refreshWorktreeContext({ silent: true });
     }, [dispatch, refreshWorktreeContext, resumeRef]);
+    // `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
+    // terminal dance of `openInEditor` but operates on an in-memory
+    // draft (round-tripped through a temp file) rather than a worktree
+    // file. Useful when the inline compose editor isn't enough — long
+    // bodies, markdown highlighting, paste from elsewhere, etc.
+    //
+    // Empty drafts are still written to the temp file so the user gets
+    // a blank canvas; the read-back uses `setDraft` which splits content
+    // into summary + body via `splitCommitDraft`, so the new content
+    // re-populates both fields correctly regardless of which one was
+    // active before.
+    const openComposeInEditor = React.useCallback(() => {
+        // Build the current draft text the same way `createManualCommit`
+        // would — single string, blank line between summary and body.
+        // Round-tripping through this format keeps the parse symmetric:
+        // the editor sees what a real commit message would look like, and
+        // `splitCommitDraft` on the way back reverses it cleanly.
+        const composeState = state.commitCompose;
+        const draft = formatCommitComposeMessage(composeState.summary, composeState.body);
+        // Temp dir + file. mkdtemp is cleaned up at the end regardless of
+        // editor success/failure (`finally` block below). `.md` extension
+        // helps editors pick up markdown highlighting — most commit-
+        // message workflows treat the body as markdown-ish.
+        let dir;
+        try {
+            dir = mkdtempSync(path$1.join(tmpdir$1(), 'coco-compose-'));
+        }
+        catch (error) {
+            dispatch({
+                type: 'setStatus',
+                value: `Failed to create temp file for editor: ${error.message}`,
+            });
+            return;
+        }
+        const file = path$1.join(dir, 'COMMIT_EDITMSG.md');
+        try {
+            writeFileSync(file, draft, 'utf8');
+        }
+        catch (error) {
+            dispatch({
+                type: 'setStatus',
+                value: `Failed to seed temp file: ${error.message}`,
+            });
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        const editorEnv = process.env.VISUAL || process.env.EDITOR || 'vi';
+        const editorArgs = editorEnv.trim().split(/\s+/).filter(Boolean);
+        const editor = editorArgs[0] || 'vi';
+        const editorPrefixArgs = editorArgs.slice(1);
+        const out = process.stdout;
+        const stdin = process.stdin;
+        const ENTER_ALT = '\x1b[?1049h';
+        const EXIT_ALT = '\x1b[?1049l';
+        const SHOW_CURSOR = '\x1b[?25h';
+        const HIDE_CURSOR = '\x1b[?25l';
+        let editorOk = false;
+        try {
+            stdin.setRawMode?.(false);
+            out.write(`${SHOW_CURSOR}${EXIT_ALT}`);
+            const result = spawnSync(editor, [...editorPrefixArgs, file], { stdio: 'inherit' });
+            if (result.error) {
+                dispatch({ type: 'setStatus', value: `Failed to launch ${editor}: ${result.error.message}` });
+            }
+            else if (result.signal) {
+                dispatch({ type: 'setStatus', value: `${editor} interrupted by ${result.signal}` });
+            }
+            else if (typeof result.status === 'number' && result.status !== 0) {
+                dispatch({ type: 'setStatus', value: `${editor} exited with status ${result.status}` });
+            }
+            else {
+                editorOk = true;
+            }
+        }
+        finally {
+            out.write(`${ENTER_ALT}${HIDE_CURSOR}`);
+            stdin.setRawMode?.(true);
+            resumeRef?.current?.();
+        }
+        // Read the (possibly edited) file back and update compose state.
+        // We only do this when the editor exited cleanly — a crash / kill
+        // shouldn't blow away the user's draft. The setDraft action
+        // re-splits into summary + body via splitCommitDraft.
+        if (editorOk) {
+            try {
+                const content = readFileSync$1(file, 'utf8');
+                dispatch({ type: 'commitCompose', action: { type: 'setDraft', value: content } });
+                dispatch({ type: 'setStatus', value: 'Commit draft updated from editor.' });
+            }
+            catch (error) {
+                dispatch({
+                    type: 'setStatus',
+                    value: `Failed to read back edited draft: ${error.message}`,
+                });
+            }
+        }
+        // Always clean up the temp dir — even on failure paths above. We
+        // don't want abandoned coco-compose-* directories accumulating in
+        // /tmp across sessions. Best-effort; ignore errors (e.g. file
+        // already removed by the user from inside their editor).
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }, [dispatch, resumeRef, state.commitCompose]);
     // Resolve the destructive-action target from the live filtered+sorted
     // list the user is looking at, run the action against it, surface the
     // result on the status line, and silently refresh so the deleted item
@@ -27834,6 +28805,32 @@ function LogInkApp(deps) {
             // — input prompts validate before they reach here, but the
             // strategy guard stays as a defensive belt-and-suspenders since
             // a future palette path could call us with a raw value.
+            'create-pr': async () => {
+                // The input-prompt submit handler validates non-empty title
+                // already; this is the defensive belt-and-suspenders for
+                // future palette callers passing in a raw payload.
+                const text = (payload || '').trim();
+                if (!text) {
+                    return { ok: false, message: 'Pull request title is required (first line of the prompt).' };
+                }
+                const lines = text.split('\n');
+                const title = lines[0].trim();
+                if (!title) {
+                    return { ok: false, message: 'Pull request title cannot be blank.' };
+                }
+                // Body: lines 2+, with the leading blank line tolerated. Empty
+                // body is allowed — GitHub renders an empty PR body fine.
+                const body = lines.slice(1).join('\n').replace(/^\n+/, '').trimEnd();
+                const head = context.branches?.currentBranch || context.provider?.currentBranch;
+                const base = context.provider?.repository.defaultBranch;
+                if (!head) {
+                    return { ok: false, message: 'No current branch detected.' };
+                }
+                if (!base) {
+                    return { ok: false, message: 'No default branch detected. Configure the GitHub remote.' };
+                }
+                return createPullRequest({ base, head, title, body });
+            },
             'merge-pr': async () => {
                 const strategy = (payload || 'merge').toLowerCase();
                 if (!isPullRequestMergeStrategy(strategy)) {
@@ -28310,6 +29307,11 @@ function LogInkApp(deps) {
                 : state.diffSource === 'commit'
                     ? filePreview?.hunks
                     : undefined,
+            // Line count of the changelog text, used by the changelog view's
+            // j/k/PgUp/PgDn scroll bindings to clamp `pageChangelog` deltas.
+            // Computed from view state rather than threaded through context
+            // because the surface owns its own content — no external loader.
+            changelogLineCount: state.changelogView.text?.split('\n').length,
         }).forEach((event) => {
             if (event.type === 'exit') {
                 exit();
@@ -28335,6 +29337,27 @@ function LogInkApp(deps) {
             else if (event.type === 'runAiCommitDraft') {
                 void runAiCommitDraft();
             }
+            else if (event.type === 'startCreatePullRequest') {
+                void startCreatePullRequest();
+            }
+            else if (event.type === 'startChangelogView') {
+                void startChangelogView();
+            }
+            else if (event.type === 'regenerateChangelog') {
+                regenerateChangelog();
+            }
+            else if (event.type === 'yankChangelog') {
+                yankChangelog();
+            }
+            else if (event.type === 'openChangelogInEditor') {
+                openChangelogInEditor();
+            }
+            else if (event.type === 'openComposeInEditor') {
+                openComposeInEditor();
+            }
+            else if (event.type === 'yankText') {
+                void yankText(event.value, event.label);
+            }
             else if (event.type === 'runWorkflowAction') {
                 void runWorkflowAction(event.id, event.payload);
             }