@loicngr/kobo 1.11.20 → 1.11.23

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.11.23
+
+- fix(test): configure git identity on the pr-checkout temp repo
+- feat: create workspaces from an existing PR/MR
+
+## 1.11.22
+
+- feat: create workspaces from an existing PR/MR
+
+## 1.11.21
+
+- fix: refine session liveness and interface feedback
+- fix(client): restore outline accent
+- feat(settings): compose custom skill prompts
+
 ## 1.11.20
 
 - fix(client): clarify automatic recovery

package/dist/server/db/migrations.js

@@ -661,6 +661,19 @@ export const migrations = [
             }
         },
     },
+    {
+        version: 37,
+        name: 'add-workspace-pr-url',
+        migrate: (db) => {
+            const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'workspaces'").get();
+            if (!table)
+                return;
+            const columns = db.prepare('PRAGMA table_info(workspaces)').all().map((column) => column.name);
+            if (!columns.includes('pr_url')) {
+                db.exec('ALTER TABLE workspaces ADD COLUMN pr_url TEXT');
+            }
+        },
+    },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -11,6 +11,7 @@ export function initSchema(db) {
       notion_url TEXT,
       notion_page_id TEXT,
       sentry_url TEXT,
+      pr_url TEXT,
       worktree_path TEXT,
       worktree_owned INTEGER NOT NULL DEFAULT 1,
       model TEXT NOT NULL DEFAULT 'claude-opus-4-8',

package/dist/server/index.js

@@ -18,6 +18,7 @@ import healthRouter from './routes/health.js';
 import imagesRouter from './routes/images.js';
 import { migrationRouter } from './routes/migration.js';
 import notionRouter from './routes/notion.js';
+import pullRequestsRouter from './routes/pull-requests.js';
 import searchRouter from './routes/search.js';
 import sentryRouter from './routes/sentry.js';
 import settingsRouter from './routes/settings.js';
@@ -128,6 +129,7 @@ app.use('/api/*', networkAuthMiddleware);
 app.get('/api/health', (c) => c.json({ status: 'ok', version: getPackageVersion() }));
 // Mount route sub-routers
 app.route('/api/workspaces', workspacesRouter);
+app.route('/api/pull-requests', pullRequestsRouter);
 app.route('/api/workspaces', imagesRouter);
 app.route('/api/notion', notionRouter);
 app.route('/api/sentry', sentryRouter);

package/dist/server/routes/pull-requests.js

@@ -0,0 +1,112 @@
+import { Hono } from 'hono';
+import { getForgeProvider } from '../services/forge/registry.js';
+import { resolveForge } from '../services/forge/resolve.js';
+import * as prCheckout from '../services/pr-checkout-service.js';
+import { listWorkspaces } from '../services/workspace-service.js';
+const app = new Hono();
+const FILTERS = ['all', 'mine', 'review-requested'];
+/** Map worktree path -> workspace id, keeping the service free of DB access. */
+function attachedWorktreePaths(workspaces) {
+    const map = new Map();
+    for (const w of workspaces ?? listWorkspaces(true)) {
+        if (w.worktreePath)
+            map.set(w.worktreePath, w.id);
+    }
+    return map;
+}
+app.get('/', async (c) => {
+    try {
+        const projectPath = c.req.query('projectPath');
+        if (!projectPath)
+            return c.json({ error: 'Missing required field: projectPath' }, 400);
+        const provider = getForgeProvider(resolveForge(projectPath));
+        if (!provider.capabilities.canListPullRequests) {
+            return c.json({ error: 'This project has no forge that can list pull requests' }, 403);
+        }
+        const rawFilter = c.req.query('filter');
+        const page = await provider.listPullRequests(projectPath, {
+            filter: rawFilter && FILTERS.includes(rawFilter) ? rawFilter : 'all',
+            search: c.req.query('search') || undefined,
+            cursor: c.req.query('cursor') || null,
+            perPage: Number(c.req.query('perPage') ?? 25),
+        });
+        return c.json(page);
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
+app.post('/diagnose', async (c) => {
+    try {
+        const { projectPath, prNumber, worktreesPath } = await c.req.json();
+        if (!projectPath || !prNumber) {
+            return c.json({ error: 'Missing required fields: projectPath, prNumber' }, 400);
+        }
+        const provider = getForgeProvider(resolveForge(projectPath));
+        const availability = await provider.isAvailable(projectPath);
+        if (!availability.available) {
+            // The forge can't be reached, so we have no way to resolve the PR's
+            // head branch. Return a minimal report early instead of diagnosing a
+            // fake empty branch name, which would produce a nonsensical report.
+            const report = {
+                projectPath,
+                headBranch: '',
+                targetWorktreePath: '',
+                blockers: [{ kind: 'forge-unavailable', reason: availability.reason ?? 'cli_missing' }],
+                workspace: { state: 'none' },
+                worktree: { state: 'none' },
+                localChanges: { present: false, modified: 0, staged: 0, untracked: 0 },
+                ongoingOperation: null,
+                branch: { state: 'absent' },
+            };
+            return c.json({ report, pr: null, fingerprint: prCheckout.computeFingerprint(report) });
+        }
+        // Page through the full list — a PR the user explicitly diagnosed by
+        // number must never come back "not found" just for sitting past the
+        // first 100 (by recency) results.
+        let pr;
+        let cursor = null;
+        do {
+            const page = await provider.listPullRequests(projectPath, { filter: 'all', perPage: 100, cursor });
+            pr = page.items.find((item) => item.number === prNumber);
+            cursor = page.nextCursor;
+        } while (!pr && cursor !== null);
+        if (!pr)
+            return c.json({ error: `Pull request #${prNumber} not found` }, 404);
+        const workspaces = listWorkspaces(true);
+        const report = prCheckout.diagnoseLocalState(projectPath, pr.headBranch, worktreesPath ?? null, attachedWorktreePaths(workspaces), workspaces);
+        if (pr.isFork)
+            report.blockers.push({ kind: 'fork-pr' });
+        return c.json({ report, pr, fingerprint: prCheckout.computeFingerprint(report) });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+});
+app.post('/resolve', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.projectPath || !body.fingerprint) {
+            return c.json({ error: 'Missing required fields: projectPath, fingerprint' }, 400);
+        }
+        const workspaces = listWorkspaces(true);
+        const result = await prCheckout.resolvePrCheckout({
+            projectPath: body.projectPath,
+            headBranch: body.headBranch,
+            baseBranch: body.baseBranch,
+            worktreesPath: body.worktreesPath ?? null,
+            decisions: body.decisions ?? {},
+            fingerprint: body.fingerprint,
+            workspaces,
+            attachedPaths: attachedWorktreePaths(workspaces),
+        });
+        return c.json(result);
+    }
+    catch (err) {
+        if (err instanceof prCheckout.StaleDiagnosisError) {
+            return c.json({ error: err.message, report: err.report }, 409);
+        }
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 422);
+    }
+});
+export default app;

package/dist/server/routes/settings.js

@@ -1,4 +1,5 @@
 import { Hono } from 'hono';
+import { isValidSkillSuite } from '../../shared/skill-suite-prompts.js';
 import { getDb } from '../db/index.js';
 import { getBackendPort } from '../services/agent/orchestrator.js';
 import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '../services/initial-prompt-template-service.js';
@@ -7,6 +8,7 @@ import { DEFAULT_REVIEW_PROMPT_TEMPLATE } from '../services/review-template-serv
 import { DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT } from '../services/settings-defaults.js';
 import * as settingsService from '../services/settings-service.js';
 import { DEFAULT_CI_FIX_PROMPT_TEMPLATE, DEFAULT_FINALIZATION_PROMPT, DEFAULT_GIT_CONVENTIONS, DEFAULT_PR_PROMPT_TEMPLATE, } from '../services/settings-service.js';
+import { getSuitePrompts } from '../services/skill-suite-prompts.js';
 import { listTemplates, replaceAllTemplates } from '../services/templates-service.js';
 import { countPrunableWsEvents } from '../services/ws-events-retention-service.js';
 /** Hono sub-router for global and per-project settings CRUD. */
@@ -33,6 +35,15 @@ app.get('/global', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/settings/skill-suite-prompts/:suite — source presets that can be
+// copied field-by-field into a custom suite before the user edits them.
+app.get('/skill-suite-prompts/:suite', (c) => {
+    const suite = c.req.param('suite');
+    if (!isValidSkillSuite(suite)) {
+        return c.json({ error: `Unknown skill suite: '${suite}'` }, 400);
+    }
+    return c.json(getSuitePrompts(suite, {}));
+});
 // GET /api/settings/defaults — expose the in-code DEFAULT_* constants for
 // global text-template settings (PR / review / git conventions / Notion /
 // Sentry initial prompts) so the UI can offer a "reset to default" button

package/dist/server/routes/workspaces.js

@@ -61,6 +61,7 @@ export const CREATE_WORKSPACE_STEPS = [
     'inspect-worktree',
     'extract-notion',
     'extract-sentry',
+    'extract-pr',
     'create-record',
     'create-tasks',
     'create-worktree',
@@ -210,6 +211,26 @@ function resolveCreateAgentPermissionMode(bodyValue, _projectPath, globalSetting
         return global;
     return 'bypass';
 }
+/**
+ * Extract the numeric PR/MR number from a forge URL.
+ *
+ * Strips any query string or fragment first (a comment-anchor link like
+ * `.../merge_requests/42#note_123` would otherwise have its trailing
+ * fragment digits greedily matched instead of the actual PR number), then
+ * takes the last path segment and requires it to be purely numeric. Throws
+ * a clear error rather than silently defaulting to 0 when the URL doesn't
+ * end on a plain PR/MR number (e.g. a "Files changed" sub-tab URL).
+ */
+function parsePrNumberFromUrl(prUrl) {
+    const withoutQueryOrFragment = prUrl.split(/[?#]/)[0];
+    const segments = withoutQueryOrFragment.replace(/\/+$/, '').split('/');
+    const last = segments[segments.length - 1];
+    const number = Number(last);
+    if (!last || !Number.isInteger(number) || number <= 0) {
+        throw new Error(`Could not parse a pull request number from '${prUrl}'`);
+    }
+    return number;
+}
 app.get('/', (c) => {
     try {
         const workspaces = workspaceService.listWorkspaces();
@@ -491,6 +512,44 @@ app.post('/', migrationGuard, async (c) => {
                     .catch((err) => console.error('[sentry] Auto-assign threw unexpectedly:', err));
             }
         }
+        // Pre-flight: extract the PR/MR before any DB write, mirroring the
+        // Notion / Sentry extraction above. A throw here must not leave a
+        // half-built workspace behind, so we run extraction before
+        // createWorkspace and surface failures as 422.
+        let prContent = null;
+        // Captured here so the write-context-files block below can reuse it
+        // instead of calling resolveForge/getForgeProvider (which shells out to
+        // git when the project's forge setting is 'auto') a second time.
+        let prForgeRequestTermShort;
+        if (body.prUrl) {
+            currentStep = 'extract-pr';
+            emitCreateProgress(creationId, currentStep);
+            try {
+                const provider = getForgeProvider(resolveForge(body.projectPath));
+                prForgeRequestTermShort = provider.capabilities.requestTermShort;
+                if (!provider.capabilities.canListPullRequests) {
+                    throw new Error('This project has no forge that can list pull requests');
+                }
+                const number = parsePrNumberFromUrl(body.prUrl);
+                // Page through the full list rather than only the first 100 (by
+                // recency) — a PR the user explicitly picked by URL must never be
+                // reported "not found" just because it hasn't been touched recently.
+                let cursor = null;
+                do {
+                    const page = await provider.listPullRequests(body.projectPath, { filter: 'all', perPage: 100, cursor });
+                    prContent = page.items.find((item) => item.number === number) ?? null;
+                    cursor = page.nextCursor;
+                } while (!prContent && cursor !== null);
+                if (!prContent)
+                    throw new Error(`Pull request #${number} not found`);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const failure = `Failed to read the pull request: ${message}`;
+                emitCreateFailed(creationId, 'extract-pr', failure);
+                return c.json({ error: failure, step: 'extract-pr' }, 422);
+            }
+        }
         // Create workspace record
         const globalSettings = settingsService.getGlobalSettings();
         // workingBranch may be updated after Notion extraction to inject the ticket ID,
@@ -574,6 +633,7 @@ app.post('/', migrationGuard, async (c) => {
             notionUrl: body.notionUrl,
             notionPageId: body.notionPageId,
             sentryUrl: body.sentryUrl,
+            prUrl: body.prUrl,
             worktreePath: prospectiveWorktreePath,
             worktreeOwned: !useReusedWorktree,
             model: body.model,
@@ -656,6 +716,13 @@ app.post('/', migrationGuard, async (c) => {
                 workspace = workspaceService.updateWorkspaceName(workspace.id, notionContent.title);
             }
         }
+        // Update workspace name with the PR/MR title if the user did not provide
+        // a custom name and neither Notion nor Sentry already claimed it. This
+        // makes the PR a THIRD context source, lowest priority of the three
+        // (Notion > Sentry > PR), consistent with the checks above.
+        if (prContent && !notionContent?.title && !sentryContent?.title && workspace.name === 'workspace') {
+            workspace = workspaceService.updateWorkspaceName(workspace.id, prContent.title);
+        }
         // Create manual tasks/criteria if no Notion content was extracted
         if (!notionContent && (Array.isArray(body.tasks) || Array.isArray(body.acceptanceCriteria))) {
             let sortOrder = 0;
@@ -879,6 +946,37 @@ app.post('/', migrationGuard, async (c) => {
             }
         }
         // ------------------------------------------------------------------------
+        // --- PR/MR file (extraction already done before worktree creation) -----
+        if (prContent && body.prUrl) {
+            try {
+                const thoughtsDir = path.join(worktreePath, '.ai', 'thoughts');
+                fs.mkdirSync(thoughtsDir, { recursive: true });
+                const today = new Date().toISOString().split('T')[0];
+                const term = prForgeRequestTermShort ?? getForgeProvider(resolveForge(body.projectPath)).capabilities.requestTermShort;
+                let md = `# ${prContent.title}\n\n`;
+                md += `## Source\n\n`;
+                md += `- ${term === 'MR' ? 'Merge request' : 'Pull request'}: ${body.prUrl}\n`;
+                md += `- Author: ${prContent.author}\n`;
+                md += `- Branches: ${prContent.headBranch} → ${prContent.baseBranch}\n`;
+                md += `- Retrieved: ${today}\n\n`;
+                // Persist the user's initial instructions, exactly like the Notion
+                // and Sentry context writes above — the description field is never
+                // overwritten, only incorporated under this heading.
+                if (body.description?.trim()) {
+                    md += `## User instructions\n\n${body.description.trim()}\n\n`;
+                }
+                fs.writeFileSync(path.join(thoughtsDir, `PR-${prContent.number}.md`), md, 'utf-8');
+            }
+            catch (err) {
+                // Best-effort, like the Notion and Sentry context writes: never break
+                // creation because a context file could not be written.
+                logError('workspaces', 'Failed to save PR content', {
+                    workspaceId: workspace.id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        // ------------------------------------------------------------------------
         // Update Notion status if both property name and value are configured
         const notionStatusProp = effectiveSettings.notionStatusProperty;
         const notionTargetStatus = effectiveSettings.notionInProgressStatus;

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -259,6 +259,7 @@ export function createClaudeCodeEngine() {
             // Guard so the post-result drain watchdog and the natural loop exit (or
             // catch block) never both emit `session:ended` for the same run.
             let sessionEndedEmitted = false;
+            let isCompacting = false;
             const emitSessionEnded = (reason, exitCode) => {
                 if (sessionEndedEmitted)
                     return;
@@ -307,6 +308,12 @@ export function createClaudeCodeEngine() {
                 }, RESULT_DRAIN_TIMEOUT_MS);
                 resultDrainTimer.unref?.();
             };
+            const clearResultDrainWatchdog = () => {
+                if (!resultDrainTimer)
+                    return;
+                clearTimeout(resultDrainTimer);
+                resultDrainTimer = undefined;
+            };
             // Safety net for the "waiting on a background subagent" branch below:
             // if `activeSubagentToolCallIds` never empties (a missed/unrecognised
             // terminal notification), the workspace would otherwise stay `executing`
@@ -347,6 +354,11 @@ export function createClaudeCodeEngine() {
                 turnLiveness.start();
                 try {
                     for await (const msg of q) {
+                        // This SDK message proves that any drain condition armed by a
+                        // *previous* message is no longer current. A drain armed while
+                        // processing this message remains active if the generator then
+                        // goes silent.
+                        clearResultDrainWatchdog();
                         const events = mapSdkMessage(msg, mapperState);
                         for (const ev of events) {
                             if (ev.kind !== 'subagent:progress')
@@ -356,6 +368,14 @@ export function createClaudeCodeEngine() {
                             else
                                 activeSubagentTaskIds.delete(ev.toolCallId);
                         }
+                        for (const ev of events) {
+                            if (ev.kind === 'session:compacting')
+                                isCompacting = ev.active;
+                            // Older SDKs can emit only compact_boundary, without a trailing
+                            // status update. This boundary marks compaction as complete.
+                            else if (ev.kind === 'session:compacted')
+                                isCompacting = false;
+                        }
                         // The stall watchdog is only armed while we're waiting purely on
                         // background subagents (no further SDK turn expected unless one
                         // reports done). React the moment the last one clears instead of
@@ -378,7 +398,7 @@ export function createClaudeCodeEngine() {
                         // A background subagent or a pending permission card can stay
                         // legitimately quiet for minutes; their own dedicated watchdogs
                         // own those windows, so suspend the turn deadline meanwhile.
-                        if (activeSubagentTaskIds.size > 0 || pendingResolvers.size > 0)
+                        if (activeSubagentTaskIds.size > 0 || pendingResolvers.size > 0 || isCompacting)
                             turnLiveness.pause();
                         else
                             turnLiveness.resume();
@@ -434,10 +454,7 @@ export function createClaudeCodeEngine() {
                     // The post-result drain watchdog (if armed) is moot once the
                     // iterator has exited — clear it so a healthy run never triggers a
                     // stray abort after it already ended.
-                    if (resultDrainTimer) {
-                        clearTimeout(resultDrainTimer);
-                        resultDrainTimer = undefined;
-                    }
+                    clearResultDrainWatchdog();
                     turnLiveness.stop();
                     clearSubagentStallWatchdog();
                     // Drain any callback still pending (SDK terminated while awaiting an

package/dist/server/services/forge/bitbucket/provider.js

@@ -102,6 +102,79 @@ function mapBktPr(raw, ci = { rollup: null, checks: [] }) {
         readyToMerge: deriveReadyToMerge({ state, ci, reviewDecision, reviewers, mergeable }),
     };
 }
+/** Bitbucket Cloud's `next` URL always carries a `page` query parameter.
+ *  Extract the bare page number so it matches Data Center's `nextPageStart`
+ *  shape — both then feed the same `--page <n>` flag on the next call. */
+function extractCloudPageCursor(next) {
+    try {
+        const page = new URL(next).searchParams.get('page');
+        if (page)
+            return page;
+    }
+    catch {
+        // fall through to regex fallback below
+    }
+    const match = next.match(/[?&]page=(\d+)/);
+    return match ? match[1] : next;
+}
+/** Map a Bitbucket Cloud or Data Center PR page. Exported for tests. */
+export function mapBitbucketPage(raw) {
+    const payload = record(raw);
+    const rows = Array.isArray(payload.values) ? payload.values : [];
+    const items = rows.map((row) => {
+        const pr = record(row);
+        const sourceRepo = record(record(pr.source).repository);
+        const destRepo = record(record(pr.destination).repository);
+        const fromRepo = record(record(pr.fromRef).repository);
+        const toRepo = record(record(pr.toRef).repository);
+        const sourceId = string(sourceRepo.uuid) || String(fromRepo.id ?? '');
+        const destId = string(destRepo.uuid) || String(toRepo.id ?? '');
+        const updated = pr.updated_on ?? pr.updatedDate;
+        return {
+            number: number(pr.id),
+            title: string(pr.title),
+            url: url(pr),
+            author: login(pr.author),
+            headBranch: branch(pr, 'source', 'fromRef'),
+            baseBranch: branch(pr, 'destination', 'toRef'),
+            isFork: Boolean(sourceId) && Boolean(destId) && sourceId !== destId,
+            isDraft: pr.draft === true,
+            updatedAt: typeof updated === 'string' ? updated : typeof updated === 'number' ? new Date(updated).toISOString() : '',
+            // `bkt pr list` doesn't expose CI/review status in list output; avoiding a per-row lookup call here.
+            ci: null,
+            reviewDecision: null,
+        };
+    });
+    const next = string(payload.next);
+    if (next)
+        return { items, nextCursor: extractCloudPageCursor(next) };
+    if (payload.isLastPage === false && payload.nextPageStart != null) {
+        return { items, nextCursor: String(payload.nextPageStart) };
+    }
+    return { items, nextCursor: null };
+}
+/**
+ * Narrow a Bitbucket page client-side: `bkt` has no author/reviewer filter.
+ *
+ * `review-requested` is a KNOWN, DELIBERATE no-op here: `PullRequestSummary`
+ * (shared across all four forge providers) carries no reviewer information,
+ * and fetching it would mean one extra Bitbucket API call per row in the
+ * list — every other filter/search operation here works on data already in
+ * hand. Rather than guess at reviewer data this provider doesn't have,
+ * `review-requested` falls through to "no filtering" like `'all'`, same as
+ * before this comment was added; `mine`, unlike before, is now genuinely
+ * narrowed once `currentUser` is supplied by the caller.
+ */
+export function filterBitbucketItems(items, opts, currentUser) {
+    const search = opts.search?.trim().toLowerCase();
+    return items.filter((item) => {
+        if (search && !item.title.toLowerCase().includes(search))
+            return false;
+        if (opts.filter === 'mine' && currentUser)
+            return item.author === currentUser;
+        return true;
+    });
+}
 function availabilityFromError(err) {
     const code = err.code;
     if (code === 'ENOENT')
@@ -207,6 +280,7 @@ export const bitbucketProvider = {
         canChangePrBase: false,
         canMergeRequest: true,
         canDeleteRemoteBranch: true,
+        canListPullRequests: true,
         requestTermShort: 'PR',
     },
     async isAvailable(repoPath) {
@@ -283,4 +357,16 @@ export const bitbucketProvider = {
     async deleteRemoteBranch(repoPath, branchName) {
         await execFileAsync('git', ['push', 'origin', '--delete', branchName], bktOptions(repoPath));
     },
+    async listPullRequests(repoPath, opts) {
+        const target = await resolveTarget(repoPath);
+        const args = ['pr', 'list', '--limit', String(opts.perPage), ...targetArgs(target), '--json'];
+        if (opts.cursor)
+            args.push('--page', opts.cursor);
+        const { stdout } = await execFileAsync('bkt', bktArgs(target, args), bktOptions(repoPath));
+        const page = mapBitbucketPage(JSON.parse(stdout || '{}'));
+        if (opts.filter === 'all' && !opts.search?.trim())
+            return page;
+        const currentUser = getGlobalSettings().bitbucketUsername || undefined;
+        return { ...page, items: filterBitbucketItems(page.items, opts, currentUser) };
+    },
 };

package/dist/server/services/forge/github/provider.js

@@ -83,6 +83,61 @@ function mapGhPrToSnapshot(raw) {
         readyToMerge: deriveReadyToMerge({ state, ci: { rollup, checks }, reviewDecision, reviewers, mergeable }),
     };
 }
+function record(value) {
+    return value !== null && typeof value === 'object' ? value : {};
+}
+const GH_LIST_QUERY = `
+query($q:String!,$first:Int!,$after:String){
+  search(query:$q, type:ISSUE, first:$first, after:$after){
+    pageInfo{ hasNextPage endCursor }
+    nodes{
+      ... on PullRequest {
+        number title url isDraft updatedAt
+        author{ login }
+        headRefName baseRefName isCrossRepository reviewDecision
+        commits(last:1){ nodes{ commit{ statusCheckRollup{ state } } } }
+      }
+    }
+  }
+}`;
+/** Build the `search` qualifier string. Exported for tests. */
+export function buildGithubSearchQuery(nameWithOwner, opts) {
+    const parts = [`repo:${nameWithOwner}`, 'is:pr', 'is:open'];
+    if (opts.filter === 'mine')
+        parts.push('author:@me');
+    if (opts.filter === 'review-requested')
+        parts.push('review-requested:@me');
+    parts.push('sort:updated-desc');
+    const query = parts.join(' ');
+    const search = opts.search?.trim();
+    return search ? `${query} ${search}` : query;
+}
+/** Map a raw `gh api graphql` response into a page. Exported for tests. */
+export function mapGithubSearchPage(raw) {
+    const search = record(record(record(raw).data).search);
+    const pageInfo = record(search.pageInfo);
+    const nodes = Array.isArray(search.nodes) ? search.nodes : [];
+    const items = nodes.map((node) => {
+        const pr = record(node);
+        const commitNodes = Array.isArray(record(pr.commits).nodes) ? record(pr.commits).nodes : [];
+        const rollup = record(record(record(commitNodes[0]).commit).statusCheckRollup).state;
+        const decision = pr.reviewDecision;
+        return {
+            number: typeof pr.number === 'number' ? pr.number : 0,
+            title: typeof pr.title === 'string' ? pr.title : '',
+            url: typeof pr.url === 'string' ? pr.url : '',
+            author: typeof record(pr.author).login === 'string' ? record(pr.author).login : '',
+            headBranch: typeof pr.headRefName === 'string' ? pr.headRefName : '',
+            baseBranch: typeof pr.baseRefName === 'string' ? pr.baseRefName : '',
+            isFork: pr.isCrossRepository === true,
+            isDraft: pr.isDraft === true,
+            updatedAt: typeof pr.updatedAt === 'string' ? pr.updatedAt : '',
+            ci: typeof rollup === 'string' ? rollup : null,
+            reviewDecision: typeof decision === 'string' ? decision : null,
+        };
+    });
+    return { items, nextCursor: pageInfo.hasNextPage === true ? String(pageInfo.endCursor ?? '') || null : null };
+}
 /** Map an execFile rejection to a ForgeAvailability reason. */
 function availabilityFromError(err) {
     const code = err.code;
@@ -101,6 +156,7 @@ export const githubProvider = {
         canChangePrBase: true,
         canMergeRequest: true,
         canDeleteRemoteBranch: true,
+        canListPullRequests: true,
         requestTermShort: 'PR',
     },
     async isAvailable(repoPath) {
@@ -140,4 +196,24 @@ export const githubProvider = {
     async deleteRemoteBranch(repoPath, branch) {
         await execFileAsync('git', ['push', 'origin', '--delete', branch], cliOptions(repoPath));
     },
+    async listPullRequests(repoPath, opts) {
+        const { stdout: repoJson } = await execFileAsync('gh', ['repo', 'view', '--json', 'nameWithOwner'], cliOptions(repoPath));
+        const nameWithOwner = String(JSON.parse(repoJson).nameWithOwner ?? '');
+        if (!nameWithOwner)
+            throw new Error('Could not determine the GitHub repository for this path');
+        const args = [
+            'api',
+            'graphql',
+            '-f',
+            `query=${GH_LIST_QUERY}`,
+            '-f',
+            `q=${buildGithubSearchQuery(nameWithOwner, opts)}`,
+            '-F',
+            `first=${opts.perPage}`,
+        ];
+        if (opts.cursor)
+            args.push('-f', `after=${opts.cursor}`);
+        const { stdout } = await execFileAsync('gh', args, cliOptions(repoPath));
+        return mapGithubSearchPage(JSON.parse(stdout));
+    },
 };