pome-sh 0.6.6

package/node_modules/@pome-sh/twin-github/dist/src/domain.js

@@ -0,0 +1,1518 @@
+import { conflict, notFound, validationFailed } from "./errors.js";
+import { fileSha, linesChanged, makeSha, nowIso, paginate, stableNumericId, treeSha } from "./util.js";
+import { defaultSeedState } from "./seed.js";
+import { authenticatedUserJson, branchJson, branchState, checkRunJson, checkRunState, collaboratorAddState, combinedStatusJson, commitJson, commitWithFilesJson, compareCommitsJson, contentDirectoryEntryJson, contentFileJson, fileState, issueAssigneesState, issueCommentJson, issueCommentState, issueJson, issueLabelsState, issueState, labelJson, labelState, milestoneJson, milestoneState, pullRequestDiffText, pullRequestFileJson, pullRequestJson, pullRequestListJson, pullRequestReviewCommentJson, pullRequestReviewCommentState, pullRequestReviewState, pullRequestState, releaseJson, releaseState, repoJson, repoState, reviewJson, statusJson, tagJson, userJson } from "./serializers.js";
+import { resetDatabase } from "./db.js";
+function contentLineCount(content) {
+    return Math.max(1, content.replace(/\n$/, "").split("\n").length);
+}
+export class GitHubDomain {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    seed(seed = defaultSeedState(), onDelta) {
+        const before = this.summarizeRepositories();
+        const tx = this.db.transaction(() => {
+            resetDatabase(this.db);
+            const users = new Set(seed.users?.map((user) => user.login) ?? []);
+            for (const repo of seed.repositories) {
+                users.add(repo.owner);
+                for (const login of repo.collaborators ?? [])
+                    users.add(login);
+                for (const issue of repo.issues ?? [])
+                    for (const login of issue.assignees ?? [])
+                        users.add(login);
+            }
+            users.add("pome-agent");
+            for (const user of seed.users ?? []) {
+                this.upsertUser(user.login, user.type ?? "User", user.name ?? "");
+            }
+            for (const login of users) {
+                this.upsertUser(login, login === "acme" ? "Organization" : "User", login);
+            }
+            for (const repoSeed of seed.repositories) {
+                const repo = this.insertRepository({
+                    owner: repoSeed.owner,
+                    name: repoSeed.name,
+                    description: repoSeed.description ?? "",
+                    private: repoSeed.private ?? false,
+                    defaultBranch: repoSeed.default_branch ?? "main",
+                    fork: false,
+                    parentFullName: null
+                });
+                for (const login of repoSeed.collaborators ?? [])
+                    this.addCollaborator(repo.id, login);
+                this.addCollaborator(repo.id, "pome-agent");
+                for (const label of repoSeed.labels ?? []) {
+                    this.createLabel(repo, label.name, label.color ?? "ededed", label.description ?? "");
+                }
+                this.createBranchInternal(repo, repo.default_branch, null);
+                const files = repoSeed.files?.filter((file) => (file.branch ?? repo.default_branch) === repo.default_branch) ?? [];
+                this.commitFiles(repo, repo.default_branch, "Initial seed commit", files, "pome-agent");
+                const nonDefaultBranches = new Set((repoSeed.files ?? []).map((file) => file.branch ?? repo.default_branch).filter((branch) => branch !== repo.default_branch));
+                for (const branch of nonDefaultBranches) {
+                    this.createBranch({ owner: repo.owner, repo: repo.name, branch, from_branch: repo.default_branch });
+                    const branchFiles = repoSeed.files?.filter((file) => (file.branch ?? repo.default_branch) === branch) ?? [];
+                    this.commitFiles(repo, branch, `Seed ${branch}`, branchFiles, "pome-agent");
+                }
+                for (const issue of repoSeed.issues ?? []) {
+                    const legacyAssignee = issue.assignee;
+                    const assignees = issue.assignees ?? (legacyAssignee ? [legacyAssignee] : []);
+                    const created = this.createIssue({ owner: repo.owner, repo: repo.name, title: issue.title, body: issue.body ?? "", labels: issue.labels ?? [], assignees });
+                    if (issue.number && issue.number !== created.number) {
+                        this.db.prepare("UPDATE issues SET number = ? WHERE repo_id = ? AND number = ?").run(issue.number, repo.id, created.number);
+                        this.bumpEntityCounter(repo.id, issue.number);
+                    }
+                    if (issue.state === "closed")
+                        this.updateIssue({ owner: repo.owner, repo: repo.name, issue_number: issue.number ?? created.number, state: "closed" });
+                }
+                for (const pull of repoSeed.pull_requests ?? []) {
+                    const createdPr = this.createPullRequest({ owner: repo.owner, repo: repo.name, title: pull.title, body: pull.body ?? "", head: pull.head, base: pull.base ?? repo.default_branch, actor: pull.author });
+                    const prNumber = createdPr.number;
+                    // The PR row and its head branch don't change across seeded reviews /
+                    // statuses, so resolve the head SHA once rather than re-querying it on
+                    // every iteration (and in both blocks below).
+                    const seedsHead = (pull.reviews ?? []).length > 0 || (pull.statuses ?? []).length > 0;
+                    const prRow = seedsHead ? this.requirePullRequest(repo.id, prNumber) : null;
+                    const headRepo = prRow ? this.requireRepoById(prRow.head_repo_id) : null;
+                    const headSha = prRow && headRepo ? this.requireBranch(headRepo.id, prRow.head_ref).head_sha ?? "" : "";
+                    // Seed reviews directly into pull_request_reviews so we can record
+                    // the author and state honestly. Going through createPullRequestReview
+                    // would hardcode user_login = "pome-agent" and lose author identity.
+                    for (const review of pull.reviews ?? []) {
+                        users.add(review.author);
+                        this.upsertUser(review.author, "User", review.author);
+                        this.db.prepare("INSERT INTO pull_request_reviews (repo_id, pull_number, user_login, state, body, commit_sha, submitted_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(repo.id, prNumber, review.author, 
+                        // parseSeed defaults this to "APPROVED"; guard direct seed() callers
+                        // that pass a hand-built seed with no explicit review state.
+                        review.state ?? "APPROVED", review.body ?? "", headSha, nowIso());
+                    }
+                    // Seed commit statuses on the PR head SHA. Same shape as
+                    // createStatus() so merge_pull_request's required-status check
+                    // sees the seeded value.
+                    if ((pull.statuses ?? []).length > 0 && headRepo) {
+                        for (const status of pull.statuses ?? []) {
+                            this.createStatus({
+                                owner: headRepo.owner,
+                                repo: headRepo.name,
+                                sha: headSha,
+                                state: status.state ?? "success",
+                                context: status.context ?? "ci/build",
+                                description: status.description ?? ""
+                            });
+                        }
+                    }
+                }
+            }
+            this.audit("seed", null, { repositories: seed.repositories.length });
+        });
+        tx();
+        onDelta?.({
+            before: { repositories: before },
+            after: { repositories: this.summarizeRepositories() }
+        });
+    }
+    summarizeRepositories() {
+        const rows = this.db.prepare("SELECT owner, name FROM repositories ORDER BY full_name ASC").all();
+        return rows;
+    }
+    exportState() {
+        const repos = this.db.prepare("SELECT * FROM repositories ORDER BY full_name ASC").all();
+        return {
+            repositories: repos.map((repo) => ({
+                ...repo,
+                branches: this.listBranches(repo.id),
+                files: this.db.prepare("SELECT * FROM files WHERE repo_id = ? ORDER BY branch, path").all(repo.id),
+                labels: this.listLabels(repo.id),
+                issues: this.listIssuesRows(repo.id).map((issue) => ({
+                    ...issue,
+                    labels: this.listIssueLabels(repo.id, issue.number),
+                    assignees: this.listIssueAssignees(repo.id, issue.number),
+                    comments: this.listIssueCommentRows(repo.id, issue.number)
+                })),
+                pull_requests: this.listPullRequestRows(repo.id).map((pull) => ({
+                    ...pull,
+                    files: this.listPullRequestFileRows(repo.id, pull.number),
+                    reviews: this.listPullRequestReviewRows(repo.id, pull.number),
+                    review_comments: this.listPullRequestReviewCommentRows(repo.id, pull.number)
+                })),
+                commit_statuses: this.db.prepare("SELECT * FROM commit_statuses WHERE repo_id = ? ORDER BY id ASC").all(repo.id),
+                check_runs: this.db.prepare("SELECT * FROM check_runs WHERE repo_id = ? ORDER BY id ASC").all(repo.id)
+            }))
+        };
+    }
+    getRepository(input) {
+        return repoJson(this.requireRepo(input.owner, input.repo));
+    }
+    createRepository(input, onDelta) {
+        const owner = input.owner ?? "pome-agent";
+        const repo = this.transaction(() => {
+            this.upsertUser(owner, "Organization", owner);
+            if (this.getRepo(owner, input.name))
+                validationFailed("name", "already_exists", input.name);
+            const created = this.insertRepository({
+                owner,
+                name: input.name,
+                description: input.description ?? "",
+                private: input.private ?? false,
+                defaultBranch: "main",
+                fork: false,
+                parentFullName: null
+            });
+            this.addCollaborator(created.id, "pome-agent");
+            this.createBranchInternal(created, "main", null);
+            this.commitFiles(created, "main", "Initial commit", [{ path: "README.md", content: `# ${input.name}\n` }], "pome-agent");
+            return created;
+        });
+        this.audit("create_repository", repo.full_name, input);
+        const final = this.requireRepo(owner, input.name);
+        onDelta?.({ before: null, after: repoState(final) });
+        return repoJson(final);
+    }
+    forkRepository(input, onDelta) {
+        const source = this.requireRepo(input.owner, input.repo);
+        const owner = input.organization ?? "pome-agent";
+        const fork = this.transaction(() => {
+            this.upsertUser(owner, owner === input.organization ? "Organization" : "User", owner);
+            if (this.getRepo(owner, source.name))
+                validationFailed("name", "already_exists", source.name);
+            const created = this.insertRepository({
+                owner,
+                name: source.name,
+                description: source.description,
+                private: Boolean(source.private),
+                defaultBranch: source.default_branch,
+                fork: true,
+                parentFullName: source.full_name
+            });
+            this.addCollaborator(created.id, "pome-agent");
+            const commitShaMap = this.copyForkCommits(source, created);
+            for (const branch of this.listBranches(source.id)) {
+                this.createBranchInternal(created, branch.name, branch.head_sha ? commitShaMap.get(branch.head_sha) ?? null : null);
+                const files = this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(source.id, branch.name);
+                for (const file of files) {
+                    this.db.prepare("INSERT INTO files (repo_id, branch, path, content, sha, size, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(created.id, file.branch, file.path, file.content, file.sha, file.size, nowIso());
+                }
+            }
+            return created;
+        });
+        this.audit("fork_repository", fork.full_name, input);
+        onDelta?.({ before: null, after: repoState(fork) });
+        return repoJson(fork);
+    }
+    searchRepositories(input) {
+        const query = (input.query ?? input.q ?? "").toLowerCase();
+        const repos = this.db.prepare("SELECT * FROM repositories ORDER BY full_name ASC").all().filter((repo) => !query || repo.full_name.toLowerCase().includes(query) || repo.description.toLowerCase().includes(query));
+        const items = paginate(repos, input.page, input.per_page ?? input.perPage).map(repoJson);
+        return { total_count: repos.length, incomplete_results: false, items };
+    }
+    searchUsers(input) {
+        const query = (input.query ?? input.q ?? "").toLowerCase();
+        const rows = this.db.prepare("SELECT login, type FROM users ORDER BY login ASC").all();
+        const users = rows.filter((user) => !query || user.login.toLowerCase().includes(query));
+        return { total_count: users.length, incomplete_results: false, items: paginate(users, input.page, input.per_page ?? input.perPage).map((user) => userJson(user.login, user.type)) };
+    }
+    searchCode(input) {
+        const query = (input.query ?? input.q ?? "").toLowerCase();
+        let rows = this.db
+            .prepare("SELECT files.*, repositories.owner, repositories.name, repositories.full_name, repositories.description, repositories.private, repositories.default_branch, repositories.fork, repositories.parent_full_name, repositories.entity_counter, repositories.created_at, repositories.updated_at FROM files INNER JOIN repositories ON files.repo_id = repositories.id WHERE files.branch = repositories.default_branch ORDER BY repositories.full_name, files.path")
+            .all();
+        if (input.owner)
+            rows = rows.filter((row) => row.owner === input.owner);
+        if (input.repo)
+            rows = rows.filter((row) => row.name === input.repo);
+        rows = rows.filter((row) => !query || row.path.toLowerCase().includes(query) || row.content.toLowerCase().includes(query));
+        return {
+            total_count: rows.length,
+            incomplete_results: false,
+            items: paginate(rows, input.page, input.per_page ?? input.perPage).map((row) => ({
+                name: row.path.split("/").at(-1),
+                path: row.path,
+                sha: row.sha,
+                url: `https://api.github.com/repos/${row.full_name}/contents/${row.path}`,
+                git_url: `https://api.github.com/repos/${row.full_name}/git/blobs/${row.sha}`,
+                html_url: `https://github.com/${row.full_name}/blob/${row.branch}/${row.path}`,
+                repository: repoJson(row)
+            }))
+        };
+    }
+    getFileContents(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = input.ref ?? repo.default_branch;
+        this.requireBranch(repo.id, branch);
+        const path = normalizePath(input.path ?? "");
+        const direct = this.getFile(repo.id, branch, path);
+        if (direct)
+            return contentFileJson(direct, repo);
+        const children = this.listDirectory(repo, branch, path);
+        if (children.length === 0)
+            notFound("Not Found");
+        return children;
+    }
+    listCommits(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = input.sha ?? repo.default_branch;
+        const branchRow = this.requireBranch(repo.id, branch);
+        const allRows = this.db.prepare("SELECT * FROM commits WHERE repo_id = ?").all(repo.id);
+        const bySha = new Map(allRows.map((commit) => [commit.sha, commit]));
+        const rows = [];
+        for (let sha = branchRow.head_sha; sha;) {
+            const commit = bySha.get(sha);
+            if (!commit)
+                break;
+            rows.push(commit);
+            sha = commit.parent_sha;
+        }
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((commit) => commitJson(commit, repo));
+    }
+    createOrUpdateFile(input, options = {}, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = input.branch ?? repo.default_branch;
+        let before = null;
+        let afterFile = null;
+        const result = this.transaction(() => {
+            this.requireBranch(repo.id, branch);
+            const path = normalizePath(input.path);
+            const existing = this.getFile(repo.id, branch, path);
+            before = existing ? fileState(existing, repo) : null;
+            if (existing && !input.sha)
+                validationFailed("sha", "missing", path);
+            if (existing && input.sha !== existing.sha)
+                validationFailed("sha", "invalid", input.sha);
+            const content = input.encoding === "base64" ? Buffer.from(input.content, "base64").toString("utf8") : input.content;
+            const commit = this.commitFiles(repo, branch, input.message, [{ path, content }], options.actor ?? "pome-agent");
+            const file = this.getFile(repo.id, branch, path);
+            afterFile = file;
+            return { content: contentFileJson(file, repo), commit: commitJson(commit, repo) };
+        });
+        this.audit("create_or_update_file", repo.full_name, { ...input, content: "[redacted]" });
+        onDelta?.({ before, after: afterFile ? fileState(afterFile, repo) : null });
+        return result;
+    }
+    pushFiles(input, options = {}, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = input.branch ?? repo.default_branch;
+        this.requireBranch(repo.id, branch);
+        if (input.files.length === 0)
+            validationFailed("files", "missing");
+        const paths = new Set();
+        const files = input.files.map((file) => {
+            const path = normalizePath(file.path);
+            if (paths.has(path))
+                validationFailed("files.path", "duplicate", path);
+            paths.add(path);
+            return { path, content: file.encoding === "base64" ? Buffer.from(file.content, "base64").toString("utf8") : file.content };
+        });
+        const beforeFiles = files.map((file) => {
+            const existing = this.getFile(repo.id, branch, file.path);
+            return { path: file.path, sha: existing?.sha ?? null };
+        });
+        const commit = this.transaction(() => this.commitFiles(repo, branch, input.message, files, options.actor ?? "pome-agent"));
+        this.audit("push_files", repo.full_name, { ...input, files: files.map((file) => file.path) });
+        const afterFiles = files.map((file) => {
+            const updated = this.getFile(repo.id, branch, file.path);
+            return { path: file.path, sha: updated.sha };
+        });
+        onDelta?.({
+            before: { repo: repo.full_name, branch, files: beforeFiles },
+            after: { repo: repo.full_name, branch, files: afterFiles, commit_sha: commit.sha }
+        });
+        return { commit: commitJson(commit, repo), files: files.map((file) => contentFileJson(this.getFile(repo.id, branch, file.path), repo)) };
+    }
+    createBranch(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = this.transaction(() => {
+            if (this.getBranch(repo.id, input.branch))
+                validationFailed("branch", "already_exists", input.branch);
+            const source = input.sha
+                ? { head_sha: input.sha }
+                : this.requireBranch(repo.id, input.from_branch ?? repo.default_branch);
+            const created = this.createBranchInternal(repo, input.branch, source.head_sha);
+            if (!input.sha) {
+                const sourceBranch = input.from_branch ?? repo.default_branch;
+                const files = this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(repo.id, sourceBranch);
+                for (const file of files) {
+                    this.db.prepare("INSERT INTO files (repo_id, branch, path, content, sha, size, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(repo.id, input.branch, file.path, file.content, file.sha, file.size, nowIso());
+                }
+            }
+            return created;
+        });
+        this.audit("create_branch", repo.full_name, input);
+        onDelta?.({ before: null, after: branchState(branch, repo) });
+        return branchJson(branch, repo);
+    }
+    createIssue(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const issue = this.transaction(() => {
+            if (!input.title.trim())
+                validationFailed("title", "missing");
+            for (const label of input.labels ?? [])
+                if (!this.getLabel(repo.id, label))
+                    validationFailed("labels", "missing", label);
+            for (const assignee of input.assignees ?? [])
+                if (!this.hasCollaborator(repo.id, assignee))
+                    validationFailed("assignees", "invalid", assignee);
+            const now = nowIso();
+            const number = this.nextNumber(repo.id);
+            this.db.prepare("INSERT INTO issues (repo_id, number, title, body, state, user_login, assignee_login, created_at, updated_at, closed_at) VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, NULL)").run(repo.id, number, input.title, input.body ?? "", "pome-agent", input.assignees?.[0] ?? null, now, now);
+            for (const label of input.labels ?? [])
+                this.db.prepare("INSERT OR IGNORE INTO issue_labels (repo_id, issue_number, label_name) VALUES (?, ?, ?)").run(repo.id, number, label);
+            for (const assignee of input.assignees ?? [])
+                this.db.prepare("INSERT OR IGNORE INTO issue_assignees (repo_id, issue_number, login) VALUES (?, ?, ?)").run(repo.id, number, assignee);
+            return this.requireIssue(repo.id, number);
+        });
+        this.audit("create_issue", repo.full_name, input);
+        const labels = this.listIssueLabels(repo.id, issue.number).map((label) => label.name);
+        const assignees = this.listIssueAssignees(repo.id, issue.number);
+        onDelta?.({ before: null, after: issueState(issue, repo, labels, assignees) });
+        return issueJson(issue, repo, this.listIssueLabels(repo.id, issue.number), this.listIssueAssignees(repo.id, issue.number), this.issueCommentCount(repo.id, issue.number));
+    }
+    listIssues(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let rows = this.listIssuesRows(repo.id);
+        if (input.state && input.state !== "all")
+            rows = rows.filter((issue) => issue.state === input.state);
+        if (input.labels) {
+            const wanted = input.labels.split(",").map((label) => label.trim()).filter(Boolean);
+            rows = rows.filter((issue) => {
+                const names = this.listIssueLabels(repo.id, issue.number).map((label) => label.name);
+                return wanted.every((label) => names.includes(label));
+            });
+        }
+        if (input.assignee)
+            rows = rows.filter((issue) => this.listIssueAssignees(repo.id, issue.number).includes(input.assignee));
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((issue) => issueJson(issue, repo, this.listIssueLabels(repo.id, issue.number), this.listIssueAssignees(repo.id, issue.number), this.issueCommentCount(repo.id, issue.number)));
+    }
+    searchIssues(input) {
+        const query = (input.query ?? input.q ?? "").toLowerCase();
+        const rows = this.db
+            .prepare("SELECT issues.*, repositories.owner, repositories.name, repositories.full_name, repositories.description, repositories.private, repositories.default_branch, repositories.fork, repositories.parent_full_name, repositories.entity_counter, repositories.created_at AS repo_created_at, repositories.updated_at AS repo_updated_at FROM issues INNER JOIN repositories ON issues.repo_id = repositories.id ORDER BY issues.updated_at DESC")
+            .all();
+        let filtered = rows.filter((issue) => !query || issue.title.toLowerCase().includes(query) || issue.body.toLowerCase().includes(query) || issue.full_name.toLowerCase().includes(query));
+        if (input.owner)
+            filtered = filtered.filter((issue) => issue.owner === input.owner);
+        if (input.repo)
+            filtered = filtered.filter((issue) => issue.name === input.repo);
+        if (input.state && input.state !== "all")
+            filtered = filtered.filter((issue) => issue.state === input.state);
+        return {
+            total_count: filtered.length,
+            incomplete_results: false,
+            items: paginate(filtered, input.page, input.per_page ?? input.perPage).map((issue) => {
+                const repo = this.requireRepoById(issue.repo_id);
+                return issueJson(issue, repo, this.listIssueLabels(issue.repo_id, issue.number), this.listIssueAssignees(issue.repo_id, issue.number), this.issueCommentCount(issue.repo_id, issue.number));
+            })
+        };
+    }
+    getIssue(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const issue = this.requireIssue(repo.id, input.issue_number);
+        return issueJson(issue, repo, this.listIssueLabels(repo.id, issue.number), this.listIssueAssignees(repo.id, issue.number), this.issueCommentCount(repo.id, issue.number));
+    }
+    updateIssue(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            const issue = this.requireIssue(repo.id, input.issue_number);
+            before = issueState(issue, repo, this.listIssueLabels(repo.id, issue.number).map((label) => label.name), this.listIssueAssignees(repo.id, issue.number));
+            for (const label of input.labels ?? [])
+                if (!this.getLabel(repo.id, label))
+                    validationFailed("labels", "missing", label);
+            for (const assignee of input.assignees ?? [])
+                if (!this.hasCollaborator(repo.id, assignee))
+                    validationFailed("assignees", "invalid", assignee);
+            const state = input.state ?? issue.state;
+            const closedAt = state === "closed" && issue.state !== "closed" ? nowIso() : state === "open" ? null : issue.closed_at;
+            this.db.prepare("UPDATE issues SET title = ?, body = ?, state = ?, assignee_login = ?, updated_at = ?, closed_at = ? WHERE repo_id = ? AND number = ?").run(input.title ?? issue.title, input.body ?? issue.body, state, input.assignees?.[0] ?? issue.assignee_login, nowIso(), closedAt, repo.id, issue.number);
+            if (input.labels) {
+                this.db.prepare("DELETE FROM issue_labels WHERE repo_id = ? AND issue_number = ?").run(repo.id, issue.number);
+                for (const label of input.labels)
+                    this.db.prepare("INSERT INTO issue_labels (repo_id, issue_number, label_name) VALUES (?, ?, ?)").run(repo.id, issue.number, label);
+            }
+            if (input.assignees) {
+                this.db.prepare("DELETE FROM issue_assignees WHERE repo_id = ? AND issue_number = ?").run(repo.id, issue.number);
+                for (const assignee of input.assignees)
+                    this.db.prepare("INSERT INTO issue_assignees (repo_id, issue_number, login) VALUES (?, ?, ?)").run(repo.id, issue.number, assignee);
+            }
+        });
+        this.audit("update_issue", repo.full_name, input);
+        const updated = this.requireIssue(repo.id, input.issue_number);
+        const afterLabels = this.listIssueLabels(repo.id, updated.number).map((label) => label.name);
+        const afterAssignees = this.listIssueAssignees(repo.id, updated.number);
+        onDelta?.({ before, after: issueState(updated, repo, afterLabels, afterAssignees) });
+        return this.getIssue(input);
+    }
+    addIssueComment(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const comment = this.transaction(() => {
+            this.requireIssue(repo.id, input.issue_number);
+            if (!input.body.trim())
+                validationFailed("body", "missing");
+            const now = nowIso();
+            const result = this.db.prepare("INSERT INTO issue_comments (repo_id, issue_number, body, user_login, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(repo.id, input.issue_number, input.body, "pome-agent", now, now);
+            return this.db.prepare("SELECT * FROM issue_comments WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("add_issue_comment", repo.full_name, input);
+        onDelta?.({ before: null, after: issueCommentState(comment, repo) });
+        return issueCommentJson(comment, repo);
+    }
+    listIssueComments(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requireIssue(repo.id, input.issue_number);
+        const rows = this.listIssueCommentRows(repo.id, input.issue_number);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((comment) => issueCommentJson(comment, repo));
+    }
+    listRepositoryLabels(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        return this.listLabels(repo.id).map(labelJson);
+    }
+    createRepositoryLabel(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.transaction(() => {
+            if (this.getLabel(repo.id, input.name))
+                validationFailed("name", "already_exists", input.name);
+            this.createLabel(repo, input.name, input.color ?? "ededed", input.description ?? "");
+        });
+        this.audit("create_label", repo.full_name, input);
+        const created = this.getLabel(repo.id, input.name);
+        onDelta?.({ before: null, after: labelState(created, repo) });
+        return labelJson(created);
+    }
+    listIssueLabelsForIssue(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requireIssue(repo.id, input.issue_number);
+        return this.listIssueLabels(repo.id, input.issue_number).map(labelJson);
+    }
+    addIssueLabels(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            this.requireIssue(repo.id, input.issue_number);
+            before = issueLabelsState(repo, input.issue_number, this.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+            for (const label of input.labels)
+                if (!this.getLabel(repo.id, label))
+                    validationFailed("labels", "missing", label);
+            for (const label of input.labels)
+                this.db.prepare("INSERT OR IGNORE INTO issue_labels (repo_id, issue_number, label_name) VALUES (?, ?, ?)").run(repo.id, input.issue_number, label);
+        });
+        this.audit("add_issue_labels", repo.full_name, input);
+        const after = issueLabelsState(repo, input.issue_number, this.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+        onDelta?.({ before, after });
+        return this.listIssueLabelsForIssue(input);
+    }
+    deleteIssueLabel(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requireIssue(repo.id, input.issue_number);
+        const before = issueLabelsState(repo, input.issue_number, this.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+        const result = this.db.prepare("DELETE FROM issue_labels WHERE repo_id = ? AND issue_number = ? AND label_name = ?").run(repo.id, input.issue_number, input.label);
+        if (!result.changes)
+            notFound("Label not found");
+        this.audit("delete_issue_label", repo.full_name, input);
+        const after = issueLabelsState(repo, input.issue_number, this.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+        onDelta?.({ before, after });
+        return this.listIssueLabelsForIssue(input);
+    }
+    listCollaborators(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const rows = this.db.prepare("SELECT login FROM collaborators WHERE repo_id = ? ORDER BY login ASC").all(repo.id);
+        return rows.map((row) => userJson(row.login));
+    }
+    isCollaborator(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        return this.hasCollaborator(repo.id, input.username);
+    }
+    hasRepositoryPermission(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const row = this.db.prepare("SELECT permission, invitation_state FROM collaborators WHERE repo_id = ? AND login = ?").get(repo.id, input.username);
+        return Boolean(row && row.invitation_state === "accepted" && input.permissions.includes(row.permission));
+    }
+    addAssignees(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            const issue = this.requireIssue(repo.id, input.issue_number);
+            before = issueAssigneesState(repo, issue.number, this.listIssueAssignees(repo.id, issue.number));
+            for (const assignee of input.assignees)
+                if (!this.hasCollaborator(repo.id, assignee))
+                    validationFailed("assignees", "invalid", assignee);
+            for (const assignee of input.assignees)
+                this.db.prepare("INSERT OR IGNORE INTO issue_assignees (repo_id, issue_number, login) VALUES (?, ?, ?)").run(repo.id, issue.number, assignee);
+            const firstAssignee = input.assignees[0] ?? issue.assignee_login;
+            this.db.prepare("UPDATE issues SET assignee_login = ?, updated_at = ? WHERE repo_id = ? AND number = ?").run(firstAssignee, nowIso(), repo.id, issue.number);
+        });
+        this.audit("add_assignees", repo.full_name, input);
+        const after = issueAssigneesState(repo, input.issue_number, this.listIssueAssignees(repo.id, input.issue_number));
+        onDelta?.({ before, after });
+        return this.getIssue(input);
+    }
+    createPullRequest(input, onDelta) {
+        const baseRepo = this.requireRepo(input.owner, input.repo);
+        const baseRef = input.base ?? baseRepo.default_branch;
+        const number = this.transaction(() => {
+            if (input.head === baseRef || input.head === `${input.owner}:${baseRef}`)
+                validationFailed("head", "invalid", input.head);
+            const { repo: headRepo, ref: headRef } = this.resolveHeadRef(baseRepo, input.head);
+            const baseBranch = this.requireBranch(baseRepo.id, baseRef);
+            const headBranch = this.requireBranch(headRepo.id, headRef);
+            const duplicate = this.db.prepare("SELECT * FROM pull_requests WHERE repo_id = ? AND state = 'open' AND head_repo_id = ? AND head_ref = ? AND base_ref = ?").get(baseRepo.id, headRepo.id, headRef, baseRef);
+            if (duplicate)
+                validationFailed("head", "already_exists", input.head);
+            const files = this.calculatePullFiles(baseRepo, baseRef, headRepo, headRef);
+            if (files.length === 0)
+                validationFailed("head", "missing_commits", input.head);
+            const now = nowIso();
+            const pullNumber = this.nextNumber(baseRepo.id);
+            this.db.prepare("INSERT INTO pull_requests (repo_id, number, title, body, state, user_login, head_repo_id, head_ref, head_sha, base_repo_id, base_ref, base_sha, merged, merge_commit_sha, created_at, updated_at, closed_at, merged_at) VALUES (?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, ?, 0, NULL, ?, ?, NULL, NULL)").run(baseRepo.id, pullNumber, input.title, input.body ?? "", input.actor ?? "pome-agent", headRepo.id, headRef, headBranch.head_sha, baseRepo.id, baseRef, baseBranch.head_sha, now, now);
+            this.replacePullFiles(baseRepo.id, pullNumber, files);
+            return pullNumber;
+        });
+        this.audit("create_pull_request", baseRepo.full_name, input);
+        const createdRow = this.requirePullRequest(baseRepo.id, number);
+        onDelta?.({ before: null, after: pullRequestState(createdRow, baseRepo) });
+        return this.getPullRequest({ owner: input.owner, repo: input.repo, pull_number: number });
+    }
+    listPullRequests(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let rows = this.listPullRequestRows(repo.id);
+        if (input.state && input.state !== "all")
+            rows = rows.filter((pr) => pr.state === input.state);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((pr) => this.serializePullSimple(pr));
+    }
+    getPullRequest(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const pr = this.requirePullRequest(repo.id, input.pull_number);
+        return this.serializePull(pr);
+    }
+    getPullRequestFiles(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requirePullRequest(repo.id, input.pull_number);
+        const rows = this.listPullRequestFileRows(repo.id, input.pull_number);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map(pullRequestFileJson);
+    }
+    getPullRequestReviews(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requirePullRequest(repo.id, input.pull_number);
+        const rows = this.listPullRequestReviewRows(repo.id, input.pull_number);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((review) => reviewJson(review, repo));
+    }
+    createPullRequestReview(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const review = this.transaction(() => {
+            const pr = this.requirePullRequest(repo.id, input.pull_number);
+            if (pr.state !== "open")
+                conflict("Pull request is closed");
+            const state = input.event === "APPROVE" ? "APPROVED" : input.event === "REQUEST_CHANGES" ? "CHANGES_REQUESTED" : "COMMENTED";
+            const headSha = this.requireBranch(pr.head_repo_id, pr.head_ref).head_sha;
+            const result = this.db.prepare("INSERT INTO pull_request_reviews (repo_id, pull_number, user_login, state, body, commit_sha, submitted_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(repo.id, pr.number, "pome-agent", state, input.body ?? "", headSha, nowIso());
+            return this.db.prepare("SELECT * FROM pull_request_reviews WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("create_pull_request_review", repo.full_name, input);
+        onDelta?.({ before: null, after: pullRequestReviewState(review, repo) });
+        return reviewJson(review, repo);
+    }
+    getPullRequestComments(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requirePullRequest(repo.id, input.pull_number);
+        const rows = this.listPullRequestReviewCommentRows(repo.id, input.pull_number);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((comment) => ({
+            id: comment.id,
+            path: comment.path,
+            body: comment.body,
+            user: userJson(comment.user_login),
+            created_at: comment.created_at,
+            updated_at: comment.updated_at
+        }));
+    }
+    getPullRequestStatus(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const pr = this.requirePullRequest(repo.id, input.pull_number);
+        const head = this.requireBranch(pr.head_repo_id, pr.head_ref);
+        const statuses = head.head_sha ? this.latestCommitStatuses(pr.head_repo_id, head.head_sha) : [];
+        return combinedStatusJson(this.requireRepoById(pr.head_repo_id), head.head_sha ?? "", statuses);
+    }
+    mergePullRequest(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        const commit = this.transaction(() => {
+            const pr = this.requirePullRequest(repo.id, input.pull_number);
+            before = pullRequestState(pr, repo);
+            if (pr.state !== "open")
+                conflict("Pull request is closed");
+            if (pr.merged)
+                conflict("Pull request already merged");
+            const status = this.getPullRequestStatus(input);
+            if (status.state === "failure")
+                conflict("Required status check failed");
+            const headRepo = this.requireRepoById(pr.head_repo_id);
+            const files = this.listPullRequestFileRows(repo.id, pr.number);
+            const changes = files.map((file) => {
+                if (file.status === "removed")
+                    return { path: file.filename, content: "", delete: true };
+                const source = this.getFile(headRepo.id, pr.head_ref, file.filename);
+                if (!source)
+                    validationFailed("files", "missing", file.filename);
+                return { path: file.filename, content: source.content };
+            });
+            const mergedCommit = this.commitFiles(repo, pr.base_ref, input.commit_title ?? `Merge pull request #${pr.number}`, changes, "pome-agent");
+            const now = nowIso();
+            this.db.prepare("UPDATE pull_requests SET state = 'closed', merged = 1, merge_commit_sha = ?, updated_at = ?, closed_at = ?, merged_at = ? WHERE repo_id = ? AND number = ?").run(mergedCommit.sha, now, now, now, repo.id, pr.number);
+            return mergedCommit;
+        });
+        this.audit("merge_pull_request", repo.full_name, input);
+        const merged = this.requirePullRequest(repo.id, input.pull_number);
+        onDelta?.({ before, after: pullRequestState(merged, repo) });
+        return { sha: commit.sha, merged: true, message: "Pull Request successfully merged" };
+    }
+    updatePullRequestBranch(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        const pullNumber = this.transaction(() => {
+            const pr = this.requirePullRequest(repo.id, input.pull_number);
+            before = pullRequestState(pr, repo);
+            if (pr.state !== "open")
+                conflict("Pull request is closed");
+            const headRepo = this.requireRepoById(pr.head_repo_id);
+            const headBranch = this.requireBranch(headRepo.id, pr.head_ref);
+            if (input.expected_head_sha && headBranch.head_sha !== input.expected_head_sha)
+                conflict("Head SHA did not match");
+            const baseBranch = this.requireBranch(repo.id, pr.base_ref);
+            const now = nowIso();
+            this.db.prepare("UPDATE branches SET head_sha = ?, updated_at = ? WHERE repo_id = ? AND name = ?").run(baseBranch.head_sha, now, headRepo.id, pr.head_ref);
+            this.db.prepare("UPDATE pull_requests SET head_sha = ?, base_sha = ?, updated_at = ? WHERE repo_id = ? AND number = ?").run(baseBranch.head_sha, baseBranch.head_sha, now, repo.id, pr.number);
+            this.replacePullFiles(repo.id, pr.number, this.calculatePullFiles(repo, pr.base_ref, headRepo, pr.head_ref));
+            return pr.number;
+        });
+        this.audit("update_pull_request_branch", repo.full_name, input);
+        const updated = this.requirePullRequest(repo.id, pullNumber);
+        onDelta?.({ before, after: pullRequestState(updated, repo) });
+        return { message: "Updating pull request branch.", url: `https://api.github.com/repos/${repo.full_name}/pulls/${pullNumber}/update-branch` };
+    }
+    createStatus(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const now = nowIso();
+        const result = this.db.prepare("INSERT INTO commit_statuses (repo_id, sha, state, context, description, target_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(repo.id, input.sha, input.state, input.context ?? "continuous-integration/local", input.description ?? "", input.target_url ?? "", now, now);
+        return this.db.prepare("SELECT * FROM commit_statuses WHERE id = ?").get(result.lastInsertRowid);
+    }
+    // ===== v2 hot paths (FDRS-300) ==========================================
+    // Cluster A — branches & files -------------------------------------------
+    listBranchesForRepo(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const rows = this.listBranches(repo.id);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((branch) => branchJson(branch, repo));
+    }
+    getBranchByName(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = this.requireBranch(repo.id, input.branch);
+        return branchJson(branch, repo);
+    }
+    deleteBranch(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            const branch = this.requireBranch(repo.id, input.branch);
+            if (input.branch === repo.default_branch) {
+                validationFailed("branch", "default_branch", input.branch);
+            }
+            // Mirror GitHub: if any open PR references this branch as head, 422.
+            const headPr = this.db.prepare("SELECT number FROM pull_requests WHERE state = 'open' AND head_repo_id = ? AND head_ref = ?").get(repo.id, input.branch);
+            if (headPr)
+                validationFailed("branch", "open_pull_request", input.branch);
+            before = branchState(branch, repo);
+            this.db.prepare("DELETE FROM files WHERE repo_id = ? AND branch = ?").run(repo.id, input.branch);
+            this.db.prepare("DELETE FROM branches WHERE repo_id = ? AND name = ?").run(repo.id, input.branch);
+        });
+        this.audit("delete_branch", repo.full_name, input);
+        onDelta?.({ before, after: null });
+        return { ok: true };
+    }
+    deleteFile(input, options = {}, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const branch = input.branch ?? repo.default_branch;
+        let before = null;
+        const commit = this.transaction(() => {
+            this.requireBranch(repo.id, branch);
+            const path = normalizePath(input.path);
+            const existing = this.getFile(repo.id, branch, path);
+            if (!existing)
+                notFound("Not Found");
+            if (!input.sha)
+                validationFailed("sha", "missing", path);
+            if (input.sha !== existing.sha)
+                validationFailed("sha", "invalid", input.sha);
+            before = fileState(existing, repo);
+            return this.commitFiles(repo, branch, input.message, [{ path, content: "", delete: true }], options.actor ?? "pome-agent");
+        });
+        this.audit("delete_file", repo.full_name, { ...input });
+        onDelta?.({ before, after: null });
+        return {
+            content: null,
+            commit: commitJson(commit, repo)
+        };
+    }
+    // Cluster B — commits & diffs --------------------------------------------
+    getCommitWithFiles(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const commit = this.resolveCommitByRef(repo, input.ref);
+        const files = this.computeCommitFiles(repo, commit);
+        return commitWithFilesJson(commit, repo, files);
+    }
+    compareCommits(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const baseCommit = this.resolveCommitByRef(repo, input.base);
+        const headCommit = this.resolveCommitByRef(repo, input.head);
+        if (baseCommit.sha === headCommit.sha) {
+            return compareCommitsJson(repo, baseCommit, headCommit, [], [], "identical", 0, 0);
+        }
+        const headAncestry = this.commitAncestry(repo.id, headCommit.sha);
+        const baseAncestry = this.commitAncestry(repo.id, baseCommit.sha);
+        const headSet = new Set(headAncestry.map((commit) => commit.sha));
+        const baseSet = new Set(baseAncestry.map((commit) => commit.sha));
+        const aheadCommits = headAncestry.filter((commit) => !baseSet.has(commit.sha));
+        const behindCommits = baseAncestry.filter((commit) => !headSet.has(commit.sha));
+        const status = aheadCommits.length > 0 && behindCommits.length > 0
+            ? "diverged"
+            : aheadCommits.length > 0
+                ? "ahead"
+                : behindCommits.length > 0
+                    ? "behind"
+                    : "identical";
+        const files = this.computeCompareFiles(repo, baseCommit, headCommit);
+        // GitHub returns commits in reverse chronological order excluding the base.
+        const commits = [...aheadCommits].reverse();
+        return compareCommitsJson(repo, baseCommit, headCommit, commits, files, status, aheadCommits.length, behindCommits.length);
+    }
+    getPullRequestDiff(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        this.requirePullRequest(repo.id, input.pull_number);
+        const files = this.listPullRequestFileRows(repo.id, input.pull_number);
+        return { diff: pullRequestDiffText(files) };
+    }
+    // Cluster C — pull requests deeper ---------------------------------------
+    updatePullRequest(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            const pr = this.requirePullRequest(repo.id, input.pull_number);
+            before = pullRequestState(pr, repo);
+            if (pr.merged && (input.state === "open" || (input.base !== undefined && input.base !== pr.base_ref))) {
+                conflict("Cannot reopen or rebase a merged pull request");
+            }
+            const nextBase = input.base ?? pr.base_ref;
+            if (nextBase !== pr.base_ref)
+                this.requireBranch(repo.id, nextBase);
+            const nextState = input.state ?? pr.state;
+            const closedAt = nextState === "closed" && pr.state !== "closed" ? nowIso() : nextState === "open" ? null : pr.closed_at;
+            const now = nowIso();
+            this.db.prepare("UPDATE pull_requests SET title = ?, body = ?, state = ?, base_ref = ?, updated_at = ?, closed_at = ? WHERE repo_id = ? AND number = ?").run(input.title ?? pr.title, input.body ?? pr.body, nextState, nextBase, now, closedAt, repo.id, pr.number);
+            if (nextBase !== pr.base_ref) {
+                const headRepo = this.requireRepoById(pr.head_repo_id);
+                this.replacePullFiles(repo.id, pr.number, this.calculatePullFiles(repo, nextBase, headRepo, pr.head_ref));
+                const baseBranch = this.requireBranch(repo.id, nextBase);
+                this.db.prepare("UPDATE pull_requests SET base_sha = ? WHERE repo_id = ? AND number = ?").run(baseBranch.head_sha, repo.id, pr.number);
+            }
+        });
+        this.audit("update_pull_request", repo.full_name, input);
+        const updated = this.requirePullRequest(repo.id, input.pull_number);
+        onDelta?.({ before, after: pullRequestState(updated, repo) });
+        return this.getPullRequest({ owner: input.owner, repo: input.repo, pull_number: input.pull_number });
+    }
+    getPullRequestCommits(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const pr = this.requirePullRequest(repo.id, input.pull_number);
+        const headRepo = this.requireRepoById(pr.head_repo_id);
+        const headSha = this.getBranch(headRepo.id, pr.head_ref)?.head_sha ?? pr.head_sha;
+        const baseSha = this.getBranch(repo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+        const commits = headSha ? this.commitsBetween(headRepo.id, headSha, baseSha) : [];
+        // GitHub returns oldest-first for PR commits — reverse the ancestry walk.
+        const ordered = [...commits].reverse();
+        return paginate(ordered, input.page, input.per_page ?? input.perPage).map((commit) => commitJson(commit, headRepo));
+    }
+    createPullRequestReviewComment(input, options = {}, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const comment = this.transaction(() => {
+            const pr = this.requirePullRequest(repo.id, input.pull_number);
+            if (!input.body.trim())
+                validationFailed("body", "missing");
+            if (!input.line)
+                validationFailed("line", "missing");
+            const path = normalizePath(input.path);
+            const prFile = this.listPullRequestFileRows(repo.id, pr.number).find((file) => file.filename === path);
+            if (!prFile)
+                validationFailed("path", "not_in_pr", path);
+            const side = input.side ?? "RIGHT";
+            const headRepo = this.requireRepoById(pr.head_repo_id);
+            const targetRepo = side === "LEFT" ? this.requireRepoById(pr.base_repo_id) : headRepo;
+            const targetRef = side === "LEFT" ? pr.base_ref : pr.head_ref;
+            const targetFile = this.getFile(targetRepo.id, targetRef, path);
+            if (!targetFile || input.line > contentLineCount(targetFile.content))
+                validationFailed("line", "invalid", input.line);
+            const headSha = this.getBranch(pr.head_repo_id, pr.head_ref)?.head_sha ?? pr.head_sha;
+            const baseSha = this.getBranch(repo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+            const commits = headSha ? this.commitsBetween(headRepo.id, headSha, baseSha) : [];
+            const commitSha = input.commit_id ?? headSha;
+            if (!commitSha || !commits.some((commit) => commit.sha === commitSha)) {
+                validationFailed("commit_id", "invalid", input.commit_id ?? commitSha ?? "");
+            }
+            const now = nowIso();
+            const result = this.db.prepare("INSERT INTO pull_request_review_comments (repo_id, pull_number, path, body, user_login, created_at, updated_at, line, side, commit_sha, in_reply_to_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)").run(repo.id, pr.number, path, input.body, options.actor ?? "pome-agent", now, now, input.line ?? null, side, commitSha);
+            return this.db.prepare("SELECT * FROM pull_request_review_comments WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("create_pull_request_review_comment", repo.full_name, input);
+        onDelta?.({ before: null, after: pullRequestReviewCommentState(comment, repo) });
+        return pullRequestReviewCommentJson(comment, repo);
+    }
+    addReplyToPullRequestComment(input, options = {}, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const reply = this.transaction(() => {
+            const pr = this.requirePullRequest(repo.id, input.pull_number);
+            const parent = this.db.prepare("SELECT * FROM pull_request_review_comments WHERE id = ? AND repo_id = ? AND pull_number = ?").get(input.comment_id, repo.id, pr.number);
+            if (!parent)
+                notFound("Review comment not found");
+            if (!input.body.trim())
+                validationFailed("body", "missing");
+            const now = nowIso();
+            const result = this.db.prepare("INSERT INTO pull_request_review_comments (repo_id, pull_number, path, body, user_login, created_at, updated_at, line, side, commit_sha, in_reply_to_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(repo.id, pr.number, parent.path, input.body, options.actor ?? "pome-agent", now, now, parent.line, parent.side, parent.commit_sha, parent.id);
+            return this.db.prepare("SELECT * FROM pull_request_review_comments WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("add_reply_to_pull_request_comment", repo.full_name, input);
+        onDelta?.({ before: null, after: pullRequestReviewCommentState(reply, repo) });
+        return pullRequestReviewCommentJson(reply, repo);
+    }
+    // Cluster D — issue comments deeper --------------------------------------
+    updateIssueComment(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        const comment = this.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM issue_comments WHERE id = ? AND repo_id = ?").get(input.comment_id, repo.id);
+            if (!row)
+                notFound("Issue comment not found");
+            before = issueCommentState(row, repo);
+            if (!input.body.trim())
+                validationFailed("body", "missing");
+            const now = nowIso();
+            this.db.prepare("UPDATE issue_comments SET body = ?, updated_at = ? WHERE id = ?").run(input.body, now, input.comment_id);
+            return this.db.prepare("SELECT * FROM issue_comments WHERE id = ?").get(input.comment_id);
+        });
+        this.audit("update_issue_comment", repo.full_name, input);
+        onDelta?.({ before, after: issueCommentState(comment, repo) });
+        return issueCommentJson(comment, repo);
+    }
+    deleteIssueComment(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            const row = this.db.prepare("SELECT * FROM issue_comments WHERE id = ? AND repo_id = ?").get(input.comment_id, repo.id);
+            if (!row)
+                notFound("Issue comment not found");
+            before = issueCommentState(row, repo);
+            this.db.prepare("DELETE FROM issue_comments WHERE id = ?").run(input.comment_id);
+        });
+        this.audit("delete_issue_comment", repo.full_name, input);
+        onDelta?.({ before, after: null });
+        return { ok: true };
+    }
+    // Cluster E — milestones CRUD --------------------------------------------
+    listMilestones(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let rows = this.db.prepare("SELECT * FROM milestones WHERE repo_id = ? ORDER BY number ASC").all(repo.id);
+        if (input.state && input.state !== "all")
+            rows = rows.filter((milestone) => milestone.state === input.state);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((milestone) => milestoneJson(milestone, repo));
+    }
+    createMilestone(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const milestone = this.transaction(() => {
+            if (!input.title.trim())
+                validationFailed("title", "missing");
+            const duplicate = this.db.prepare("SELECT number FROM milestones WHERE repo_id = ? AND title = ?").get(repo.id, input.title);
+            if (duplicate)
+                validationFailed("title", "already_exists", input.title);
+            const number = this.nextMilestoneNumber(repo.id);
+            const now = nowIso();
+            const state = input.state ?? "open";
+            this.db.prepare("INSERT INTO milestones (repo_id, number, title, state, description, due_on, creator_login, created_at, updated_at, closed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(repo.id, number, input.title, state, input.description ?? "", input.due_on ?? null, "pome-agent", now, now, state === "closed" ? now : null);
+            return this.db.prepare("SELECT * FROM milestones WHERE repo_id = ? AND number = ?").get(repo.id, number);
+        });
+        this.audit("create_milestone", repo.full_name, input);
+        onDelta?.({ before: null, after: milestoneState(milestone, repo) });
+        return milestoneJson(milestone, repo);
+    }
+    updateMilestone(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        const milestone = this.transaction(() => {
+            const existing = this.db.prepare("SELECT * FROM milestones WHERE repo_id = ? AND number = ?").get(repo.id, input.milestone_number);
+            if (!existing)
+                notFound("Milestone not found");
+            before = milestoneState(existing, repo);
+            const nextTitle = input.title ?? existing.title;
+            if (!nextTitle.trim())
+                validationFailed("title", "missing");
+            if (nextTitle !== existing.title) {
+                const duplicate = this.db.prepare("SELECT number FROM milestones WHERE repo_id = ? AND title = ? AND number != ?").get(repo.id, nextTitle, existing.number);
+                if (duplicate)
+                    validationFailed("title", "already_exists", nextTitle);
+            }
+            const state = input.state ?? existing.state;
+            const closedAt = state === "closed" && existing.state !== "closed" ? nowIso() : state === "open" ? null : existing.closed_at;
+            const now = nowIso();
+            this.db.prepare("UPDATE milestones SET title = ?, description = ?, state = ?, due_on = ?, updated_at = ?, closed_at = ? WHERE repo_id = ? AND number = ?").run(nextTitle, input.description ?? existing.description, state, input.due_on ?? existing.due_on, now, closedAt, repo.id, existing.number);
+            return this.db.prepare("SELECT * FROM milestones WHERE repo_id = ? AND number = ?").get(repo.id, existing.number);
+        });
+        this.audit("update_milestone", repo.full_name, input);
+        onDelta?.({ before, after: milestoneState(milestone, repo) });
+        return milestoneJson(milestone, repo);
+    }
+    deleteMilestone(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let before = null;
+        this.transaction(() => {
+            const existing = this.db.prepare("SELECT * FROM milestones WHERE repo_id = ? AND number = ?").get(repo.id, input.milestone_number);
+            if (!existing)
+                notFound("Milestone not found");
+            before = milestoneState(existing, repo);
+            this.db.prepare("DELETE FROM milestones WHERE repo_id = ? AND number = ?").run(repo.id, input.milestone_number);
+        });
+        this.audit("delete_milestone", repo.full_name, input);
+        onDelta?.({ before, after: null });
+        return { ok: true };
+    }
+    // Cluster F — commit status + checks -------------------------------------
+    createCommitStatus(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const row = this.transaction(() => {
+            this.requireCommitOnRepo(repo.id, input.sha);
+            const now = nowIso();
+            const result = this.db.prepare("INSERT INTO commit_statuses (repo_id, sha, state, context, description, target_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(repo.id, input.sha, input.state, input.context ?? "default", input.description ?? "", input.target_url ?? "", now, now);
+            return this.db.prepare("SELECT * FROM commit_statuses WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("create_commit_status", repo.full_name, input);
+        onDelta?.({
+            before: null,
+            after: { repo: repo.full_name, id: row.id, sha: row.sha, state: row.state, context: row.context }
+        });
+        return statusJson(row, repo);
+    }
+    getCombinedStatusForRef(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const sha = this.resolveRefToSha(repo, input.ref);
+        return combinedStatusJson(repo, sha, this.latestCommitStatuses(repo.id, sha));
+    }
+    latestCommitStatuses(repoId, sha) {
+        const statuses = this.db.prepare("SELECT * FROM commit_statuses WHERE repo_id = ? AND sha = ? ORDER BY updated_at DESC, id DESC").all(repoId, sha);
+        const latestByContext = new Map();
+        for (const status of statuses) {
+            if (!latestByContext.has(status.context))
+                latestByContext.set(status.context, status);
+        }
+        return [...latestByContext.values()];
+    }
+    createCheckRun(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const row = this.transaction(() => {
+            if (!input.name.trim())
+                validationFailed("name", "missing");
+            this.requireCommitOnRepo(repo.id, input.head_sha);
+            const status = input.status ?? "queued";
+            if (status === "completed" && !input.conclusion) {
+                validationFailed("conclusion", "missing", "required when status=completed");
+            }
+            if (status !== "completed" && input.conclusion) {
+                validationFailed("conclusion", "invalid", "only allowed when status=completed");
+            }
+            if (status !== "completed" && input.completed_at) {
+                validationFailed("completed_at", "invalid", "only allowed when status=completed");
+            }
+            const started = input.started_at ?? nowIso();
+            const completed = status === "completed" ? input.completed_at ?? nowIso() : input.completed_at ?? null;
+            const result = this.db.prepare("INSERT INTO check_runs (repo_id, head_sha, name, status, conclusion, details_url, external_id, output_title, output_summary, started_at, completed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(repo.id, input.head_sha, input.name, status, input.conclusion ?? null, input.details_url ?? "", input.external_id ?? "", input.output?.title ?? null, input.output?.summary ?? null, started, completed);
+            return this.db.prepare("SELECT * FROM check_runs WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("create_check_run", repo.full_name, input);
+        onDelta?.({ before: null, after: checkRunState(row, repo) });
+        return checkRunJson(row, repo);
+    }
+    listCheckRunsForRef(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const sha = this.resolveRefToSha(repo, input.ref);
+        const rows = this.db.prepare("SELECT * FROM check_runs WHERE repo_id = ? AND head_sha = ? ORDER BY started_at DESC").all(repo.id, sha);
+        const paged = paginate(rows, input.page, input.per_page ?? input.perPage);
+        return {
+            total_count: rows.length,
+            check_runs: paged.map((run) => checkRunJson(run, repo))
+        };
+    }
+    // Cluster G — tags & releases --------------------------------------------
+    listTags(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const rows = this.db.prepare("SELECT * FROM tags WHERE repo_id = ? ORDER BY created_at DESC").all(repo.id);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((tag) => tagJson(tag, repo));
+    }
+    listReleases(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const rows = this.db.prepare("SELECT * FROM releases WHERE repo_id = ? ORDER BY created_at DESC").all(repo.id);
+        return paginate(rows, input.page, input.per_page ?? input.perPage).map((release) => releaseJson(release, repo));
+    }
+    getLatestRelease(input) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const row = this.db.prepare("SELECT * FROM releases WHERE repo_id = ? AND draft = 0 AND prerelease = 0 AND published_at IS NOT NULL ORDER BY published_at DESC LIMIT 1").get(repo.id);
+        if (!row)
+            notFound("Not Found");
+        return releaseJson(row, repo);
+    }
+    createRelease(input, options = {}, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        const release = this.transaction(() => {
+            if (!input.tag_name.trim())
+                validationFailed("tag_name", "missing");
+            const existingRelease = this.db.prepare("SELECT id FROM releases WHERE repo_id = ? AND tag_name = ?").get(repo.id, input.tag_name);
+            if (existingRelease)
+                validationFailed("tag_name", "already_exists", input.tag_name);
+            const target = input.target_commitish ?? repo.default_branch;
+            let tag = this.db.prepare("SELECT * FROM tags WHERE repo_id = ? AND name = ?").get(repo.id, input.tag_name);
+            if (!tag) {
+                // Auto-create tag from target_commitish (branch name or SHA).
+                const sha = this.resolveRefToSha(repo, target);
+                const now = nowIso();
+                this.db.prepare("INSERT INTO tags (repo_id, name, commit_sha, created_at) VALUES (?, ?, ?, ?)").run(repo.id, input.tag_name, sha, now);
+                tag = { repo_id: repo.id, name: input.tag_name, commit_sha: sha, created_at: now };
+            }
+            const draft = input.draft ? 1 : 0;
+            const prerelease = input.prerelease ? 1 : 0;
+            const now = nowIso();
+            const result = this.db.prepare("INSERT INTO releases (repo_id, tag_name, target_commitish, name, body, draft, prerelease, author_login, created_at, published_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(repo.id, input.tag_name, target, input.name ?? null, input.body ?? "", draft, prerelease, options.actor ?? "pome-agent", now, draft ? null : now);
+            return this.db.prepare("SELECT * FROM releases WHERE id = ?").get(result.lastInsertRowid);
+        });
+        this.audit("create_release", repo.full_name, input);
+        onDelta?.({ before: null, after: releaseState(release, repo) });
+        return releaseJson(release, repo);
+    }
+    // Cluster H — identity & collaborators -----------------------------------
+    getMe(input = {}) {
+        const login = input.actor ?? "pome-agent";
+        return authenticatedUserJson(login);
+    }
+    addCollaboratorAction(input, onDelta) {
+        const repo = this.requireRepo(input.owner, input.repo);
+        let invitationState = "accepted";
+        let alreadyCollaborator = false;
+        let beforeState = null;
+        let afterState = null;
+        this.transaction(() => {
+            if (!input.username.trim())
+                validationFailed("username", "missing");
+            const existing = this.db.prepare("SELECT * FROM collaborators WHERE repo_id = ? AND login = ?").get(repo.id, input.username);
+            if (existing) {
+                alreadyCollaborator = true;
+                invitationState = existing.invitation_state ?? "accepted";
+                beforeState = collaboratorAddState(repo, input.username, invitationState, existing.permission);
+                const nextPermission = input.permission ?? existing.permission;
+                if (input.permission && input.permission !== existing.permission) {
+                    this.db.prepare("UPDATE collaborators SET permission = ? WHERE repo_id = ? AND login = ?").run(input.permission, repo.id, input.username);
+                }
+                afterState = collaboratorAddState(repo, input.username, invitationState, nextPermission);
+                return;
+            }
+            const isSeededUser = Boolean(this.db.prepare("SELECT 1 FROM users WHERE login = ?").get(input.username));
+            invitationState = isSeededUser ? "accepted" : "pending";
+            this.upsertUser(input.username, "User", input.username);
+            this.db.prepare("INSERT INTO collaborators (repo_id, login, permission, invitation_state) VALUES (?, ?, ?, ?)").run(repo.id, input.username, input.permission ?? "push", invitationState);
+            afterState = collaboratorAddState(repo, input.username, invitationState, input.permission ?? "push");
+        });
+        this.audit("add_collaborator", repo.full_name, input);
+        onDelta?.({ before: beforeState, after: afterState });
+        if (alreadyCollaborator && invitationState === "accepted") {
+            // GitHub returns 204 for "already a collaborator". We surface the same via `status`.
+            return { status: 204, body: null };
+        }
+        return {
+            status: 201,
+            body: {
+                id: stableNumericId(`${repo.full_name}:invite:${input.username}`),
+                node_id: `RI_${stableNumericId(`${repo.full_name}:invite:${input.username}`)}`,
+                repository: repoJson(repo),
+                invitee: userJson(input.username),
+                inviter: userJson(input.actor ?? "pome-agent"),
+                permissions: input.permission ?? "push",
+                created_at: nowIso(),
+                expired: false,
+                url: `https://api.github.com/repos/${repo.full_name}/invitations/${input.username}`,
+                html_url: `https://github.com/${repo.full_name}/invitations`
+            }
+        };
+    }
+    // ===== private helpers added for v2 hot paths ============================
+    requireCommitOnRepo(repoId, sha) {
+        const exists = this.db.prepare("SELECT 1 FROM commits WHERE repo_id = ? AND sha = ?").get(repoId, sha);
+        if (!exists)
+            notFound("No commit found for SHA");
+    }
+    resolveCommitByRef(repo, ref) {
+        // Try as SHA first.
+        const byHash = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, ref);
+        if (byHash)
+            return byHash;
+        // Try as branch name.
+        const branch = this.getBranch(repo.id, ref);
+        if (branch?.head_sha) {
+            const commit = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, branch.head_sha);
+            if (commit)
+                return commit;
+        }
+        // Try as tag name.
+        const tag = this.db.prepare("SELECT * FROM tags WHERE repo_id = ? AND name = ?").get(repo.id, ref);
+        if (tag) {
+            const commit = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, tag.commit_sha);
+            if (commit)
+                return commit;
+        }
+        notFound("No commit found for ref");
+    }
+    resolveRefToSha(repo, ref) {
+        return this.resolveCommitByRef(repo, ref).sha;
+    }
+    commitAncestry(repoId, sha) {
+        const all = this.db.prepare("SELECT * FROM commits WHERE repo_id = ?").all(repoId);
+        const bySha = new Map(all.map((commit) => [commit.sha, commit]));
+        const out = [];
+        const seen = new Set();
+        const MAX_DEPTH = 2000;
+        let cursor = sha;
+        while (cursor && out.length < MAX_DEPTH) {
+            if (seen.has(cursor))
+                break;
+            seen.add(cursor);
+            const commit = bySha.get(cursor);
+            if (!commit)
+                break;
+            out.push(commit);
+            cursor = commit.parent_sha;
+        }
+        return out;
+    }
+    commitsBetween(repoId, headSha, baseSha) {
+        const ancestry = this.commitAncestry(repoId, headSha);
+        if (!baseSha)
+            return ancestry;
+        const stopIndex = ancestry.findIndex((commit) => commit.sha === baseSha);
+        if (stopIndex === -1)
+            return ancestry;
+        return ancestry.slice(0, stopIndex);
+    }
+    computeCommitFiles(repo, commit) {
+        const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(repo.id, commit.sha);
+        return versions.map((version) => {
+            const additions = version.status === "removed" ? 0 : version.content.split("\n").filter(Boolean).length || 1;
+            const deletions = version.status === "added" ? 0 : version.content.split("\n").filter(Boolean).length || 0;
+            return {
+                repo_id: repo.id,
+                pull_number: 0,
+                filename: version.path,
+                status: version.status,
+                additions,
+                deletions,
+                changes: additions + deletions,
+                blob_url: `https://github.com/${repo.full_name}/blob/${commit.sha}/${version.path}`,
+                raw_url: `https://raw.githubusercontent.com/${repo.full_name}/${commit.sha}/${version.path}`,
+                contents_url: `https://api.github.com/repos/${repo.full_name}/contents/${version.path}?ref=${commit.sha}`,
+                patch: `@@ ${version.path} @@`
+            };
+        });
+    }
+    computeCompareFiles(repo, base, head) {
+        // Build path → latest version snapshot at each commit by walking ancestry
+        // and folding file_versions. Used by /compare.
+        const baseSnapshot = this.snapshotAtCommit(repo.id, base.sha);
+        const headSnapshot = this.snapshotAtCommit(repo.id, head.sha);
+        const paths = [...new Set([...baseSnapshot.keys(), ...headSnapshot.keys()])].sort();
+        const rows = [];
+        for (const path of paths) {
+            const baseFile = baseSnapshot.get(path);
+            const headFile = headSnapshot.get(path);
+            if (baseFile?.sha === headFile?.sha)
+                continue;
+            const diff = linesChanged(baseFile?.content, headFile?.content ?? "");
+            rows.push({
+                repo_id: repo.id,
+                pull_number: 0,
+                filename: path,
+                status: baseFile && headFile ? "modified" : headFile ? "added" : "removed",
+                additions: diff.additions,
+                deletions: headFile ? diff.deletions : (baseFile?.content.split("\n").length ?? 0),
+                changes: diff.additions + diff.deletions,
+                blob_url: `https://github.com/${repo.full_name}/blob/${head.sha}/${path}`,
+                raw_url: `https://raw.githubusercontent.com/${repo.full_name}/${head.sha}/${path}`,
+                contents_url: `https://api.github.com/repos/${repo.full_name}/contents/${path}?ref=${head.sha}`,
+                patch: `@@ ${path} @@`
+            });
+        }
+        return rows;
+    }
+    snapshotAtCommit(repoId, sha) {
+        // Walk ancestry oldest → newest, folding file_versions per path. Removed rows clear the entry.
+        const ancestry = this.commitAncestry(repoId, sha).reverse();
+        const out = new Map();
+        for (const commit of ancestry) {
+            const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(repoId, commit.sha);
+            for (const version of versions) {
+                if (version.status === "removed")
+                    out.delete(version.path);
+                else
+                    out.set(version.path, { content: version.content, sha: version.sha });
+            }
+        }
+        return out;
+    }
+    nextMilestoneNumber(repoId) {
+        const row = this.db.prepare("SELECT COALESCE(MAX(number), 0) AS max FROM milestones WHERE repo_id = ?").get(repoId);
+        return row.max + 1;
+    }
+    transaction(fn) {
+        return this.db.transaction(fn).immediate();
+    }
+    insertRepository(input) {
+        const now = nowIso();
+        this.db.prepare("INSERT INTO repositories (owner, name, full_name, description, private, default_branch, fork, parent_full_name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(input.owner, input.name, `${input.owner}/${input.name}`, input.description, input.private ? 1 : 0, input.defaultBranch, input.fork ? 1 : 0, input.parentFullName, now, now);
+        return this.requireRepo(input.owner, input.name);
+    }
+    copyForkCommits(source, fork) {
+        const sourceCommits = this.db.prepare("SELECT * FROM commits WHERE repo_id = ?").all(source.id);
+        const bySha = new Map(sourceCommits.map((commit) => [commit.sha, commit]));
+        const copied = new Map();
+        const copyCommit = (commit) => {
+            const existing = copied.get(commit.sha);
+            if (existing)
+                return existing;
+            const parent = commit.parent_sha ? bySha.get(commit.parent_sha) : undefined;
+            const parentSha = parent ? copyCommit(parent) : null;
+            const sha = makeSha(fork.full_name, commit.sha);
+            copied.set(commit.sha, sha);
+            this.db.prepare("INSERT INTO commits (sha, repo_id, message, author_login, committer_login, parent_sha, tree_sha, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(sha, fork.id, commit.message, commit.author_login, commit.committer_login, parentSha, commit.tree_sha, commit.created_at);
+            const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(source.id, commit.sha);
+            for (const version of versions) {
+                this.db.prepare("INSERT INTO file_versions (commit_sha, repo_id, path, content, sha, status) VALUES (?, ?, ?, ?, ?, ?)").run(sha, fork.id, version.path, version.content, version.sha, version.status);
+            }
+            return sha;
+        };
+        for (const commit of sourceCommits)
+            copyCommit(commit);
+        return copied;
+    }
+    commitFiles(repo, branchName, message, files, actor) {
+        const branch = this.requireBranch(repo.id, branchName);
+        const now = nowIso();
+        const normalizedFiles = files.map((file) => ({ ...file, path: normalizePath(file.path) }));
+        const existingPaths = this.db.prepare("SELECT path FROM files WHERE repo_id = ? AND branch = ? ORDER BY path").all(repo.id, branchName).map((row) => row.path);
+        const nextPaths = new Set(existingPaths);
+        for (const file of normalizedFiles) {
+            if (file.delete)
+                nextPaths.delete(file.path);
+            else
+                nextPaths.add(file.path);
+        }
+        const sha = makeSha(repo.full_name, branchName, message, normalizedFiles, now);
+        const commit = {
+            sha,
+            repo_id: repo.id,
+            message,
+            author_login: actor,
+            committer_login: actor,
+            parent_sha: branch.head_sha,
+            tree_sha: treeSha([...nextPaths]),
+            created_at: now
+        };
+        this.db.prepare("INSERT INTO commits (sha, repo_id, message, author_login, committer_login, parent_sha, tree_sha, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(commit.sha, commit.repo_id, commit.message, commit.author_login, commit.committer_login, commit.parent_sha, commit.tree_sha, commit.created_at);
+        for (const file of normalizedFiles) {
+            const path = file.path;
+            const existing = this.getFile(repo.id, branchName, path);
+            if (file.delete) {
+                if (!existing)
+                    validationFailed("files", "missing", path);
+                this.db.prepare("INSERT INTO file_versions (commit_sha, repo_id, path, content, sha, status) VALUES (?, ?, ?, ?, ?, 'removed')").run(commit.sha, repo.id, path, existing.content, existing.sha);
+                this.db.prepare("DELETE FROM files WHERE repo_id = ? AND branch = ? AND path = ?").run(repo.id, branchName, path);
+                continue;
+            }
+            const sha = fileSha(file.content);
+            this.db.prepare("INSERT INTO file_versions (commit_sha, repo_id, path, content, sha, status) VALUES (?, ?, ?, ?, ?, ?)").run(commit.sha, repo.id, path, file.content, sha, existing ? "modified" : "added");
+            this.db.prepare("INSERT INTO files (repo_id, branch, path, content, sha, size, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(repo_id, branch, path) DO UPDATE SET content = excluded.content, sha = excluded.sha, size = excluded.size, updated_at = excluded.updated_at").run(repo.id, branchName, path, file.content, sha, Buffer.byteLength(file.content), now);
+        }
+        this.db.prepare("UPDATE branches SET head_sha = ?, updated_at = ? WHERE repo_id = ? AND name = ?").run(commit.sha, now, repo.id, branchName);
+        this.db.prepare("UPDATE repositories SET updated_at = ? WHERE id = ?").run(now, repo.id);
+        return commit;
+    }
+    calculatePullFiles(baseRepo, baseRef, headRepo, headRef) {
+        const baseFiles = new Map(this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(baseRepo.id, baseRef).map((file) => [file.path, file]));
+        const headFiles = new Map(this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(headRepo.id, headRef).map((file) => [file.path, file]));
+        const paths = [...new Set([...baseFiles.keys(), ...headFiles.keys()])].sort();
+        const rows = [];
+        for (const path of paths) {
+            const base = baseFiles.get(path);
+            const head = headFiles.get(path);
+            if (base?.sha === head?.sha)
+                continue;
+            const diff = linesChanged(base?.content, head?.content ?? "");
+            rows.push({
+                repo_id: baseRepo.id,
+                pull_number: 0,
+                filename: path,
+                status: base && head ? "modified" : head ? "added" : "removed",
+                additions: diff.additions,
+                deletions: head ? diff.deletions : base?.content.split("\n").length ?? 0,
+                changes: diff.additions + diff.deletions,
+                blob_url: `https://github.com/${headRepo.full_name}/blob/${headRef}/${path}`,
+                raw_url: `https://raw.githubusercontent.com/${headRepo.full_name}/${headRef}/${path}`,
+                contents_url: `https://api.github.com/repos/${headRepo.full_name}/contents/${path}`,
+                patch: `@@ ${path} @@`
+            });
+        }
+        return rows;
+    }
+    replacePullFiles(repoId, pullNumber, files) {
+        this.db.prepare("DELETE FROM pull_request_files WHERE repo_id = ? AND pull_number = ?").run(repoId, pullNumber);
+        for (const file of files) {
+            this.db.prepare("INSERT INTO pull_request_files (repo_id, pull_number, filename, status, additions, deletions, changes, blob_url, raw_url, contents_url, patch) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(repoId, pullNumber, file.filename, file.status, file.additions, file.deletions, file.changes, file.blob_url, file.raw_url, file.contents_url, file.patch);
+        }
+    }
+    // Single-PR GET (full PullRequest shape: keeps merged / commits / additions /
+    // deletions / changed_files).
+    serializePull(pr) {
+        const baseRepo = this.requireRepoById(pr.base_repo_id);
+        const headRepo = this.requireRepoById(pr.head_repo_id);
+        const files = this.db.prepare("SELECT * FROM pull_request_files WHERE repo_id = ? AND pull_number = ?").all(pr.repo_id, pr.number);
+        const headSha = this.getBranch(headRepo.id, pr.head_ref)?.head_sha ?? pr.head_sha;
+        const baseSha = this.getBranch(baseRepo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+        return pullRequestJson(pr, baseRepo, headRepo, 1, files.length, headSha, baseSha);
+    }
+    // LIST endpoint (leaner PullRequestSimple shape: drops the single-PR-only
+    // diff-stat fields, matching real GitHub).
+    serializePullSimple(pr) {
+        const baseRepo = this.requireRepoById(pr.base_repo_id);
+        const headRepo = this.requireRepoById(pr.head_repo_id);
+        const headSha = this.getBranch(headRepo.id, pr.head_ref)?.head_sha ?? pr.head_sha;
+        const baseSha = this.getBranch(baseRepo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+        return pullRequestListJson(pr, baseRepo, headRepo, headSha, baseSha);
+    }
+    resolveHeadRef(baseRepo, head) {
+        const [owner, ref] = head.includes(":") ? head.split(":", 2) : [baseRepo.owner, head];
+        const repo = this.requireRepo(owner, baseRepo.name);
+        return { repo, ref: ref };
+    }
+    listDirectory(repo, branch, path) {
+        const prefix = path ? `${path}/` : "";
+        const rows = this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ? AND path LIKE ? ORDER BY path ASC").all(repo.id, branch, `${prefix}%`);
+        const seen = new Set();
+        const entries = [];
+        for (const file of rows) {
+            const rest = file.path.slice(prefix.length);
+            const first = rest.split("/")[0];
+            const childPath = prefix ? `${prefix}${first}` : first;
+            if (seen.has(childPath))
+                continue;
+            seen.add(childPath);
+            entries.push(contentDirectoryEntryJson(childPath, repo, branch, rest.includes("/") ? undefined : file));
+        }
+        return entries;
+    }
+    createBranchInternal(repo, name, headSha) {
+        const now = nowIso();
+        this.db.prepare("INSERT INTO branches (repo_id, name, head_sha, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(repo.id, name, headSha, now, now);
+        return this.requireBranch(repo.id, name);
+    }
+    upsertUser(login, type, name) {
+        this.db.prepare("INSERT INTO users (login, type, name, created_at) VALUES (?, ?, ?, ?) ON CONFLICT(login) DO UPDATE SET type = excluded.type, name = excluded.name").run(login, type, name, nowIso());
+    }
+    addCollaborator(repoId, login) {
+        this.upsertUser(login, "User", login);
+        this.db.prepare("INSERT OR IGNORE INTO collaborators (repo_id, login, permission) VALUES (?, ?, 'push')").run(repoId, login);
+    }
+    createLabel(repo, name, color, description) {
+        this.db.prepare("INSERT OR IGNORE INTO labels (repo_id, name, color, description) VALUES (?, ?, ?, ?)").run(repo.id, name, color, description);
+        return labelJson(this.getLabel(repo.id, name));
+    }
+    getRepo(owner, repo) {
+        return this.db.prepare("SELECT * FROM repositories WHERE owner = ? AND name = ?").get(owner, repo);
+    }
+    requireRepo(owner, repo) {
+        return this.getRepo(owner, repo) ?? notFound("Not Found");
+    }
+    requireRepoById(repoId) {
+        return this.db.prepare("SELECT * FROM repositories WHERE id = ?").get(repoId) ?? notFound("Not Found");
+    }
+    getBranch(repoId, name) {
+        return this.db.prepare("SELECT * FROM branches WHERE repo_id = ? AND name = ?").get(repoId, name);
+    }
+    requireBranch(repoId, name) {
+        return this.getBranch(repoId, name) ?? notFound("Branch not found");
+    }
+    listBranches(repoId) {
+        return this.db.prepare("SELECT * FROM branches WHERE repo_id = ? ORDER BY name ASC").all(repoId);
+    }
+    getFile(repoId, branch, path) {
+        return this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ? AND path = ?").get(repoId, branch, path);
+    }
+    getLabel(repoId, name) {
+        return this.db.prepare("SELECT * FROM labels WHERE repo_id = ? AND name = ?").get(repoId, name);
+    }
+    listLabels(repoId) {
+        return this.db.prepare("SELECT * FROM labels WHERE repo_id = ? ORDER BY name ASC").all(repoId);
+    }
+    listIssuesRows(repoId) {
+        return this.db.prepare("SELECT * FROM issues WHERE repo_id = ? ORDER BY number ASC").all(repoId);
+    }
+    requireIssue(repoId, number) {
+        return this.db.prepare("SELECT * FROM issues WHERE repo_id = ? AND number = ?").get(repoId, number) ?? notFound("Issue not found");
+    }
+    listIssueLabels(repoId, issueNumber) {
+        return this.db
+            .prepare("SELECT labels.* FROM labels INNER JOIN issue_labels ON labels.repo_id = issue_labels.repo_id AND labels.name = issue_labels.label_name WHERE issue_labels.repo_id = ? AND issue_labels.issue_number = ? ORDER BY labels.name ASC")
+            .all(repoId, issueNumber);
+    }
+    listIssueAssignees(repoId, issueNumber) {
+        const rows = this.db.prepare("SELECT login FROM issue_assignees WHERE repo_id = ? AND issue_number = ? ORDER BY login ASC").all(repoId, issueNumber);
+        return rows.map((row) => row.login);
+    }
+    issueCommentCount(repoId, issueNumber) {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM issue_comments WHERE repo_id = ? AND issue_number = ?").get(repoId, issueNumber);
+        return row.count;
+    }
+    listIssueCommentRows(repoId, issueNumber) {
+        return this.db.prepare("SELECT * FROM issue_comments WHERE repo_id = ? AND issue_number = ? ORDER BY id ASC").all(repoId, issueNumber);
+    }
+    hasCollaborator(repoId, login) {
+        return Boolean(this.db.prepare("SELECT 1 FROM collaborators WHERE repo_id = ? AND login = ?").get(repoId, login));
+    }
+    listPullRequestRows(repoId) {
+        return this.db.prepare("SELECT * FROM pull_requests WHERE repo_id = ? ORDER BY number ASC").all(repoId);
+    }
+    listPullRequestFileRows(repoId, pullNumber) {
+        return this.db.prepare("SELECT * FROM pull_request_files WHERE repo_id = ? AND pull_number = ? ORDER BY filename ASC").all(repoId, pullNumber);
+    }
+    listPullRequestReviewRows(repoId, pullNumber) {
+        return this.db.prepare("SELECT * FROM pull_request_reviews WHERE repo_id = ? AND pull_number = ? ORDER BY submitted_at ASC").all(repoId, pullNumber);
+    }
+    listPullRequestReviewCommentRows(repoId, pullNumber) {
+        return this.db.prepare("SELECT * FROM pull_request_review_comments WHERE repo_id = ? AND pull_number = ? ORDER BY id ASC").all(repoId, pullNumber);
+    }
+    requirePullRequest(repoId, number) {
+        return this.db.prepare("SELECT * FROM pull_requests WHERE repo_id = ? AND number = ?").get(repoId, number) ?? notFound("Pull request not found");
+    }
+    nextNumber(repoId) {
+        this.db.prepare("UPDATE repositories SET entity_counter = entity_counter + 1 WHERE id = ?").run(repoId);
+        const row = this.db.prepare("SELECT entity_counter AS next FROM repositories WHERE id = ?").get(repoId);
+        return row.next;
+    }
+    bumpEntityCounter(repoId, number) {
+        this.db.prepare("UPDATE repositories SET entity_counter = CASE WHEN entity_counter < ? THEN ? ELSE entity_counter END WHERE id = ?").run(number, number, repoId);
+    }
+    audit(action, repoFullName, payload) {
+        this.db.prepare("INSERT INTO audit_log (ts, action, repo_full_name, payload_json) VALUES (?, ?, ?, ?)").run(nowIso(), action, repoFullName, JSON.stringify(payload));
+    }
+}
+function normalizePath(path) {
+    const normalized = path.replace(/^\/+/, "").replace(/\/+/g, "/").trim();
+    if (normalized.includes(".."))
+        validationFailed("path", "invalid", path);
+    return normalized;
+}
+//# sourceMappingURL=domain.js.map