@pome-sh/cli 0.20.0 → 0.21.0

package/dist/chunk-OKDJRKJV.js

@@ -0,0 +1,4390 @@
+import { defineTwin, twinBuildInfo, UnknownToolError, openTwinDatabase, createApp } from './chunk-LZIPGCQJ.js';
+import { z, ZodError } from 'zod';
+import { createHash, randomUUID } from 'node:crypto';
+
+// ../packages/twin-github/dist/src/errors.js
+var TwinError = class extends Error {
+  status;
+  errors;
+  constructor(message, status, errors) {
+    super(message);
+    this.status = status;
+    this.errors = errors;
+  }
+};
+function githubError(message, status, errors) {
+  return {
+    message,
+    documentation_url: "https://docs.github.com/rest",
+    status,
+    ...errors ? { errors } : {}
+  };
+}
+function notFound(message = "Not Found") {
+  throw new TwinError(message, 404);
+}
+function conflict(message) {
+  throw new TwinError(message, 409);
+}
+function validationFailed(field, code, value) {
+  throw new TwinError("Validation Failed", 422, [
+    {
+      resource: "Request",
+      field,
+      code,
+      ...value === void 0 ? {} : { value }
+    }
+  ]);
+}
+
+// ../packages/twin-github/dist/src/tools.js
+var pageShape = {
+  page: z.coerce.number().int().positive().optional(),
+  per_page: z.coerce.number().int().positive().optional(),
+  perPage: z.coerce.number().int().positive().optional()
+};
+var ownerRepo = {
+  owner: z.string().min(1),
+  repo: z.string().min(1)
+};
+var prNumber = {
+  pull_number: z.coerce.number().int().positive().optional(),
+  pullNumber: z.coerce.number().int().positive().optional()
+};
+({
+  issue_number: z.coerce.number().int().positive(),
+  issueNumber: z.coerce.number().int().positive().optional()
+});
+function normalizeIssueNumber(input) {
+  return { ...input, issue_number: input.issue_number ?? input.issueNumber };
+}
+function normalizePullNumber(input) {
+  return { ...input, pull_number: input.pull_number ?? input.pullNumber };
+}
+function normalizeCommentId(input) {
+  return { ...input, comment_id: input.comment_id ?? input.commentId };
+}
+function normalizeMilestoneNumber(input) {
+  return { ...input, milestone_number: input.milestone_number ?? input.milestoneNumber };
+}
+function normalizeHeadSha(input) {
+  return { ...input, head_sha: input.head_sha ?? input.headSha };
+}
+function normalizeTagName(input) {
+  return { ...input, tag_name: input.tag_name ?? input.tagName };
+}
+var toolDefinitions = [
+  {
+    name: "search_repositories",
+    description: "Search local repositories by name or description.",
+    schema: z.object({ query: z.string().optional(), q: z.string().optional(), ...pageShape })
+  },
+  {
+    name: "create_repository",
+    description: "Create a repository with an initial README and main branch.",
+    schema: z.object({ name: z.string().min(1), owner: z.string().min(1).optional(), description: z.string().optional(), private: z.boolean().optional() })
+  },
+  {
+    name: "fork_repository",
+    description: "Fork a repository into the current user or an organization.",
+    schema: z.object({ ...ownerRepo, organization: z.string().min(1).optional() })
+  },
+  {
+    name: "get_repository",
+    description: "Get one repository.",
+    schema: z.object({ ...ownerRepo })
+  },
+  {
+    name: "search_code",
+    description: "Search files in the local GitHub twin.",
+    schema: z.object({ query: z.string().optional(), q: z.string().optional(), owner: z.string().optional(), repo: z.string().optional(), ...pageShape })
+  },
+  {
+    name: "search_users",
+    description: "Search seeded users and organizations.",
+    schema: z.object({ query: z.string().optional(), q: z.string().optional(), ...pageShape })
+  },
+  {
+    name: "get_file_contents",
+    description: "Read a file or directory from a repository branch.",
+    schema: z.object({ ...ownerRepo, path: z.string().optional(), ref: z.string().optional() })
+  },
+  {
+    name: "list_commits",
+    description: "List commits for a repository.",
+    schema: z.object({ ...ownerRepo, sha: z.string().optional(), ...pageShape })
+  },
+  {
+    name: "create_or_update_file",
+    description: "Create or update one file and advance the branch head atomically.",
+    schema: z.object({ ...ownerRepo, path: z.string().min(1), message: z.string().min(1), content: z.string(), branch: z.string().optional(), sha: z.string().optional(), encoding: z.enum(["utf-8", "base64"]).optional() })
+  },
+  {
+    name: "create_branch",
+    description: "Create a branch from an existing branch or SHA.",
+    schema: z.object({ ...ownerRepo, branch: z.string().min(1), from_branch: z.string().optional(), sha: z.string().optional() })
+  },
+  {
+    name: "push_files",
+    description: "Push multiple files in a single commit.",
+    schema: z.object({ ...ownerRepo, branch: z.string().optional(), message: z.string().min(1), files: z.array(z.object({ path: z.string().min(1), content: z.string(), encoding: z.enum(["utf-8", "base64"]).optional() })).min(1) })
+  },
+  {
+    name: "get_issue",
+    description: "Get one issue.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional() }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "update_issue",
+    description: "Update an issue title, body, state, labels, or assignees.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional(), title: z.string().optional(), body: z.string().optional(), state: z.enum(["open", "closed"]).optional(), labels: z.array(z.string()).optional(), assignees: z.array(z.string()).optional() }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "search_issues",
+    description: "Search all local issues.",
+    schema: z.object({ query: z.string().optional(), q: z.string().optional(), state: z.enum(["open", "closed", "all"]).optional(), ...pageShape })
+  },
+  {
+    name: "list_issues",
+    description: "List repository issues with common filters.",
+    schema: z.object({ ...ownerRepo, state: z.enum(["open", "closed", "all"]).optional(), labels: z.string().optional(), assignee: z.string().optional(), ...pageShape })
+  },
+  {
+    name: "add_issue_comment",
+    description: "Add an issue comment.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional(), body: z.string().min(1) }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "list_issue_comments",
+    description: "List comments on an issue.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional(), ...pageShape }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "create_issue",
+    description: "Create an issue.",
+    schema: z.object({ ...ownerRepo, title: z.string().min(1), body: z.string().optional(), labels: z.array(z.string()).optional(), assignees: z.array(z.string()).optional() })
+  },
+  {
+    name: "list_repository_labels",
+    description: "List labels defined on a repository.",
+    schema: z.object({ ...ownerRepo })
+  },
+  {
+    name: "create_label",
+    description: "Create a repository label.",
+    schema: z.object({ ...ownerRepo, name: z.string().min(1), color: z.string().default("ededed"), description: z.string().default("") })
+  },
+  {
+    name: "list_issue_labels",
+    description: "List labels applied to an issue.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional() }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "add_issue_labels",
+    description: "Apply one or more labels to an issue.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional(), labels: z.array(z.string().min(1)).min(1) }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "remove_issue_label",
+    description: "Remove one label from an issue.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional(), label: z.string().min(1) }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "list_collaborators",
+    description: "List repository collaborators.",
+    schema: z.object({ ...ownerRepo })
+  },
+  {
+    name: "add_assignees",
+    description: "Add assignees to an issue.",
+    schema: z.object({ ...ownerRepo, issue_number: z.coerce.number().int().positive().optional(), issueNumber: z.coerce.number().int().positive().optional(), assignees: z.array(z.string().min(1)).min(1) }).refine((value) => value.issue_number ?? value.issueNumber, "issue_number is required")
+  },
+  {
+    name: "get_pull_request",
+    description: "Get one pull request.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "get_pull_request_reviews",
+    description: "List pull request reviews.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional(), ...pageShape }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "create_pull_request_review",
+    description: "Create a pull request review.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional(), event: z.enum(["APPROVE", "REQUEST_CHANGES", "COMMENT"]), body: z.string().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "get_pull_request_comments",
+    description: "List review comments on a pull request.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional(), ...pageShape }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "get_pull_request_files",
+    description: "List files changed by a pull request.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional(), ...pageShape }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "get_pull_request_status",
+    description: "Get combined status for a pull request head commit.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "list_pull_requests",
+    description: "List repository pull requests.",
+    schema: z.object({ ...ownerRepo, state: z.enum(["open", "closed", "all"]).optional(), ...pageShape })
+  },
+  {
+    name: "merge_pull_request",
+    description: "Merge a pull request using simplified local merge semantics.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional(), commit_title: z.string().optional(), commit_message: z.string().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "update_pull_request_branch",
+    description: "Update a PR branch from its base branch.",
+    schema: z.object({ ...ownerRepo, pull_number: z.coerce.number().int().positive().optional(), pullNumber: z.coerce.number().int().positive().optional(), expected_head_sha: z.string().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "create_pull_request",
+    description: "Create a pull request from a head branch to a base branch.",
+    schema: z.object({ ...ownerRepo, title: z.string().min(1), body: z.string().optional(), head: z.string().min(1), base: z.string().optional() })
+  },
+  // ===== v2 hot paths (FDRS-300) ==========================================
+  // Cluster A — branches & files
+  {
+    name: "list_branches",
+    description: "List branches for a repository.",
+    schema: z.object({ ...ownerRepo, ...pageShape })
+  },
+  {
+    name: "get_branch",
+    description: "Get one branch by name.",
+    schema: z.object({ ...ownerRepo, branch: z.string().min(1) })
+  },
+  {
+    name: "delete_branch",
+    description: "Delete a branch (cannot delete the default branch or a branch backing an open PR).",
+    schema: z.object({ ...ownerRepo, branch: z.string().min(1) })
+  },
+  {
+    name: "delete_file",
+    description: "Delete one file and advance the branch head atomically.",
+    schema: z.object({ ...ownerRepo, path: z.string().min(1), message: z.string().min(1), sha: z.string().min(1), branch: z.string().optional() })
+  },
+  // Cluster B — commits & diffs
+  {
+    name: "get_commit",
+    description: "Get one commit with its file changes and stats.",
+    schema: z.object({ ...ownerRepo, ref: z.string().min(1) })
+  },
+  {
+    name: "compare_commits",
+    description: "Compare two commits, branches, or tags. Returns ahead/behind/identical/diverged.",
+    schema: z.object({ ...ownerRepo, base: z.string().min(1), head: z.string().min(1) })
+  },
+  {
+    name: "get_pull_request_diff",
+    description: "Get a unified-diff-style text representation of a pull request.",
+    schema: z.object({ ...ownerRepo, ...prNumber }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  // Cluster C — PR deeper
+  {
+    name: "update_pull_request",
+    description: "Update a pull request title, body, state, or base branch.",
+    schema: z.object({ ...ownerRepo, ...prNumber, title: z.string().optional(), body: z.string().optional(), state: z.enum(["open", "closed"]).optional(), base: z.string().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "get_pull_request_commits",
+    description: "List commits on a pull request, oldest first.",
+    schema: z.object({ ...ownerRepo, ...prNumber, ...pageShape }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "create_pull_request_review_comment",
+    description: "Create an inline review comment on a pull request at a file path and line.",
+    schema: z.object({ ...ownerRepo, ...prNumber, body: z.string().min(1), path: z.string().min(1), line: z.coerce.number().int().positive(), side: z.enum(["LEFT", "RIGHT"]).optional(), commit_id: z.string().optional(), commitId: z.string().optional() }).refine((value) => value.pull_number ?? value.pullNumber, "pull_number is required")
+  },
+  {
+    name: "add_reply_to_pull_request_comment",
+    description: "Reply to an existing pull request review comment.",
+    schema: z.object({ ...ownerRepo, ...prNumber, comment_id: z.coerce.number().int().positive().optional(), commentId: z.coerce.number().int().positive().optional(), body: z.string().min(1) }).refine((value) => (value.pull_number ?? value.pullNumber) && (value.comment_id ?? value.commentId), "pull_number and comment_id are required")
+  },
+  // Cluster D — issue comments deeper
+  {
+    name: "update_issue_comment",
+    description: "Update the body of an existing issue comment.",
+    schema: z.object({ ...ownerRepo, comment_id: z.coerce.number().int().positive().optional(), commentId: z.coerce.number().int().positive().optional(), body: z.string().min(1) }).refine((value) => value.comment_id ?? value.commentId, "comment_id is required")
+  },
+  {
+    name: "delete_issue_comment",
+    description: "Delete an issue comment by ID.",
+    schema: z.object({ ...ownerRepo, comment_id: z.coerce.number().int().positive().optional(), commentId: z.coerce.number().int().positive().optional() }).refine((value) => value.comment_id ?? value.commentId, "comment_id is required")
+  },
+  // Cluster E — milestones
+  {
+    name: "list_milestones",
+    description: "List milestones for a repository.",
+    schema: z.object({ ...ownerRepo, state: z.enum(["open", "closed", "all"]).optional(), ...pageShape })
+  },
+  {
+    name: "create_milestone",
+    description: "Create a milestone.",
+    schema: z.object({ ...ownerRepo, title: z.string().min(1), description: z.string().optional(), due_on: z.string().optional(), dueOn: z.string().optional(), state: z.enum(["open", "closed"]).optional() })
+  },
+  {
+    name: "update_milestone",
+    description: "Update a milestone.",
+    schema: z.object({ ...ownerRepo, milestone_number: z.coerce.number().int().positive().optional(), milestoneNumber: z.coerce.number().int().positive().optional(), title: z.string().optional(), description: z.string().optional(), due_on: z.string().optional(), dueOn: z.string().optional(), state: z.enum(["open", "closed"]).optional() }).refine((value) => value.milestone_number ?? value.milestoneNumber, "milestone_number is required")
+  },
+  {
+    name: "delete_milestone",
+    description: "Delete a milestone.",
+    schema: z.object({ ...ownerRepo, milestone_number: z.coerce.number().int().positive().optional(), milestoneNumber: z.coerce.number().int().positive().optional() }).refine((value) => value.milestone_number ?? value.milestoneNumber, "milestone_number is required")
+  },
+  // Cluster F — status + checks
+  {
+    name: "create_commit_status",
+    description: "Create a commit status (pending/success/failure/error) on a commit SHA.",
+    schema: z.object({ ...ownerRepo, sha: z.string().min(1), state: z.enum(["error", "failure", "pending", "success"]), context: z.string().optional(), description: z.string().optional(), target_url: z.string().optional(), targetUrl: z.string().optional() })
+  },
+  {
+    name: "get_combined_status_for_ref",
+    description: "Get the combined status for a ref (SHA, branch, or tag).",
+    schema: z.object({ ...ownerRepo, ref: z.string().min(1) })
+  },
+  {
+    name: "create_check_run",
+    description: "Create a check run on a commit SHA.",
+    schema: z.object({ ...ownerRepo, name: z.string().min(1), head_sha: z.string().min(1).optional(), headSha: z.string().min(1).optional(), status: z.enum(["queued", "in_progress", "completed"]).optional(), conclusion: z.enum(["success", "failure", "neutral", "cancelled", "timed_out", "action_required", "skipped", "stale"]).optional(), details_url: z.string().optional(), detailsUrl: z.string().optional(), external_id: z.string().optional(), externalId: z.string().optional(), output: z.object({ title: z.string().optional(), summary: z.string().optional() }).optional(), started_at: z.string().optional(), startedAt: z.string().optional(), completed_at: z.string().optional(), completedAt: z.string().optional() }).refine((value) => value.head_sha ?? value.headSha, "head_sha is required")
+  },
+  {
+    name: "list_check_runs_for_ref",
+    description: "List check runs for a ref (SHA, branch, or tag).",
+    schema: z.object({ ...ownerRepo, ref: z.string().min(1), ...pageShape })
+  },
+  // Cluster G — tags & releases
+  {
+    name: "list_tags",
+    description: "List tags for a repository, most recent first.",
+    schema: z.object({ ...ownerRepo, ...pageShape })
+  },
+  {
+    name: "list_releases",
+    description: "List releases for a repository, most recent first.",
+    schema: z.object({ ...ownerRepo, ...pageShape })
+  },
+  {
+    name: "get_latest_release",
+    description: "Get the latest published (non-draft, non-prerelease) release.",
+    schema: z.object({ ...ownerRepo })
+  },
+  {
+    name: "create_release",
+    description: "Create a release. Auto-creates the tag if it doesn't exist.",
+    schema: z.object({ ...ownerRepo, tag_name: z.string().min(1).optional(), tagName: z.string().min(1).optional(), target_commitish: z.string().optional(), targetCommitish: z.string().optional(), name: z.string().optional(), body: z.string().optional(), draft: z.boolean().optional(), prerelease: z.boolean().optional() }).refine((value) => value.tag_name ?? value.tagName, "tag_name is required")
+  },
+  // Cluster H — identity & collaborators
+  {
+    name: "get_me",
+    description: "Get the authenticated user.",
+    schema: z.object({})
+  },
+  {
+    name: "add_collaborator",
+    description: "Add a collaborator to a repository. Returns 201 + invitation envelope for new users, 204 when already a collaborator.",
+    schema: z.object({ ...ownerRepo, username: z.string().min(1), permission: z.enum(["pull", "push", "admin", "maintain", "triage"]).optional() })
+  },
+  // M5 hot gaps (F-735)
+  {
+    name: "search_commits",
+    description: "Search commits on repository default branches by message or author.",
+    schema: z.object({ query: z.string().optional(), q: z.string().optional(), owner: z.string().optional(), repo: z.string().optional(), ...pageShape })
+  },
+  {
+    name: "get_release_by_tag",
+    description: "Get a release by its tag name.",
+    schema: z.object({ ...ownerRepo, tag: z.string().min(1) })
+  },
+  {
+    name: "get_tag",
+    description: "Get a tag by name, including the commit it points at.",
+    schema: z.object({ ...ownerRepo, tag: z.string().min(1) })
+  }
+];
+function listTools() {
+  return toolDefinitions.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: z.toJSONSchema(tool.schema)
+  }));
+}
+var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "create_repository",
+  "fork_repository",
+  "create_or_update_file",
+  "create_branch",
+  "push_files",
+  "update_issue",
+  "add_issue_comment",
+  "create_label",
+  "add_issue_labels",
+  "remove_issue_label",
+  "add_assignees",
+  "create_issue",
+  "create_pull_request_review",
+  "merge_pull_request",
+  "update_pull_request_branch",
+  "create_pull_request",
+  // v2 hot paths (FDRS-300)
+  "delete_branch",
+  "delete_file",
+  "update_pull_request",
+  "create_pull_request_review_comment",
+  "add_reply_to_pull_request_comment",
+  "update_issue_comment",
+  "delete_issue_comment",
+  "create_milestone",
+  "update_milestone",
+  "delete_milestone",
+  "create_commit_status",
+  "create_check_run",
+  "create_release",
+  "add_collaborator"
+]);
+function isMutatingTool(name) {
+  return MUTATING_TOOL_NAMES.has(name);
+}
+var TAPE_ASSERTABLE_TOOLS = ["create_commit_status", "create_check_run"];
+function executeTool(domain, name, input, onDelta, options = {}) {
+  const definition = toolDefinitions.find((tool) => tool.name === name);
+  if (!definition) {
+    validationFailed("tool", "invalid", name);
+  }
+  const parsed = definition.schema.parse(input);
+  switch (name) {
+    case "search_repositories":
+      return domain.searchRepositories(parsed);
+    case "create_repository":
+      return domain.createRepository(parsed, onDelta);
+    case "fork_repository":
+      return domain.forkRepository(parsed, onDelta);
+    case "get_repository":
+      return domain.getRepository(parsed);
+    case "search_code":
+      return domain.searchCode(parsed);
+    case "search_users":
+      return domain.searchUsers(parsed);
+    case "get_file_contents":
+      return domain.getFileContents(parsed);
+    case "list_commits":
+      return domain.listCommits(parsed);
+    case "create_or_update_file":
+      return domain.createOrUpdateFile(parsed, { actor: options.actor }, onDelta);
+    case "create_branch":
+      return domain.createBranch(parsed, onDelta);
+    case "push_files":
+      return domain.pushFiles(parsed, { actor: options.actor }, onDelta);
+    case "get_issue":
+      return domain.getIssue(normalizeIssueNumber(parsed));
+    case "update_issue":
+      return domain.updateIssue(normalizeIssueNumber(parsed), onDelta);
+    case "search_issues":
+      return domain.searchIssues(parsed);
+    case "list_issues":
+      return domain.listIssues(parsed);
+    case "add_issue_comment":
+      return domain.addIssueComment(normalizeIssueNumber(parsed), onDelta);
+    case "list_issue_comments":
+      return domain.listIssueComments(normalizeIssueNumber(parsed));
+    case "create_issue":
+      return domain.createIssue(parsed, onDelta);
+    case "list_repository_labels":
+      return domain.listRepositoryLabels(parsed);
+    case "create_label":
+      return domain.createRepositoryLabel(parsed, onDelta);
+    case "list_issue_labels":
+      return domain.listIssueLabelsForIssue(normalizeIssueNumber(parsed));
+    case "add_issue_labels":
+      return domain.addIssueLabels(normalizeIssueNumber(parsed), onDelta);
+    case "remove_issue_label":
+      return domain.deleteIssueLabel(normalizeIssueNumber(parsed), onDelta);
+    case "list_collaborators":
+      return domain.listCollaborators(parsed);
+    case "add_assignees":
+      return domain.addAssignees(normalizeIssueNumber(parsed), onDelta);
+    case "get_pull_request":
+      return domain.getPullRequest(normalizePullNumber(parsed));
+    case "get_pull_request_reviews":
+      return domain.getPullRequestReviews(normalizePullNumber(parsed));
+    case "create_pull_request_review":
+      return domain.createPullRequestReview(normalizePullNumber(parsed), onDelta);
+    case "get_pull_request_comments":
+      return domain.getPullRequestComments(normalizePullNumber(parsed));
+    case "get_pull_request_files":
+      return domain.getPullRequestFiles(normalizePullNumber(parsed));
+    case "get_pull_request_status":
+      return domain.getPullRequestStatus(normalizePullNumber(parsed));
+    case "list_pull_requests":
+      return domain.listPullRequests(parsed);
+    case "merge_pull_request":
+      if (!options.actor || !domain.hasRepositoryPermission({ owner: parsed.owner, repo: parsed.repo, username: options.actor, permissions: ["push", "maintain", "admin"] })) {
+        throw new TwinError("Must have push access to the repository to merge pull requests.", 403);
+      }
+      return domain.mergePullRequest(normalizePullNumber(parsed), onDelta);
+    case "update_pull_request_branch":
+      return domain.updatePullRequestBranch(normalizePullNumber(parsed), onDelta);
+    case "create_pull_request":
+      return domain.createPullRequest({ ...parsed, actor: parsed.actor ?? options.actor }, onDelta);
+    // ===== v2 hot paths (FDRS-300) ========================================
+    case "list_branches":
+      return domain.listBranchesForRepo(parsed);
+    case "get_branch":
+      return domain.getBranchByName(parsed);
+    case "delete_branch":
+      return domain.deleteBranch(parsed, onDelta);
+    case "delete_file":
+      return domain.deleteFile(parsed, { actor: options.actor }, onDelta);
+    case "get_commit":
+      return domain.getCommitWithFiles(parsed);
+    case "compare_commits":
+      return domain.compareCommits(parsed);
+    case "get_pull_request_diff":
+      return domain.getPullRequestDiff(normalizePullNumber(parsed));
+    case "update_pull_request":
+      return domain.updatePullRequest(normalizePullNumber(parsed), onDelta);
+    case "get_pull_request_commits":
+      return domain.getPullRequestCommits(normalizePullNumber(parsed));
+    case "create_pull_request_review_comment": {
+      const merged = normalizePullNumber(parsed);
+      const commitId = merged.commit_id ?? merged.commitId;
+      return domain.createPullRequestReviewComment({ ...merged, commit_id: commitId }, { actor: options.actor }, onDelta);
+    }
+    case "add_reply_to_pull_request_comment":
+      return domain.addReplyToPullRequestComment(normalizeCommentId(normalizePullNumber(parsed)), { actor: options.actor }, onDelta);
+    case "update_issue_comment":
+      return domain.updateIssueComment(normalizeCommentId(parsed), onDelta);
+    case "delete_issue_comment":
+      return domain.deleteIssueComment(normalizeCommentId(parsed), onDelta);
+    case "list_milestones":
+      return domain.listMilestones(parsed);
+    case "create_milestone": {
+      const dueOn = parsed.due_on ?? parsed.dueOn;
+      return domain.createMilestone({ ...parsed, due_on: dueOn }, onDelta);
+    }
+    case "update_milestone": {
+      const merged = normalizeMilestoneNumber(parsed);
+      const dueOn = merged.due_on ?? merged.dueOn;
+      return domain.updateMilestone({ ...merged, due_on: dueOn }, onDelta);
+    }
+    case "delete_milestone":
+      return domain.deleteMilestone(normalizeMilestoneNumber(parsed), onDelta);
+    case "create_commit_status": {
+      const targetUrl = parsed.target_url ?? parsed.targetUrl;
+      return domain.createCommitStatus({ ...parsed, target_url: targetUrl }, onDelta);
+    }
+    case "get_combined_status_for_ref":
+      return domain.getCombinedStatusForRef(parsed);
+    case "create_check_run": {
+      const merged = normalizeHeadSha(parsed);
+      return domain.createCheckRun({
+        ...merged,
+        details_url: merged.details_url ?? merged.detailsUrl,
+        external_id: merged.external_id ?? merged.externalId,
+        started_at: merged.started_at ?? merged.startedAt,
+        completed_at: merged.completed_at ?? merged.completedAt
+      }, onDelta);
+    }
+    case "list_check_runs_for_ref":
+      return domain.listCheckRunsForRef(parsed);
+    case "list_tags":
+      return domain.listTags(parsed);
+    case "list_releases":
+      return domain.listReleases(parsed);
+    case "get_latest_release":
+      return domain.getLatestRelease(parsed);
+    case "create_release": {
+      const merged = normalizeTagName(parsed);
+      return domain.createRelease({
+        ...merged,
+        target_commitish: merged.target_commitish ?? merged.targetCommitish
+      }, { actor: options.actor }, onDelta);
+    }
+    case "get_me":
+      return domain.getMe({ actor: options.actor });
+    case "add_collaborator":
+      if (!options.actor || !domain.hasRepositoryPermission({ ...parsed, username: options.actor, permissions: ["push", "maintain", "admin"] })) {
+        throw new TwinError("Must have push access to the repository to add collaborators.", 403);
+      }
+      return domain.addCollaboratorAction({ ...parsed, actor: options.actor }, onDelta);
+    // M5 hot gaps (F-735)
+    case "search_commits":
+      return domain.searchCommits(parsed);
+    case "get_release_by_tag":
+      return domain.getReleaseByTag(parsed);
+    case "get_tag":
+      return domain.getTag(parsed);
+  }
+}
+
+// ../packages/twin-github/dist/src/access-control.js
+var githubAccessControlCategorySchema = z.enum([
+  "issues",
+  "issue_comments",
+  "pull_requests",
+  "branches_files",
+  "commits_diffs",
+  "milestones",
+  "status_checks",
+  "tags_releases",
+  "labels",
+  "collaborators"
+]);
+var GITHUB_ACCESS_CONTROL_CATEGORY_LABELS = {
+  issues: "Issues",
+  issue_comments: "Issue comments",
+  pull_requests: "Pull requests",
+  branches_files: "Branches & files",
+  commits_diffs: "Commits & diffs",
+  milestones: "Milestones",
+  status_checks: "Status & checks",
+  tags_releases: "Tags & releases",
+  labels: "Labels",
+  collaborators: "Collaborators & identity"
+};
+var GITHUB_ACCESS_CONTROL_CATEGORY_ORDER = [
+  "issues",
+  "issue_comments",
+  "pull_requests",
+  "branches_files",
+  "commits_diffs",
+  "milestones",
+  "status_checks",
+  "tags_releases",
+  "labels",
+  "collaborators"
+];
+var githubAccessControlEndpointSchema = z.object({
+  /** MCP tool name (snake_case). Stable id for policy storage. */
+  tool: z.string().min(1),
+  /** Dashboard label operation segment, e.g. `listIssues`. */
+  operation: z.string().min(1),
+  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  category: githubAccessControlCategorySchema,
+  /** Default allow/deny when a session has no explicit override. */
+  default_allowed: z.boolean(),
+  /** FDRS-300 v2 hot-path; false for the original 25-endpoint surface. */
+  v2: z.boolean().default(false)
+});
+var githubAccessControlCategoryGroupSchema = z.object({
+  category: githubAccessControlCategorySchema,
+  label: z.string().min(1),
+  endpoints: z.array(githubAccessControlEndpointSchema)
+});
+z.object({
+  version: z.literal(2),
+  twin: z.literal("github"),
+  endpoints: z.array(githubAccessControlEndpointSchema).min(1),
+  categories: z.array(githubAccessControlCategoryGroupSchema).min(1)
+});
+function entry(tool, operation, method, category, defaultAllowed, v2 = false) {
+  return { tool, operation, method, category, default_allowed: defaultAllowed, v2 };
+}
+var ENDPOINTS = [
+  // Issues
+  entry("list_issues", "listIssues", "GET", "issues", true),
+  entry("get_issue", "getIssue", "GET", "issues", true),
+  entry("create_issue", "createIssue", "POST", "issues", true),
+  entry("update_issue", "updateIssue", "PATCH", "issues", true),
+  entry("add_assignees", "addAssignees", "POST", "issues", false),
+  // Issue comments
+  entry("add_issue_comment", "addComment", "POST", "issue_comments", true),
+  entry("update_issue_comment", "updateIssueComment", "PATCH", "issue_comments", true, true),
+  entry("delete_issue_comment", "deleteIssueComment", "DELETE", "issue_comments", false, true),
+  // Pull requests
+  entry("list_pull_requests", "listPullRequests", "GET", "pull_requests", true),
+  entry("get_pull_request", "getPullRequest", "GET", "pull_requests", true),
+  entry("create_pull_request", "createPullRequest", "POST", "pull_requests", true),
+  entry("update_pull_request", "updatePullRequest", "PATCH", "pull_requests", true, true),
+  entry("merge_pull_request", "mergePullRequest", "POST", "pull_requests", false),
+  entry("create_pull_request_review", "createReview", "POST", "pull_requests", false),
+  entry("get_pull_request_reviews", "getPullRequestReviews", "GET", "pull_requests", true),
+  entry("get_pull_request_comments", "getPullRequestComments", "GET", "pull_requests", true),
+  entry("get_pull_request_files", "getPullRequestFiles", "GET", "pull_requests", true),
+  entry("get_pull_request_status", "getPullRequestStatus", "GET", "pull_requests", true),
+  entry("update_pull_request_branch", "updatePullRequestBranch", "POST", "pull_requests", false),
+  entry("get_pull_request_diff", "getPullRequestDiff", "GET", "pull_requests", true, true),
+  entry("get_pull_request_commits", "getPullRequestCommits", "GET", "pull_requests", true, true),
+  entry("create_pull_request_review_comment", "createPullRequestReviewComment", "POST", "pull_requests", true, true),
+  entry("add_reply_to_pull_request_comment", "addReplyToPullRequestComment", "POST", "pull_requests", true, true),
+  // Branches & files
+  entry("create_branch", "createBranch", "POST", "branches_files", true),
+  entry("list_branches", "listBranches", "GET", "branches_files", true, true),
+  entry("get_branch", "getBranch", "GET", "branches_files", true, true),
+  entry("delete_branch", "deleteBranch", "DELETE", "branches_files", false, true),
+  entry("get_file_contents", "getContent", "GET", "branches_files", true),
+  entry("create_or_update_file", "createOrUpdateFile", "PUT", "branches_files", true),
+  entry("delete_file", "deleteFile", "DELETE", "branches_files", false, true),
+  entry("push_files", "pushFiles", "POST", "branches_files", false),
+  // Commits & diffs
+  entry("list_commits", "listCommits", "GET", "commits_diffs", true),
+  entry("get_commit", "getCommit", "GET", "commits_diffs", true, true),
+  entry("compare_commits", "compareCommits", "GET", "commits_diffs", true, true),
+  // Milestones
+  entry("list_milestones", "listMilestones", "GET", "milestones", true, true),
+  entry("create_milestone", "createMilestone", "POST", "milestones", true, true),
+  entry("update_milestone", "updateMilestone", "PATCH", "milestones", true, true),
+  entry("delete_milestone", "deleteMilestone", "DELETE", "milestones", false, true),
+  // Status & checks
+  entry("create_commit_status", "createCommitStatus", "POST", "status_checks", true, true),
+  entry("get_combined_status_for_ref", "getCombinedStatusForRef", "GET", "status_checks", true, true),
+  entry("create_check_run", "createCheckRun", "POST", "status_checks", true, true),
+  entry("list_check_runs_for_ref", "listCheckRunsForRef", "GET", "status_checks", true, true),
+  // Tags & releases
+  entry("list_tags", "listTags", "GET", "tags_releases", true, true),
+  entry("list_releases", "listReleases", "GET", "tags_releases", true, true),
+  entry("get_latest_release", "getLatestRelease", "GET", "tags_releases", true, true),
+  entry("create_release", "createRelease", "POST", "tags_releases", false, true),
+  // Labels
+  entry("create_label", "createLabel", "POST", "labels", false),
+  entry("add_issue_labels", "addIssueLabels", "POST", "labels", false),
+  entry("remove_issue_label", "removeIssueLabel", "DELETE", "labels", false),
+  // Collaborators & identity
+  entry("list_collaborators", "listCollaborators", "GET", "collaborators", true),
+  entry("get_me", "getMe", "GET", "collaborators", true, true),
+  entry("add_collaborator", "addCollaborator", "PUT", "collaborators", false, true)
+];
+function groupGitHubAccessControlByCategory(endpoints = ENDPOINTS) {
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const category of GITHUB_ACCESS_CONTROL_CATEGORY_ORDER) {
+    byCategory.set(category, []);
+  }
+  for (const endpoint of endpoints) {
+    byCategory.get(endpoint.category).push(endpoint);
+  }
+  return GITHUB_ACCESS_CONTROL_CATEGORY_ORDER.map((category) => ({
+    category,
+    label: GITHUB_ACCESS_CONTROL_CATEGORY_LABELS[category],
+    endpoints: byCategory.get(category)
+  })).filter((group) => group.endpoints.length > 0);
+}
+var GITHUB_ACCESS_CONTROL_CATALOG = {
+  version: 2,
+  twin: "github",
+  endpoints: ENDPOINTS,
+  categories: groupGitHubAccessControlByCategory(ENDPOINTS)
+};
+function summarizeGitHubAccessControlCatalog(catalog = GITHUB_ACCESS_CONTROL_CATALOG, allowedOverrides) {
+  let allowed = 0;
+  let denied = 0;
+  for (const endpoint of catalog.endpoints) {
+    const isAllowed = endpoint.default_allowed;
+    if (isAllowed)
+      allowed += 1;
+    else
+      denied += 1;
+  }
+  return { total: catalog.endpoints.length, allowed, denied };
+}
+function githubAccessControlToolNames(catalog = GITHUB_ACCESS_CONTROL_CATALOG) {
+  return catalog.endpoints.map((endpoint) => endpoint.tool);
+}
+function assertAccessControlCatalogMatchesTools() {
+  const toolNames = new Set(toolDefinitions.map((tool) => tool.name));
+  const missing = githubAccessControlToolNames().filter((name) => !toolNames.has(name));
+  if (missing.length > 0) {
+    throw new Error(`access-control catalog references unknown tools: ${missing.join(", ")}`);
+  }
+}
+function githubAccessControlPayload() {
+  assertAccessControlCatalogMatchesTools();
+  return {
+    ...GITHUB_ACCESS_CONTROL_CATALOG,
+    summary: summarizeGitHubAccessControlCatalog()
+  };
+}
+
+// ../packages/twin-github/dist/src/db.js
+var MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS users (
+  login TEXT PRIMARY KEY,
+  type TEXT NOT NULL DEFAULT 'User',
+  name TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS repositories (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  owner TEXT NOT NULL,
+  name TEXT NOT NULL,
+  full_name TEXT NOT NULL UNIQUE,
+  description TEXT NOT NULL DEFAULT '',
+  private INTEGER NOT NULL DEFAULT 0,
+  default_branch TEXT NOT NULL DEFAULT 'main',
+  fork INTEGER NOT NULL DEFAULT 0,
+  parent_full_name TEXT,
+  entity_counter INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS collaborators (
+  repo_id INTEGER NOT NULL,
+  login TEXT NOT NULL,
+  permission TEXT NOT NULL DEFAULT 'push',
+  PRIMARY KEY (repo_id, login),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS branches (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  head_sha TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (repo_id, name),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS commits (
+  sha TEXT PRIMARY KEY,
+  repo_id INTEGER NOT NULL,
+  message TEXT NOT NULL,
+  author_login TEXT NOT NULL,
+  committer_login TEXT NOT NULL,
+  parent_sha TEXT,
+  tree_sha TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS files (
+  repo_id INTEGER NOT NULL,
+  branch TEXT NOT NULL,
+  path TEXT NOT NULL,
+  content TEXT NOT NULL,
+  sha TEXT NOT NULL,
+  size INTEGER NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (repo_id, branch, path),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS file_versions (
+  commit_sha TEXT NOT NULL,
+  repo_id INTEGER NOT NULL,
+  path TEXT NOT NULL,
+  content TEXT NOT NULL,
+  sha TEXT NOT NULL,
+  status TEXT NOT NULL,
+  PRIMARY KEY (commit_sha, path),
+  FOREIGN KEY (commit_sha) REFERENCES commits(sha) ON DELETE CASCADE,
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS labels (
+  repo_id INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  color TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (repo_id, name),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS milestones (
+  repo_id INTEGER NOT NULL,
+  number INTEGER NOT NULL,
+  title TEXT NOT NULL,
+  state TEXT NOT NULL DEFAULT 'open',
+  description TEXT NOT NULL DEFAULT '',
+  due_on TEXT,
+  creator_login TEXT NOT NULL DEFAULT 'pome-agent',
+  created_at TEXT NOT NULL DEFAULT '',
+  updated_at TEXT NOT NULL DEFAULT '',
+  closed_at TEXT,
+  PRIMARY KEY (repo_id, number),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  repo_id INTEGER NOT NULL,
+  name TEXT NOT NULL,
+  commit_sha TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (repo_id, name),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS releases (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  tag_name TEXT NOT NULL,
+  target_commitish TEXT NOT NULL DEFAULT 'main',
+  name TEXT,
+  body TEXT NOT NULL DEFAULT '',
+  draft INTEGER NOT NULL DEFAULT 0,
+  prerelease INTEGER NOT NULL DEFAULT 0,
+  author_login TEXT NOT NULL DEFAULT 'pome-agent',
+  created_at TEXT NOT NULL,
+  published_at TEXT,
+  UNIQUE (repo_id, tag_name),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS check_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  head_sha TEXT NOT NULL,
+  name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'queued',
+  conclusion TEXT,
+  details_url TEXT NOT NULL DEFAULT '',
+  external_id TEXT NOT NULL DEFAULT '',
+  output_title TEXT,
+  output_summary TEXT,
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS issues (
+  repo_id INTEGER NOT NULL,
+  number INTEGER NOT NULL,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  state TEXT NOT NULL DEFAULT 'open',
+  user_login TEXT NOT NULL DEFAULT 'pome-agent',
+  assignee_login TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  closed_at TEXT,
+  PRIMARY KEY (repo_id, number),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS issue_assignees (
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  login TEXT NOT NULL,
+  PRIMARY KEY (repo_id, issue_number, login),
+  FOREIGN KEY (repo_id, issue_number) REFERENCES issues(repo_id, number) ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS issue_labels (
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  label_name TEXT NOT NULL,
+  PRIMARY KEY (repo_id, issue_number, label_name),
+  FOREIGN KEY (repo_id, issue_number) REFERENCES issues(repo_id, number) ON UPDATE CASCADE ON DELETE CASCADE,
+  FOREIGN KEY (repo_id, label_name) REFERENCES labels(repo_id, name) ON DELETE CASCADE
+);
+
+-- issue_number names an issue OR a pull request, so no FK to issues \u2014 see
+-- ensureCommentsAllowPullRequests below (F-1151).
+CREATE TABLE IF NOT EXISTS issue_comments (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  body TEXT NOT NULL,
+  user_login TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS pull_requests (
+  repo_id INTEGER NOT NULL,
+  number INTEGER NOT NULL,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  state TEXT NOT NULL DEFAULT 'open',
+  user_login TEXT NOT NULL DEFAULT 'pome-agent',
+  head_repo_id INTEGER NOT NULL,
+  head_ref TEXT NOT NULL,
+  head_sha TEXT,
+  base_repo_id INTEGER NOT NULL,
+  base_ref TEXT NOT NULL,
+  base_sha TEXT,
+  merged INTEGER NOT NULL DEFAULT 0,
+  merge_commit_sha TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  closed_at TEXT,
+  merged_at TEXT,
+  PRIMARY KEY (repo_id, number),
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE,
+  FOREIGN KEY (head_repo_id) REFERENCES repositories(id) ON DELETE CASCADE,
+  FOREIGN KEY (base_repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS pull_request_files (
+  repo_id INTEGER NOT NULL,
+  pull_number INTEGER NOT NULL,
+  filename TEXT NOT NULL,
+  status TEXT NOT NULL,
+  additions INTEGER NOT NULL DEFAULT 0,
+  deletions INTEGER NOT NULL DEFAULT 0,
+  changes INTEGER NOT NULL DEFAULT 0,
+  blob_url TEXT NOT NULL DEFAULT '',
+  raw_url TEXT NOT NULL DEFAULT '',
+  contents_url TEXT NOT NULL DEFAULT '',
+  patch TEXT NOT NULL DEFAULT '',
+  PRIMARY KEY (repo_id, pull_number, filename),
+  FOREIGN KEY (repo_id, pull_number) REFERENCES pull_requests(repo_id, number) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS pull_request_reviews (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  pull_number INTEGER NOT NULL,
+  user_login TEXT NOT NULL,
+  state TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  commit_sha TEXT,
+  submitted_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id, pull_number) REFERENCES pull_requests(repo_id, number) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS pull_request_review_comments (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  pull_number INTEGER NOT NULL,
+  path TEXT NOT NULL,
+  body TEXT NOT NULL,
+  user_login TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id, pull_number) REFERENCES pull_requests(repo_id, number) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS commit_statuses (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  sha TEXT NOT NULL,
+  state TEXT NOT NULL,
+  context TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  target_url TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS audit_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts TEXT NOT NULL,
+  action TEXT NOT NULL,
+  repo_full_name TEXT,
+  payload_json TEXT NOT NULL
+);
+`;
+var RESET_SQL = `
+DELETE FROM audit_log;
+DELETE FROM check_runs;
+DELETE FROM commit_statuses;
+DELETE FROM pull_request_review_comments;
+DELETE FROM pull_request_reviews;
+DELETE FROM pull_request_files;
+DELETE FROM pull_requests;
+DELETE FROM releases;
+DELETE FROM tags;
+DELETE FROM issue_comments;
+DELETE FROM issue_labels;
+DELETE FROM issue_assignees;
+DELETE FROM issues;
+DELETE FROM milestones;
+DELETE FROM labels;
+DELETE FROM file_versions;
+DELETE FROM files;
+DELETE FROM commits;
+DELETE FROM branches;
+DELETE FROM collaborators;
+DELETE FROM repositories;
+DELETE FROM users;
+`;
+function openGitHubCloneDatabase(path = process.env.GITHUB_CLONE_DB ?? ":memory:") {
+  return openTwinDatabase(path, { migrate });
+}
+function migrate(db) {
+  db.exec(MIGRATION_SQL);
+  ensureColumn(db, "repositories", "entity_counter", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "pull_requests", "head_sha", "TEXT");
+  ensureColumn(db, "pull_requests", "base_sha", "TEXT");
+  ensureColumn(db, "milestones", "description", "TEXT NOT NULL DEFAULT ''");
+  ensureColumn(db, "milestones", "due_on", "TEXT");
+  ensureColumn(db, "milestones", "creator_login", "TEXT NOT NULL DEFAULT 'pome-agent'");
+  ensureColumn(db, "milestones", "created_at", "TEXT NOT NULL DEFAULT ''");
+  ensureColumn(db, "milestones", "updated_at", "TEXT NOT NULL DEFAULT ''");
+  ensureColumn(db, "milestones", "closed_at", "TEXT");
+  ensureColumn(db, "pull_request_review_comments", "line", "INTEGER");
+  ensureColumn(db, "pull_request_review_comments", "side", "TEXT");
+  ensureColumn(db, "pull_request_review_comments", "commit_sha", "TEXT");
+  ensureColumn(db, "pull_request_review_comments", "in_reply_to_id", "INTEGER");
+  ensureColumn(db, "collaborators", "invitation_state", "TEXT NOT NULL DEFAULT 'accepted'");
+  ensureIssueNumberCascade(db);
+  ensureCommentsAllowPullRequests(db);
+  hydrateDerivedColumns(db);
+}
+function resetDatabase(db) {
+  db.exec(RESET_SQL);
+}
+function ensureColumn(db, table, column, definition) {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((row) => row.name === column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  }
+}
+function ensureIssueNumberCascade(db) {
+  const tables = ["issue_assignees", "issue_labels"];
+  const needsRebuild = tables.some((table) => {
+    const foreignKeys = db.prepare(`PRAGMA foreign_key_list(${table})`).all();
+    return foreignKeys.some((key) => key.table === "issues" && key.on_update !== "CASCADE");
+  });
+  if (!needsRebuild)
+    return;
+  db.pragma("foreign_keys = OFF");
+  db.exec(`
+ALTER TABLE issue_assignees RENAME TO issue_assignees_old;
+CREATE TABLE issue_assignees (
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  login TEXT NOT NULL,
+  PRIMARY KEY (repo_id, issue_number, login),
+  FOREIGN KEY (repo_id, issue_number) REFERENCES issues(repo_id, number) ON UPDATE CASCADE ON DELETE CASCADE
+);
+INSERT INTO issue_assignees (repo_id, issue_number, login)
+  SELECT repo_id, issue_number, login FROM issue_assignees_old;
+DROP TABLE issue_assignees_old;
+
+ALTER TABLE issue_labels RENAME TO issue_labels_old;
+CREATE TABLE issue_labels (
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  label_name TEXT NOT NULL,
+  PRIMARY KEY (repo_id, issue_number, label_name),
+  FOREIGN KEY (repo_id, issue_number) REFERENCES issues(repo_id, number) ON UPDATE CASCADE ON DELETE CASCADE,
+  FOREIGN KEY (repo_id, label_name) REFERENCES labels(repo_id, name) ON DELETE CASCADE
+);
+INSERT INTO issue_labels (repo_id, issue_number, label_name)
+  SELECT repo_id, issue_number, label_name FROM issue_labels_old;
+DROP TABLE issue_labels_old;
+`);
+  db.pragma("foreign_keys = ON");
+}
+function ensureCommentsAllowPullRequests(db) {
+  const foreignKeys = db.prepare("PRAGMA foreign_key_list(issue_comments)").all();
+  if (!foreignKeys.some((key) => key.table === "issues"))
+    return;
+  db.pragma("foreign_keys = OFF");
+  db.exec(`
+ALTER TABLE issue_comments RENAME TO issue_comments_old;
+CREATE TABLE issue_comments (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  repo_id INTEGER NOT NULL,
+  issue_number INTEGER NOT NULL,
+  body TEXT NOT NULL,
+  user_login TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (repo_id) REFERENCES repositories(id) ON DELETE CASCADE
+);
+INSERT INTO issue_comments (id, repo_id, issue_number, body, user_login, created_at, updated_at)
+  SELECT id, repo_id, issue_number, body, user_login, created_at, updated_at FROM issue_comments_old;
+DROP TABLE issue_comments_old;
+`);
+  db.pragma("foreign_keys = ON");
+}
+function hydrateDerivedColumns(db) {
+  db.exec(`
+UPDATE repositories
+SET entity_counter = MAX(
+  entity_counter,
+  COALESCE((SELECT MAX(number) FROM issues WHERE issues.repo_id = repositories.id), 0),
+  COALESCE((SELECT MAX(number) FROM pull_requests WHERE pull_requests.repo_id = repositories.id), 0)
+);
+
+UPDATE pull_requests
+SET
+  head_sha = COALESCE(head_sha, (SELECT head_sha FROM branches WHERE branches.repo_id = pull_requests.head_repo_id AND branches.name = pull_requests.head_ref)),
+  base_sha = COALESCE(base_sha, (SELECT head_sha FROM branches WHERE branches.repo_id = pull_requests.base_repo_id AND branches.name = pull_requests.base_ref));
+`);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function stableNumericId(input) {
+  let hash = 0;
+  for (const char of input) {
+    hash = hash * 31 + char.charCodeAt(0) >>> 0;
+  }
+  return hash;
+}
+function makeSha(...parts) {
+  return createHash("sha1").update(JSON.stringify(parts)).update(randomUUID()).digest("hex");
+}
+function fileSha(content) {
+  return createHash("sha1").update(`blob ${Buffer.byteLength(content)}\0${content}`).digest("hex");
+}
+function treeSha(paths) {
+  return createHash("sha1").update(paths.sort().join("\n")).digest("hex");
+}
+function encodeContent(content) {
+  return Buffer.from(content, "utf8").toString("base64");
+}
+function paginate(items, page = 1, perPage = 30) {
+  const safePage = Math.max(1, page);
+  const safePerPage = Math.min(100, Math.max(1, perPage));
+  const start = (safePage - 1) * safePerPage;
+  return items.slice(start, start + safePerPage);
+}
+function linesChanged(before, after) {
+  if (before === void 0) {
+    return { additions: after.split("\n").filter(Boolean).length || 1, deletions: 0 };
+  }
+  const oldLines = before.split("\n");
+  const newLines = after.split("\n");
+  let additions = 0;
+  let deletions = 0;
+  const max = Math.max(oldLines.length, newLines.length);
+  for (let index = 0; index < max; index += 1) {
+    if (oldLines[index] === newLines[index])
+      continue;
+    if (newLines[index] !== void 0)
+      additions += 1;
+    if (oldLines[index] !== void 0)
+      deletions += 1;
+  }
+  return { additions, deletions };
+}
+var seedSchema = z.object({
+  users: z.array(z.object({
+    login: z.string().min(1),
+    type: z.enum(["User", "Organization"]).default("User"),
+    name: z.string().default("")
+  })).default([]),
+  repositories: z.array(z.object({
+    owner: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().default(""),
+    private: z.boolean().default(false),
+    default_branch: z.string().min(1).default("main"),
+    collaborators: z.array(z.string().min(1)).default([]),
+    labels: z.array(z.object({
+      name: z.string().min(1),
+      color: z.string().default("ededed"),
+      description: z.string().default("")
+    })).default([]),
+    files: z.array(z.object({ path: z.string().min(1), content: z.string(), branch: z.string().optional() })).default([]),
+    issues: z.array(z.object({
+      number: z.number().int().positive().optional(),
+      title: z.string().min(1),
+      body: z.string().default(""),
+      state: z.enum(["open", "closed"]).default("open"),
+      labels: z.array(z.string().min(1)).default([]),
+      assignees: z.array(z.string().min(1)).default([])
+    })).default([]),
+    pull_requests: z.array(z.object({
+      number: z.number().int().positive().optional(),
+      title: z.string().min(1),
+      body: z.string().default(""),
+      head: z.string().min(1),
+      base: z.string().min(1).default("main"),
+      state: z.enum(["open", "closed"]).default("open"),
+      author: z.string().min(1).optional(),
+      // Reviews seeded on this PR. `state` mirrors GitHub's review
+      // state enum; `author` must exist in the user/collaborator set.
+      reviews: z.array(z.object({
+        author: z.string().min(1),
+        state: z.enum(["APPROVED", "CHANGES_REQUESTED", "COMMENTED"]).default("APPROVED"),
+        body: z.string().default("")
+      })).default([]),
+      // Commit statuses applied to this PR's head SHA. Wired into the
+      // commit_statuses table so get_pull_request_status and the merge
+      // path see them without needing a separate setup call.
+      statuses: z.array(z.object({
+        context: z.string().min(1).default("ci/build"),
+        state: z.enum(["error", "failure", "pending", "success"]).default("success"),
+        description: z.string().default("")
+      })).default([])
+    })).default([])
+  }))
+});
+function parseSeed(input) {
+  const seed = seedSchema.parse(normalizeLegacyGitHubSeed(input));
+  if (seed.repositories.length === 0) {
+    throw new Error("GitHub seed must contain at least one repository");
+  }
+  return seed;
+}
+function normalizeLegacyGitHubSeed(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return input;
+  const seed = input;
+  if (!Array.isArray(seed.repositories))
+    return input;
+  return {
+    ...seed,
+    repositories: seed.repositories.map((repo) => {
+      if (!repo || typeof repo !== "object" || Array.isArray(repo))
+        return repo;
+      const record = repo;
+      if (!Array.isArray(record.issues))
+        return repo;
+      return {
+        ...record,
+        issues: record.issues.map((issue) => normalizeLegacyIssueAssignee(issue))
+      };
+    })
+  };
+}
+function normalizeLegacyIssueAssignee(issue) {
+  if (!issue || typeof issue !== "object" || Array.isArray(issue))
+    return issue;
+  const record = issue;
+  if (!("assignee" in record) || "assignees" in record)
+    return issue;
+  const { assignee, ...rest } = record;
+  if (assignee === null || assignee === void 0 || assignee === "") {
+    return { ...rest, assignees: [] };
+  }
+  if (typeof assignee === "string") {
+    return { ...rest, assignees: [assignee] };
+  }
+  return issue;
+}
+function defaultSeedState() {
+  return {
+    users: [
+      { login: "acme", type: "Organization", name: "Acme" },
+      { login: "alice", type: "User", name: "Alice" },
+      { login: "bob", type: "User", name: "Bob" },
+      { login: "pome-agent", type: "User", name: "Pome Agent" }
+    ],
+    repositories: [
+      {
+        owner: "acme",
+        name: "api",
+        description: "Example API service used by GitHub twin tests.",
+        default_branch: "main",
+        collaborators: ["alice", "bob", "pome-agent"],
+        labels: [
+          { name: "bug", color: "d73a4a", description: "Something is not working" },
+          { name: "feature", color: "a2eeef", description: "New feature or request" },
+          { name: "question", color: "d876e3", description: "More information needed" }
+        ],
+        files: [
+          { path: "README.md", content: "# Acme API\n\nA seeded repository for local GitHub twin tests.\n" },
+          { path: "src/index.ts", content: "export function handler() {\n  return 'ok';\n}\n" }
+        ],
+        issues: [
+          {
+            number: 1,
+            title: "500 error on POST /orders after deploy",
+            body: "Started failing right after the 14:00 deploy. Stack trace points to OrderController#create.",
+            labels: ["bug"],
+            assignees: []
+          }
+        ]
+      }
+    ]
+  };
+}
+
+// ../packages/twin-github/dist/src/serializers.js
+function repoState(repo) {
+  return {
+    owner: repo.owner,
+    name: repo.name,
+    full_name: repo.full_name,
+    description: repo.description,
+    private: Boolean(repo.private),
+    default_branch: repo.default_branch,
+    fork: Boolean(repo.fork),
+    parent_full_name: repo.parent_full_name,
+    created_at: repo.created_at,
+    updated_at: repo.updated_at
+  };
+}
+function branchState(branch, repo) {
+  return {
+    repo: repo.full_name,
+    name: branch.name,
+    head_sha: branch.head_sha,
+    created_at: branch.created_at,
+    updated_at: branch.updated_at
+  };
+}
+function fileState(file, repo) {
+  return {
+    repo: repo.full_name,
+    branch: file.branch,
+    path: file.path,
+    content: file.content,
+    sha: file.sha,
+    size: file.size,
+    updated_at: file.updated_at
+  };
+}
+function issueState(issue, repo, labels, assignees) {
+  return {
+    repo: repo.full_name,
+    number: issue.number,
+    title: issue.title,
+    body: issue.body,
+    state: issue.state,
+    user_login: issue.user_login,
+    assignee_login: issue.assignee_login,
+    labels,
+    assignees,
+    created_at: issue.created_at,
+    updated_at: issue.updated_at,
+    closed_at: issue.closed_at
+  };
+}
+function issueCommentState(comment, repo) {
+  return {
+    repo: repo.full_name,
+    id: comment.id,
+    issue_number: comment.issue_number,
+    body: comment.body,
+    user_login: comment.user_login,
+    created_at: comment.created_at,
+    updated_at: comment.updated_at
+  };
+}
+function labelState(label, repo) {
+  return {
+    repo: repo.full_name,
+    name: label.name,
+    color: label.color,
+    description: label.description
+  };
+}
+function issueLabelsState(repo, issueNumber2, labels) {
+  return { repo: repo.full_name, issue_number: issueNumber2, labels };
+}
+function issueAssigneesState(repo, issueNumber2, assignees) {
+  return { repo: repo.full_name, issue_number: issueNumber2, assignees };
+}
+function pullRequestState(pr, repo) {
+  return {
+    repo: repo.full_name,
+    number: pr.number,
+    title: pr.title,
+    body: pr.body,
+    state: pr.state,
+    user_login: pr.user_login,
+    head_ref: pr.head_ref,
+    head_sha: pr.head_sha,
+    base_ref: pr.base_ref,
+    base_sha: pr.base_sha,
+    merged: Boolean(pr.merged),
+    merge_commit_sha: pr.merge_commit_sha,
+    created_at: pr.created_at,
+    updated_at: pr.updated_at,
+    closed_at: pr.closed_at,
+    merged_at: pr.merged_at
+  };
+}
+function pullRequestReviewState(review, repo) {
+  return {
+    repo: repo.full_name,
+    pull_number: review.pull_number,
+    id: review.id,
+    user_login: review.user_login,
+    state: review.state,
+    body: review.body,
+    commit_sha: review.commit_sha,
+    submitted_at: review.submitted_at
+  };
+}
+function userJson(login, type = "User") {
+  return {
+    login,
+    id: stableNumericId(login),
+    node_id: `U_${stableNumericId(login)}`,
+    avatar_url: `https://avatars.githubusercontent.com/u/${stableNumericId(login)}?v=4`,
+    html_url: `https://github.com/${login}`,
+    type,
+    site_admin: false
+  };
+}
+function repoJson(repo) {
+  const parentRef = repo.parent_full_name ? { parent: { full_name: repo.parent_full_name } } : {};
+  return {
+    id: repo.id,
+    node_id: `R_${repo.id}`,
+    name: repo.name,
+    full_name: repo.full_name,
+    owner: userJson(repo.owner, "Organization"),
+    private: Boolean(repo.private),
+    html_url: `https://github.com/${repo.full_name}`,
+    description: repo.description,
+    fork: Boolean(repo.fork),
+    url: `https://api.github.com/repos/${repo.full_name}`,
+    contents_url: `https://api.github.com/repos/${repo.full_name}/contents/{+path}`,
+    issues_url: `https://api.github.com/repos/${repo.full_name}/issues{/number}`,
+    pulls_url: `https://api.github.com/repos/${repo.full_name}/pulls{/number}`,
+    default_branch: repo.default_branch,
+    created_at: repo.created_at,
+    updated_at: repo.updated_at,
+    pushed_at: repo.updated_at,
+    ...parentRef
+  };
+}
+function branchJson(branch, repo) {
+  return {
+    name: branch.name,
+    commit: {
+      // Upstream `short-branch.commit.sha` is a non-null string; the twin emits
+      // an empty string (rather than null) when head_sha is unresolved.
+      sha: branch.head_sha ?? "",
+      // Upstream `commit.url` is a required non-null string; the twin surfaces
+      // null in the pre-resolution state (no commit seeded yet). Intentional
+      // twin behavior — narrow the null away for the type anchor only
+      // (FDRS-454: a faithful twin may surface a pre-resolution null), runtime
+      // value unchanged.
+      url: branch.head_sha ? `https://api.github.com/repos/${repo.full_name}/commits/${branch.head_sha}` : null
+    },
+    protected: false
+  };
+}
+function commitJson(commit, repo) {
+  return {
+    sha: commit.sha,
+    node_id: `C_${commit.sha}`,
+    commit: {
+      author: {
+        name: commit.author_login,
+        email: `${commit.author_login}@example.local`,
+        date: commit.created_at
+      },
+      committer: {
+        name: commit.committer_login,
+        email: `${commit.committer_login}@example.local`,
+        date: commit.created_at
+      },
+      message: commit.message,
+      tree: {
+        sha: commit.tree_sha,
+        url: `https://api.github.com/repos/${repo.full_name}/git/trees/${commit.tree_sha}`
+      },
+      url: `https://api.github.com/repos/${repo.full_name}/git/commits/${commit.sha}`
+    },
+    url: `https://api.github.com/repos/${repo.full_name}/commits/${commit.sha}`,
+    html_url: `https://github.com/${repo.full_name}/commit/${commit.sha}`,
+    author: userJson(commit.author_login),
+    committer: userJson(commit.committer_login),
+    parents: commit.parent_sha ? [{ sha: commit.parent_sha, url: `https://api.github.com/repos/${repo.full_name}/commits/${commit.parent_sha}` }] : [],
+    comments_url: `https://api.github.com/repos/${repo.full_name}/commits/${commit.sha}/comments`
+  };
+}
+function contentFileJson(file, repo) {
+  return {
+    type: "file",
+    encoding: "base64",
+    size: file.size,
+    name: file.path.split("/").at(-1) ?? file.path,
+    path: file.path,
+    content: encodeContent(file.content),
+    sha: file.sha,
+    url: `https://api.github.com/repos/${repo.full_name}/contents/${file.path}`,
+    git_url: `https://api.github.com/repos/${repo.full_name}/git/blobs/${file.sha}`,
+    html_url: `https://github.com/${repo.full_name}/blob/${file.branch}/${file.path}`,
+    download_url: `https://raw.githubusercontent.com/${repo.full_name}/${file.branch}/${file.path}`,
+    _links: {
+      git: file.sha ? `https://api.github.com/repos/${repo.full_name}/git/blobs/${file.sha}` : null,
+      html: `https://github.com/${repo.full_name}/blob/${file.branch}/${file.path}`,
+      self: `https://api.github.com/repos/${repo.full_name}/contents/${file.path}`
+    }
+  };
+}
+function contentDirectoryEntryJson(path, repo, branch, file) {
+  const name = path.split("/").filter(Boolean).at(-1) ?? path;
+  const isFile = Boolean(file);
+  return {
+    type: isFile ? "file" : "dir",
+    size: file?.size ?? 0,
+    name,
+    path,
+    sha: file?.sha ?? `dir_${stableNumericId(`${repo.full_name}:${branch}:${path}`)}`,
+    url: `https://api.github.com/repos/${repo.full_name}/contents/${path}`,
+    // `git_url` is a hypermedia link relation (key ends in `_url`). On a directory
+    // entry the twin has no git blob to point at; rather than emit `git_url: null`
+    // (a string→null type-changed against real GitHub's blob URL on files), omit the
+    // key entirely on directories so the field-removed direction is covered by the
+    // categorical hypermedia exemption (FDRS-451) — a faithful twin returning a
+    // SUBSET of GitHub's link relations, not drift (FDRS-454).
+    ...isFile ? { git_url: `https://api.github.com/repos/${repo.full_name}/git/blobs/${file.sha}` } : {},
+    html_url: `https://github.com/${repo.full_name}/${isFile ? "blob" : "tree"}/${branch}/${path}`,
+    download_url: isFile ? `https://raw.githubusercontent.com/${repo.full_name}/${branch}/${path}` : null
+    // `_links` is intentionally omitted — the categorical hypermedia subset
+    // exemption (FDRS-451); DeepPartial makes it optional so omission is legal.
+    // The upstream `content-directory` schema is an ARRAY of entries; this
+    // serializer emits one entry, so it anchors against the element type.
+  };
+}
+function labelJson(label) {
+  return {
+    id: stableNumericId(label.name),
+    node_id: `LA_${stableNumericId(label.name)}`,
+    url: `https://api.github.com/labels/${encodeURIComponent(label.name)}`,
+    name: label.name,
+    color: label.color,
+    default: false,
+    description: label.description
+  };
+}
+function issueJson(issue, repo, labels = [], assignees = [], comments = 0) {
+  return {
+    id: stableNumericId(`${repo.full_name}#${issue.number}`),
+    node_id: `I_${stableNumericId(`${repo.full_name}#${issue.number}`)}`,
+    number: issue.number,
+    title: issue.title,
+    body: issue.body,
+    state: issue.state,
+    locked: false,
+    user: userJson(issue.user_login),
+    labels: labels.map(labelJson),
+    assignee: issue.assignee_login ? userJson(issue.assignee_login) : null,
+    assignees: assignees.map((login) => userJson(login)),
+    comments,
+    html_url: `https://github.com/${repo.full_name}/issues/${issue.number}`,
+    repository_url: `https://api.github.com/repos/${repo.full_name}`,
+    labels_url: `https://api.github.com/repos/${repo.full_name}/issues/${issue.number}/labels{/name}`,
+    comments_url: `https://api.github.com/repos/${repo.full_name}/issues/${issue.number}/comments`,
+    created_at: issue.created_at,
+    updated_at: issue.updated_at,
+    closed_at: issue.closed_at
+  };
+}
+function issueCommentJson(comment, repo, target = "issue") {
+  return {
+    id: comment.id,
+    node_id: `IC_${comment.id}`,
+    body: comment.body,
+    user: userJson(comment.user_login),
+    html_url: `https://github.com/${repo.full_name}/${target === "pull_request" ? "pull" : "issues"}/${comment.issue_number}#issuecomment-${comment.id}`,
+    issue_url: `https://api.github.com/repos/${repo.full_name}/issues/${comment.issue_number}`,
+    created_at: comment.created_at,
+    updated_at: comment.updated_at
+  };
+}
+function pullRequestSimpleJson(pr, baseRepo, headRepo, headSha = null, baseSha = null) {
+  return {
+    id: stableNumericId(`${baseRepo.full_name}/pull/${pr.number}`),
+    node_id: `PR_${stableNumericId(`${baseRepo.full_name}/pull/${pr.number}`)}`,
+    number: pr.number,
+    state: pr.state,
+    locked: false,
+    title: pr.title,
+    body: pr.body,
+    user: userJson(pr.user_login),
+    html_url: `https://github.com/${baseRepo.full_name}/pull/${pr.number}`,
+    url: `https://api.github.com/repos/${baseRepo.full_name}/pulls/${pr.number}`,
+    issue_url: `https://api.github.com/repos/${baseRepo.full_name}/issues/${pr.number}`,
+    commits_url: `https://api.github.com/repos/${baseRepo.full_name}/pulls/${pr.number}/commits`,
+    review_comments_url: `https://api.github.com/repos/${baseRepo.full_name}/pulls/${pr.number}/comments`,
+    review_comment_url: `https://api.github.com/repos/${baseRepo.full_name}/pulls/comments{/number}`,
+    comments_url: `https://api.github.com/repos/${baseRepo.full_name}/issues/${pr.number}/comments`,
+    statuses_url: `https://api.github.com/repos/${headRepo.full_name}/statuses/{sha}`,
+    head: {
+      label: `${headRepo.owner}:${pr.head_ref}`,
+      ref: pr.head_ref,
+      // Upstream merge-base `sha` is a non-null string; the twin emits null when
+      // the head SHA is unresolved (no commits seeded yet). Intentional twin
+      // behavior — narrow the null away for the type anchor only (FDRS-454:
+      // faithful twin may surface a pre-resolution null), runtime value unchanged.
+      sha: headSha,
+      repo: repoJson(headRepo),
+      user: userJson(headRepo.owner, "Organization")
+    },
+    base: {
+      label: `${baseRepo.owner}:${pr.base_ref}`,
+      ref: pr.base_ref,
+      // See head.sha note above — same pre-resolution null exemption.
+      sha: baseSha,
+      repo: repoJson(baseRepo),
+      user: userJson(baseRepo.owner, "Organization")
+    },
+    merge_commit_sha: pr.merge_commit_sha,
+    draft: false,
+    created_at: pr.created_at,
+    updated_at: pr.updated_at,
+    closed_at: pr.closed_at,
+    merged_at: pr.merged_at
+  };
+}
+function pullRequestListJson(pr, baseRepo, headRepo, headSha = null, baseSha = null) {
+  return pullRequestSimpleJson(pr, baseRepo, headRepo, headSha, baseSha);
+}
+function pullRequestJson(pr, baseRepo, headRepo, commits = 1, changedFiles = 0, headSha = null, baseSha = null) {
+  const simple = pullRequestSimpleJson(pr, baseRepo, headRepo, headSha, baseSha);
+  return {
+    ...simple,
+    merged: Boolean(pr.merged),
+    commits,
+    additions: 0,
+    deletions: 0,
+    changed_files: changedFiles
+  };
+}
+function pullRequestFileJson(file) {
+  return {
+    sha: `file_${stableNumericId(file.filename)}`,
+    filename: file.filename,
+    status: file.status,
+    additions: file.additions,
+    deletions: file.deletions,
+    changes: file.changes,
+    blob_url: file.blob_url,
+    raw_url: file.raw_url,
+    contents_url: file.contents_url,
+    patch: file.patch
+  };
+}
+function reviewJson(review, repo) {
+  return {
+    id: review.id,
+    node_id: `PRR_${review.id}`,
+    user: userJson(review.user_login),
+    body: review.body,
+    state: review.state,
+    html_url: `https://github.com/${repo.full_name}/pull/${review.pull_number}#pullrequestreview-${review.id}`,
+    pull_request_url: `https://api.github.com/repos/${repo.full_name}/pulls/${review.pull_number}`,
+    commit_id: review.commit_sha,
+    submitted_at: review.submitted_at
+  };
+}
+function statusJson(status, repo) {
+  return {
+    id: status.id,
+    node_id: `ST_${status.id}`,
+    state: status.state,
+    description: status.description,
+    target_url: status.target_url,
+    context: status.context,
+    created_at: status.created_at,
+    updated_at: status.updated_at,
+    url: `https://api.github.com/repos/${repo.full_name}/statuses/${status.sha}`
+  };
+}
+function combinedStatusJson(repo, sha, statuses) {
+  const state = statuses.length === 0 ? "pending" : statuses.some((status) => status.state === "failure" || status.state === "error") ? "failure" : statuses.some((status) => status.state === "pending") ? "pending" : "success";
+  return {
+    state,
+    sha,
+    total_count: statuses.length,
+    statuses: statuses.map((status) => statusJson(status, repo)),
+    repository: repoJson(repo),
+    commit_url: `https://api.github.com/repos/${repo.full_name}/commits/${sha}`,
+    url: `https://api.github.com/repos/${repo.full_name}/commits/${sha}/status`
+  };
+}
+function milestoneJson(milestone, repo, openIssues = 0, closedIssues = 0) {
+  return {
+    id: stableNumericId(`${repo.full_name}/milestone/${milestone.number}`),
+    node_id: `MI_${stableNumericId(`${repo.full_name}/milestone/${milestone.number}`)}`,
+    number: milestone.number,
+    title: milestone.title,
+    description: milestone.description,
+    state: milestone.state,
+    creator: userJson(milestone.creator_login),
+    open_issues: openIssues,
+    closed_issues: closedIssues,
+    due_on: milestone.due_on,
+    created_at: milestone.created_at,
+    updated_at: milestone.updated_at,
+    closed_at: milestone.closed_at,
+    html_url: `https://github.com/${repo.full_name}/milestone/${milestone.number}`,
+    url: `https://api.github.com/repos/${repo.full_name}/milestones/${milestone.number}`,
+    labels_url: `https://api.github.com/repos/${repo.full_name}/milestones/${milestone.number}/labels`
+  };
+}
+function milestoneState(milestone, repo) {
+  return {
+    repo: repo.full_name,
+    number: milestone.number,
+    title: milestone.title,
+    description: milestone.description,
+    state: milestone.state,
+    due_on: milestone.due_on,
+    creator_login: milestone.creator_login,
+    created_at: milestone.created_at,
+    updated_at: milestone.updated_at,
+    closed_at: milestone.closed_at
+  };
+}
+function tagJson(tag, repo) {
+  return {
+    name: tag.name,
+    commit: {
+      sha: tag.commit_sha,
+      url: `https://api.github.com/repos/${repo.full_name}/commits/${tag.commit_sha}`
+    },
+    zipball_url: `https://api.github.com/repos/${repo.full_name}/zipball/refs/tags/${tag.name}`,
+    tarball_url: `https://api.github.com/repos/${repo.full_name}/tarball/refs/tags/${tag.name}`,
+    node_id: `T_${stableNumericId(`${repo.full_name}/tag/${tag.name}`)}`
+  };
+}
+function releaseJson(release, repo) {
+  return {
+    id: release.id,
+    node_id: `RE_${release.id}`,
+    tag_name: release.tag_name,
+    target_commitish: release.target_commitish,
+    name: release.name,
+    body: release.body,
+    draft: Boolean(release.draft),
+    prerelease: Boolean(release.prerelease),
+    author: userJson(release.author_login),
+    created_at: release.created_at,
+    published_at: release.published_at,
+    html_url: `https://github.com/${repo.full_name}/releases/tag/${release.tag_name}`,
+    url: `https://api.github.com/repos/${repo.full_name}/releases/${release.id}`,
+    assets_url: `https://api.github.com/repos/${repo.full_name}/releases/${release.id}/assets`,
+    upload_url: `https://uploads.github.com/repos/${repo.full_name}/releases/${release.id}/assets{?name,label}`,
+    tarball_url: `https://api.github.com/repos/${repo.full_name}/tarball/${release.tag_name}`,
+    zipball_url: `https://api.github.com/repos/${repo.full_name}/zipball/${release.tag_name}`,
+    assets: []
+  };
+}
+function releaseState(release, repo) {
+  return {
+    repo: repo.full_name,
+    id: release.id,
+    tag_name: release.tag_name,
+    target_commitish: release.target_commitish,
+    name: release.name,
+    body: release.body,
+    draft: Boolean(release.draft),
+    prerelease: Boolean(release.prerelease),
+    author_login: release.author_login,
+    created_at: release.created_at,
+    published_at: release.published_at
+  };
+}
+function checkRunJson(run, repo) {
+  return {
+    id: run.id,
+    node_id: `CR_${run.id}`,
+    head_sha: run.head_sha,
+    external_id: run.external_id,
+    url: `https://api.github.com/repos/${repo.full_name}/check-runs/${run.id}`,
+    html_url: `https://github.com/${repo.full_name}/runs/${run.id}`,
+    details_url: run.details_url,
+    status: run.status,
+    // The twin's `conclusion` column carries the full GitHub check-run
+    // conclusion vocabulary including `"stale"`, but the pinned
+    // @octokit/openapi-types version's `check-run.conclusion` enum predates
+    // `"stale"`. The twin faithfully emits a real upstream value; narrow it to
+    // the schema's declared union for the type anchor only (FDRS-454: twin
+    // tracks live GitHub, not a lagging spec snapshot), runtime value unchanged.
+    conclusion: run.conclusion,
+    started_at: run.started_at,
+    completed_at: run.completed_at,
+    output: {
+      title: run.output_title,
+      summary: run.output_summary,
+      text: null,
+      annotations_count: 0,
+      annotations_url: `https://api.github.com/repos/${repo.full_name}/check-runs/${run.id}/annotations`
+    },
+    name: run.name,
+    check_suite: null,
+    app: null,
+    pull_requests: []
+  };
+}
+function checkRunState(run, repo) {
+  return {
+    repo: repo.full_name,
+    id: run.id,
+    head_sha: run.head_sha,
+    name: run.name,
+    status: run.status,
+    conclusion: run.conclusion,
+    details_url: run.details_url,
+    external_id: run.external_id,
+    output_title: run.output_title,
+    output_summary: run.output_summary,
+    started_at: run.started_at,
+    completed_at: run.completed_at
+  };
+}
+function pullRequestReviewCommentJson(comment, repo) {
+  return {
+    id: comment.id,
+    node_id: `PRC_${comment.id}`,
+    pull_request_review_id: null,
+    diff_hunk: "",
+    path: comment.path,
+    // `position` is the one location field the upstream schema declares
+    // nullable (`number | null`); all the sibling line/position fields below
+    // are non-null in the schema. The twin's row column is `number | null`, so
+    // for the non-null schema fields we narrow the row's pre-resolution null
+    // away for the type anchor only (FDRS-454: a faithful twin may surface a
+    // pre-resolution null on a not-yet-positioned comment), runtime unchanged.
+    position: comment.line,
+    original_position: comment.line,
+    // `commit_sha` row column is `string | null`; schema commit ids are
+    // non-null strings (FDRS-454 pre-resolution null narrow).
+    commit_id: comment.commit_sha,
+    original_commit_id: comment.commit_sha,
+    in_reply_to_id: comment.in_reply_to_id,
+    user: userJson(comment.user_login),
+    body: comment.body,
+    side: comment.side ?? "RIGHT",
+    line: comment.line,
+    original_line: comment.line,
+    start_line: null,
+    original_start_line: null,
+    start_side: null,
+    html_url: `https://github.com/${repo.full_name}/pull/${comment.pull_number}#discussion_r${comment.id}`,
+    pull_request_url: `https://api.github.com/repos/${repo.full_name}/pulls/${comment.pull_number}`,
+    url: `https://api.github.com/repos/${repo.full_name}/pulls/comments/${comment.id}`,
+    created_at: comment.created_at,
+    updated_at: comment.updated_at
+  };
+}
+function pullRequestReviewCommentState(comment, repo) {
+  return {
+    repo: repo.full_name,
+    pull_number: comment.pull_number,
+    id: comment.id,
+    path: comment.path,
+    body: comment.body,
+    user_login: comment.user_login,
+    line: comment.line,
+    side: comment.side,
+    commit_sha: comment.commit_sha,
+    in_reply_to_id: comment.in_reply_to_id,
+    created_at: comment.created_at,
+    updated_at: comment.updated_at
+  };
+}
+function commitWithFilesJson(commit, repo, files) {
+  const additions = files.reduce((sum, file) => sum + file.additions, 0);
+  const deletions = files.reduce((sum, file) => sum + file.deletions, 0);
+  return {
+    ...commitJson(commit, repo),
+    stats: { additions, deletions, total: additions + deletions },
+    files: files.map(pullRequestFileJson)
+  };
+}
+function compareCommitsJson(baseRepo, base, head, commits, files, status, aheadBy, behindBy) {
+  return {
+    url: `https://api.github.com/repos/${baseRepo.full_name}/compare/${base.sha}...${head.sha}`,
+    html_url: `https://github.com/${baseRepo.full_name}/compare/${base.sha}...${head.sha}`,
+    permalink_url: `https://github.com/${baseRepo.full_name}/compare/${base.sha.slice(0, 7)}...${head.sha.slice(0, 7)}`,
+    diff_url: `https://github.com/${baseRepo.full_name}/compare/${base.sha}...${head.sha}.diff`,
+    patch_url: `https://github.com/${baseRepo.full_name}/compare/${base.sha}...${head.sha}.patch`,
+    base_commit: commitJson(base, baseRepo),
+    merge_base_commit: commitJson(base, baseRepo),
+    status,
+    ahead_by: aheadBy,
+    behind_by: behindBy,
+    total_commits: commits.length,
+    commits: commits.map((commit) => commitJson(commit, baseRepo)),
+    files: files.map(pullRequestFileJson)
+  };
+}
+function authenticatedUserJson(login) {
+  return {
+    ...userJson(login, "User"),
+    name: login,
+    email: `${login}@example.local`,
+    bio: null,
+    company: null,
+    blog: null,
+    location: null,
+    public_repos: 0,
+    public_gists: 0,
+    followers: 0,
+    following: 0,
+    created_at: "2026-01-01T00:00:00Z",
+    updated_at: "2026-01-01T00:00:00Z"
+  };
+}
+function collaboratorAddState(repo, login, invitation, permission) {
+  return {
+    repo: repo.full_name,
+    login,
+    invitation_state: invitation,
+    permission
+  };
+}
+function pullRequestDiffText(files) {
+  const blocks = files.map((file) => {
+    const header = `diff --git a/${file.filename} b/${file.filename}`;
+    const status = file.status === "added" ? `new file mode 100644
+--- /dev/null
++++ b/${file.filename}` : file.status === "removed" ? `deleted file mode 100644
+--- a/${file.filename}
++++ /dev/null` : `--- a/${file.filename}
++++ b/${file.filename}`;
+    const hunkHeader = `@@ -0,${file.deletions || 0} +0,${file.additions || 0} @@`;
+    return `${header}
+${status}
+${hunkHeader}
+${file.patch || ""}`.trim();
+  });
+  return blocks.join("\n");
+}
+
+// ../packages/twin-github/dist/src/domain/checks.js
+function createStatus(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const now = nowIso();
+  const result = domain.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 domain.db.prepare("SELECT * FROM commit_statuses WHERE id = ?").get(result.lastInsertRowid);
+}
+function createCommitStatus(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const row = domain.transaction(() => {
+    domain.requireCommitOnRepo(repo.id, input.sha);
+    const now = nowIso();
+    const result = domain.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 domain.db.prepare("SELECT * FROM commit_statuses WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.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);
+}
+function getCombinedStatusForRef(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const sha = domain.resolveRefToSha(repo, input.ref);
+  return combinedStatusJson(repo, sha, domain.latestCommitStatuses(repo.id, sha));
+}
+function createCheckRun(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const row = domain.transaction(() => {
+    if (!input.name.trim())
+      validationFailed("name", "missing");
+    domain.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 = domain.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 domain.db.prepare("SELECT * FROM check_runs WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.audit("create_check_run", repo.full_name, input);
+  onDelta?.({ before: null, after: checkRunState(row, repo) });
+  return checkRunJson(row, repo);
+}
+function listCheckRunsForRef(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const sha = domain.resolveRefToSha(repo, input.ref);
+  const rows = domain.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))
+  };
+}
+
+// ../packages/twin-github/dist/src/domain/helpers.js
+function commitIdentityKey(commit) {
+  return [commit.message, commit.author_login, commit.committer_login, commit.tree_sha, commit.created_at].join("");
+}
+function contentLineCount(content) {
+  return Math.max(1, content.replace(/\n$/, "").split("\n").length);
+}
+function normalizePath(path) {
+  const normalized = path.replace(/^\/+/, "").replace(/\/+/g, "/").trim();
+  if (normalized.includes(".."))
+    validationFailed("path", "invalid", path);
+  return normalized;
+}
+
+// ../packages/twin-github/dist/src/domain/git.js
+function getFileContents(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = input.ref ?? repo.default_branch;
+  domain.requireBranch(repo.id, branch);
+  const path = normalizePath(input.path ?? "");
+  const direct = domain.getFile(repo.id, branch, path);
+  if (direct)
+    return contentFileJson(direct, repo);
+  const children = domain.listDirectory(repo, branch, path);
+  if (children.length === 0)
+    notFound("Not Found");
+  return children;
+}
+function listCommits(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = input.sha ?? repo.default_branch;
+  const branchRow = domain.requireBranch(repo.id, branch);
+  const allRows = domain.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));
+}
+function createOrUpdateFile(domain, input, options = {}, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = input.branch ?? repo.default_branch;
+  let before = null;
+  let afterFile = null;
+  const result = domain.transaction(() => {
+    domain.requireBranch(repo.id, branch);
+    const path = normalizePath(input.path);
+    const existing = domain.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 = domain.commitFiles(repo, branch, input.message, [{ path, content }], options.actor ?? "pome-agent");
+    const file = domain.getFile(repo.id, branch, path);
+    afterFile = file;
+    return { content: contentFileJson(file, repo), commit: commitJson(commit, repo) };
+  });
+  domain.audit("create_or_update_file", repo.full_name, { ...input, content: "[redacted]" });
+  onDelta?.({ before, after: afterFile ? fileState(afterFile, repo) : null });
+  return result;
+}
+function pushFiles(domain, input, options = {}, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = input.branch ?? repo.default_branch;
+  domain.requireBranch(repo.id, branch);
+  if (input.files.length === 0)
+    validationFailed("files", "missing");
+  const paths = /* @__PURE__ */ 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 = domain.getFile(repo.id, branch, file.path);
+    return { path: file.path, sha: existing?.sha ?? null };
+  });
+  const commit = domain.transaction(() => domain.commitFiles(repo, branch, input.message, files, options.actor ?? "pome-agent"));
+  domain.audit("push_files", repo.full_name, { ...input, files: files.map((file) => file.path) });
+  const afterFiles = files.map((file) => {
+    const updated = domain.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(domain.getFile(repo.id, branch, file.path), repo)) };
+}
+function createBranch(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = domain.transaction(() => {
+    if (domain.getBranch(repo.id, input.branch))
+      validationFailed("branch", "already_exists", input.branch);
+    const source = input.sha ? { head_sha: input.sha } : domain.requireBranch(repo.id, input.from_branch ?? repo.default_branch);
+    const created2 = domain.createBranchInternal(repo, input.branch, source.head_sha);
+    if (!input.sha) {
+      const sourceBranch = input.from_branch ?? repo.default_branch;
+      const files = domain.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(repo.id, sourceBranch);
+      for (const file of files) {
+        domain.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 created2;
+  });
+  domain.audit("create_branch", repo.full_name, input);
+  onDelta?.({ before: null, after: branchState(branch, repo) });
+  return branchJson(branch, repo);
+}
+function listBranchesForRepo(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const rows = domain.listBranches(repo.id);
+  return paginate(rows, input.page, input.per_page ?? input.perPage).map((branch) => branchJson(branch, repo));
+}
+function getBranchByName(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = domain.requireBranch(repo.id, input.branch);
+  return branchJson(branch, repo);
+}
+function deleteBranch(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    const branch = domain.requireBranch(repo.id, input.branch);
+    if (input.branch === repo.default_branch) {
+      validationFailed("branch", "default_branch", input.branch);
+    }
+    const headPr = domain.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);
+    domain.db.prepare("DELETE FROM files WHERE repo_id = ? AND branch = ?").run(repo.id, input.branch);
+    domain.db.prepare("DELETE FROM branches WHERE repo_id = ? AND name = ?").run(repo.id, input.branch);
+  });
+  domain.audit("delete_branch", repo.full_name, input);
+  onDelta?.({ before, after: null });
+  return { ok: true };
+}
+function deleteFile(domain, input, options = {}, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const branch = input.branch ?? repo.default_branch;
+  let before = null;
+  const commit = domain.transaction(() => {
+    domain.requireBranch(repo.id, branch);
+    const path = normalizePath(input.path);
+    const existing = domain.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 domain.commitFiles(repo, branch, input.message, [{ path, content: "", delete: true }], options.actor ?? "pome-agent");
+  });
+  domain.audit("delete_file", repo.full_name, { ...input });
+  onDelta?.({ before, after: null });
+  return {
+    content: null,
+    commit: commitJson(commit, repo)
+  };
+}
+function getCommitWithFiles(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const commit = domain.resolveCommitByRef(repo, input.ref);
+  const files = domain.computeCommitFiles(repo, commit);
+  return commitWithFilesJson(commit, repo, files);
+}
+function compareCommits(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const baseCommit = domain.resolveCommitByRef(repo, input.base);
+  const headCommit = domain.resolveCommitByRef(repo, input.head);
+  if (baseCommit.sha === headCommit.sha) {
+    return compareCommitsJson(repo, baseCommit, headCommit, [], [], "identical", 0, 0);
+  }
+  const headAncestry = domain.commitAncestry(repo.id, headCommit.sha);
+  const baseAncestry = domain.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 = domain.computeCompareFiles(repo, baseCommit, headCommit);
+  const commits = [...aheadCommits].reverse();
+  return compareCommitsJson(repo, baseCommit, headCommit, commits, files, status, aheadCommits.length, behindCommits.length);
+}
+
+// ../packages/twin-github/dist/src/domain/issues.js
+function createIssue(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const issue = domain.transaction(() => {
+    if (!input.title.trim())
+      validationFailed("title", "missing");
+    for (const label of input.labels ?? [])
+      if (!domain.getLabel(repo.id, label))
+        validationFailed("labels", "missing", label);
+    for (const assignee of input.assignees ?? [])
+      if (!domain.hasCollaborator(repo.id, assignee))
+        validationFailed("assignees", "invalid", assignee);
+    const now = nowIso();
+    const number = domain.nextNumber(repo.id);
+    domain.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 ?? [])
+      domain.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 ?? [])
+      domain.db.prepare("INSERT OR IGNORE INTO issue_assignees (repo_id, issue_number, login) VALUES (?, ?, ?)").run(repo.id, number, assignee);
+    return domain.requireIssue(repo.id, number);
+  });
+  domain.audit("create_issue", repo.full_name, input);
+  const labels = domain.listIssueLabels(repo.id, issue.number).map((label) => label.name);
+  const assignees = domain.listIssueAssignees(repo.id, issue.number);
+  onDelta?.({ before: null, after: issueState(issue, repo, labels, assignees) });
+  return issueJson(issue, repo, domain.listIssueLabels(repo.id, issue.number), domain.listIssueAssignees(repo.id, issue.number), domain.issueCommentCount(repo.id, issue.number));
+}
+function listIssues(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let rows = domain.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 = domain.listIssueLabels(repo.id, issue.number).map((label) => label.name);
+      return wanted.every((label) => names.includes(label));
+    });
+  }
+  if (input.assignee)
+    rows = rows.filter((issue) => domain.listIssueAssignees(repo.id, issue.number).includes(input.assignee));
+  return paginate(rows, input.page, input.per_page ?? input.perPage).map((issue) => issueJson(issue, repo, domain.listIssueLabels(repo.id, issue.number), domain.listIssueAssignees(repo.id, issue.number), domain.issueCommentCount(repo.id, issue.number)));
+}
+function getIssue(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const issue = domain.requireIssue(repo.id, input.issue_number);
+  return issueJson(issue, repo, domain.listIssueLabels(repo.id, issue.number), domain.listIssueAssignees(repo.id, issue.number), domain.issueCommentCount(repo.id, issue.number));
+}
+function updateIssue(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    const issue = domain.requireIssue(repo.id, input.issue_number);
+    before = issueState(issue, repo, domain.listIssueLabels(repo.id, issue.number).map((label) => label.name), domain.listIssueAssignees(repo.id, issue.number));
+    for (const label of input.labels ?? [])
+      if (!domain.getLabel(repo.id, label))
+        validationFailed("labels", "missing", label);
+    for (const assignee of input.assignees ?? [])
+      if (!domain.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;
+    domain.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) {
+      domain.db.prepare("DELETE FROM issue_labels WHERE repo_id = ? AND issue_number = ?").run(repo.id, issue.number);
+      for (const label of input.labels)
+        domain.db.prepare("INSERT INTO issue_labels (repo_id, issue_number, label_name) VALUES (?, ?, ?)").run(repo.id, issue.number, label);
+    }
+    if (input.assignees) {
+      domain.db.prepare("DELETE FROM issue_assignees WHERE repo_id = ? AND issue_number = ?").run(repo.id, issue.number);
+      for (const assignee of input.assignees)
+        domain.db.prepare("INSERT INTO issue_assignees (repo_id, issue_number, login) VALUES (?, ?, ?)").run(repo.id, issue.number, assignee);
+    }
+  });
+  domain.audit("update_issue", repo.full_name, input);
+  const updated = domain.requireIssue(repo.id, input.issue_number);
+  const afterLabels = domain.listIssueLabels(repo.id, updated.number).map((label) => label.name);
+  const afterAssignees = domain.listIssueAssignees(repo.id, updated.number);
+  onDelta?.({ before, after: issueState(updated, repo, afterLabels, afterAssignees) });
+  return domain.getIssue(input);
+}
+function addIssueComment(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let target = "issue";
+  const comment = domain.transaction(() => {
+    target = domain.requireCommentTarget(repo.id, input.issue_number);
+    if (!input.body.trim())
+      validationFailed("body", "missing");
+    const now = nowIso();
+    const result = domain.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 domain.db.prepare("SELECT * FROM issue_comments WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.audit("add_issue_comment", repo.full_name, input);
+  onDelta?.({ before: null, after: issueCommentState(comment, repo) });
+  return issueCommentJson(comment, repo, target);
+}
+function listIssueComments(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const target = domain.requireCommentTarget(repo.id, input.issue_number);
+  const rows = domain.listIssueCommentRows(repo.id, input.issue_number);
+  return paginate(rows, input.page, input.per_page ?? input.perPage).map((comment) => issueCommentJson(comment, repo, target));
+}
+function listRepositoryLabels(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  return domain.listLabels(repo.id).map(labelJson);
+}
+function createRepositoryLabel(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.transaction(() => {
+    if (domain.getLabel(repo.id, input.name))
+      validationFailed("name", "already_exists", input.name);
+    domain.createLabel(repo, input.name, input.color ?? "ededed", input.description ?? "");
+  });
+  domain.audit("create_label", repo.full_name, input);
+  const created2 = domain.getLabel(repo.id, input.name);
+  onDelta?.({ before: null, after: labelState(created2, repo) });
+  return labelJson(created2);
+}
+function listIssueLabelsForIssue(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.requireIssue(repo.id, input.issue_number);
+  return domain.listIssueLabels(repo.id, input.issue_number).map(labelJson);
+}
+function addIssueLabels(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    domain.requireIssue(repo.id, input.issue_number);
+    before = issueLabelsState(repo, input.issue_number, domain.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+    for (const label of input.labels)
+      if (!domain.getLabel(repo.id, label))
+        validationFailed("labels", "missing", label);
+    for (const label of input.labels)
+      domain.db.prepare("INSERT OR IGNORE INTO issue_labels (repo_id, issue_number, label_name) VALUES (?, ?, ?)").run(repo.id, input.issue_number, label);
+  });
+  domain.audit("add_issue_labels", repo.full_name, input);
+  const after = issueLabelsState(repo, input.issue_number, domain.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+  onDelta?.({ before, after });
+  return domain.listIssueLabelsForIssue(input);
+}
+function deleteIssueLabel(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.requireIssue(repo.id, input.issue_number);
+  const before = issueLabelsState(repo, input.issue_number, domain.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+  const result = domain.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");
+  domain.audit("delete_issue_label", repo.full_name, input);
+  const after = issueLabelsState(repo, input.issue_number, domain.listIssueLabels(repo.id, input.issue_number).map((label) => label.name));
+  onDelta?.({ before, after });
+  return domain.listIssueLabelsForIssue(input);
+}
+function addAssignees(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    const issue = domain.requireIssue(repo.id, input.issue_number);
+    before = issueAssigneesState(repo, issue.number, domain.listIssueAssignees(repo.id, issue.number));
+    for (const assignee of input.assignees)
+      if (!domain.hasCollaborator(repo.id, assignee))
+        validationFailed("assignees", "invalid", assignee);
+    for (const assignee of input.assignees)
+      domain.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;
+    domain.db.prepare("UPDATE issues SET assignee_login = ?, updated_at = ? WHERE repo_id = ? AND number = ?").run(firstAssignee, nowIso(), repo.id, issue.number);
+  });
+  domain.audit("add_assignees", repo.full_name, input);
+  const after = issueAssigneesState(repo, input.issue_number, domain.listIssueAssignees(repo.id, input.issue_number));
+  onDelta?.({ before, after });
+  return domain.getIssue(input);
+}
+function updateIssueComment(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  const comment = domain.transaction(() => {
+    const row = domain.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();
+    domain.db.prepare("UPDATE issue_comments SET body = ?, updated_at = ? WHERE id = ?").run(input.body, now, input.comment_id);
+    return domain.db.prepare("SELECT * FROM issue_comments WHERE id = ?").get(input.comment_id);
+  });
+  domain.audit("update_issue_comment", repo.full_name, input);
+  onDelta?.({ before, after: issueCommentState(comment, repo) });
+  return issueCommentJson(comment, repo, domain.commentTargetKind(repo.id, comment.issue_number) ?? "issue");
+}
+function deleteIssueComment(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    const row = domain.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);
+    domain.db.prepare("DELETE FROM issue_comments WHERE id = ?").run(input.comment_id);
+  });
+  domain.audit("delete_issue_comment", repo.full_name, input);
+  onDelta?.({ before, after: null });
+  return { ok: true };
+}
+function listMilestones(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let rows = domain.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));
+}
+function createMilestone(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const milestone = domain.transaction(() => {
+    if (!input.title.trim())
+      validationFailed("title", "missing");
+    const duplicate = domain.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 = domain.nextMilestoneNumber(repo.id);
+    const now = nowIso();
+    const state = input.state ?? "open";
+    domain.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 domain.db.prepare("SELECT * FROM milestones WHERE repo_id = ? AND number = ?").get(repo.id, number);
+  });
+  domain.audit("create_milestone", repo.full_name, input);
+  onDelta?.({ before: null, after: milestoneState(milestone, repo) });
+  return milestoneJson(milestone, repo);
+}
+function updateMilestone(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  const milestone = domain.transaction(() => {
+    const existing = domain.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 = domain.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();
+    domain.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 domain.db.prepare("SELECT * FROM milestones WHERE repo_id = ? AND number = ?").get(repo.id, existing.number);
+  });
+  domain.audit("update_milestone", repo.full_name, input);
+  onDelta?.({ before, after: milestoneState(milestone, repo) });
+  return milestoneJson(milestone, repo);
+}
+function deleteMilestone(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    const existing = domain.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);
+    domain.db.prepare("DELETE FROM milestones WHERE repo_id = ? AND number = ?").run(repo.id, input.milestone_number);
+  });
+  domain.audit("delete_milestone", repo.full_name, input);
+  onDelta?.({ before, after: null });
+  return { ok: true };
+}
+
+// ../packages/twin-github/dist/src/domain/pulls.js
+function createPullRequest(domain, input, onDelta) {
+  const baseRepo = domain.requireRepo(input.owner, input.repo);
+  const baseRef = input.base ?? baseRepo.default_branch;
+  const number = domain.transaction(() => {
+    if (input.head === baseRef || input.head === `${input.owner}:${baseRef}`)
+      validationFailed("head", "invalid", input.head);
+    const { repo: headRepo, ref: headRef } = domain.resolveHeadRef(baseRepo, input.head);
+    const baseBranch = domain.requireBranch(baseRepo.id, baseRef);
+    const headBranch = domain.requireBranch(headRepo.id, headRef);
+    const duplicate = domain.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 = domain.calculatePullFiles(baseRepo, baseRef, headRepo, headRef);
+    if (files.length === 0)
+      validationFailed("head", "missing_commits", input.head);
+    const now = nowIso();
+    const pullNumber = domain.nextNumber(baseRepo.id);
+    domain.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);
+    domain.replacePullFiles(baseRepo.id, pullNumber, files);
+    return pullNumber;
+  });
+  domain.audit("create_pull_request", baseRepo.full_name, input);
+  const createdRow = domain.requirePullRequest(baseRepo.id, number);
+  onDelta?.({ before: null, after: pullRequestState(createdRow, baseRepo) });
+  return domain.getPullRequest({ owner: input.owner, repo: input.repo, pull_number: number });
+}
+function listPullRequests(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let rows = domain.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) => domain.serializePullSimple(pr));
+}
+function getPullRequest(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const pr = domain.requirePullRequest(repo.id, input.pull_number);
+  return domain.serializePull(pr);
+}
+function getPullRequestFiles(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.requirePullRequest(repo.id, input.pull_number);
+  const rows = domain.listPullRequestFileRows(repo.id, input.pull_number);
+  return paginate(rows, input.page, input.per_page ?? input.perPage).map(pullRequestFileJson);
+}
+function getPullRequestReviews(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.requirePullRequest(repo.id, input.pull_number);
+  const rows = domain.listPullRequestReviewRows(repo.id, input.pull_number);
+  return paginate(rows, input.page, input.per_page ?? input.perPage).map((review) => reviewJson(review, repo));
+}
+function createPullRequestReview(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const review = domain.transaction(() => {
+    const pr = domain.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 = domain.requireBranch(pr.head_repo_id, pr.head_ref).head_sha;
+    const result = domain.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 domain.db.prepare("SELECT * FROM pull_request_reviews WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.audit("create_pull_request_review", repo.full_name, input);
+  onDelta?.({ before: null, after: pullRequestReviewState(review, repo) });
+  return reviewJson(review, repo);
+}
+function getPullRequestComments(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.requirePullRequest(repo.id, input.pull_number);
+  const rows = domain.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
+  }));
+}
+function getPullRequestStatus(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const pr = domain.requirePullRequest(repo.id, input.pull_number);
+  const head = domain.requireBranch(pr.head_repo_id, pr.head_ref);
+  const statuses = head.head_sha ? domain.latestCommitStatuses(pr.head_repo_id, head.head_sha) : [];
+  return combinedStatusJson(domain.requireRepoById(pr.head_repo_id), head.head_sha ?? "", statuses);
+}
+function mergePullRequest(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  const commit = domain.transaction(() => {
+    const pr = domain.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 = domain.getPullRequestStatus(input);
+    if (status.state === "failure")
+      conflict("Required status check failed");
+    const headRepo = domain.requireRepoById(pr.head_repo_id);
+    const files = domain.listPullRequestFileRows(repo.id, pr.number);
+    const changes = files.map((file) => {
+      if (file.status === "removed")
+        return { path: file.filename, content: "", delete: true };
+      const source = domain.getFile(headRepo.id, pr.head_ref, file.filename);
+      if (!source)
+        validationFailed("files", "missing", file.filename);
+      return { path: file.filename, content: source.content };
+    });
+    const mergedCommit = domain.commitFiles(repo, pr.base_ref, input.commit_title ?? `Merge pull request #${pr.number}`, changes, "pome-agent");
+    const now = nowIso();
+    domain.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;
+  });
+  domain.audit("merge_pull_request", repo.full_name, input);
+  const merged = domain.requirePullRequest(repo.id, input.pull_number);
+  onDelta?.({ before, after: pullRequestState(merged, repo) });
+  return { sha: commit.sha, merged: true, message: "Pull Request successfully merged" };
+}
+function updatePullRequestBranch(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  const pullNumber = domain.transaction(() => {
+    const pr = domain.requirePullRequest(repo.id, input.pull_number);
+    before = pullRequestState(pr, repo);
+    if (pr.state !== "open")
+      conflict("Pull request is closed");
+    const headRepo = domain.requireRepoById(pr.head_repo_id);
+    const headBranch = domain.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 = domain.requireBranch(repo.id, pr.base_ref);
+    const mergeBase = domain.findMergeBase(repo, baseBranch.head_sha, headRepo, headBranch.head_sha);
+    if (baseBranch.head_sha === mergeBase)
+      return pr.number;
+    const changes = domain.mergeChangesFromBase(repo, pr.base_ref, headRepo, pr.head_ref, mergeBase);
+    if (changes.length === 0)
+      return pr.number;
+    const mergeCommit = domain.commitFiles(headRepo, pr.head_ref, `Merge branch '${pr.base_ref}' into ${pr.head_ref}`, changes, "pome-agent");
+    domain.db.prepare("UPDATE pull_requests SET head_sha = ?, updated_at = ? WHERE repo_id = ? AND number = ?").run(mergeCommit.sha, nowIso(), repo.id, pr.number);
+    domain.replacePullFiles(repo.id, pr.number, domain.calculatePullFiles(repo, pr.base_ref, headRepo, pr.head_ref));
+    return pr.number;
+  });
+  domain.audit("update_pull_request_branch", repo.full_name, input);
+  const updated = domain.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` };
+}
+function getPullRequestDiff(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  domain.requirePullRequest(repo.id, input.pull_number);
+  const files = domain.listPullRequestFileRows(repo.id, input.pull_number);
+  return { diff: pullRequestDiffText(files) };
+}
+function updatePullRequest(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let before = null;
+  domain.transaction(() => {
+    const pr = domain.requirePullRequest(repo.id, input.pull_number);
+    before = pullRequestState(pr, repo);
+    if (pr.merged && (input.state === "open" || input.base !== void 0 && 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)
+      domain.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();
+    domain.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 = domain.requireRepoById(pr.head_repo_id);
+      domain.replacePullFiles(repo.id, pr.number, domain.calculatePullFiles(repo, nextBase, headRepo, pr.head_ref));
+      const baseBranch = domain.requireBranch(repo.id, nextBase);
+      domain.db.prepare("UPDATE pull_requests SET base_sha = ? WHERE repo_id = ? AND number = ?").run(baseBranch.head_sha, repo.id, pr.number);
+    }
+  });
+  domain.audit("update_pull_request", repo.full_name, input);
+  const updated = domain.requirePullRequest(repo.id, input.pull_number);
+  onDelta?.({ before, after: pullRequestState(updated, repo) });
+  return domain.getPullRequest({ owner: input.owner, repo: input.repo, pull_number: input.pull_number });
+}
+function getPullRequestCommits(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const pr = domain.requirePullRequest(repo.id, input.pull_number);
+  const headRepo = domain.requireRepoById(pr.head_repo_id);
+  const headSha = domain.getBranch(headRepo.id, pr.head_ref)?.head_sha ?? pr.head_sha;
+  const baseSha = domain.getBranch(repo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+  const commits = headSha ? domain.commitsBetween(headRepo.id, headSha, baseSha) : [];
+  const ordered = [...commits].reverse();
+  return paginate(ordered, input.page, input.per_page ?? input.perPage).map((commit) => commitJson(commit, headRepo));
+}
+function createPullRequestReviewComment(domain, input, options = {}, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const comment = domain.transaction(() => {
+    const pr = domain.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 = domain.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 = domain.requireRepoById(pr.head_repo_id);
+    const targetRepo = side === "LEFT" ? domain.requireRepoById(pr.base_repo_id) : headRepo;
+    const targetRef = side === "LEFT" ? pr.base_ref : pr.head_ref;
+    const targetFile = domain.getFile(targetRepo.id, targetRef, path);
+    if (!targetFile || input.line > contentLineCount(targetFile.content))
+      validationFailed("line", "invalid", input.line);
+    const headSha = domain.getBranch(pr.head_repo_id, pr.head_ref)?.head_sha ?? pr.head_sha;
+    const baseSha = domain.getBranch(repo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+    const commits = headSha ? domain.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 = domain.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 domain.db.prepare("SELECT * FROM pull_request_review_comments WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.audit("create_pull_request_review_comment", repo.full_name, input);
+  onDelta?.({ before: null, after: pullRequestReviewCommentState(comment, repo) });
+  return pullRequestReviewCommentJson(comment, repo);
+}
+function addReplyToPullRequestComment(domain, input, options = {}, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const reply = domain.transaction(() => {
+    const pr = domain.requirePullRequest(repo.id, input.pull_number);
+    const parent = domain.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 = domain.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 domain.db.prepare("SELECT * FROM pull_request_review_comments WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.audit("add_reply_to_pull_request_comment", repo.full_name, input);
+  onDelta?.({ before: null, after: pullRequestReviewCommentState(reply, repo) });
+  return pullRequestReviewCommentJson(reply, repo);
+}
+
+// ../packages/twin-github/dist/src/domain/releases.js
+function listTags(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const rows = domain.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));
+}
+function listReleases(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const rows = domain.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));
+}
+function getLatestRelease(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const row = domain.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);
+}
+function getReleaseByTag(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const row = domain.db.prepare("SELECT * FROM releases WHERE repo_id = ? AND tag_name = ?").get(repo.id, input.tag);
+  if (!row)
+    notFound("Not Found");
+  return releaseJson(row, repo);
+}
+function getTag(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const row = domain.db.prepare("SELECT * FROM tags WHERE repo_id = ? AND name = ?").get(repo.id, input.tag);
+  if (!row)
+    notFound("Not Found");
+  return tagJson(row, repo);
+}
+function createRelease(domain, input, options = {}, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const release = domain.transaction(() => {
+    if (!input.tag_name.trim())
+      validationFailed("tag_name", "missing");
+    const existingRelease = domain.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 = domain.db.prepare("SELECT * FROM tags WHERE repo_id = ? AND name = ?").get(repo.id, input.tag_name);
+    if (!tag) {
+      const sha = domain.resolveRefToSha(repo, target);
+      const now2 = nowIso();
+      domain.db.prepare("INSERT INTO tags (repo_id, name, commit_sha, created_at) VALUES (?, ?, ?, ?)").run(repo.id, input.tag_name, sha, now2);
+      tag = { repo_id: repo.id, name: input.tag_name, commit_sha: sha, created_at: now2 };
+    }
+    const draft = input.draft ? 1 : 0;
+    const prerelease = input.prerelease ? 1 : 0;
+    const now = nowIso();
+    const result = domain.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 domain.db.prepare("SELECT * FROM releases WHERE id = ?").get(result.lastInsertRowid);
+  });
+  domain.audit("create_release", repo.full_name, input);
+  onDelta?.({ before: null, after: releaseState(release, repo) });
+  return releaseJson(release, repo);
+}
+
+// ../packages/twin-github/dist/src/domain/repos.js
+function getRepository(domain, input) {
+  return repoJson(domain.requireRepo(input.owner, input.repo));
+}
+function createRepository(domain, input, onDelta) {
+  const owner = input.owner ?? "pome-agent";
+  const repo = domain.transaction(() => {
+    domain.upsertUser(owner, "Organization", owner);
+    if (domain.getRepo(owner, input.name))
+      validationFailed("name", "already_exists", input.name);
+    const created2 = domain.insertRepository({
+      owner,
+      name: input.name,
+      description: input.description ?? "",
+      private: input.private ?? false,
+      defaultBranch: "main",
+      fork: false,
+      parentFullName: null
+    });
+    domain.addCollaborator(created2.id, "pome-agent");
+    domain.createBranchInternal(created2, "main", null);
+    domain.commitFiles(created2, "main", "Initial commit", [{ path: "README.md", content: `# ${input.name}
+` }], "pome-agent");
+    return created2;
+  });
+  domain.audit("create_repository", repo.full_name, input);
+  const final = domain.requireRepo(owner, input.name);
+  onDelta?.({ before: null, after: repoState(final) });
+  return repoJson(final);
+}
+function forkRepository(domain, input, onDelta) {
+  const source = domain.requireRepo(input.owner, input.repo);
+  const owner = input.organization ?? "pome-agent";
+  const fork = domain.transaction(() => {
+    domain.upsertUser(owner, owner === input.organization ? "Organization" : "User", owner);
+    if (domain.getRepo(owner, source.name))
+      validationFailed("name", "already_exists", source.name);
+    const created2 = domain.insertRepository({
+      owner,
+      name: source.name,
+      description: source.description,
+      private: Boolean(source.private),
+      defaultBranch: source.default_branch,
+      fork: true,
+      parentFullName: source.full_name
+    });
+    domain.addCollaborator(created2.id, "pome-agent");
+    const commitShaMap = domain.copyForkCommits(source, created2);
+    for (const branch of domain.listBranches(source.id)) {
+      domain.createBranchInternal(created2, branch.name, branch.head_sha ? commitShaMap.get(branch.head_sha) ?? null : null);
+      const files = domain.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(source.id, branch.name);
+      for (const file of files) {
+        domain.db.prepare("INSERT INTO files (repo_id, branch, path, content, sha, size, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(created2.id, file.branch, file.path, file.content, file.sha, file.size, nowIso());
+      }
+    }
+    return created2;
+  });
+  domain.audit("fork_repository", fork.full_name, input);
+  onDelta?.({ before: null, after: repoState(fork) });
+  return repoJson(fork);
+}
+function listCollaborators(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const rows = domain.db.prepare("SELECT login FROM collaborators WHERE repo_id = ? ORDER BY login ASC").all(repo.id);
+  return rows.map((row) => userJson(row.login));
+}
+function isCollaborator(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  return domain.hasCollaborator(repo.id, input.username);
+}
+function hasRepositoryPermission(domain, input) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  const row = domain.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));
+}
+function getMe(domain, input = {}) {
+  const login = input.actor ?? "pome-agent";
+  return authenticatedUserJson(login);
+}
+function addCollaboratorAction(domain, input, onDelta) {
+  const repo = domain.requireRepo(input.owner, input.repo);
+  let invitationState = "accepted";
+  let alreadyCollaborator = false;
+  let beforeState = null;
+  let afterState = null;
+  domain.transaction(() => {
+    if (!input.username.trim())
+      validationFailed("username", "missing");
+    const existing = domain.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) {
+        domain.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(domain.db.prepare("SELECT 1 FROM users WHERE login = ?").get(input.username));
+    invitationState = isSeededUser ? "accepted" : "pending";
+    domain.upsertUser(input.username, "User", input.username);
+    domain.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");
+  });
+  domain.audit("add_collaborator", repo.full_name, input);
+  onDelta?.({ before: beforeState, after: afterState });
+  if (alreadyCollaborator && invitationState === "accepted") {
+    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`
+    }
+  };
+}
+
+// ../packages/twin-github/dist/src/domain/search.js
+function searchRepositories(domain, input) {
+  const query = (input.query ?? input.q ?? "").toLowerCase();
+  const repos = domain.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 };
+}
+function searchUsers(domain, input) {
+  const query = (input.query ?? input.q ?? "").toLowerCase();
+  const rows = domain.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)) };
+}
+function searchCode(domain, input) {
+  const query = (input.query ?? input.q ?? "").toLowerCase();
+  let rows = domain.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)
+    }))
+  };
+}
+function searchCommits(domain, input) {
+  const query = (input.query ?? input.q ?? "").toLowerCase();
+  let repos = domain.db.prepare("SELECT * FROM repositories ORDER BY full_name ASC").all();
+  if (input.owner)
+    repos = repos.filter((repo) => repo.owner === input.owner);
+  if (input.repo)
+    repos = repos.filter((repo) => repo.name === input.repo);
+  const matches = [];
+  for (const repo of repos) {
+    const branch = domain.db.prepare("SELECT * FROM branches WHERE repo_id = ? AND name = ?").get(repo.id, repo.default_branch);
+    if (!branch?.head_sha)
+      continue;
+    for (const commit of domain.commitAncestry(repo.id, branch.head_sha)) {
+      if (!query || commit.message.toLowerCase().includes(query) || commit.author_login.toLowerCase().includes(query))
+        matches.push({ commit, repo });
+    }
+  }
+  return {
+    total_count: matches.length,
+    incomplete_results: false,
+    items: paginate(matches, input.page, input.per_page ?? input.perPage).map(({ commit, repo }) => ({ ...commitJson(commit, repo), repository: repoJson(repo), score: 1 }))
+  };
+}
+function searchIssues(domain, input) {
+  const query = (input.query ?? input.q ?? "").toLowerCase();
+  const rows = domain.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 = domain.requireRepoById(issue.repo_id);
+      return issueJson(issue, repo, domain.listIssueLabels(issue.repo_id, issue.number), domain.listIssueAssignees(issue.repo_id, issue.number), domain.issueCommentCount(issue.repo_id, issue.number));
+    })
+  };
+}
+
+// ../packages/twin-github/dist/src/domain/github-domain.js
+var GitHubDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  seed(seed = defaultSeedState(), onDelta) {
+    const parsedSeed = parseSeed(seed);
+    const before = this.summarizeRepositories();
+    const tx = this.db.transaction(() => {
+      resetDatabase(this.db);
+      const users = new Set(parsedSeed.users?.map((user) => user.login) ?? []);
+      for (const repo of parsedSeed.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 parsedSeed.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 parsedSeed.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 created2 = this.createIssue({ owner: repo.owner, repo: repo.name, title: issue.title, body: issue.body ?? "", labels: issue.labels ?? [], assignees });
+          if (issue.number && issue.number !== created2.number) {
+            const from = created2.number;
+            const to = issue.number;
+            this.db.prepare("UPDATE issues SET number = ? WHERE repo_id = ? AND number = ?").run(to, repo.id, from);
+            this.db.prepare("UPDATE issue_labels SET issue_number = ? WHERE repo_id = ? AND issue_number = ?").run(to, repo.id, from);
+            this.db.prepare("UPDATE issue_assignees SET issue_number = ? WHERE repo_id = ? AND issue_number = ?").run(to, repo.id, from);
+            this.db.prepare("UPDATE issue_comments SET issue_number = ? WHERE repo_id = ? AND issue_number = ?").run(to, repo.id, from);
+            this.bumpEntityCounter(repo.id, to);
+          }
+          if (issue.state === "closed")
+            this.updateIssue({ owner: repo.owner, repo: repo.name, issue_number: issue.number ?? created2.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 prNumber2 = createdPr.number;
+          const seedsHead = (pull.reviews ?? []).length > 0 || (pull.statuses ?? []).length > 0;
+          const prRow = seedsHead ? this.requirePullRequest(repo.id, prNumber2) : null;
+          const headRepo = prRow ? this.requireRepoById(prRow.head_repo_id) : null;
+          const headSha = prRow && headRepo ? this.requireBranch(headRepo.id, prRow.head_ref).head_sha ?? "" : "";
+          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,
+              prNumber2,
+              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()
+            );
+          }
+          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: parsedSeed.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),
+          // F-1151. THREE distinct comment surfaces reach a pull request and this
+          // is the third, so the export keeps them apart rather than merging them
+          // into one count a predicate could not attribute:
+          //   `reviews[].body`     — the prose attached to a review verdict
+          //   `review_comments[]`  — inline comments anchored to a file and line
+          //   `comments[]`         — the conversation timeline, THIS one
+          // Read from `issue_comments` because that is where GitHub puts them:
+          // conversation comments on a PR go through the issue-comment endpoints,
+          // and the number space is shared, so a PR's number selects its own rows
+          // and no issue's.
+          comments: this.listIssueCommentRows(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 getRepository(this, input);
+  }
+  createRepository(input, onDelta) {
+    return createRepository(this, input, onDelta);
+  }
+  forkRepository(input, onDelta) {
+    return forkRepository(this, input, onDelta);
+  }
+  searchRepositories(input) {
+    return searchRepositories(this, input);
+  }
+  searchUsers(input) {
+    return searchUsers(this, input);
+  }
+  searchCode(input) {
+    return searchCode(this, input);
+  }
+  searchCommits(input) {
+    return searchCommits(this, input);
+  }
+  getFileContents(input) {
+    return getFileContents(this, input);
+  }
+  listCommits(input) {
+    return listCommits(this, input);
+  }
+  createOrUpdateFile(input, options = {}, onDelta) {
+    return createOrUpdateFile(this, input, options, onDelta);
+  }
+  pushFiles(input, options = {}, onDelta) {
+    return pushFiles(this, input, options, onDelta);
+  }
+  createBranch(input, onDelta) {
+    return createBranch(this, input, onDelta);
+  }
+  createIssue(input, onDelta) {
+    return createIssue(this, input, onDelta);
+  }
+  listIssues(input) {
+    return listIssues(this, input);
+  }
+  searchIssues(input) {
+    return searchIssues(this, input);
+  }
+  getIssue(input) {
+    return getIssue(this, input);
+  }
+  updateIssue(input, onDelta) {
+    return updateIssue(this, input, onDelta);
+  }
+  addIssueComment(input, onDelta) {
+    return addIssueComment(this, input, onDelta);
+  }
+  listIssueComments(input) {
+    return listIssueComments(this, input);
+  }
+  listRepositoryLabels(input) {
+    return listRepositoryLabels(this, input);
+  }
+  createRepositoryLabel(input, onDelta) {
+    return createRepositoryLabel(this, input, onDelta);
+  }
+  listIssueLabelsForIssue(input) {
+    return listIssueLabelsForIssue(this, input);
+  }
+  addIssueLabels(input, onDelta) {
+    return addIssueLabels(this, input, onDelta);
+  }
+  deleteIssueLabel(input, onDelta) {
+    return deleteIssueLabel(this, input, onDelta);
+  }
+  listCollaborators(input) {
+    return listCollaborators(this, input);
+  }
+  isCollaborator(input) {
+    return isCollaborator(this, input);
+  }
+  hasRepositoryPermission(input) {
+    return hasRepositoryPermission(this, input);
+  }
+  addAssignees(input, onDelta) {
+    return addAssignees(this, input, onDelta);
+  }
+  createPullRequest(input, onDelta) {
+    return createPullRequest(this, input, onDelta);
+  }
+  listPullRequests(input) {
+    return listPullRequests(this, input);
+  }
+  getPullRequest(input) {
+    return getPullRequest(this, input);
+  }
+  getPullRequestFiles(input) {
+    return getPullRequestFiles(this, input);
+  }
+  getPullRequestReviews(input) {
+    return getPullRequestReviews(this, input);
+  }
+  createPullRequestReview(input, onDelta) {
+    return createPullRequestReview(this, input, onDelta);
+  }
+  getPullRequestComments(input) {
+    return getPullRequestComments(this, input);
+  }
+  getPullRequestStatus(input) {
+    return getPullRequestStatus(this, input);
+  }
+  mergePullRequest(input, onDelta) {
+    return mergePullRequest(this, input, onDelta);
+  }
+  updatePullRequestBranch(input, onDelta) {
+    return updatePullRequestBranch(this, input, onDelta);
+  }
+  createStatus(input) {
+    return createStatus(this, input);
+  }
+  listBranchesForRepo(input) {
+    return listBranchesForRepo(this, input);
+  }
+  getBranchByName(input) {
+    return getBranchByName(this, input);
+  }
+  deleteBranch(input, onDelta) {
+    return deleteBranch(this, input, onDelta);
+  }
+  deleteFile(input, options = {}, onDelta) {
+    return deleteFile(this, input, options, onDelta);
+  }
+  getCommitWithFiles(input) {
+    return getCommitWithFiles(this, input);
+  }
+  compareCommits(input) {
+    return compareCommits(this, input);
+  }
+  getPullRequestDiff(input) {
+    return getPullRequestDiff(this, input);
+  }
+  updatePullRequest(input, onDelta) {
+    return updatePullRequest(this, input, onDelta);
+  }
+  getPullRequestCommits(input) {
+    return getPullRequestCommits(this, input);
+  }
+  createPullRequestReviewComment(input, options = {}, onDelta) {
+    return createPullRequestReviewComment(this, input, options, onDelta);
+  }
+  addReplyToPullRequestComment(input, options = {}, onDelta) {
+    return addReplyToPullRequestComment(this, input, options, onDelta);
+  }
+  updateIssueComment(input, onDelta) {
+    return updateIssueComment(this, input, onDelta);
+  }
+  deleteIssueComment(input, onDelta) {
+    return deleteIssueComment(this, input, onDelta);
+  }
+  listMilestones(input) {
+    return listMilestones(this, input);
+  }
+  createMilestone(input, onDelta) {
+    return createMilestone(this, input, onDelta);
+  }
+  updateMilestone(input, onDelta) {
+    return updateMilestone(this, input, onDelta);
+  }
+  deleteMilestone(input, onDelta) {
+    return deleteMilestone(this, input, onDelta);
+  }
+  createCommitStatus(input, onDelta) {
+    return createCommitStatus(this, input, onDelta);
+  }
+  getCombinedStatusForRef(input) {
+    return getCombinedStatusForRef(this, input);
+  }
+  createCheckRun(input, onDelta) {
+    return createCheckRun(this, input, onDelta);
+  }
+  listCheckRunsForRef(input) {
+    return listCheckRunsForRef(this, input);
+  }
+  listTags(input) {
+    return listTags(this, input);
+  }
+  listReleases(input) {
+    return listReleases(this, input);
+  }
+  getLatestRelease(input) {
+    return getLatestRelease(this, input);
+  }
+  getReleaseByTag(input) {
+    return getReleaseByTag(this, input);
+  }
+  getTag(input) {
+    return getTag(this, input);
+  }
+  createRelease(input, options = {}, onDelta) {
+    return createRelease(this, input, options, onDelta);
+  }
+  getMe(input = {}) {
+    return getMe(this, input);
+  }
+  addCollaboratorAction(input, onDelta) {
+    return addCollaboratorAction(this, input, onDelta);
+  }
+  // ----- shared helpers (used by domain/* modules) -----
+  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 = /* @__PURE__ */ new Map();
+    for (const status of statuses) {
+      if (!latestByContext.has(status.context))
+        latestByContext.set(status.context, status);
+    }
+    return [...latestByContext.values()];
+  }
+  // ===== 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) {
+    const byHash = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, ref);
+    if (byHash)
+      return byHash;
+    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;
+    }
+    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 = /* @__PURE__ */ new Set();
+    const MAX_DEPTH = 2e3;
+    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;
+  }
+  findMergeBase(baseRepo, baseSha, headRepo, headSha) {
+    if (!baseSha || !headSha)
+      return null;
+    const headAncestry = this.commitAncestry(headRepo.id, headSha);
+    const headShas = new Set(headAncestry.map((commit) => commit.sha));
+    const headKeys = baseRepo.id === headRepo.id ? null : new Set(headAncestry.map((commit) => commitIdentityKey(commit)));
+    for (const commit of this.commitAncestry(baseRepo.id, baseSha)) {
+      if (headShas.has(commit.sha))
+        return commit.sha;
+      if (headKeys?.has(commitIdentityKey(commit)))
+        return commit.sha;
+    }
+    return null;
+  }
+  /** File state (path → blob) as of a commit, reconstructed from file_versions. */
+  fileStateAtCommit(repoId, sha) {
+    const state = /* @__PURE__ */ new Map();
+    if (!sha)
+      return state;
+    const seen = /* @__PURE__ */ new Set();
+    for (const commit of this.commitAncestry(repoId, sha)) {
+      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 (seen.has(version.path))
+          continue;
+        seen.add(version.path);
+        if (version.status !== "removed")
+          state.set(version.path, { content: version.content, sha: version.sha });
+      }
+    }
+    return state;
+  }
+  /** Net base-branch changes since the merge base, skipping paths the head branch also touched (head wins). */
+  mergeChangesFromBase(baseRepo, baseRef, headRepo, headRef, mergeBase) {
+    const branchFiles = (repoId, branch) => new Map(this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(repoId, branch).map((file) => [file.path, file]));
+    const baseNow = branchFiles(baseRepo.id, baseRef);
+    const headNow = branchFiles(headRepo.id, headRef);
+    const atMergeBase = this.fileStateAtCommit(baseRepo.id, mergeBase);
+    const changes = [];
+    for (const path of /* @__PURE__ */ new Set([...baseNow.keys(), ...atMergeBase.keys()])) {
+      const current = baseNow.get(path);
+      const original = atMergeBase.get(path);
+      if (current?.sha === original?.sha)
+        continue;
+      if (headNow.get(path)?.sha !== original?.sha)
+        continue;
+      if (!current)
+        changes.push({ path, content: "", delete: true });
+      else
+        changes.push({ path, content: current.content });
+    }
+    return changes;
+  }
+  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) {
+    const baseSnapshot = this.snapshotAtCommit(repo.id, base.sha);
+    const headSnapshot = this.snapshotAtCommit(repo.id, head.sha);
+    const paths = [.../* @__PURE__ */ 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) {
+    const ancestry = this.commitAncestry(repoId, sha).reverse();
+    const out = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) : void 0;
+      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 sha2 = 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, sha2, 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, sha2, 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 = [.../* @__PURE__ */ 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 };
+  }
+  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 = /* @__PURE__ */ 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("/") ? void 0 : 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");
+  }
+  // F-1151 — what the ISSUE COMMENT endpoints may address.
+  //
+  // Real GitHub models every pull request as an issue and documents
+  // `/repos/:o/:r/issues/:number/comments` as the way to comment on a PR's
+  // conversation; `pulls/:number/comments` is the inline REVIEW comment surface,
+  // which is a different thing. So a comment target is an issue OR a pull
+  // request, and `requireIssue` is too narrow for these two routes — it 404'd
+  // every PR comment, including the only one the bundled `pr-summary-*` examples
+  // know how to write.
+  //
+  // Deliberately NOT widened past the comment routes. Everything else reached
+  // through `requireIssue` (labels, assignees, state) really is issue-only in
+  // this twin, and making a PR answer those would be divergence #16's read half
+  // — a bigger change than a comment target, and still out of scope.
+  //
+  // The lookup order does not matter: `nextNumber()` draws issue and PR numbers
+  // from one per-repo counter, so at most one of the two can match.
+  //
+  // The KIND is returned rather than a boolean because the serializer needs it:
+  // GitHub's `html_url` for a comment on a PR is `/pull/N#issuecomment-…`, not
+  // `/issues/N#…`, and the twin would otherwise ship a divergence nothing had
+  // recorded.
+  commentTargetKind(repoId, number) {
+    if (this.db.prepare("SELECT 1 FROM issues WHERE repo_id = ? AND number = ?").get(repoId, number)) {
+      return "issue";
+    }
+    if (this.db.prepare("SELECT 1 FROM pull_requests WHERE repo_id = ? AND number = ?").get(repoId, number)) {
+      return "pull_request";
+    }
+    return null;
+  }
+  requireCommentTarget(repoId, number) {
+    return this.commentTargetKind(repoId, number) ?? notFound("Issue not found");
+  }
+  listIssueLabels(repoId, issueNumber2) {
+    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, issueNumber2);
+  }
+  listIssueAssignees(repoId, issueNumber2) {
+    const rows = this.db.prepare("SELECT login FROM issue_assignees WHERE repo_id = ? AND issue_number = ? ORDER BY login ASC").all(repoId, issueNumber2);
+    return rows.map((row) => row.login);
+  }
+  issueCommentCount(repoId, issueNumber2) {
+    const row = this.db.prepare("SELECT COUNT(*) AS count FROM issue_comments WHERE repo_id = ? AND issue_number = ?").get(repoId, issueNumber2);
+    return row.count;
+  }
+  listIssueCommentRows(repoId, issueNumber2) {
+    return this.db.prepare("SELECT * FROM issue_comments WHERE repo_id = ? AND issue_number = ? ORDER BY id ASC").all(repoId, issueNumber2);
+  }
+  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 captureDelta(fn) {
+  let delta = null;
+  const value = fn((d) => {
+    delta = d;
+  });
+  return { value, delta };
+}
+var createRepoSchema = z.object({ name: z.string().min(1), owner: z.string().min(1).optional(), description: z.string().optional(), private: z.boolean().optional() });
+var contentSchema = z.object({ message: z.string().min(1), content: z.string(), branch: z.string().optional(), sha: z.string().optional(), encoding: z.enum(["utf-8", "base64"]).optional() });
+var createIssueSchema = z.object({ title: z.string().min(1), body: z.string().optional(), labels: z.array(z.string()).optional(), assignees: z.array(z.string()).optional() });
+var updateIssueSchema = z.object({ title: z.string().optional(), body: z.string().optional(), state: z.enum(["open", "closed"]).optional(), labels: z.array(z.string()).optional(), assignees: z.array(z.string()).optional() });
+var commentSchema = z.object({ body: z.string().min(1) });
+var labelSchema = z.object({ name: z.string().min(1), color: z.string().default("ededed"), description: z.string().default("") });
+var labelsSchema = z.object({ labels: z.array(z.string().min(1)).min(1) });
+var assigneesSchema = z.object({ assignees: z.array(z.string().min(1)).min(1) });
+var createPullSchema = z.object({ title: z.string().min(1), body: z.string().optional(), head: z.string().min(1), base: z.string().optional() });
+var reviewSchema = z.object({ event: z.enum(["APPROVE", "REQUEST_CHANGES", "COMMENT"]), body: z.string().optional() });
+var mergeSchema = z.object({ commit_title: z.string().optional(), commit_message: z.string().optional() });
+var updateBranchSchema = z.object({ expected_head_sha: z.string().optional() });
+var deleteFileSchema = z.object({ message: z.string().min(1), sha: z.string().min(1), branch: z.string().optional() });
+var updatePrSchema = z.object({ title: z.string().optional(), body: z.string().optional(), state: z.enum(["open", "closed"]).optional(), base: z.string().optional() });
+var reviewCommentSchema = z.object({ body: z.string().min(1), path: z.string().min(1), line: z.coerce.number().int().positive(), side: z.enum(["LEFT", "RIGHT"]).optional(), commit_id: z.string().optional() });
+var replyCommentSchema = z.object({ body: z.string().min(1) });
+var updateCommentSchema = z.object({ body: z.string().min(1) });
+var milestoneSchema = z.object({ title: z.string().min(1), description: z.string().optional(), due_on: z.string().optional(), state: z.enum(["open", "closed"]).optional() });
+var updateMilestoneSchema = z.object({ title: z.string().optional(), description: z.string().optional(), due_on: z.string().optional(), state: z.enum(["open", "closed"]).optional() });
+var createStatusSchema = z.object({ state: z.enum(["error", "failure", "pending", "success"]), context: z.string().optional(), description: z.string().optional(), target_url: z.string().optional() });
+var createCheckRunSchema = z.object({
+  name: z.string().min(1),
+  head_sha: z.string().min(1),
+  status: z.enum(["queued", "in_progress", "completed"]).optional(),
+  conclusion: z.enum(["success", "failure", "neutral", "cancelled", "timed_out", "action_required", "skipped", "stale"]).optional(),
+  details_url: z.string().optional(),
+  external_id: z.string().optional(),
+  output: z.object({ title: z.string().optional(), summary: z.string().optional() }).optional(),
+  started_at: z.string().optional(),
+  completed_at: z.string().optional()
+});
+var createReleaseSchema = z.object({
+  tag_name: z.string().min(1),
+  target_commitish: z.string().optional(),
+  name: z.string().optional(),
+  body: z.string().optional(),
+  draft: z.boolean().optional(),
+  prerelease: z.boolean().optional()
+});
+var addCollaboratorSchema = z.object({ permission: z.enum(["pull", "push", "admin", "maintain", "triage"]).optional() });
+function registerGitHubRoutes(session, { domain, recorder }) {
+  const handle = (fn) => recorder.handle({ mutation: false }, async (c) => {
+    const result = await fn(c);
+    return { status: result.status, body: result.body, mutation: result.mutation ?? false, delta: result.delta ?? null };
+  });
+  const handleAs = (tool, fn) => recorder.handle({ mutation: false, tool }, async (c) => {
+    const result = await fn(c);
+    return { status: result.status, body: result.body, mutation: result.mutation ?? false, delta: result.delta ?? null };
+  });
+  session.get("/search/repositories", handle((c) => ok(domain.searchRepositories({ q: c.req.query("q"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/search/code", handle((c) => ok(domain.searchCode({ q: c.req.query("q"), owner: c.req.query("owner"), repo: c.req.query("repo"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/search/issues", handle((c) => ok(domain.searchIssues({ q: c.req.query("q"), owner: c.req.query("owner"), repo: c.req.query("repo"), state: stateQuery(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/search/users", handle((c) => ok(domain.searchUsers({ q: c.req.query("q"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/search/commits", handle((c) => ok(domain.searchCommits({ q: c.req.query("q"), owner: c.req.query("owner"), repo: c.req.query("repo"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo", handle((c) => ok(domain.getRepository(params(c)))));
+  session.post("/user/repos", handle(async (c) => {
+    const args = createRepoSchema.parse(await readJson(c));
+    const { value, delta } = captureDelta((onDelta) => domain.createRepository(args, onDelta));
+    return created(value, delta);
+  }));
+  session.post("/orgs/:owner/repos", handle(async (c) => {
+    const args = { ...createRepoSchema.parse(await readJson(c)), owner: c.req.param("owner") };
+    const { value, delta } = captureDelta((onDelta) => domain.createRepository(args, onDelta));
+    return created(value, delta);
+  }));
+  session.post("/repos/:owner/:repo/forks", handle(async (c) => {
+    const organization = (await maybeJson(c)).organization;
+    const { value, delta } = captureDelta((onDelta) => domain.forkRepository({ ...params(c), organization }, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/contents", handle((c) => ok(domain.getFileContents({ ...params(c), path: "", ref: c.req.query("ref") }))));
+  session.get("/repos/:owner/:repo/contents/*", handle((c) => ok(domain.getFileContents({ ...params(c), path: contentPath(c), ref: c.req.query("ref") }))));
+  session.put("/repos/:owner/:repo/contents/*", handle(async (c) => {
+    const body = contentSchema.parse(await readJson(c));
+    const args = { ...params(c), path: contentPath(c), ...body };
+    const actor = sessionLogin(c);
+    const { value, delta } = captureDelta((onDelta) => domain.createOrUpdateFile(args, { actor }, onDelta));
+    const status = delta !== null && delta.before === null ? 201 : 200;
+    return { status, body: value, mutation: true, delta };
+  }));
+  session.get("/repos/:owner/:repo/commits", handle((c) => ok(domain.listCommits({ ...params(c), sha: c.req.query("sha"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/git/refs", handle(async (c) => {
+    const body = z.object({ ref: z.string().min(1), sha: z.string().optional() }).parse(await readJson(c));
+    const branch = body.ref.replace(/^refs\/heads\//, "");
+    const { value, delta } = captureDelta((onDelta) => domain.createBranch({ ...params(c), branch, sha: body.sha }, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/issues", handle((c) => ok(domain.listIssues({ ...params(c), state: stateQuery(c), labels: c.req.query("labels"), assignee: c.req.query("assignee"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/issues", handle(async (c) => {
+    const args = { ...params(c), ...createIssueSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.createIssue(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/issues/:number", handle((c) => ok(domain.getIssue({ ...params(c), issue_number: numberParam(c, "number") }))));
+  session.patch("/repos/:owner/:repo/issues/:number", handle(async (c) => {
+    const args = { ...params(c), issue_number: numberParam(c, "number"), ...updateIssueSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.updateIssue(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.get("/repos/:owner/:repo/issues/:number/comments", handle((c) => ok(domain.listIssueComments({ ...params(c), issue_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/issues/:number/comments", handle(async (c) => {
+    const args = { ...params(c), issue_number: numberParam(c, "number"), ...commentSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.addIssueComment(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/labels", handle((c) => ok(domain.listRepositoryLabels(params(c)))));
+  session.post("/repos/:owner/:repo/labels", handle(async (c) => {
+    const args = { ...params(c), ...labelSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.createRepositoryLabel(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/issues/:number/labels", handle((c) => ok(domain.listIssueLabelsForIssue({ ...params(c), issue_number: numberParam(c, "number") }))));
+  session.post("/repos/:owner/:repo/issues/:number/labels", handle(async (c) => {
+    const args = { ...params(c), issue_number: numberParam(c, "number"), ...labelsSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.addIssueLabels(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.delete("/repos/:owner/:repo/issues/:number/labels/:name", handle((c) => {
+    const args = { ...params(c), issue_number: numberParam(c, "number"), label: requireParam(c, "name") };
+    const { value, delta } = captureDelta((onDelta) => domain.deleteIssueLabel(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.get("/repos/:owner/:repo/collaborators", handle((c) => ok(domain.listCollaborators(params(c)))));
+  session.get("/repos/:owner/:repo/collaborators/:username", handle((c) => {
+    const found = domain.isCollaborator({ ...params(c), username: requireParam(c, "username") });
+    if (!found)
+      throw new TwinError("Not Found", 404);
+    return { status: 204, body: null, mutation: false };
+  }));
+  session.post("/repos/:owner/:repo/issues/:number/assignees", handle(async (c) => {
+    const args = { ...params(c), issue_number: numberParam(c, "number"), ...assigneesSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.addAssignees(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/pulls", handle((c) => ok(domain.listPullRequests({ ...params(c), state: stateQuery(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/pulls", handle(async (c) => {
+    const actor = sessionLogin(c);
+    const args = { ...params(c), ...createPullSchema.parse(await readJson(c)), actor };
+    const { value, delta } = captureDelta((onDelta) => domain.createPullRequest(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/pulls/:number", handle((c) => ok(domain.getPullRequest({ ...params(c), pull_number: numberParam(c, "number") }))));
+  session.get("/repos/:owner/:repo/pulls/:number/files", handle((c) => ok(domain.getPullRequestFiles({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo/pulls/:number/reviews", handle((c) => ok(domain.getPullRequestReviews({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/pulls/:number/reviews", handle(async (c) => {
+    const args = { ...params(c), pull_number: numberParam(c, "number"), ...reviewSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.createPullRequestReview(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/pulls/:number/comments", handle((c) => ok(domain.getPullRequestComments({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo/pulls/:number/status", handle((c) => ok(domain.getPullRequestStatus({ ...params(c), pull_number: numberParam(c, "number") }))));
+  session.put("/repos/:owner/:repo/pulls/:number/merge", handle(async (c) => {
+    const args = { ...params(c), pull_number: numberParam(c, "number"), ...mergeSchema.parse(await maybeJson(c)) };
+    const actor = sessionLogin(c);
+    if (!actor || !domain.hasRepositoryPermission({ owner: args.owner, repo: args.repo, username: actor, permissions: ["push", "maintain", "admin"] })) {
+      throw new TwinError("Must have push access to the repository to merge pull requests.", 403);
+    }
+    const { value, delta } = captureDelta((onDelta) => domain.mergePullRequest(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.put("/repos/:owner/:repo/pulls/:number/update-branch", handle(async (c) => {
+    const args = { ...params(c), pull_number: numberParam(c, "number"), ...updateBranchSchema.parse(await maybeJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.updatePullRequestBranch(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.get("/repos/:owner/:repo/branches", handle((c) => ok(domain.listBranchesForRepo({ ...params(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo/branches/*", handle((c) => ok(domain.getBranchByName({ ...params(c), branch: routeTail(c, "branches/") }))));
+  session.delete("/repos/:owner/:repo/git/refs/heads/*", handle((c) => {
+    const args = { ...params(c), branch: routeTail(c, "git/refs/heads/") };
+    const { delta } = captureDelta((onDelta) => domain.deleteBranch(args, onDelta));
+    return { status: 204, body: null, mutation: true, delta };
+  }));
+  session.delete("/repos/:owner/:repo/contents/*", handle(async (c) => {
+    const body = deleteFileSchema.parse(await readJson(c));
+    const args = { ...params(c), path: contentPath(c), ...body };
+    const actor = sessionLogin(c);
+    const { value, delta } = captureDelta((onDelta) => domain.deleteFile(args, { actor }, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.get("/repos/:owner/:repo/commits/:ref", handle((c) => ok(domain.getCommitWithFiles({ ...params(c), ref: requireParam(c, "ref") }))));
+  session.get("/repos/:owner/:repo/compare/:basehead{.+}", handle((c) => {
+    const basehead = requireParam(c, "basehead");
+    const parts = basehead.split("...");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new TwinError("Invalid compare ref. Expected 'base...head'.", 422);
+    }
+    return ok(domain.compareCommits({ ...params(c), base: parts[0], head: parts[1] }));
+  }));
+  session.get("/repos/:owner/:repo/pulls/:number/diff", handle((c) => ok(domain.getPullRequestDiff({ ...params(c), pull_number: numberParam(c, "number") }))));
+  session.patch("/repos/:owner/:repo/pulls/:number", handle(async (c) => {
+    const args = { ...params(c), pull_number: numberParam(c, "number"), ...updatePrSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.updatePullRequest(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.get("/repos/:owner/:repo/pulls/:number/commits", handle((c) => ok(domain.getPullRequestCommits({ ...params(c), pull_number: numberParam(c, "number"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/pulls/:number/comments", handle(async (c) => {
+    const args = { ...params(c), pull_number: numberParam(c, "number"), ...reviewCommentSchema.parse(await readJson(c)) };
+    const actor = sessionLogin(c);
+    const { value, delta } = captureDelta((onDelta) => domain.createPullRequestReviewComment(args, { actor }, onDelta));
+    return created(value, delta);
+  }));
+  session.post("/repos/:owner/:repo/pulls/:number/comments/:comment_id/replies", handle(async (c) => {
+    const args = { ...params(c), pull_number: numberParam(c, "number"), comment_id: numberParam(c, "comment_id"), ...replyCommentSchema.parse(await readJson(c)) };
+    const actor = sessionLogin(c);
+    const { value, delta } = captureDelta((onDelta) => domain.addReplyToPullRequestComment(args, { actor }, onDelta));
+    return created(value, delta);
+  }));
+  session.patch("/repos/:owner/:repo/issues/comments/:comment_id", handle(async (c) => {
+    const args = { ...params(c), comment_id: numberParam(c, "comment_id"), ...updateCommentSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.updateIssueComment(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.delete("/repos/:owner/:repo/issues/comments/:comment_id", handle((c) => {
+    const args = { ...params(c), comment_id: numberParam(c, "comment_id") };
+    const { delta } = captureDelta((onDelta) => domain.deleteIssueComment(args, onDelta));
+    return { status: 204, body: null, mutation: true, delta };
+  }));
+  session.get("/repos/:owner/:repo/milestones", handle((c) => ok(domain.listMilestones({ ...params(c), state: stateQuery(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.post("/repos/:owner/:repo/milestones", handle(async (c) => {
+    const args = { ...params(c), ...milestoneSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.createMilestone(args, onDelta));
+    return created(value, delta);
+  }));
+  session.patch("/repos/:owner/:repo/milestones/:number", handle(async (c) => {
+    const args = { ...params(c), milestone_number: numberParam(c, "number"), ...updateMilestoneSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.updateMilestone(args, onDelta));
+    return ok(value, true, delta);
+  }));
+  session.delete("/repos/:owner/:repo/milestones/:number", handle((c) => {
+    const args = { ...params(c), milestone_number: numberParam(c, "number") };
+    const { delta } = captureDelta((onDelta) => domain.deleteMilestone(args, onDelta));
+    return { status: 204, body: null, mutation: true, delta };
+  }));
+  session.post("/repos/:owner/:repo/statuses/:sha", handleAs("create_commit_status", async (c) => {
+    const args = { ...params(c), sha: requireParam(c, "sha"), ...createStatusSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.createCommitStatus(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/commits/:ref/status", handle((c) => ok(domain.getCombinedStatusForRef({ ...params(c), ref: requireParam(c, "ref") }))));
+  session.post("/repos/:owner/:repo/check-runs", handleAs("create_check_run", async (c) => {
+    const args = { ...params(c), ...createCheckRunSchema.parse(await readJson(c)) };
+    const { value, delta } = captureDelta((onDelta) => domain.createCheckRun(args, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/repos/:owner/:repo/commits/:ref/check-runs", handle((c) => ok(domain.listCheckRunsForRef({ ...params(c), ref: requireParam(c, "ref"), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo/tags", handle((c) => ok(domain.listTags({ ...params(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo/releases", handle((c) => ok(domain.listReleases({ ...params(c), page: numberQuery(c, "page"), per_page: numberQuery(c, "per_page") }))));
+  session.get("/repos/:owner/:repo/releases/latest", handle((c) => ok(domain.getLatestRelease(params(c)))));
+  session.get("/repos/:owner/:repo/releases/tags/*", handle((c) => ok(domain.getReleaseByTag({ ...params(c), tag: routeTail(c, "releases/tags/") }))));
+  session.post("/repos/:owner/:repo/releases", handle(async (c) => {
+    const args = { ...params(c), ...createReleaseSchema.parse(await readJson(c)) };
+    const actor = sessionLogin(c);
+    const { value, delta } = captureDelta((onDelta) => domain.createRelease(args, { actor }, onDelta));
+    return created(value, delta);
+  }));
+  session.get("/user", handle((c) => ok(domain.getMe({ actor: sessionLogin(c) }))));
+  session.put("/repos/:owner/:repo/collaborators/:username", handle(async (c) => {
+    const body = addCollaboratorSchema.parse(await maybeJson(c));
+    const actor = sessionLogin(c);
+    if (!actor || !domain.hasRepositoryPermission({ ...params(c), username: actor, permissions: ["push", "maintain", "admin"] })) {
+      throw new TwinError("Must have push access to the repository to add collaborators.", 403);
+    }
+    const args = { ...params(c), username: requireParam(c, "username"), permission: body.permission };
+    const { value, delta } = captureDelta((onDelta) => domain.addCollaboratorAction({ ...args, actor }, onDelta));
+    return { status: value.status, body: value.body, mutation: true, delta };
+  }));
+}
+function ok(body, mutation = false, delta = null) {
+  return { status: 200, body, mutation, delta };
+}
+function created(body, delta = null) {
+  return { status: 201, body, mutation: true, delta };
+}
+async function readJson(c) {
+  try {
+    return await c.req.json();
+  } catch {
+    throw new SyntaxError("Problems parsing JSON");
+  }
+}
+async function maybeJson(c) {
+  try {
+    return await c.req.json();
+  } catch {
+    return {};
+  }
+}
+function params(c) {
+  return { owner: requireParam(c, "owner"), repo: requireParam(c, "repo") };
+}
+function sessionLogin(c) {
+  const session = c.get("session");
+  return typeof session?.login === "string" ? session.login : void 0;
+}
+function numberParam(c, name) {
+  const value = Number(c.req.param(name));
+  if (!Number.isInteger(value) || value < 1)
+    validationFailed(name, "invalid", c.req.param(name));
+  return value;
+}
+function requireParam(c, name) {
+  const value = c.req.param(name);
+  if (!value)
+    throw new TwinError(`Missing route parameter: ${name}`, 400);
+  return value;
+}
+function contentPath(c) {
+  return routeTail(c, "contents/");
+}
+function routeTail(c, marker) {
+  const { owner, repo } = params(c);
+  const pathname = new URL(c.req.url).pathname;
+  const sid = pathname.match(/^\/s\/([^/]+)\//)?.[1] ?? "";
+  const prefix = `/s/${sid}/repos/${owner}/${repo}/${marker}`;
+  const value = decodeURIComponent(pathname.startsWith(prefix) ? pathname.slice(prefix.length) : "");
+  if (!value)
+    throw new TwinError(`Missing route path after ${marker}`, 400);
+  return value;
+}
+function numberQuery(c, name) {
+  const value = c.req.query(name);
+  return value ? Number(value) : void 0;
+}
+function stateQuery(c) {
+  const state = c.req.query("state");
+  return state === "open" || state === "closed" || state === "all" ? state : void 0;
+}
+
+// ../packages/twin-github/dist/src/unsupported-envelope.js
+var unsupportedEnvelope = {
+  status: 501,
+  body: {
+    message: "This endpoint is not supported by this GitHub twin clone.",
+    _twin: {
+      fidelity: "unsupported",
+      supported_surfaces: [
+        "GitHub-shaped REST",
+        "POST /s/:sid/mcp",
+        "GET /s/:sid/mcp/tools",
+        "POST /s/:sid/mcp/tools/:name",
+        "POST /s/:sid/mcp/call"
+      ]
+    }
+  }
+};
+
+// ../packages/twin-github/dist/src/twin.js
+var seedParser = {
+  parse(input) {
+    if (input === null || input === void 0)
+      throw new SyntaxError("Problems parsing JSON");
+    return parseSeed(input);
+  },
+  safeParse(input) {
+    try {
+      return { success: true, data: seedParser.parse(input) };
+    } catch (error) {
+      return { success: false, error };
+    }
+  }
+};
+function actorFromSession(session) {
+  return typeof session?.login === "string" ? session.login : void 0;
+}
+function zodIssues(err) {
+  if (err instanceof ZodError)
+    return err.issues;
+  if (err instanceof Error && err.name === "ZodError" && Array.isArray(err.issues)) {
+    return err.issues;
+  }
+  return void 0;
+}
+function githubErrorEnvelope(err) {
+  if (err instanceof UnknownToolError) {
+    return {
+      status: 422,
+      body: githubError("Validation Failed", 422, [
+        { resource: "Request", field: "tool", code: "invalid", value: err.tool }
+      ])
+    };
+  }
+  if (err instanceof TwinError) {
+    return { status: err.status, body: githubError(err.message, err.status, err.errors) };
+  }
+  const issues = zodIssues(err);
+  if (issues) {
+    return {
+      status: 422,
+      body: githubError("Validation Failed", 422, issues.map((issue) => ({
+        resource: "Request",
+        field: issue.path.join("."),
+        code: issue.code
+      })))
+    };
+  }
+  if (err instanceof SyntaxError) {
+    return { status: 400, body: githubError("Problems parsing JSON", 400) };
+  }
+  return {
+    status: 500,
+    body: githubError(err instanceof Error ? err.message : "Internal Server Error", 500)
+  };
+}
+var toolListing = new Map(listTools().map((tool) => [tool.name, tool]));
+var githubTwinDefinition = defineTwin({
+  id: "github",
+  version: process.env.POME_TWIN_VERSION ?? "0.1.0",
+  implementation: "github_clone",
+  packageName: "@pome-sh/twin-github",
+  fidelity: { default: "semantic" },
+  seed: seedParser,
+  domain: ({ db, seed }) => {
+    const domain = new GitHubDomain(db ?? openGitHubCloneDatabase());
+    if (seed !== void 0)
+      domain.seed(seed);
+    return domain;
+  },
+  routes: registerGitHubRoutes,
+  state: ({ domain }) => domain.exportState(),
+  admin: {
+    reset: ({ domain, reportDelta }) => {
+      domain.seed(defaultSeedState(), reportDelta);
+      return { ok: true, message: "GitHub twin state reset to default seed." };
+    },
+    seed: ({ domain, seed, reportDelta }) => {
+      domain.seed(seed, reportDelta);
+      return { ok: true, repositories: seed.repositories.length };
+    }
+    // The admin-gate 403 body is the gate's default GitHub envelope
+    // ({message: "Forbidden"}); no per-twin override needed.
+  },
+  tools: toolDefinitions.map((def) => ({
+    name: def.name,
+    description: def.description,
+    schema: def.schema,
+    mutation: isMutatingTool(def.name),
+    inputSchema: toolListing.get(def.name)?.input_schema,
+    handler: (domain, args, ctx) => executeTool(domain, def.name, args, ctx.reportDelta, {
+      actor: actorFromSession(ctx.session)
+    })
+  })),
+  // Frozen healthz shape: {ok, twin, implementation, fidelity, tools,
+  // access_control, runtime} — no version field (github never carried it).
+  healthz: () => ({
+    fidelity: "semantic",
+    access_control: summarizeGitHubAccessControlCatalog()
+  }),
+  // Frozen per-session health shape: implementation + fidelity + runtime,
+  // no version (pre-port /_pome/health).
+  pomeHealth: () => ({
+    implementation: "github_clone",
+    fidelity: "semantic",
+    runtime: twinBuildInfo("@pome-sh/twin-github")
+  }),
+  // Frozen extra session route (CONTRACT.md per-twin table).
+  pomeRoutes: {
+    "access-control": () => githubAccessControlPayload()
+  },
+  // FDRS-402 adapter-rich tape pin: x-pome-correlation-id persists as
+  // tool_call_id on every recorded event (github's frozen tape shape).
+  stampToolCallId: true,
+  // Frozen JSON-RPC unknown-tool result text (the legacy /mcp/call surface
+  // keeps the 422 validation envelope from errorEnvelope above).
+  mcpUnknownTool: (name) => ({ message: `Unknown tool: ${name}` }),
+  unsupported: () => unsupportedEnvelope,
+  errorEnvelope: githubErrorEnvelope,
+  auth: {
+    // F-712 pins (wire-frozen): Bearer-header only (no extra token
+    // resolvers), raw bearer rejected (allowRawBearer=false), sid mismatch
+    // → 401 {message:"Forbidden"}, and every credential failure — expired
+    // JWT included — renders 401 {message:"Bad credentials"}. The pre-port
+    // explicit "Token expired" branch was dead code: hono/jwt's verify
+    // throws JwtTokenExpired before the branch was ever reached, so the
+    // wire always said "Bad credentials" (pre-ruled: deleting it is zero
+    // wire diff).
+    providerToken: { provider: "github", prefixes: ["ghp_pome_", "github_pat_pome_"] },
+    allowRawBearer: false,
+    unauthorized: () => ({
+      status: 401,
+      body: { message: "Bad credentials", documentation_url: "" }
+    }),
+    sidMismatch: () => ({
+      status: 401,
+      body: { message: "Forbidden", documentation_url: "" }
+    }),
+    sessionExtras: (claims) => typeof claims.login === "string" && claims.login.length > 0 ? { login: claims.login } : {}
+  }
+});
+function createGitHubCloneApp(options = {}) {
+  return createApp(githubTwinDefinition, {
+    db: options.db ?? openGitHubCloneDatabase(),
+    recorder: options.recorder,
+    runId: options.runId ?? "local",
+    // Pre-port factory semantics: an explicit `db` carries its own state
+    // (the boot path seeds before binding); otherwise seed the supplied or
+    // default world.
+    seed: options.db ? void 0 : options.seed ?? defaultSeedState()
+  });
+}
+
+export { GitHubDomain, TAPE_ASSERTABLE_TOOLS, createGitHubCloneApp, defaultSeedState, executeTool, githubTwinDefinition, listTools, openGitHubCloneDatabase, parseSeed, resetDatabase, seedSchema, toolDefinitions };