opencode-forgekeeper 1.0.0

package/dist/index.js

@@ -0,0 +1,2319 @@
+// @bun
+// packages/_shared/src/exec.ts
+import { execFile } from "child_process";
+function exec(file, args, options = {}) {
+  return new Promise((resolve) => {
+    execFile(file, args, {
+      cwd: options.cwd,
+      env: options.env ? { ...process.env, ...options.env } : process.env,
+      timeout: options.timeout,
+      maxBuffer: 16 * 1024 * 1024,
+      encoding: "utf8"
+    }, (error, stdout, stderr) => {
+      if (!error) {
+        resolve({ stdout, stderr, code: 0 });
+        return;
+      }
+      const code = typeof error.code === "number" ? error.code : -1;
+      resolve({ stdout, stderr: stderr || error.message, code });
+    });
+  });
+}
+// packages/forgekeeper/src/exec.ts
+var execWithTimeout = (timeout) => (file, args, cwd) => exec(file, args, { cwd, timeout });
+var exec2 = execWithTimeout(30000);
+
+// packages/forgekeeper/src/git.ts
+function parseRemote(url) {
+  const trimmed = url.trim();
+  let host;
+  let path;
+  const scp = trimmed.match(/^(?:[^@/]+@)?([^:/]+):(?!\/)(.+)$/);
+  if (scp && !/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
+    host = scp[1];
+    path = scp[2];
+  } else {
+    let parsed;
+    try {
+      parsed = new URL(trimmed);
+    } catch {
+      return;
+    }
+    if (!["ssh:", "https:", "http:", "git+ssh:", "ssh+git:"].includes(parsed.protocol))
+      return;
+    host = parsed.hostname;
+    path = decodeURIComponent(parsed.pathname);
+  }
+  path = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/, "");
+  if (!host || !path.includes("/"))
+    return;
+  return { host: host.toLowerCase(), path };
+}
+var stripHeads = (ref) => ref.replace(/^refs\/heads\//, "");
+async function git(run, directory, args) {
+  const result = await run("git", args, directory);
+  return result.code === 0 ? result.stdout.trim() : undefined;
+}
+async function resolveRepository(run, directory, supported) {
+  const top = await git(run, directory, ["rev-parse", "--show-toplevel"]);
+  if (top === undefined)
+    return { kind: "none", reason: "Not a Git repository" };
+  const branch = await git(run, directory, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  if (!branch)
+    return { kind: "none", reason: "Detached HEAD" };
+  const [head, refs, remoteConfig] = await Promise.all([
+    git(run, directory, ["rev-parse", "HEAD"]),
+    git(run, directory, [
+      "for-each-ref",
+      "--format=%(push:remotename)%00%(push:remoteref)%00%(upstream:remotename)%00%(upstream:remoteref)",
+      `refs/heads/${branch}`
+    ]),
+    git(run, directory, ["config", "--get-regexp", "^remote\\..*\\.url$"])
+  ]);
+  const remotes = new Map;
+  for (const line of (remoteConfig ?? "").split(`
+`)) {
+    const match = line.match(/^remote\.(.+)\.url\s+(.+)$/);
+    if (match)
+      remotes.set(match[1], match[2]);
+  }
+  if (remotes.size === 0)
+    return { kind: "none", reason: "No Git remotes" };
+  const [pushRemote, pushRef, upstreamRemote, upstreamRef] = (refs ?? "").split("\x00");
+  let sourceRemote;
+  let sourceBranch = branch;
+  if (pushRemote && remotes.has(pushRemote)) {
+    sourceRemote = pushRemote;
+    if (pushRef)
+      sourceBranch = stripHeads(pushRef);
+  } else if (upstreamRemote && remotes.has(upstreamRemote)) {
+    sourceRemote = upstreamRemote;
+    if (upstreamRef)
+      sourceBranch = stripHeads(upstreamRef);
+  } else if (remotes.has("origin")) {
+    sourceRemote = "origin";
+  } else if (remotes.size === 1) {
+    sourceRemote = [...remotes.keys()][0];
+  }
+  if (!sourceRemote)
+    return { kind: "none", reason: "No remote for the current branch" };
+  const source = parseRemote(remotes.get(sourceRemote));
+  if (!source || !supported(source.host))
+    return { kind: "none", reason: "Not a supported forge remote" };
+  const remoteHead = await git(run, directory, [
+    "symbolic-ref",
+    "--quiet",
+    "--short",
+    `refs/remotes/${sourceRemote}/HEAD`
+  ]);
+  if (remoteHead && remoteHead === `${sourceRemote}/${sourceBranch}`) {
+    return { kind: "none", reason: "Default branch" };
+  }
+  const targets = [source];
+  for (const url of remotes.values()) {
+    const project = parseRemote(url);
+    if (!project || project.host !== source.host)
+      continue;
+    if (targets.some((target) => target.path.toLowerCase() === project.path.toLowerCase()))
+      continue;
+    targets.push(project);
+  }
+  return {
+    kind: "repository",
+    repository: { head: head ?? "", branch, sourceBranch, source, targets }
+  };
+}
+async function resolveProjects(run, directory, accepted) {
+  const remoteConfig = await git(run, directory, ["config", "--get-regexp", "^remote\\..*\\.url$"]);
+  if (remoteConfig === undefined)
+    return { kind: "none", reason: "No Git remotes" };
+  const remotes = [];
+  for (const line of remoteConfig.split(`
+`)) {
+    const match = line.match(/^remote\.(.+)\.url\s+(.+)$/);
+    if (match)
+      remotes.push([match[1], match[2]]);
+  }
+  remotes.sort(([a], [b]) => Number(b === "origin") - Number(a === "origin"));
+  const projects = [];
+  for (const [, url] of remotes) {
+    const project = parseRemote(url);
+    if (!project || !accepted(project.host))
+      continue;
+    if (projects.length > 0 && project.host !== projects[0].host)
+      continue;
+    if (projects.some((known) => known.path.toLowerCase() === project.path.toLowerCase()))
+      continue;
+    projects.push(project);
+  }
+  return projects.length > 0 ? { kind: "projects", projects } : { kind: "none", reason: "No matching forge remote" };
+}
+
+// packages/forgekeeper/src/forge.ts
+var ownedBy = (kind) => (request) => request.forge === kind;
+var titlePrefix = (title) => title?.match(/^\[[^\]]*\]/)?.[0] ?? "";
+function prefixReferences(title, sigil) {
+  return titlePrefix(title).slice(1, -1).split(/[\s,]+/).flatMap((token) => token.startsWith(sigil) && /^[1-9]\d*$/.test(token.slice(sigil.length)) ? [token.slice(sigil.length)] : []);
+}
+function parseWebUrl(kind, value, pattern) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return;
+  }
+  if (!["https:", "http:"].includes(url.protocol))
+    return;
+  const match = url.pathname.match(pattern);
+  if (!match)
+    return;
+  return {
+    forge: kind,
+    host: url.hostname.toLowerCase(),
+    project: decodeURIComponent(match[1]),
+    iid: match[2]
+  };
+}
+var yesNo = (value) => value ? "yes" : "no";
+var humanize = (value) => value.toLowerCase().replace(/_/g, " ");
+
+class ForgeError extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+}
+
+// packages/forgekeeper/src/gitlab-feedback.ts
+var PAGE_SIZE = 100;
+var MAX_COMMENT_PAGES = 20;
+var COMMENTS_QUERY = `query($project: ID!, $iid: String!, $before: String) {
+  currentUser { id }
+  project(fullPath: $project) {
+    mergeRequest(iid: $iid) {
+      notes(last: ${PAGE_SIZE}, before: $before, filter: ONLY_COMMENTS) {
+        pageInfo { hasPreviousPage startCursor }
+        nodes {
+          id url createdAt updatedAt lastEditedAt system
+          discussion { resolved }
+          author { id username bot }
+        }
+      }
+    }
+  }
+}`;
+var noteNumber = (id) => id.slice(id.lastIndexOf("/") + 1);
+var timestamp = (node) => Date.parse(node.lastEditedAt ?? node.updatedAt ?? node.createdAt);
+function toComment(node) {
+  const editedAt = timestamp(node);
+  const id = noteNumber(node.id);
+  if (node.system || !node.author || !Number.isFinite(editedAt) || !/^\d+$/.test(id))
+    return;
+  return {
+    id,
+    order: Number(id),
+    url: node.url ?? "",
+    editedAt,
+    resolved: node.discussion?.resolved === true,
+    bot: node.author.bot,
+    authorID: node.author.id,
+    username: node.author.username
+  };
+}
+async function fetchComments(graphql, host, project, iid) {
+  const pages = [];
+  let viewerID;
+  let before;
+  const snapshot = (complete) => ({
+    complete: complete && viewerID !== undefined,
+    viewerID,
+    comments: pages.toReversed().flat()
+  });
+  for (let page = 0;page < MAX_COMMENT_PAGES; page++) {
+    const variables = { project, iid };
+    if (before)
+      variables.before = before;
+    const data = await graphql(host, COMMENTS_QUERY, variables);
+    viewerID ??= data?.currentUser?.id ?? undefined;
+    const connection = data?.project?.mergeRequest?.notes;
+    if (!connection)
+      return page === 0 ? undefined : snapshot(false);
+    pages.push(connection.nodes.flatMap((node) => toComment(node) ?? []));
+    if (!connection.pageInfo.hasPreviousPage)
+      return snapshot(true);
+    before = connection.pageInfo.startCursor ?? undefined;
+    if (!before)
+      return snapshot(false);
+  }
+  return snapshot(true);
+}
+
+// packages/forgekeeper/src/gitlab.ts
+var DISCUSSIONS = "pageInfo { hasNextPage endCursor } nodes { resolvable resolved }";
+var PAGE_SIZE2 = 100;
+var MAX_DISCUSSION_PAGES = 50;
+var MERGE_REQUEST_FIELDS = `
+  iid title webUrl state draft conflicts approved detailedMergeStatus diffHeadSha updatedAt targetBranch
+  approvedBy(first: 100) { nodes { id bot } }
+  sourceProject { fullPath }
+  targetProject { fullPath }
+  headPipeline { status path detailedStatus { label } }
+  reviewers(first: 100) { nodes { type username bot mergeRequestInteraction { reviewState approved } } }
+  discussions(first: ${PAGE_SIZE2}) { ${DISCUSSIONS} }
+`;
+function mergeRequestsQuery(projectCount) {
+  const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
+  const projects = Array.from({ length: projectCount }, (_, index) => `p${index}: project(fullPath: $p${index}) {
+        mergeRequests(sourceBranches: [$branch], state: opened, first: 20) { nodes { ${MERGE_REQUEST_FIELDS} } }
+      }`).join(`
+`);
+  return `query($branch: String!, ${variables}) {
+${projects}
+}`;
+}
+function mergeRequestQuery(projectCount) {
+  const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
+  const projects = Array.from({ length: projectCount }, (_, index) => `p${index}: project(fullPath: $p${index}) { mergeRequest(iid: $iid) { ${MERGE_REQUEST_FIELDS} } }`).join(`
+`);
+  return `query($iid: String!, ${variables}) {
+${projects}
+}`;
+}
+function mergeRequestNumbersQuery(projectCount) {
+  const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
+  const projects = Array.from({ length: projectCount }, (_, index) => `p${index}: project(fullPath: $p${index}) {
+        mergeRequests(sourceBranches: [$branch], state: opened, first: 20) { nodes { iid updatedAt sourceProject { fullPath } } }
+      }`).join(`
+`);
+  return `query($branch: String!, ${variables}) {
+${projects}
+}`;
+}
+var SOURCE_BRANCH_QUERY = `query($project: ID!, $iid: String!) {
+  project(fullPath: $project) { mergeRequest(iid: $iid) { sourceBranch } }
+}`;
+var DISCUSSIONS_QUERY = `query($project: ID!, $iid: String!, $after: String) {
+  project(fullPath: $project) {
+    mergeRequest(iid: $iid) { discussions(first: ${PAGE_SIZE2}, after: $after) { ${DISCUSSIONS} } }
+  }
+}`;
+function classifyError(message, code) {
+  const text = message.trim().replace(/^glab:\s*/, "") || `glab exited with code ${code}`;
+  if (/ENOENT|command not found/i.test(text))
+    return new ForgeError("missing-glab", "glab is not installed");
+  if (/\b401\b|unauthori[sz]ed|not logged in|authenticate|invalid token|token.*expired/i.test(text)) {
+    return new ForgeError("auth", "GitLab authentication failed. Run `glab auth status`.");
+  }
+  if (/\b429\b|rate limit|too many requests/i.test(text))
+    return new ForgeError("rate-limit", "GitLab rate limit reached");
+  return new ForgeError("request", text.split(`
+`)[0]);
+}
+var isResponse = (body) => typeof body === "object" && body !== null && (!("errors" in body) || Array.isArray(body.errors)) && (!("data" in body) || typeof body.data === "object");
+function glabGraphQL(run, cwd) {
+  return async (host, query, variables) => {
+    const args = ["api", "graphql", "--hostname", host, "-f", `query=${query}`];
+    for (const [name, value] of Object.entries(variables))
+      args.push("-f", `${name}=${value}`);
+    const result = await run("glab", args, cwd);
+    let body;
+    try {
+      body = JSON.parse(result.stdout);
+    } catch {
+      throw classifyError(result.stderr, result.code);
+    }
+    if (!isResponse(body))
+      throw classifyError(result.stderr || "Unexpected GitLab response", result.code);
+    if (body.errors?.length)
+      throw classifyError(String(body.errors[0]?.message ?? ""), result.code);
+    if (result.code !== 0)
+      throw classifyError(result.stderr, result.code);
+    if (!body.data)
+      throw classifyError("GitLab returned no data", result.code);
+    return body.data;
+  };
+}
+var countUnresolved = (page) => page.nodes.filter((discussion) => discussion.resolvable && !discussion.resolved).length;
+var gitlabTraits = {
+  kind: "gitlab",
+  noun: "MR",
+  ci: "pipeline",
+  recognizes: (host) => /(^|\.)gitlab\./.test(host),
+  open: (run, directory) => new GitLabForge(glabGraphQL(run, directory)),
+  owns: ownedBy("gitlab"),
+  parseUrl: (url) => parseWebUrl("gitlab", url, /^\/(.+)\/-\/merge_requests\/([1-9]\d*)\/?$/),
+  parseIssueUrl: (url) => parseWebUrl("gitlab", url, /^\/(.+)\/-\/(?:issues|work_items)\/([1-9]\d*)\/?$/),
+  reference: (iid) => `!${iid}`,
+  issueReference: (iid) => `#${iid}`,
+  titleReferences: (title) => prefixReferences(title, "!"),
+  indicators: () => [],
+  details(request) {
+    const requirements = request.approvalRequirementsSatisfied === null ? "unknown" : yesNo(request.approvalRequirementsSatisfied);
+    const lines = [
+      `Human approvals: ${yesNo(request.hasApprovals)} \xB7 Approval requirements satisfied: ${requirements}`
+    ];
+    if (request.mergeStatus)
+      lines.push(`Merge status: ${humanize(request.mergeStatus)}`);
+    return lines;
+  },
+  automatedReview: {
+    name: "GitLab Duo",
+    status(request) {
+      const state = request.duoReviewState;
+      if (!state)
+        return;
+      return { state: duoState(state), label: humanize(state) };
+    }
+  },
+  feedback: {
+    async fetch(run, directory, request) {
+      const ref = gitlabTraits.parseUrl(request.url);
+      return ref ? fetchComments(glabGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
+    }
+  }
+};
+var DUO_FEEDBACK = new Set(["REVIEWED", "REQUESTED_CHANGES"]);
+function duoState(state) {
+  if (state === "REVIEW_STARTED")
+    return "running";
+  return DUO_FEEDBACK.has(state) ? "feedback" : "settled";
+}
+
+class GitLabForge {
+  graphql;
+  traits = gitlabTraits;
+  constructor(graphql) {
+    this.graphql = graphql;
+  }
+  async findByBranch(repository) {
+    const { source, targets, sourceBranch } = repository;
+    const variables = { branch: sourceBranch };
+    targets.forEach((target, index) => variables[`p${index}`] = target.path);
+    const data = await this.graphql(source.host, mergeRequestsQuery(targets.length), variables);
+    const sourcePath = source.path.toLowerCase();
+    const seen = new Set;
+    const nodes = [];
+    targets.forEach((_, index) => {
+      for (const node of data?.[`p${index}`]?.mergeRequests?.nodes ?? []) {
+        if (node.sourceProject?.fullPath.toLowerCase() !== sourcePath)
+          continue;
+        const key = `${node.targetProject.fullPath}!${node.iid}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        nodes.push(node);
+      }
+    });
+    const requests = await Promise.all(nodes.map((node) => this.normalize(source.host, node)));
+    return requests.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+  }
+  async findNumberByBranch(repository) {
+    const { source, targets, sourceBranch } = repository;
+    const variables = { branch: sourceBranch };
+    targets.forEach((target, index) => variables[`p${index}`] = target.path);
+    const data = await this.graphql(source.host, mergeRequestNumbersQuery(targets.length), variables);
+    const sourcePath = source.path.toLowerCase();
+    const nodes = targets.flatMap((_, index) => data?.[`p${index}`]?.mergeRequests?.nodes ?? []);
+    return nodes.filter((node) => node.sourceProject?.fullPath.toLowerCase() === sourcePath).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))[0]?.iid;
+  }
+  async sourceBranch(ref) {
+    const data = await this.graphql(ref.host, SOURCE_BRANCH_QUERY, {
+      project: ref.project,
+      iid: ref.iid
+    });
+    const branch = data?.project?.mergeRequest?.sourceBranch;
+    return typeof branch === "string" && branch ? branch : undefined;
+  }
+  async findByNumber(projects, iid) {
+    if (projects.length === 0)
+      return;
+    const host = projects[0].host;
+    const variables = { iid };
+    projects.forEach((project, index) => variables[`p${index}`] = project.path);
+    const data = await this.graphql(host, mergeRequestQuery(projects.length), variables);
+    for (let index = 0;index < projects.length; index++) {
+      const node = data?.[`p${index}`]?.mergeRequest ?? undefined;
+      if (node)
+        return this.normalize(host, node);
+    }
+    return;
+  }
+  async unresolvedThreads(host, node) {
+    let count = countUnresolved(node.discussions);
+    let page = node.discussions.pageInfo;
+    let pages = 1;
+    while (page.hasNextPage && page.endCursor && pages < MAX_DISCUSSION_PAGES) {
+      const data = await this.graphql(host, DISCUSSIONS_QUERY, {
+        project: node.targetProject.fullPath,
+        iid: node.iid,
+        after: page.endCursor
+      });
+      const next = data?.project?.mergeRequest?.discussions;
+      if (!next)
+        break;
+      count += countUnresolved(next);
+      page = next.pageInfo;
+      pages++;
+    }
+    return { count, complete: !page.hasNextPage };
+  }
+  async normalize(host, node) {
+    const threads = await this.unresolvedThreads(host, node);
+    const pipeline = node.headPipeline;
+    const hasApprovals = (node.approvedBy?.nodes ?? []).some((approver) => approver.bot !== true);
+    const awaitingReviewers = (node.reviewers?.nodes ?? []).filter((reviewer) => reviewer.bot !== true && reviewer.username && reviewer.mergeRequestInteraction?.approved !== true).map((reviewer) => reviewer.username);
+    return {
+      forge: "gitlab",
+      iid: node.iid,
+      title: node.title,
+      url: node.webUrl,
+      state: node.state.toLowerCase(),
+      draft: node.draft,
+      conflicts: node.conflicts,
+      conflictsKnown: true,
+      approved: node.approved === true && hasApprovals && awaitingReviewers.length === 0,
+      hasApprovals,
+      approvalRequirementsSatisfied: node.approved,
+      awaitingReviewers,
+      reviewersComplete: true,
+      mergeStatus: node.detailedMergeStatus ?? undefined,
+      targetProject: node.targetProject.fullPath,
+      targetBranch: node.targetBranch,
+      headSha: node.diffHeadSha ?? undefined,
+      updatedAt: node.updatedAt ?? undefined,
+      pipeline: pipeline ? {
+        status: pipeline.status,
+        label: pipeline.detailedStatus?.label ?? pipeline.status.toLowerCase().replace(/_/g, " "),
+        url: pipeline.path ? `https://${host}${pipeline.path}` : undefined
+      } : undefined,
+      unresolvedThreads: threads.count,
+      threadsComplete: threads.complete,
+      duoReviewState: node.reviewers?.nodes.find((reviewer) => reviewer.type === "DUO_CODE_REVIEW_BOT")?.mergeRequestInteraction?.reviewState ?? undefined
+    };
+  }
+}
+
+// packages/forgekeeper/src/github.ts
+var fields = `number title url state isDraft mergeable reviewDecision headRefOid headRefName
+  headRepository { nameWithOwner } baseRepository { nameWithOwner } baseRefName updatedAt
+  reviewThreads(first:100) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
+  reviewRequests(first:100) { nodes { requestedReviewer { ... on User { login } ... on Team { name } } } pageInfo { hasNextPage } }
+  commits(last:1) { nodes { commit { statusCheckRollup { contexts(first:100) {
+    nodes { __typename ... on CheckRun { status conclusion detailsUrl } ... on StatusContext { state targetUrl } }
+    pageInfo { hasNextPage endCursor }
+  } } } } }`;
+var MAX_PAGES = 50;
+function ghGraphQL(run, cwd) {
+  return async (host, query, variables) => {
+    const args = ["api", "graphql", "--hostname", host, "-f", `query=${query}`];
+    for (const [name, value] of Object.entries(variables))
+      args.push(typeof value === "number" ? "-F" : "-f", `${name}=${value}`);
+    const result = await run("gh", args, cwd);
+    let body;
+    try {
+      body = JSON.parse(result.stdout);
+    } catch {
+      throw classifyError2(result.stderr, result.code);
+    }
+    const errors = (body.errors ?? []).filter((error) => error.type !== "NOT_FOUND");
+    if (!body.data || errors.length || result.code !== 0 && !body.errors?.length) {
+      throw classifyError2(errors[0]?.message ?? result.stderr, result.code);
+    }
+    return body.data;
+  };
+}
+function classifyError2(message, code) {
+  const text = message.trim() || `gh exited with code ${code}`;
+  if (/ENOENT|command not found/i.test(text))
+    return new ForgeError("missing-gh", "gh is not installed");
+  if (/401|unauthori[sz]ed|authenticate|not logged|token.*expired/i.test(text))
+    return new ForgeError("auth", "GitHub authentication failed. Run `gh auth status`.");
+  if (/429|rate limit|too many requests/i.test(text))
+    return new ForgeError("rate-limit", "GitHub rate limit reached");
+  return new ForgeError("request", text.split(`
+`)[0]);
+}
+var FAILED = [
+  "FAILURE",
+  "ERROR",
+  "TIMED_OUT",
+  "CANCELLED",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+];
+var CONCLUSIONS = [
+  "SUCCESS",
+  "NEUTRAL",
+  "SKIPPED",
+  "FAILURE",
+  "TIMED_OUT",
+  "CANCELLED",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+];
+var STATES = ["SUCCESS", "FAILURE", "ERROR", "PENDING", "EXPECTED"];
+function checks(nodes, complete, url) {
+  const failed = nodes.filter((node) => FAILED.includes(node.conclusion ?? node.state ?? "")).length;
+  const pending = nodes.filter((node) => node.status ? node.status !== "COMPLETED" : ["PENDING", "EXPECTED"].includes(node.state ?? "")).length;
+  const unknown = nodes.some((node) => node.status === "COMPLETED" ? !CONCLUSIONS.includes(node.conclusion ?? "") : !node.status && !STATES.includes(node.state ?? ""));
+  if (failed)
+    return {
+      status: "FAILED",
+      label: `${failed} failed${pending ? `, ${pending} pending` : ""}${complete ? "" : " (partial)"}`,
+      url
+    };
+  if (pending || !complete || unknown)
+    return {
+      status: "PENDING",
+      label: `${pending ? `${pending} pending` : "unknown"}${complete ? "" : " (partial)"}`,
+      url
+    };
+  return { status: "SUCCESS", label: `${nodes.length} passed or skipped`, url };
+}
+function parseGitHubUrl(url, pattern) {
+  const ref = parseWebUrl("github", url, pattern);
+  return ref && !gitlabTraits.recognizes(ref.host) ? ref : undefined;
+}
+var githubTraits = {
+  kind: "github",
+  noun: "PR",
+  ci: "checks",
+  recognizes: () => false,
+  open: (run, directory) => new GitHubForge(ghGraphQL(run, directory)),
+  owns: ownedBy("github"),
+  parseUrl: (url) => parseGitHubUrl(url, /^\/([^/]+\/[^/]+)\/pull\/([1-9]\d*)\/?$/),
+  parseIssueUrl: (url) => parseGitHubUrl(url, /^\/([^/]+\/[^/]+)\/issues\/([1-9]\d*)\/?$/),
+  reference: (iid) => `#${iid}`,
+  issueReference: (iid) => `#${iid}`,
+  titleReferences: (title) => prefixReferences(title, "#"),
+  indicators: (request) => request.reviewDecision === "CHANGES_REQUESTED" ? [{ text: "changes requested", tone: "warning", essential: true }] : [],
+  details: (request) => [
+    `Review decision: ${request.reviewDecision ? humanize(request.reviewDecision) : "not reported"}`
+  ]
+};
+
+class GitHubForge {
+  graphql;
+  traits = githubTraits;
+  constructor(graphql) {
+    this.graphql = graphql;
+  }
+  async findByNumber(projects, number) {
+    for (const project of projects) {
+      const [owner, repo] = project.path.split("/");
+      const data = await this.graphql(project.host, `query($owner:String!,$repo:String!,$number:Int!) {
+        repository(owner:$owner,name:$repo) { pullRequest(number:$number) { ${fields} } }
+      }`, { owner, repo, number: Number(number) });
+      const node = data.repository?.pullRequest;
+      if (node)
+        return this.normalize(project.host, node);
+    }
+    return;
+  }
+  async findNumberByBranch(repository) {
+    let newest;
+    for (const target of repository.targets) {
+      const [owner, repo] = target.path.split("/");
+      const data = await this.graphql(target.host, `query($owner:String!,$repo:String!,$branch:String!) {
+        repository(owner:$owner,name:$repo) { pullRequests(first:100,states:OPEN,headRefName:$branch,orderBy:{field:UPDATED_AT,direction:DESC}) {
+          nodes { number updatedAt headRepository { nameWithOwner } }
+        } } }`, { owner, repo, branch: repository.sourceBranch });
+      const nodes = data.repository?.pullRequests?.nodes ?? [];
+      for (const node of nodes) {
+        if (node.headRepository?.nameWithOwner.toLowerCase() !== repository.source.path.toLowerCase())
+          continue;
+        if (!newest || node.updatedAt > newest.updatedAt)
+          newest = node;
+      }
+    }
+    return newest ? String(newest.number) : undefined;
+  }
+  async sourceBranch(ref) {
+    const [owner, repo] = ref.project.split("/");
+    const data = await this.graphql(ref.host, `query($owner:String!,$repo:String!,$number:Int!) {
+      repository(owner:$owner,name:$repo) { pullRequest(number:$number) { headRefName } }
+    }`, { owner, repo, number: Number(ref.iid) });
+    const branch = data.repository?.pullRequest?.headRefName;
+    return typeof branch === "string" && branch ? branch : undefined;
+  }
+  async findByBranch(repository) {
+    const found = new Map;
+    for (const target of repository.targets) {
+      const [owner, repo] = target.path.split("/");
+      let after;
+      let complete = false;
+      for (let page = 0;page < MAX_PAGES; page++) {
+        const data = await this.graphql(target.host, `query($owner:String!,$repo:String!,$branch:String!${after ? ",$after:String!" : ""}) {
+          repository(owner:$owner,name:$repo) { pullRequests(first:100,states:OPEN,headRefName:$branch${after ? ",after:$after" : ""}) {
+            nodes { ${fields} } pageInfo { hasNextPage endCursor }
+          } } }`, { owner, repo, branch: repository.sourceBranch, ...after ? { after } : {} });
+        const pulls = data.repository?.pullRequests;
+        if (!pulls)
+          throw new ForgeError("request", "GitHub repository unavailable");
+        for (const node of pulls.nodes) {
+          if (node.headRepository?.nameWithOwner.toLowerCase() !== repository.source.path.toLowerCase())
+            continue;
+          if (!found.has(node.url))
+            found.set(node.url, await this.normalize(target.host, node));
+        }
+        if (!pulls.pageInfo?.hasNextPage) {
+          complete = true;
+          break;
+        }
+        after = pulls.pageInfo.endCursor;
+        if (!after)
+          break;
+      }
+      if (!complete)
+        throw new ForgeError("request", "GitHub PR discovery exceeded its pagination limit");
+    }
+    return [...found.values()].sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+  }
+  async threads(host, node) {
+    const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
+    const threads = [...node.reviewThreads.nodes];
+    let page = node.reviewThreads.pageInfo;
+    for (let count = 1;page?.hasNextPage && page.endCursor && count < MAX_PAGES; count++) {
+      const data = await this.graphql(host, `query($owner:String!,$repo:String!,$number:Int!,$after:String!) {
+        repository(owner:$owner,name:$repo) { pullRequest(number:$number) {
+          reviewThreads(first:100,after:$after) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
+        } } }`, { owner, repo, number: node.number, after: page.endCursor });
+      const next = data.repository?.pullRequest?.reviewThreads;
+      if (!next)
+        break;
+      threads.push(...next.nodes);
+      page = next.pageInfo;
+    }
+    return {
+      unresolved: threads.filter((thread) => !thread.isResolved).length,
+      complete: !page?.hasNextPage
+    };
+  }
+  async contexts(host, node) {
+    const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
+    const rollup = node.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
+    const contexts = [...rollup?.nodes ?? []];
+    let cursor = rollup?.pageInfo;
+    for (let count = 1;cursor?.hasNextPage && cursor.endCursor && count < MAX_PAGES; count++) {
+      const data = await this.graphql(host, `query($owner:String!,$repo:String!,$oid:GitObjectID!,$after:String!) {
+        repository(owner:$owner,name:$repo) { object(oid:$oid) { ... on Commit { statusCheckRollup {
+          contexts(first:100,after:$after) { nodes { __typename ... on CheckRun { status conclusion detailsUrl } ... on StatusContext { state targetUrl } } pageInfo { hasNextPage endCursor } }
+        } } } } }`, { owner, repo, oid: node.headRefOid, after: cursor.endCursor });
+      const next = data.repository?.object?.statusCheckRollup?.contexts;
+      if (!next)
+        break;
+      contexts.push(...next.nodes);
+      cursor = next.pageInfo;
+    }
+    return { nodes: contexts, complete: !cursor?.hasNextPage };
+  }
+  async normalize(host, node) {
+    const [threads, contexts] = [await this.threads(host, node), await this.contexts(host, node)];
+    return {
+      forge: "github",
+      iid: String(node.number),
+      title: node.title,
+      url: node.url,
+      state: node.state === "OPEN" ? "opened" : node.state.toLowerCase(),
+      draft: node.isDraft,
+      conflicts: node.mergeable === "CONFLICTING",
+      conflictsKnown: node.mergeable !== "UNKNOWN",
+      approved: node.reviewDecision === "APPROVED",
+      reviewDecision: node.reviewDecision ?? undefined,
+      awaitingReviewers: node.reviewRequests.nodes.flatMap((request) => {
+        const reviewer = request.requestedReviewer;
+        return reviewer?.login ? [reviewer.login] : reviewer?.name ? [reviewer.name] : [];
+      }),
+      reviewersComplete: !node.reviewRequests.pageInfo?.hasNextPage,
+      targetProject: node.baseRepository.nameWithOwner,
+      targetBranch: node.baseRefName,
+      headSha: node.headRefOid,
+      updatedAt: node.updatedAt,
+      pipeline: contexts.nodes.length || !contexts.complete ? checks(contexts.nodes, contexts.complete, `${node.url}/checks`) : undefined,
+      unresolvedThreads: threads.unresolved,
+      threadsComplete: threads.complete
+    };
+  }
+}
+
+// packages/forgekeeper/src/forges.ts
+var registry = { gitlab: gitlabTraits, github: githubTraits };
+var kinds = Object.keys(registry);
+var traits = (kind) => registry[kind];
+var traitsOf = (request) => registry[request.forge];
+var reference = (request) => traitsOf(request).reference(request.iid);
+function parseUrl(url) {
+  for (const kind of kinds) {
+    const ref = registry[kind].parseUrl(url);
+    if (ref)
+      return ref;
+  }
+  return;
+}
+function parseReference(url) {
+  for (const kind of kinds) {
+    const request = registry[kind].parseUrl(url);
+    if (request)
+      return { ref: request, issue: false };
+    const issue = registry[kind].parseIssueUrl(url);
+    if (issue)
+      return { ref: issue, issue: true };
+  }
+  return;
+}
+function hostsFrom(options) {
+  const list = (value, fallback) => Array.isArray(value) ? value.filter((host) => typeof host === "string") : [fallback];
+  return {
+    gitlab: list(options.hosts, "gitlab.com"),
+    github: list(options.githubHosts, "github.com")
+  };
+}
+
+class Forges {
+  run;
+  hosts;
+  kinds = kinds;
+  constructor(run, hosts) {
+    this.run = run;
+    this.hosts = hosts;
+  }
+  kind(host) {
+    return kinds.find((kind) => this.hosts[kind].includes(host)) ?? kinds.find((kind) => registry[kind].recognizes(host));
+  }
+  forHost(host, directory) {
+    const kind = this.kind(host);
+    return kind ? registry[kind].open(this.run, directory) : undefined;
+  }
+  async projects(directory, kind) {
+    const lookup = await resolveProjects(this.run, directory, (host) => this.kind(host) === kind);
+    return lookup.kind === "projects" ? lookup.projects : [];
+  }
+  repository(directory) {
+    return resolveRepository(this.run, directory, (host) => this.kind(host) !== undefined);
+  }
+}
+
+// packages/forgekeeper/src/limit.ts
+var CONCURRENCY = 4;
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
+function createLimiter(limit) {
+  let running = 0;
+  const queue = [];
+  const release = () => {
+    const next = queue.shift();
+    if (next)
+      next();
+    else
+      running--;
+  };
+  return async (task) => {
+    if (running >= limit)
+      await new Promise((resolve) => queue.push(resolve));
+    else
+      running++;
+    try {
+      return await task();
+    } finally {
+      release();
+    }
+  };
+}
+function limitExec(run, limit = CONCURRENCY, signal) {
+  const limited = createLimiter(limit);
+  const cancelled = { stdout: "", stderr: "The plugin stopped", code: -1 };
+  return (file, args, cwd) => limited(async () => signal?.aborted ? cancelled : run(file, args, cwd));
+}
+
+// packages/forgekeeper/src/lookups.ts
+var NUMBER_TTL = 10 * 60000;
+function createTitleLookups(forges, run, now = Date.now) {
+  const numbers = new Map;
+  return {
+    async branch(directory) {
+      const lookup = await forges.repository(directory);
+      if (lookup.kind === "none")
+        return;
+      const { repository } = lookup;
+      const forge = forges.forHost(repository.source.host, directory);
+      if (!forge)
+        return;
+      const key = JSON.stringify([
+        directory,
+        repository.source.host,
+        repository.source.path,
+        repository.sourceBranch
+      ]);
+      const cached = numbers.get(key);
+      let number = cached && now() - cached.at < NUMBER_TTL ? cached.number : undefined;
+      if (!number) {
+        try {
+          number = await forge.findNumberByBranch(repository);
+          if (number)
+            numbers.set(key, { number, at: now() });
+          else
+            numbers.delete(key);
+        } catch {
+          number = cached?.number;
+        }
+      }
+      return { forge: forge.traits, branch: repository.branch, number };
+    },
+    async sourceBranch(ref, directory) {
+      return traits(ref.forge).open(run, directory).sourceBranch(ref).catch(() => {
+        return;
+      });
+    }
+  };
+}
+
+// packages/forgekeeper/src/options.ts
+function statusOptions(options) {
+  const source = options && typeof options === "object" ? options : {};
+  const poll = Number(source.pollSeconds);
+  return {
+    enabled: source.reviewStatus !== false,
+    pollSeconds: poll > 0 ? poll : 120,
+    notifyAutomatedReviews: (source.notifyAutomatedReviews ?? source.notifyDuoReview) !== false,
+    notifyHumanReviews: source.notifyHumanReviews !== false,
+    resumeSession: source.resumeSession !== false
+  };
+}
+
+// packages/forgekeeper/src/rpc.ts
+var urls = {
+  url: { type: "string" },
+  issueUrl: { type: "string" }
+};
+var target = {
+  type: "object",
+  properties: {
+    ...urls,
+    targets: {
+      type: "array",
+      items: { type: "object", properties: urls, required: ["url"], additionalProperties: false }
+    }
+  },
+  additionalProperties: false
+};
+var key = { type: "string" };
+var snapshot = { type: "object" };
+var status = {
+  type: "object",
+  properties: { enabled: { type: "boolean" }, snapshot },
+  required: ["enabled", "snapshot"]
+};
+var ForgeSessionRpc = {
+  id: "opencode-forge-session-title",
+  methods: {
+    target: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" } },
+        required: ["sessionID"],
+        additionalProperties: false
+      },
+      output: target
+    },
+    watch: {
+      input: {
+        type: "object",
+        properties: {
+          clientID: { type: "string" },
+          keys: { type: "array", items: key },
+          visible: key
+        },
+        required: ["clientID", "keys"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: { enabled: { type: "boolean" }, statuses: { type: "object" } },
+        required: ["enabled", "statuses"]
+      }
+    },
+    release: {
+      input: {
+        type: "object",
+        properties: { clientID: { type: "string" } },
+        required: ["clientID"],
+        additionalProperties: false
+      },
+      output: { type: "object" }
+    },
+    refresh: {
+      input: {
+        type: "object",
+        properties: { key },
+        required: ["key"],
+        additionalProperties: false
+      },
+      output: status
+    }
+  },
+  events: {
+    targetChanged: {
+      schema: {
+        type: "object",
+        properties: { sessionID: { type: "string" }, ...target.properties },
+        required: ["sessionID"],
+        additionalProperties: false
+      }
+    },
+    status: {
+      schema: {
+        type: "object",
+        properties: { directory: { type: "string" }, key, snapshot },
+        required: ["directory", "key", "snapshot"]
+      }
+    },
+    notice: {
+      schema: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          title: { type: "string" },
+          message: { type: "string" },
+          variant: { type: "string", enum: ["info", "error"] }
+        },
+        required: ["message", "variant"]
+      }
+    }
+  }
+};
+var HOME = "";
+var HEARTBEAT = 60000;
+var LEASE_TIME = 3 * HEARTBEAT;
+
+// packages/forgekeeper/src/automated-review-watch.ts
+var requests = (lookup) => lookup?.kind === "found" ? lookup.requests : [];
+function automatedReview(request) {
+  const reviewer = traitsOf(request).automatedReview;
+  const status2 = reviewer?.status(request);
+  return reviewer && status2 ? { name: reviewer.name, ...status2 } : undefined;
+}
+var isReviewRunning = (lookup) => requests(lookup).some((request) => automatedReview(request)?.state === "running");
+function finishedReviews(previous, next) {
+  const running = new Set(requests(previous).filter((request) => automatedReview(request)?.state === "running").map((request) => request.url));
+  return requests(next).filter((request) => running.has(request.url) && automatedReview(request)?.state === "feedback");
+}
+var reviewer = (request) => automatedReview(request)?.name ?? "The automated reviewer";
+var shared = (requests2, value, fallback) => {
+  const values = new Set(requests2.map(value));
+  return values.size === 1 ? [...values][0] : fallback;
+};
+var reviewers = (requests2) => shared(requests2, reviewer, "Automated reviewers");
+var nouns = (requests2) => shared(requests2, (request) => `${traitsOf(request).noun}s`, "PRs/MRs");
+function reviewOutcome(request) {
+  const label = automatedReview(request)?.label ?? "";
+  return label.charAt(0).toUpperCase() + label.slice(1);
+}
+function reviewTitle(requests2) {
+  if (requests2.length === 1)
+    return `${reviewer(requests2[0])} finished reviewing ${reference(requests2[0])}`;
+  return `${reviewers(requests2)} finished reviewing ${requests2.length} ${nouns(requests2)}`;
+}
+function reviewMessage(requests2) {
+  const state = (request) => `the state "${automatedReview(request)?.label ?? ""}"`;
+  if (requests2.length === 1) {
+    const [request] = requests2;
+    const name2 = reviewer(request);
+    return [
+      `${name2} finished reviewing ${reference(request)} (${request.url}) with ${state(request)}.`,
+      `Fetch ${name2}'s new comments and discussion threads on the ${traitsOf(request).noun}, then work through its feedback.`
+    ].join(" ");
+  }
+  const name = reviewers(requests2);
+  return [
+    `${name} finished reviewing ${requests2.length} ${nouns(requests2)}:`,
+    ...requests2.map((request) => `- ${reference(request)} (${request.url}) with ${state(request)}`),
+    "For each one, fetch the reviewer's new comments and discussion threads, then work through its feedback."
+  ].join(`
+`);
+}
+function reviewToast(requests2) {
+  const outcome = requests2.length === 1 ? reviewOutcome(requests2[0]) : requests2.map((request) => `${reference(request)}: ${automatedReview(request)?.label ?? ""}`).join(", ");
+  return { title: reviewTitle(requests2), message: `${outcome}. Sent to the agent.` };
+}
+var RETRY_DELAY = 10 * 60000;
+var PENDING_RETENTION = 24 * 60 * 60000;
+var notificationKey = (sessionID, request) => `${sessionID} ${request.url}`;
+var isOpen = (request) => request.state === "opened";
+function createAutomatedReviewWatcher(options) {
+  const now = options.now ?? Date.now;
+  const known = new Map;
+  const sending = new Set;
+  const write = (sessionID, url, delivery) => options.write?.(sessionID, url, delivery);
+  return {
+    async observe(sessionID, previous, next) {
+      const pending = known.get(sessionID) ?? { ...await options.read?.(sessionID) };
+      known.set(sessionID, pending);
+      const at = now();
+      const targets = requests(next).filter((request) => isOpen(request) && options.isTarget(sessionID, request.url));
+      for (const [key2, entry] of Object.entries(pending)) {
+        const request = targets.find((target2) => target2.url === entry.url);
+        if (request && automatedReview(request)?.state === "feedback" && at - entry.since < PENDING_RETENTION)
+          continue;
+        if (sending.has(key2))
+          continue;
+        delete pending[key2];
+        write(sessionID, entry.url);
+      }
+      const finished = finishedReviews(previous, next).filter((request) => isOpen(request) && options.isTarget(sessionID, request.url));
+      const due = targets.filter((request) => (pending[notificationKey(sessionID, request)]?.retryAt ?? Infinity) <= at);
+      const batch = [
+        ...new Map([...finished, ...due].map((request) => [request.url, request])).values()
+      ].filter((request) => !sending.has(notificationKey(sessionID, request)));
+      if (batch.length === 0)
+        return;
+      const keys = batch.map((request) => notificationKey(sessionID, request));
+      for (const key2 of keys)
+        sending.add(key2);
+      try {
+        await options.send(sessionID, batch);
+        batch.forEach((request, index) => {
+          delete pending[keys[index]];
+          write(sessionID, request.url);
+        });
+      } catch (error) {
+        const retryAt = now() + RETRY_DELAY;
+        batch.forEach((request, index) => {
+          const key2 = keys[index];
+          pending[key2] = { sessionID, url: request.url, since: pending[key2]?.since ?? at, retryAt };
+          write(sessionID, request.url, pending[key2]);
+        });
+        options.onSendError?.(error, sessionID, batch);
+      } finally {
+        for (const key2 of keys)
+          sending.delete(key2);
+      }
+    },
+    hasPending: (sessionID) => Object.keys(known.get(sessionID) ?? {}).length > 0,
+    forget: (sessionID) => void known.delete(sessionID)
+  };
+}
+
+// packages/forgekeeper/src/human-review-watch.ts
+var SETTLE_TIME = 5 * 60000;
+var FETCH_INTERVAL = 60000;
+var RETRY_DELAY2 = 10 * 60000;
+var RECORD_RETENTION = 30 * 24 * 60 * 60000;
+var TOUCH_INTERVAL = 24 * 60 * 60000;
+var MAX_LINKS = 20;
+var feedbackKey = (sessionID, request) => `${sessionID} ${request.url}`;
+function applyFeedback(record, change, now) {
+  const announced = [...record?.announced ?? []];
+  for (const id of change.announced ?? [])
+    if (!announced.includes(id))
+      announced.push(id);
+  return { baseline: record?.baseline ?? change.baseline ?? 0, announced, seenAt: now };
+}
+var isExpired = (record, now) => now - record.seenAt > RECORD_RETENTION;
+var baselineOf = (snapshot2) => snapshot2.comments.reduce((highest, comment) => Math.max(highest, comment.order), 0);
+var isNew = (comment, seen) => comment.order > seen.baseline && !seen.announced.has(comment.id);
+var humanFeedback = (snapshot2) => snapshot2.comments.filter((comment) => !comment.bot && comment.authorID !== snapshot2.viewerID && !comment.resolved);
+function eligibleFeedback(snapshot2, seen, now) {
+  const human = humanFeedback(snapshot2);
+  const pending = human.filter((comment) => isNew(comment, seen));
+  if (pending.length === 0)
+    return [];
+  const lastActivity = Math.max(...human.map((comment) => comment.editedAt));
+  return now - lastActivity >= SETTLE_TIME ? pending : [];
+}
+var authors = (comments) => [
+  ...new Set(comments.map((comment) => `@${comment.username}`))
+];
+function list(items) {
+  if (items.length <= 2)
+    return items.join(" and ");
+  return `${items.slice(0, -1).join(", ")}, and ${items.at(-1)}`;
+}
+function feedbackMessage(request, comments) {
+  const links = comments.slice(0, MAX_LINKS).map((comment) => `- @${comment.username}: ${comment.url}`);
+  if (comments.length > MAX_LINKS)
+    links.push(`- and ${comments.length - MAX_LINKS} more`);
+  return [
+    `New review feedback from ${list(authors(comments))} on ${reference(request)} (${request.url}).`,
+    "No review comment has changed for at least 5 minutes. New comments:",
+    ...links,
+    "Fetch these comments and their discussion threads, then assess and address the feedback."
+  ].join(`
+`);
+}
+function feedbackToast(request, comments) {
+  const count = comments.length === 1 ? "1 comment" : `${comments.length} comments`;
+  return {
+    title: `New review feedback on ${reference(request)}`,
+    message: `${count} from ${list(authors(comments))}. Sent to the agent.`
+  };
+}
+function createFeedbackWatcher(options) {
+  const now = options.now ?? Date.now;
+  const local = new Map;
+  const reserved = new Set;
+  const inflight = new Set;
+  const fetchedAt = new Map;
+  const retryAt = new Map;
+  const seen = (key2, shared2) => {
+    const mine = local.get(key2);
+    if (!shared2 && !mine)
+      return;
+    return {
+      baseline: Math.max(shared2?.baseline ?? 0, mine?.baseline ?? 0),
+      announced: new Set([...shared2?.announced ?? [], ...mine?.announced ?? []])
+    };
+  };
+  const remember = (key2, change, at) => {
+    const mine = local.get(key2) ?? { baseline: change.baseline ?? 0, announced: new Set };
+    for (const id of change.announced ?? [])
+      mine.announced.add(id);
+    local.set(key2, mine);
+    options.persist(key2, change, at);
+  };
+  async function observe(sessionID, request, snapshot2) {
+    if (!snapshot2.complete)
+      return;
+    const key2 = feedbackKey(sessionID, request);
+    const stored = await options.record(key2);
+    const at = now();
+    const previous = seen(key2, stored);
+    if (!previous)
+      return remember(key2, { baseline: baselineOf(snapshot2) }, at);
+    if (at < (retryAt.get(key2) ?? 0))
+      return;
+    const comments = eligibleFeedback(snapshot2, previous, at).filter((comment) => !reserved.has(`${key2} ${comment.id}`));
+    if (comments.length === 0) {
+      if (stored && at - stored.seenAt > TOUCH_INTERVAL)
+        options.persist(key2, {}, at);
+      return;
+    }
+    const ids = comments.map((comment) => comment.id);
+    for (const id of ids)
+      reserved.add(`${key2} ${id}`);
+    try {
+      await options.send(sessionID, request, comments);
+      retryAt.delete(key2);
+      remember(key2, { announced: ids }, now());
+    } catch (error) {
+      retryAt.set(key2, now() + RETRY_DELAY2);
+      options.onSendError?.(error);
+    } finally {
+      for (const id of ids)
+        reserved.delete(`${key2} ${id}`);
+    }
+  }
+  return {
+    async check(sessionID, request) {
+      const key2 = feedbackKey(sessionID, request);
+      if (inflight.has(key2) || now() - (fetchedAt.get(key2) ?? -Infinity) < FETCH_INTERVAL)
+        return;
+      if (!options.current(sessionID, request))
+        return;
+      inflight.add(key2);
+      fetchedAt.set(key2, now());
+      try {
+        const snapshot2 = await options.fetch(sessionID, request);
+        if (!snapshot2 || !options.current(sessionID, request))
+          return;
+        await observe(sessionID, request, snapshot2);
+      } catch (error) {
+        options.onFetchError?.(error);
+      } finally {
+        inflight.delete(key2);
+      }
+    }
+  };
+}
+
+// packages/forgekeeper/src/target.ts
+var MAX_TARGETS = 50;
+var PREFIX_REFERENCES = 4;
+var INVALID_URL = "Use a full HTTP(S) issue, pull request, or merge request URL.";
+function parseTargetUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(INVALID_URL);
+  }
+  if (!["https:", "http:"].includes(url.protocol) || url.username || url.password)
+    throw new Error(INVALID_URL);
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/$/, "");
+  const parsed = parseReference(url.href);
+  if (!parsed)
+    throw new Error("Use a GitHub or GitLab issue, pull request, or merge request URL.");
+  return { url: url.href, ...parsed };
+}
+function parseTarget(input) {
+  if (!input || typeof input !== "object" || !("target" in input) || typeof input.target !== "string") {
+    throw new Error('Provide a target URL or "branch".');
+  }
+  const issueUrl = "issue_url" in input ? input.issue_url : undefined;
+  if (input.target === "branch") {
+    if (issueUrl !== undefined)
+      throw new Error("Branch mode does not accept issue_url.");
+    return;
+  }
+  return relate(parseTargetUrl(input.target), issueUrl);
+}
+function relate(target2, issueUrl) {
+  if (issueUrl === undefined)
+    return { url: target2.url };
+  if (typeof issueUrl !== "string")
+    throw new Error("issue_url must be a full issue URL.");
+  const issue = parseTargetUrl(issueUrl);
+  if (target2.issue || !issue.issue || target2.ref.forge !== issue.ref.forge) {
+    throw new Error("Only a pull or merge request can have a related issue from the same forge.");
+  }
+  return { url: target2.url, issueUrl: issue.url };
+}
+var OPERATIONS = new Set(["replace", "add", "remove"]);
+var dedupe = (targets) => [
+  ...new Map(targets.map((target2) => [target2.url, target2])).values()
+];
+function parseTargetChange(input) {
+  if (!input || typeof input !== "object")
+    throw new Error('Provide a target URL, "branch", or a list of targets.');
+  const value = input;
+  const operation = value.operation ?? "replace";
+  if (!OPERATIONS.has(operation))
+    throw new Error('operation must be "replace", "add", or "remove".');
+  if (operation === "remove" && value.issue_url !== undefined)
+    throw new Error("Removing a target does not accept issue_url.");
+  if (value.targets !== undefined) {
+    if (value.target !== undefined)
+      throw new Error("Use either target or targets, not both.");
+    const urls2 = value.targets;
+    if (!Array.isArray(urls2) || urls2.length === 0 || !urls2.every((url) => typeof url === "string")) {
+      throw new Error("targets must be a non-empty list of full URLs.");
+    }
+    if (urls2.includes("branch"))
+      throw new Error('Use target: "branch" on its own to return to branch-based naming.');
+    if (urls2.length > MAX_TARGETS)
+      throw new Error(`A session can have at most ${MAX_TARGETS} targets.`);
+    return {
+      operation,
+      targets: dedupe(urls2.map((url) => relate(parseTargetUrl(url), value.issue_url)))
+    };
+  }
+  if (value.target === "branch" && operation !== "replace")
+    throw new Error('"branch" replaces every target, so it takes no operation.');
+  const target2 = parseTarget(value);
+  return target2 ? { operation, targets: [target2] } : { operation: "branch" };
+}
+function applyTargetChange(current, change) {
+  if (change.operation === "branch")
+    return { targets: [], missing: [] };
+  const known = new Map(current.map((target2) => [target2.url, target2]));
+  if (change.operation === "remove") {
+    const removed = new Set(change.targets.map((target2) => target2.url));
+    return {
+      targets: current.filter((target2) => !removed.has(target2.url)),
+      missing: [...removed].filter((url) => !known.has(url))
+    };
+  }
+  const merge = (target2) => {
+    const existing = known.get(target2.url);
+    if (!existing || target2.issueUrl)
+      return target2;
+    if (change.operation === "add")
+      return { ...existing };
+    return {
+      url: target2.url,
+      ...existing.branchIssue ? { branchIssue: existing.branchIssue } : {}
+    };
+  };
+  const targets = change.operation === "replace" ? change.targets.map(merge) : dedupe([...current.map((target2) => ({ ...target2 })), ...change.targets.map(merge)]);
+  if (targets.length > MAX_TARGETS)
+    throw new Error(`A session can have at most ${MAX_TARGETS} targets.`);
+  return { targets, missing: [] };
+}
+function targetRequest(target2) {
+  const { ref, issue } = parseTargetUrl(target2.url);
+  return issue ? undefined : ref;
+}
+var sameRef = (a, b) => a.forge === b.forge && a.host === b.host && a.iid === b.iid && a.project.toLowerCase() === b.project.toLowerCase();
+function includesRequest(targets, url) {
+  const ref = parseUrl(url);
+  if (!ref)
+    return false;
+  return targets.some((target2) => {
+    const request = targetRequest(target2);
+    return request !== undefined && sameRef(request, ref);
+  });
+}
+function mainReference(target2) {
+  const { ref, issue } = parseTargetUrl(target2.url);
+  const forge = traits(ref.forge);
+  return issue ? forge.issueReference(ref.iid) : forge.reference(ref.iid);
+}
+function relatedIssue(target2) {
+  const { ref, issue } = parseTargetUrl(target2.url);
+  let related;
+  if (target2.issueUrl)
+    related = parseTargetUrl(target2.issueUrl).ref;
+  else if (!issue && target2.branchIssue)
+    related = { ...ref, iid: target2.branchIssue };
+  else
+    return;
+  return {
+    id: `${related.forge} ${related.host} ${related.project.toLowerCase()} ${related.iid}`,
+    reference: traits(related.forge).issueReference(related.iid)
+  };
+}
+function targetsPrefix(targets) {
+  if (targets.length === 0)
+    return;
+  const issues = targets.map(relatedIssue);
+  const shared2 = issues.every((issue) => issue && issue.id === issues[0]?.id) ? issues[0]?.reference : undefined;
+  const references = targets.map(mainReference);
+  const shown = references.length > PREFIX_REFERENCES ? [
+    ...references.slice(0, PREFIX_REFERENCES - 1),
+    `+${references.length - PREFIX_REFERENCES + 1}`
+  ] : references;
+  return `[${[...shared2 ? [shared2] : [], ...shown].join(", ")}]`;
+}
+var urlsOf = (target2) => ({
+  url: target2.url,
+  ...target2.issueUrl ? { issueUrl: target2.issueUrl } : {}
+});
+var targetOutput = (targets) => targets?.length ? { ...urlsOf(targets[0]), targets: targets.map(urlsOf) } : {};
+var classify = (url) => {
+  const ref = parseUrl(url);
+  return ref ? { kind: "merge-request", ref, url } : { kind: "other", url };
+};
+function classifyTargets(output) {
+  const value = output;
+  const urls2 = (Array.isArray(value?.targets) ? value.targets.map((target2) => target2?.url) : [value?.url]).filter((url) => typeof url === "string" && url !== "");
+  return urls2.length ? urls2.map(classify) : undefined;
+}
+
+// packages/forgekeeper/src/locate.ts
+var UNRESOLVED = "Explicit PR/MR target could not be resolved";
+async function locateTargets(forges, directory, targets, previous) {
+  const requests2 = targets.flatMap((target2) => target2.kind === "merge-request" ? [target2] : []);
+  if (requests2.length === 0) {
+    const reason = targets.length === 1 ? `The session target is not a PR/MR (${targets[0].url})` : "No session target is a PR/MR";
+    return { kind: "none", reason };
+  }
+  const outcomes = await mapLimit(requests2, CONCURRENCY, async ({ ref }) => {
+    const forge = forges.kind(ref.host) === ref.forge ? forges.forHost(ref.host, directory) : undefined;
+    if (!forge)
+      return { missing: "Unsupported session target host" };
+    try {
+      const request = await forge.findByNumber([{ host: ref.host, path: ref.project }], ref.iid);
+      return request ? { request } : { missing: UNRESOLVED };
+    } catch (error2) {
+      return { error: error2 };
+    }
+  });
+  const earlier = previous?.kind === "found" ? previous.requests : [];
+  const found = [];
+  const failed = [];
+  let error;
+  outcomes.forEach((outcome, index) => {
+    const { ref, url } = requests2[index];
+    if ("request" in outcome) {
+      found.push(outcome.request);
+      return;
+    }
+    if ("missing" in outcome) {
+      failed.push({ url, reason: outcome.missing });
+      return;
+    }
+    error ??= outcome.error;
+    const last = earlier.find((request) => {
+      const parsed = parseUrl(request.url);
+      return parsed && sameRef(parsed, ref);
+    });
+    if (last)
+      found.push(last);
+    failed.push({
+      url,
+      reason: outcome.error instanceof Error ? outcome.error.message : String(outcome.error)
+    });
+  });
+  if (error !== undefined && !outcomes.some((outcome) => ("request" in outcome)))
+    throw error;
+  if (found.length === 0)
+    return {
+      kind: "none",
+      reason: requests2.length === 1 ? failed[0].reason : "No session target PR/MR could be resolved"
+    };
+  return {
+    kind: "found",
+    sessionTarget: requests2.length === 1 ? found[0].url : `${requests2.length} PRs/MRs set with set_session_target`,
+    explicitTarget: true,
+    requests: found,
+    ...failed.length ? { failed } : {}
+  };
+}
+async function locate(forges, hints) {
+  const { directory, targets, title } = hints;
+  if (targets?.length)
+    return locateTargets(forges, directory, targets, hints.previous);
+  for (const kind of forges.kinds) {
+    const numbers = traits(kind).titleReferences(title);
+    if (numbers.length === 0)
+      continue;
+    const projects = await forges.projects(directory, kind);
+    const forge2 = projects.length ? forges.forHost(projects[0].host, directory) : undefined;
+    if (!forge2)
+      continue;
+    for (const number of numbers) {
+      const request = await forge2.findByNumber(projects, number);
+      if (request) {
+        return {
+          kind: "found",
+          sessionTarget: `${forge2.traits.reference(number)} (from the session title)`,
+          requests: [request]
+        };
+      }
+    }
+  }
+  const lookup = await forges.repository(directory);
+  if (lookup.kind === "none")
+    return lookup;
+  const forge = forges.forHost(lookup.repository.source.host, directory);
+  if (!forge)
+    return { kind: "none", reason: "Not a supported forge remote" };
+  return {
+    kind: "found",
+    repository: lookup.repository,
+    requests: await forge.findByBranch(lookup.repository)
+  };
+}
+
+// packages/forgekeeper/src/store.ts
+function createStatusStore(options) {
+  const now = options.now ?? Date.now;
+  const setTimer = options.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
+  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+  const interval = options.interval ?? 120000;
+  const maxBackoff = options.maxBackoff ?? 900000;
+  const minEventInterval = options.minEventInterval ?? 15000;
+  const entries = new Map;
+  let disposed = false;
+  let revision = now() * 1000;
+  const entry = (key2) => {
+    let value = entries.get(key2);
+    if (!value) {
+      value = { snapshot: { loading: false }, refs: 0, failures: 0 };
+      entries.set(key2, value);
+    }
+    return value;
+  };
+  const update = (key2, value, patch) => {
+    value.snapshot = { ...value.snapshot, ...patch, revision: ++revision };
+    if (!disposed)
+      options.onChange(key2);
+  };
+  const cancelTimer = (value) => {
+    if (value.timer === undefined)
+      return;
+    clearTimer(value.timer);
+    value.timer = undefined;
+  };
+  const baseInterval = (value) => options.active?.(value.snapshot.lookup) ? options.activeInterval ?? interval : interval;
+  const pollDelay = (value) => Math.min(baseInterval(value) * 2 ** value.failures, maxBackoff);
+  const lastAttempt = (value) => Math.max(value.snapshot.fetchedAt ?? -Infinity, value.snapshot.error?.at ?? -Infinity);
+  const schedule = (key2, value, delay = pollDelay(value)) => {
+    cancelTimer(value);
+    if (disposed || value.refs === 0)
+      return;
+    const lookup = value.snapshot.lookup;
+    if (!value.snapshot.error && (lookup?.kind !== "found" || lookup.requests.length === 0))
+      return;
+    value.timer = setTimer(() => {
+      value.timer = undefined;
+      refresh(key2);
+    }, delay);
+  };
+  function refresh(key2) {
+    if (disposed)
+      return Promise.resolve({ loading: false });
+    const value = entry(key2);
+    if (value.inflight)
+      return value.inflight;
+    value.stale = false;
+    update(key2, value, { loading: true });
+    value.inflight = options.load(key2).then((lookup) => {
+      if (disposed || value.invalidated)
+        return;
+      const previous = value.snapshot.lookup;
+      value.failures = 0;
+      update(key2, value, { lookup, fetchedAt: now(), error: undefined, loading: false });
+      try {
+        if (!disposed)
+          options.onLoad?.(key2, previous, lookup);
+      } catch (error) {
+        try {
+          options.onLoadError?.(error);
+        } catch {}
+      }
+    }, (error) => {
+      if (disposed || value.invalidated)
+        return;
+      value.failures++;
+      const known = error instanceof ForgeError;
+      update(key2, value, {
+        loading: false,
+        error: {
+          kind: known ? error.kind : "request",
+          message: error instanceof Error ? error.message : String(error),
+          at: now()
+        }
+      });
+    }).then(() => {
+      value.inflight = undefined;
+      if (value.invalidated && !disposed) {
+        value.invalidated = false;
+        return refresh(key2);
+      }
+      schedule(key2, value);
+      return value.snapshot;
+    });
+    return value.inflight;
+  }
+  return {
+    get(key2) {
+      return entries.get(key2)?.snapshot ?? { loading: false };
+    },
+    acquire(key2) {
+      const value = entry(key2);
+      value.refs++;
+      if (value.refs === 1 && !value.inflight) {
+        const remaining = lastAttempt(value) + pollDelay(value) - now();
+        if (value.stale || remaining <= 0)
+          refresh(key2);
+        else
+          schedule(key2, value, remaining);
+      }
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        value.refs--;
+        if (value.refs === 0)
+          cancelTimer(value);
+      };
+    },
+    refresh,
+    keys() {
+      return [...entries.keys()];
+    },
+    notify(key2) {
+      const value = entries.get(key2);
+      if (!value || value.refs === 0 || value.inflight)
+        return;
+      const last = Math.max(value.snapshot.fetchedAt ?? 0, value.snapshot.error?.at ?? 0);
+      if (now() - last < minEventInterval)
+        return;
+      refresh(key2);
+    },
+    invalidate(key2) {
+      const value = entries.get(key2);
+      if (!value)
+        return;
+      if (value.inflight)
+        value.invalidated = true;
+      else if (value.refs > 0)
+        refresh(key2);
+      else
+        value.stale = true;
+    },
+    dispose() {
+      disposed = true;
+      for (const value of entries.values())
+        cancelTimer(value);
+      entries.clear();
+    }
+  };
+}
+
+// packages/forgekeeper/src/status-service.ts
+function createStatusService(options) {
+  const now = options.now ?? Date.now;
+  const setTimer = options.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
+  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+  const leaseTime = options.leaseTime ?? LEASE_TIME;
+  const leases = new Map;
+  const holds = new Map;
+  const tasks = new Set;
+  const track = (task) => {
+    tasks.add(task);
+    task.finally(() => tasks.delete(task));
+  };
+  const owns = (key2) => key2 !== HOME && (options.owns?.(key2) ?? true);
+  let sweepTimer;
+  let disposed = false;
+  const report = (error) => {
+    try {
+      options.onWatchError?.(error);
+    } catch {}
+  };
+  const store = createStatusStore({
+    load: (key2) => options.load(key2, store.get(key2).lookup),
+    onChange: (key2) => options.publish(key2, store.get(key2)),
+    onLoad: (key2, previous, next) => onLoad(key2, previous, next),
+    onLoadError: report,
+    active: isReviewRunning,
+    interval: options.interval,
+    activeInterval: options.activeInterval,
+    now,
+    setTimer: options.setTimer,
+    clearTimer: options.clearTimer
+  });
+  const targets = (key2, lookup) => owns(key2) && lookup?.kind === "found" && lookup.explicitTarget ? lookup.requests.filter((request) => options.isTarget(key2, request.url)) : [];
+  const watchedForFeedback = (key2, lookup) => options.human ? targets(key2, lookup).filter((request) => traitsOf(request).feedback && request.state === "opened") : [];
+  function needsWatch(key2) {
+    const lookup = store.get(key2).lookup;
+    if (options.automated) {
+      if (targets(key2, lookup).some((request) => automatedReview(request)?.state === "running"))
+        return true;
+      if (owns(key2) && options.automated.hasPending(key2))
+        return true;
+    }
+    return watchedForFeedback(key2, lookup).length > 0;
+  }
+  const unknown = (key2) => owns(key2) && store.get(key2).lookup === undefined;
+  const liveLeases = (key2) => [...leases.get(key2)?.values() ?? []].filter((lease) => lease.until > now());
+  function sync(key2) {
+    if (disposed)
+      return;
+    const live = liveLeases(key2);
+    const wanted = live.length > 0 && (live.some((lease) => lease.visible) || unknown(key2) || needsWatch(key2));
+    const release = holds.get(key2);
+    if (wanted && !release)
+      holds.set(key2, store.acquire(key2));
+    else if (!wanted && release) {
+      release();
+      holds.delete(key2);
+    }
+  }
+  function onLoad(key2, previous, next) {
+    if (owns(key2) && options.automated) {
+      track(options.automated.observe(key2, previous, next).catch(report).finally(() => sync(key2)));
+    }
+    for (const request of watchedForFeedback(key2, next)) {
+      track(Promise.resolve().then(() => options.human?.check(key2, request)).catch(report));
+    }
+    sync(key2);
+  }
+  function sweep() {
+    const at = now();
+    for (const key2 of new Set([...leases.keys(), ...holds.keys()])) {
+      const clients = leases.get(key2);
+      for (const [clientID, lease] of clients ?? [])
+        if (lease.until <= at)
+          clients?.delete(clientID);
+      if (clients?.size === 0)
+        leases.delete(key2);
+      sync(key2);
+    }
+  }
+  function scheduleSweep() {
+    if (disposed || sweepTimer !== undefined || leases.size === 0)
+      return;
+    sweepTimer = setTimer(() => {
+      sweepTimer = undefined;
+      sweep();
+      scheduleSweep();
+    }, leaseTime / 3);
+  }
+  function forget(clientID, keep = new Set) {
+    const changed = [];
+    for (const [key2, clients] of leases) {
+      if (keep.has(key2) || !clients.delete(clientID))
+        continue;
+      if (clients.size === 0)
+        leases.delete(key2);
+      changed.push(key2);
+    }
+    return changed;
+  }
+  return {
+    watch(clientID, keys, visible) {
+      const listed = new Set(keys);
+      const changed = new Set([...forget(clientID, listed), ...listed]);
+      const until = now() + leaseTime;
+      for (const key2 of listed) {
+        const clients = leases.get(key2) ?? new Map;
+        leases.set(key2, clients);
+        clients.set(clientID, { until, visible: key2 === visible });
+      }
+      for (const key2 of changed)
+        sync(key2);
+      scheduleSweep();
+      return Object.fromEntries([...listed].map((key2) => [key2, store.get(key2)]));
+    },
+    release(clientID) {
+      for (const key2 of forget(clientID))
+        sync(key2);
+    },
+    get: (key2) => store.get(key2),
+    refresh: (key2) => store.refresh(key2),
+    invalidate(key2) {
+      store.invalidate(key2);
+      if (!disposed && !holds.has(key2) && liveLeases(key2).length > 0)
+        store.refresh(key2);
+    },
+    notify: (key2) => store.notify(key2),
+    keys: () => store.keys(),
+    polling: (key2) => holds.has(key2),
+    async dispose(wait = 0) {
+      disposed = true;
+      if (sweepTimer !== undefined)
+        clearTimer(sweepTimer);
+      for (const release of holds.values())
+        release();
+      holds.clear();
+      store.dispose();
+      if (wait <= 0 || tasks.size === 0)
+        return;
+      let timer;
+      await Promise.race([
+        Promise.allSettled([...tasks]),
+        new Promise((resolve) => timer = setTimer(resolve, wait))
+      ]);
+      clearTimer(timer);
+    }
+  };
+}
+
+// packages/forgekeeper/src/status-server.ts
+var REVIEW_POLL_SECONDS = 30;
+var DRAIN_TIME = 5000;
+var PENDING_PREFIX = "status/pending/";
+var FEEDBACK_PREFIX = "status/feedback/";
+var pendingPrefix = (sessionID) => `${PENDING_PREFIX}${encodeURIComponent(sessionID)}/`;
+var pendingKey = (sessionID, url) => `${pendingPrefix(sessionID)}${encodeURIComponent(url)}`;
+var feedbackRecordKey = (key2) => `${FEEDBACK_PREFIX}${encodeURIComponent(key2)}`;
+var LEGACY_KEYS = ["status/humanReviewFeedback", "status/automatedReviewPending"];
+function userTitle(title, prefix) {
+  if (!title || !prefix)
+    return title;
+  if (title === prefix)
+    return "";
+  return title.startsWith(`${prefix} `) ? title.slice(prefix.length + 1) : title;
+}
+async function setupStatus(ctx, settings, deps, host) {
+  const directory = ctx.location.directory;
+  let closing = false;
+  let closed = false;
+  const foreign = new Set;
+  let invalidate = () => {};
+  let writes = Promise.resolve();
+  const write = (task) => {
+    if (closed)
+      return;
+    writes = writes.then(task).catch((error) => reportOnce("storage", "Could not store review state", error));
+  };
+  async function scanAll(prefix) {
+    const entries = [];
+    let after;
+    do {
+      const page = await ctx.storage.scan({ prefix, ...after ? { after } : {} });
+      entries.push(...page.entries);
+      after = page.next;
+    } while (after);
+    return entries;
+  }
+  const notice = (value) => {
+    if (closed || closing && value.variant === "error")
+      return;
+    host.notice(value);
+  };
+  const isTarget = (sessionID, url) => !closing && !foreign.has(sessionID) && host.isTarget(sessionID, url);
+  async function owns(sessionID) {
+    const session = await ctx.session.get({ sessionID });
+    if (session.location.directory === directory)
+      return true;
+    markForeign(sessionID);
+    return false;
+  }
+  function markForeign(sessionID) {
+    if (foreign.has(sessionID))
+      return;
+    foreign.add(sessionID);
+    automated?.forget(sessionID);
+    invalidate(sessionID);
+  }
+  const reported = new Set;
+  const reportOnce = (kind, prefix, error) => {
+    if (reported.has(kind))
+      return;
+    reported.add(kind);
+    const reason = error instanceof Error ? error.message : String(error);
+    notice({ message: `${prefix}: ${reason}`, variant: "error" });
+  };
+  async function tell(sessionID, requests2, compose) {
+    if (closing)
+      throw new Error("The plugin stopped");
+    if (!await owns(sessionID))
+      return [];
+    if (closing)
+      throw new Error("The plugin stopped");
+    const current = requests2.filter((request) => isTarget(sessionID, request.url));
+    if (current.length === 0)
+      return [];
+    const { text, description } = compose(current);
+    await ctx.session.synthetic({
+      sessionID,
+      text,
+      description,
+      delivery: "queue",
+      resume: settings.resumeSession
+    });
+    return current;
+  }
+  const readFeedback = deps.feedback ?? (async (request, cwd) => traitsOf(request).feedback?.fetch(deps.exec, cwd, request));
+  const automated = settings.notifyAutomatedReviews ? createAutomatedReviewWatcher({
+    isTarget,
+    now: deps.now,
+    async read(sessionID) {
+      const deliveries = {};
+      for (const { value } of await scanAll(pendingPrefix(sessionID))) {
+        const delivery = value;
+        deliveries[notificationKey(sessionID, delivery)] = delivery;
+      }
+      return deliveries;
+    },
+    write: (sessionID, url, delivery) => write(() => delivery ? ctx.storage.set(pendingKey(sessionID, url), delivery) : ctx.storage.remove(pendingKey(sessionID, url))),
+    async send(sessionID, requests2) {
+      const sent = await tell(sessionID, requests2, (current) => ({
+        text: reviewMessage(current),
+        description: reviewTitle(current)
+      }));
+      if (sent.length > 0)
+        notice({ sessionID, ...reviewToast(sent), variant: "info" });
+    },
+    onSendError(error, sessionID, requests2) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const name = automatedReview(requests2[0])?.name ?? "the automated reviewer";
+      notice({
+        sessionID,
+        message: `Could not tell the session about ${name}'s review: ${reason}. Retrying in 10 minutes.`,
+        variant: "error"
+      });
+    }
+  }) : undefined;
+  const human = settings.notifyHumanReviews ? createFeedbackWatcher({
+    record: async (key2) => await ctx.storage.get(feedbackRecordKey(key2)),
+    now: deps.now,
+    persist: (key2, change, at) => write(async () => {
+      const stored = await ctx.storage.get(feedbackRecordKey(key2));
+      await ctx.storage.set(feedbackRecordKey(key2), applyFeedback(stored, change, at));
+    }),
+    fetch: async (_sessionID, request) => closing ? undefined : readFeedback(request, directory),
+    current: (sessionID, request) => isTarget(sessionID, request.url),
+    async send(sessionID, request, comments) {
+      const sent = await tell(sessionID, [request], () => ({
+        text: feedbackMessage(request, comments),
+        description: `New review feedback on ${reference(request)}`
+      }));
+      if (sent.length > 0)
+        notice({ sessionID, ...feedbackToast(request, comments), variant: "info" });
+    },
+    onFetchError: (error) => reportOnce("feedback-fetch", "Could not check PR/MR review feedback", error),
+    onSendError: (error) => {
+      const reason = error instanceof Error ? error.message : String(error);
+      notice({
+        message: `Could not tell the session about review feedback: ${reason}`,
+        variant: "error"
+      });
+    }
+  }) : undefined;
+  const service = createStatusService({
+    async load(key2, previous) {
+      if (key2 === HOME)
+        return locate(deps.forges, { directory });
+      const session = await ctx.session.get({ sessionID: key2 });
+      if (session.location.directory !== directory) {
+        foreign.add(key2);
+        automated?.forget(key2);
+        return { kind: "none", reason: "The session moved to another checkout" };
+      }
+      foreign.delete(key2);
+      const state = await host.state(key2);
+      return locate(deps.forges, {
+        directory,
+        targets: classifyTargets(targetOutput(state.targets)),
+        title: userTitle(session.title, state.prefix),
+        previous
+      });
+    },
+    isTarget,
+    owns: (sessionID) => !foreign.has(sessionID),
+    publish: host.publish,
+    automated,
+    human,
+    onWatchError: (error) => reportOnce("watch", "PR/MR status watcher failed", error),
+    interval: settings.pollSeconds * 1000,
+    activeInterval: Math.min(settings.pollSeconds, REVIEW_POLL_SECONDS) * 1000,
+    now: deps.now
+  });
+  invalidate = (sessionID) => service.invalidate(sessionID);
+  write(async () => {
+    for (const key2 of LEGACY_KEYS)
+      await ctx.storage.remove(key2);
+    const at = (deps.now ?? Date.now)();
+    for (const { key: key2, value } of await scanAll(FEEDBACK_PREFIX)) {
+      if (isExpired(value, at))
+        await ctx.storage.remove(key2);
+    }
+  });
+  return {
+    service,
+    targetsChanged: (sessionID) => service.invalidate(sessionID),
+    async titleChanged(sessionID) {
+      if (!service.keys().includes(sessionID))
+        return;
+      if ((await host.state(sessionID)).targets.length === 0)
+        service.invalidate(sessionID);
+    },
+    turnEnded() {
+      for (const key2 of service.keys())
+        service.notify(key2);
+    },
+    async branchChanged() {
+      for (const key2 of service.keys()) {
+        if (key2 === HOME || (await host.state(key2)).targets.length === 0)
+          service.invalidate(key2);
+      }
+    },
+    sessionMoved(sessionID) {
+      if (service.keys().includes(sessionID))
+        service.invalidate(sessionID);
+    },
+    async dispose() {
+      closing = true;
+      await service.dispose(DRAIN_TIME);
+      closed = true;
+      await writes;
+    }
+  };
+}
+
+// packages/forgekeeper/src/title.ts
+var LEGACY_PREFIX_RE = /^\[[^[\],]+, [!#](?:\d+|N\/A)\] /;
+var MAX_TITLE_LENGTH = 100;
+var MAX_BRANCH_LABEL = 40;
+var ISSUE_PATTERNS = [
+  /(?:^|[/])(\d+)[-/]/,
+  /[-/](\d+)$/,
+  /^(?:issue|gh|bug|fix|feat|feature|hotfix)[-/](\d+)\b/i
+];
+function extractIssueNumber(branch) {
+  for (const pattern of ISSUE_PATTERNS) {
+    const match = branch.match(pattern);
+    if (match)
+      return match[1];
+  }
+  return;
+}
+function reconcileTitle(title, prefix, previousPrefix) {
+  let rest;
+  if (previousPrefix && title === previousPrefix)
+    rest = "";
+  else if (previousPrefix && title.startsWith(`${previousPrefix} `))
+    rest = title.slice(previousPrefix.length + 1);
+  else
+    rest = title.replace(LEGACY_PREFIX_RE, "");
+  if (!prefix)
+    return rest.slice(0, MAX_TITLE_LENGTH);
+  const kept = rest.slice(0, Math.max(0, MAX_TITLE_LENGTH - prefix.length - 1));
+  return kept ? `${prefix} ${kept}` : prefix;
+}
+function branchPrefix(forge, branch, number) {
+  const issue = extractIssueNumber(branch);
+  const label = issue ? forge.issueReference(issue) : shorten(branch, MAX_BRANCH_LABEL);
+  return `[${label}, ${forge.reference(number ?? "N/A")}]`;
+}
+var shorten = (text, length) => text.length > length ? `${text.slice(0, length - 1)}\u2026` : text;
+
+// packages/forgekeeper/src/server.ts
+var SKIP_BRANCHES = new Set(["master", "main", "HEAD", "develop"]);
+var GUIDANCE = [
+  "When the user establishes or changes the primary issue, PR, or MR for this session, call set_session_target with its full URL before starting that work.",
+  "When the user asks you to work on several issues, PRs, or MRs together, call set_session_target with all of their full URLs in targets. If the user describes them instead of linking them, find them first, then set them before starting that work. When they are all PRs/MRs for one established issue, pass it as issue_url.",
+  'After you create a PR or MR for the current task (for example with gpsup, glab mr create, gh pr create, or a forge tool), call set_session_target with the new PR/MR URL. Pass the current issue as issue_url when the PR/MR was created for it. If the session has several targets that are still part of the task, use operation "add" so they are kept.',
+  'When the user drops some of several targets from the task, call set_session_target with operation "remove" and their URLs.',
+  "Background references, comparisons, and dependencies do not change the target. Follow-ups without a new primary target keep the current target.",
+  "Include issue_url only when its relationship to the target PRs/MRs is established. Never carry over the checked-out branch\u2019s issue to another target.",
+  'When the user explicitly returns to work on the checked-out branch, call set_session_target with target "branch".'
+];
+function describeTargets(targets) {
+  if (targets.length === 0)
+    return "checked-out branch (automatic)";
+  if (targets.length === 1)
+    return JSON.stringify(targets[0]);
+  return `${targets.length} targets: ${JSON.stringify(targets)}`;
+}
+function toolResult(targets, missing) {
+  const lines = targets.length === 0 ? ["Session target: checked-out branch."] : targets.length === 1 ? [`Session target: ${targets[0].url}`] : [`Session targets (${targets.length}):`, ...targets.map((target2) => `- ${target2.url}`)];
+  if (missing.length)
+    lines.push(`Not session targets, so not removed: ${missing.join(", ")}`);
+  return lines.join(`
+`);
+}
+var DISABLED = { enabled: false, snapshot: { loading: false } };
+var DRAIN_TIME2 = 5000;
+async function drain(tasks, limit) {
+  let timer;
+  await Promise.race([
+    Promise.allSettled(tasks),
+    new Promise((resolve) => timer = setTimeout(resolve, limit))
+  ]);
+  clearTimeout(timer);
+}
+var json = (value) => JSON.parse(JSON.stringify(value));
+async function setupServer(ctx, lookups, status2) {
+  const pending = new Map;
+  const controller = new AbortController;
+  let closing = false;
+  const known = new Map;
+  const revisions = new Map;
+  const revision = (sessionID) => revisions.get(sessionID) ?? 0;
+  const bump = (sessionID) => revisions.set(sessionID, revision(sessionID) + 1);
+  async function stateFor(sessionID) {
+    const started = revision(sessionID);
+    const stored = await ctx.storage.get(`sessions/${sessionID}`) ?? {};
+    const targets = Array.isArray(stored.targets) ? stored.targets : stored.target ? [stored.target] : [];
+    if (revision(sessionID) === started)
+      known.set(sessionID, targets);
+    return { targets, ...stored.prefix ? { prefix: stored.prefix } : {} };
+  }
+  const save = async (sessionID, state) => {
+    if (closing)
+      throw new Error("The plugin is reloading. Try again.");
+    bump(sessionID);
+    known.set(sessionID, state.targets);
+    try {
+      await ctx.storage.set(`sessions/${sessionID}`, {
+        ...state.targets.length ? { targets: state.targets } : {},
+        ...state.prefix ? { prefix: state.prefix } : {}
+      });
+    } finally {
+      bump(sessionID);
+    }
+  };
+  let watcher;
+  const rpc = await ctx.rpc.register(ForgeSessionRpc, {
+    target: async (input) => {
+      const { sessionID } = input;
+      return targetOutput((await stateFor(sessionID)).targets);
+    },
+    watch: async (input) => {
+      const { clientID, keys, visible } = input;
+      return watcher ? { enabled: true, statuses: json(watcher.service.watch(clientID, keys, visible)) } : { enabled: false, statuses: {} };
+    },
+    release: async (input) => {
+      watcher?.service.release(input.clientID);
+      return {};
+    },
+    refresh: async (input) => {
+      const { key: key2 } = input;
+      return watcher ? { enabled: true, snapshot: json(await watcher.service.refresh(key2)) } : DISABLED;
+    }
+  });
+  const settings = statusOptions(ctx.options);
+  if (status2 && settings.enabled) {
+    watcher = await setupStatus(ctx, settings, status2, {
+      state: stateFor,
+      isTarget: (sessionID, url) => includesRequest(known.get(sessionID) ?? [], url),
+      publish: (key2, snapshot2) => void rpc.events.emit("status", { directory: ctx.location.directory, key: key2, snapshot: json(snapshot2) }).catch(() => {}),
+      notice: (notice) => void rpc.events.emit("notice", json(notice)).catch(() => {})
+    });
+  }
+  async function update(sessionID) {
+    const session = await ctx.session.get({ sessionID });
+    if (session.parentID || !session.title)
+      return;
+    const directory = session.location.directory;
+    if (directory !== ctx.location.directory)
+      return;
+    const state = await stateFor(sessionID);
+    let prefix = targetsPrefix(state.targets);
+    if (state.targets.length === 0) {
+      const vcs = await ctx.vcs.get({ location: session.location });
+      const info = vcs.data?.branch;
+      const branch = info?.current;
+      if (branch && !SKIP_BRANCHES.has(branch) && branch !== info?.default) {
+        const found = await lookups.branch(directory);
+        if (found)
+          prefix = branchPrefix(found.forge, found.branch, found.number);
+      }
+    }
+    if (closing)
+      return;
+    const title = reconcileTitle(session.title, prefix, state.prefix);
+    if (title !== session.title)
+      await ctx.session.update({ sessionID, title });
+    await save(sessionID, { targets: state.targets, ...prefix ? { prefix } : {} });
+  }
+  function schedule(sessionID, action = () => update(sessionID)) {
+    if (closing)
+      return Promise.reject(new Error("The plugin is reloading. Try again."));
+    const previous = pending.get(sessionID) ?? Promise.resolve();
+    const next = previous.then(action);
+    const settled = next.catch(() => {});
+    pending.set(sessionID, settled);
+    settled.then(() => {
+      if (pending.get(sessionID) === settled)
+        pending.delete(sessionID);
+    });
+    return next;
+  }
+  async function inferIssues(targets, previous) {
+    const known2 = new Set(previous.filter((target2) => !target2.issueUrl).map((target2) => target2.url));
+    await mapLimit(targets, CONCURRENCY, async (target2) => {
+      if (target2.issueUrl || target2.branchIssue || known2.has(target2.url))
+        return;
+      const request = targetRequest(target2);
+      const branch = request ? await lookups.sourceBranch(request, ctx.location.directory) : undefined;
+      const issue = branch ? extractIssueNumber(branch) : undefined;
+      if (issue)
+        target2.branchIssue = issue;
+    });
+  }
+  const tools = await ctx.tool.transform((editor) => {
+    editor.add({
+      name: "set_session_target",
+      description: 'Set the issues, PRs, or MRs this session works on, for its title and PR/MR status. Use target for one full URL, or "branch" to return to branch-based naming. Use targets for several full URLs. The default operation, "replace", sets exactly the given targets; "add" keeps the current targets, and "remove" drops the given ones. Call it after creating a PR/MR for the current task. Without issue_url, the related issue is inferred from the PR/MR source branch name. This only changes local session metadata.',
+      input: {
+        type: "object",
+        properties: {
+          target: {
+            type: "string",
+            description: 'Full GitHub/GitLab issue, PR, or MR URL, or "branch".'
+          },
+          targets: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            maxItems: MAX_TARGETS,
+            description: "Several full GitHub/GitLab issue, PR, or MR URLs, instead of target."
+          },
+          operation: {
+            type: "string",
+            enum: ["replace", "add", "remove"],
+            description: 'How the given targets change the current ones. Defaults to "replace".'
+          },
+          issue_url: {
+            type: "string",
+            description: "Optional full URL of an established related issue for target, or for every PR/MR in targets. Omit when unknown."
+          }
+        },
+        additionalProperties: false
+      },
+      execute: async (input, { sessionID }) => {
+        const change = parseTargetChange(input);
+        let result = { targets: [], missing: [] };
+        await schedule(sessionID, async () => {
+          const session = await ctx.session.get({ sessionID });
+          if (session.parentID || session.location.directory !== ctx.location.directory) {
+            throw new Error("Session targets can only be set in the current root session.");
+          }
+          const state = await stateFor(sessionID);
+          result = applyTargetChange(state.targets, change);
+          await inferIssues(result.targets, state.targets);
+          await save(sessionID, {
+            targets: result.targets,
+            ...state.prefix ? { prefix: state.prefix } : {}
+          });
+          watcher?.targetsChanged(sessionID);
+          await rpc.events.emit("targetChanged", { sessionID, ...targetOutput(result.targets) });
+          await update(sessionID);
+        });
+        return { content: toolResult(result.targets, result.missing) };
+      }
+    });
+  });
+  await ctx.session.hook("context", async (event) => {
+    try {
+      const session = await ctx.session.get({ sessionID: event.sessionID });
+      if (session.parentID || session.location.directory !== ctx.location.directory)
+        return;
+      const state = await stateFor(event.sessionID);
+      event.system.push({
+        type: "text",
+        text: [...GUIDANCE, `Current session target: ${describeTargets(state.targets)}.`].join(`
+`)
+      });
+    } catch {}
+  });
+  (async () => {
+    for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+      const { type } = event;
+      const sessionID = event.data?.sessionID;
+      if ((type === "session.renamed" || type === "session.execution.succeeded") && sessionID) {
+        schedule(sessionID).catch(() => {});
+      }
+      if (type === "session.renamed" && sessionID)
+        watcher?.titleChanged(sessionID).catch(() => {});
+      if (type === "session.moved" && sessionID)
+        watcher?.sessionMoved(sessionID);
+      if (type === "session.execution.succeeded" || type === "session.execution.failed")
+        watcher?.turnEnded();
+      if (type === "vcs.branch.updated") {
+        const location = event.location;
+        if (!location?.directory || location.directory === ctx.location.directory)
+          watcher?.branchChanged().catch(() => {});
+      }
+    }
+  })().catch((error) => {
+    if (controller.signal.aborted)
+      return;
+    const reason = error instanceof Error ? error.message : String(error);
+    rpc.events.emit("notice", {
+      message: `Session title and PR/MR status updates stopped: ${reason}`,
+      variant: "error"
+    }).catch(() => {});
+  });
+  return async () => {
+    closing = true;
+    controller.abort();
+    await drain([...pending.values()], DRAIN_TIME2);
+    await watcher?.dispose();
+    await tools.dispose();
+    await rpc.dispose();
+  };
+}
+
+// packages/forgekeeper/src/index.ts
+var src_default = {
+  id: "opencode-forge-session-title",
+  async setup(ctx) {
+    const hosts = hostsFrom(ctx.options ?? {});
+    const stopped = new AbortController;
+    const statusExec = limitExec(exec2, CONCURRENCY, stopped.signal);
+    const cleanup = await setupServer(ctx, createTitleLookups(new Forges(exec2, hosts), execWithTimeout(15000)), {
+      forges: new Forges(statusExec, hosts),
+      exec: statusExec
+    });
+    return async () => {
+      stopped.abort();
+      await cleanup();
+    };
+  }
+};
+export {
+  src_default as default
+};