@preventive/triage 1.0.0-alpha.49 → 1.0.0-alpha.50

package/server-managed/repository-agents.ts

@@ -1,8 +1,13 @@
 // What the code viewer's Agents tab reconstructs agents' sessions
 // from (GET /api/admin/repositories/agents, common/managed/agent-tasks.ts):
 // a page of the repository's pull requests, the most recently updated first,
-// and of its default branch's commits, the newest first, those no pull
-// request merged; on the first page, its latest issues and the newest of
+// as kept for the Pulse too (repository-pulls.ts readPulls), those past
+// them searched for, and of its default branch's commits, the newest first,
+// those no pull request merged, read from its history as the Commits tab
+// keeps it, the
+// marks an agent left kept with each (repository-history.ts commitMarks),
+// whether a pull request brought one looked up for those marked alone, and
+// kept by the commit; on the first page, its latest issues and the newest of
 // its agents' branches (GitHub lists branches by name alone, so every one an
 // agent's prefix names is read, as many as fifty pages of each, and the newest
 // kept). Each artifact's own texts (never comments: an agent links its
@@ -10,12 +15,14 @@
 // for the marks an agent leaves, and a pull request's labels for one naming
 // an agent, and those alone are answered, never the texts. GraphQL alone
 // gives them, so it needs a token.
-import { type AgentAuthor, type AgentBranch, type AgentCommit, type AgentIssue, type AgentPull, type AppAgent, agentSignals } from '../common/managed/agent-tasks.ts'
+import { type AgentAuthor, type AgentBranch, type AgentCommit, type AgentIssue, type AgentPull, type AgentSignals, type AppAgent, agentSignals } from '../common/managed/agent-tasks.ts'
 import { GITHUB_AGENTS, type GithubAgentAccount, type GithubAgentId } from '../common/managed/github-agents.ts'
 import { AGENT_BRANCH_PREFIXES, APP_AGENTS } from './app-agents.ts'
 import { GithubApiError } from './github-app.ts'
-import { ACTOR, type NamedAccount, actorOf, commitAccount, githubGraphql, linkNoreplyUsers } from './repository-history.ts'
-import { ISSUES_CURSOR } from './repository-issues.ts'
+import type { GraphqlError } from './github-graphql.ts'
+import { ACTOR, ALL_BRANCHES, type HistoryCommit, type HistoryPages, type NamedAccount, actorOf, commitAccount, commitMarks, githubGraphql, historyFrom, historyMarks,
+  inBatches, linkNoreplyUsers, messageMarks, variablesOf } from './repository-history.ts'
+import type { PullList } from './repository-pulls.ts'
 
 export const AGENT_PULLS_PAGE = 50
 export const AGENT_COMMITS_PAGE = 100
@@ -30,8 +37,10 @@ const MAX_TITLE = 1000
 const MAX_NAME = 256
 const LOGIN = /^[A-Za-z\d][A-Za-z\d-]{0,38}(?:\[bot\])?$/u
 const SHA = /^[a-f\d]{40}$/u
-// The address Claude's own commits are authored with.
-const CLAUDE_EMAIL = 'noreply@anthropic.com'
+// Commits whether a pull request brought each is looked up of, in a query,
+// and queries at once.
+const PULLED_COMMITS = 100
+const PULLED_PARALLEL = 4
 
 // The app agents' accounts' no-reply addresses, by each login of theirs.
 const AGENT_EMAILS = APP_AGENTS.flatMap(({ id }) => GITHUB_AGENTS[id as GithubAgentId].accounts
@@ -58,40 +67,51 @@ const AUTHORED_QUERY = `query($owner: String!, $name: String!, $emails: [String!
     defaultBranchRef { target { ... on Commit { history(first: ${AGENT_COMMITS_PAGE}, author: { emails: $emails }) { nodes { ${COMMIT_FIELDS} } } } } }
   }
 }`
-const PAGE_QUERY = `query($owner: String!, $name: String!, $pulls: String, $commits: String, $first: Boolean!, $readPulls: Boolean!, $readCommits: Boolean!) {
+// What a pull request is read by, for its row (pull): its texts for the
+// marks an agent leaves in them (its body, its last commit's message, its
+// merge commit's), never answered; its commits counted beside (`commits {
+// totalCount }`, as the reads of it ask theirs).
+export const AGENT_PULL_FIELDS = `number title state isDraft createdAt updatedAt author { __typename ${ACTOR} } body headRefName isCrossRepository
+  headRepositoryOwner { login } additions deletions last: commits(last: 1) { nodes { commit { message } } } mergeCommit { message }
+  closingIssuesReferences(first: ${CLOSES}) { nodes { number } } labels(first: ${LABELS}) { nodes { name } }`
+// On the first page, the default branch's head and the latest issues.
+const PAGE_QUERY = `query($owner: String!, $name: String!) {
   repository(owner: $owner, name: $name) {
-    pullRequests(first: ${AGENT_PULLS_PAGE}, after: $pulls, orderBy: { field: UPDATED_AT, direction: DESC }) @include(if: $readPulls) {
-      pageInfo { hasNextPage endCursor }
-      nodes { number title state isDraft createdAt updatedAt author { ${ACTOR} } body headRefName isCrossRepository headRepositoryOwner { login } additions deletions
-        commits(last: 1) { totalCount nodes { commit { message } } }
-        mergeCommit { message }
-        closingIssuesReferences(first: ${CLOSES}) { nodes { number } }
-        labels(first: ${LABELS}) { nodes { name } } }
-    }
-    defaultBranchRef { target { ... on Commit {
-      history(first: ${AGENT_COMMITS_PAGE}, after: $commits) @include(if: $readCommits) {
-        pageInfo { hasNextPage endCursor }
-        nodes { ${COMMIT_FIELDS} }
-      }
-    } } }
-    issues(first: ${AGENT_ISSUES}, orderBy: { field: UPDATED_AT, direction: DESC }) @include(if: $first) {
+    defaultBranchRef { target { oid } }
+    issues(first: ${AGENT_ISSUES}, orderBy: { field: UPDATED_AT, direction: DESC }) {
       nodes { number title state createdAt updatedAt author { ${ACTOR} } }
     }
   }
 }`
+// A page of the pull requests a search finds, as GitHub sorts them, on from
+// where `after` says its page before ended.
+const SEARCH_QUERY = `query($query: String!, $after: String) {
+  search(type: ISSUE, query: $query, first: ${AGENT_PULLS_PAGE}, after: $after) {
+    pageInfo { endCursor } nodes { ... on PullRequest { ${AGENT_PULL_FIELDS} commits { totalCount } } }
+  }
+}`
 
 type Login = { login?: unknown; databaseId?: unknown } | null | undefined
-type PullNode = { number?: unknown; title?: unknown; state?: unknown; isDraft?: unknown; createdAt?: unknown; updatedAt?: unknown; author?: Login; body?: unknown
-  headRefName?: unknown; isCrossRepository?: unknown; headRepositoryOwner?: Login; additions?: unknown; deletions?: unknown; commits?: { totalCount?: unknown; nodes?: ({ commit?: { message?: unknown } | null } | null)[] }
-  mergeCommit?: { message?: unknown } | null; closingIssuesReferences?: { nodes?: ({ number?: unknown } | null)[] }; labels?: { nodes?: ({ name?: unknown } | null)[] } }
+export type PullNode = { number?: unknown; title?: unknown; state?: unknown; isDraft?: unknown; createdAt?: unknown; updatedAt?: unknown; author?: Login; body?: unknown
+  headRefName?: unknown; isCrossRepository?: unknown; headRepositoryOwner?: Login; additions?: unknown; deletions?: unknown; commits?: { totalCount?: unknown } | null
+  last?: { nodes?: ({ commit?: { message?: unknown } | null } | null)[] } | null; mergeCommit?: { message?: unknown } | null
+  closingIssuesReferences?: { nodes?: ({ number?: unknown } | null)[] }; labels?: { nodes?: ({ name?: unknown } | null)[] } }
 type GitActor = { email?: unknown; user?: Login }
 type CommitNode = { oid?: unknown; messageHeadline?: unknown; message?: unknown; committedDate?: unknown; additions?: unknown; deletions?: unknown
   author?: GitActor | null; associatedPullRequests?: { totalCount?: unknown } }
 type IssueNode = { number?: unknown; title?: unknown; state?: unknown; createdAt?: unknown; updatedAt?: unknown; author?: Login }
 type RefNode = { prefix?: unknown; name?: unknown; target?: { committedDate?: unknown; message?: unknown; author?: GitActor | null } | null }
 type Connection<T> = { pageInfo?: { hasNextPage?: unknown; endCursor?: unknown }; nodes?: (T | null)[] }
-type Page = { repository?: { pullRequests?: Connection<PullNode>; defaultBranchRef?: { target?: { history?: Connection<CommitNode> } | null } | null
+// Whether a pull request brought each commit, `c<n>` the `n`th's.
+const pulledQuery = (count: number) => `query($owner: String!, $name: String!, ${variablesOf('o', count, 'GitObjectID!')}) {
+  repository(owner: $owner, name: $name) {
+    ${Array.from({ length: count }, (_, at) => `c${at}: object(oid: $o${at}) { ... on Commit { associatedPullRequests(first: 1) { totalCount } } }`).join('\n    ')}
+  }
+}`
+type Pulled = { repository?: Record<string, { associatedPullRequests?: { totalCount?: unknown } } | null> | null }
+type Page = { repository?: { defaultBranchRef?: { target?: { oid?: unknown; history?: Connection<CommitNode> } | null } | null
   issues?: Connection<IssueNode> } | null }
+type Found = { search?: { pageInfo?: { endCursor?: unknown }; nodes?: (PullNode | null)[] } | null } | null
 type RefsPage = { repository?: { refs?: Connection<RefNode> } | null }
 
 const count = (value: unknown) => Number.isSafeInteger(value) && (value as number) >= 0 ? value as number : 0
@@ -104,7 +124,8 @@ const nameOf = (value: unknown, max = MAX_NAME) => typeof value === 'string' &&
 const loginOf = (author: Login) => typeof author?.login === 'string' && LOGIN.test(author.login) ? author.login : null
 const PULL_STATES: Record<string, AgentPull['state']> = { OPEN: 'open', MERGED: 'merged', CLOSED: 'closed' }
 
-function pull(node: PullNode | null): AgentPull | null {
+// A pull request's row: what it is, and the marks an agent left on it.
+export function pull(node: PullNode | null): AgentPull | null {
   const at = number(node?.number)
   if (!node || !at) return null
   const author = accountOf(node.author)
@@ -114,7 +135,7 @@ function pull(node: PullNode | null): AgentPull | null {
     fork: node.isCrossRepository === true ? loginOf(node.headRepositoryOwner) ?? `pull-${at}` : null,
     additions: count(node.additions), deletions: count(node.deletions), commits: count(node.commits?.totalCount),
     closes: (node.closingIssuesReferences?.nodes ?? []).flatMap(closed => number(closed?.number) ?? []),
-    signals: agentSignals([node.body, node.commits?.nodes?.[0]?.commit?.message, node.mergeCommit?.message], APP_AGENTS, nameOf(node.headRefName),
+    signals: agentSignals([node.body, node.last?.nodes?.[0]?.commit?.message, node.mergeCommit?.message], APP_AGENTS, nameOf(node.headRefName),
       author, (node.labels?.nodes ?? []).map(label => label?.name)) }
 }
 
@@ -127,18 +148,67 @@ const accountOf = (actor: Login) => both(actorOf(actor))
 const authorOf = (actor: GitActor | null | undefined) => both(commitAccount(actor))
 
 // A commit to the default branch no pull request merged, where an agent left
-// its marks on it, or Claude authored it.
+// its marks on it, or Claude authored it (commitMarks).
 function directCommit(node: CommitNode | null): AgentCommit | null {
   if (!node || typeof node.oid !== 'string' || !SHA.test(node.oid) || count(node.associatedPullRequests?.totalCount) > 0) return null
   const author = authorOf(node.author)
-  const signals = agentSignals([node.message], APP_AGENTS, null, author)
-  if (node.author?.email === CLAUDE_EMAIL) signals.claude = true
-  if (!signals.claude && !signals.codex && signals.agents.length === 0 && signals.sessions.length === 0 && signals.tasks.length === 0) return null
+  const signals = commitMarks(messageMarks(node.message), { name: null, email: node.author?.email, account: commitAccount(node.author) })
+  if (!signals) return null
   return { oid: node.oid, title: nameOf(node.messageHeadline, MAX_TITLE) ?? '', at: timeOf(node.committedDate),
     author: author?.login ?? loginOf(node.author?.user), authorId: author?.id ?? null,
     additions: count(node.additions), deletions: count(node.deletions), signals }
 }
 
+// A commit of the history kept an agent marked (`signals`,
+// repository-history.ts historyMarks), as one of the default branch's.
+const keptCommit = (commit: HistoryCommit, signals: AgentSignals): AgentCommit => ({ oid: commit.sha, title: commit.subject, at: commit.committedAt,
+  author: commit.authorLogin, authorId: commit.authorId ?? null, additions: commit.additions ?? 0, deletions: commit.deletions ?? 0, signals })
+
+// Whether a pull request brought each commit, kept by the commit.
+export interface CommitPulls {
+  read(shas: string[]): Promise<Map<string, boolean>>
+  write(sha: string, pulled: boolean): Promise<void>
+}
+
+// A commit GitHub has none of, as one rewritten away: its field null.
+const notFound = (error: GraphqlError) => error?.type === 'NOT_FOUND'
+
+// Those of `shas` a pull request brought: as kept (`kept`), the rest looked
+// up, PULLED_COMMITS a query, and kept; one GitHub has none of, none.
+async function pulledCommits(fullName: string, token: string, shas: string[], kept: CommitPulls, fetchImpl: typeof fetch) {
+  const [owner, name] = fullName.split('/') as [string, string]
+  const known = await kept.read(shas)
+  await inBatches(shas.filter(sha => !known.has(sha)), PULLED_COMMITS, PULLED_PARALLEL, async batch => {
+    const data = await githubGraphql(pulledQuery(batch.length), { owner, name, ...Object.fromEntries(batch.map((sha, at) => [`o${at}`, sha])) }, token, fetchImpl,
+      notFound) as Pulled
+    await Promise.all(batch.map((sha, at) => {
+      const node = data?.repository?.[`c${at}`]
+      if (!node) return Promise.resolve()
+      known.set(sha, count(node.associatedPullRequests?.totalCount) > 0)
+      return kept.write(sha, known.get(sha)!)
+    }))
+  })
+  return new Set(shas.filter(sha => known.get(sha) === true))
+}
+
+// Where commits listed stop: those the cursor named but left unread still
+// unlisted (`left`, newer than those below the commits read from the rest),
+// then the parents of those listed not listed, the newest first (each by its
+// child's time), as the Commits tab reads on from (repository-history.js):
+// each read in its turn, as many as ALL_BRANCHES an answer, none dropped
+// till MAX_FRONTIER are left (a cursor's length bounded, a URL's); null
+// where none are.
+function frontier(commits: HistoryCommit[], left: string[]) {
+  const listed = new Set(commits.map(commit => commit.sha))
+  const at = new Map<string, number>()
+  for (const commit of commits) {
+    for (const parent of commit.parents) if (!listed.has(parent)) at.set(parent, Math.max(at.get(parent) ?? Number.NEGATIVE_INFINITY, commit.committedAt ?? 0))
+  }
+  const below = [...at].toSorted((a, b) => b[1] - a[1]).map(([sha]) => sha)
+  const starts = [...new Set([...left.filter(sha => !listed.has(sha)), ...below])].slice(0, MAX_FRONTIER)
+  return starts.length > 0 ? starts.join(',') : null
+}
+
 function issue(node: IssueNode | null): AgentIssue | null {
   const at = number(node?.number)
   if (!node || !at) return null
@@ -175,46 +245,108 @@ async function agentBranches(owner: string, name: string, prefix: string, token:
 
 // What its answers are kept by, with their cursors (http.ts
 // handleRepositoryAgents): bumped as what a page reads, or how it tells an
-// agent, changes, so that no answer an older server kept is sent for a day.
-export const AGENTS_READ_VERSION = 7
+// agent, changes (with AGENT_MARKS_READ, app-agents.ts, where commits' marks
+// do), so that no answer an older server kept is sent for a day.
+export const AGENTS_READ_VERSION = 9
+
+// A cursor of the default branch's commits: those the pages before stopped
+// at (frontier), as many as MAX_FRONTIER, commas between, the first
+// ALL_BRANCHES of them read next; one an older server gave, GitHub's,
+// `<oid> <offset>`, read on from its commit.
+const MAX_FRONTIER = 4 * ALL_BRANCHES
+export const COMMITS_CURSOR = new RegExp(`^(?:[\\da-f]{40}(?:,[\\da-f]{40}){0,${MAX_FRONTIER - 1}}|[\\da-f]{40} \\d{1,9})$`, 'u')
+const startsOf = (cursor: string) => cursor.split(/[ ,]/u).filter(part => SHA.test(part))
 
-// A cursor of the default branch's commits: GitHub names one by a commit
-// and how many on from it, `<oid> <offset>`, a space between.
-export const COMMITS_CURSOR = /^(?:[!-~]{1,256}|[\da-f]{40} \d{1,9})$/u
+// A cursor of the pull requests: the last listed, by when it was updated and
+// its number (`<ms>.<number>`), those below it read next; of a search's page
+// all updated together, the time it searched by and where its page ended too
+// (`~<ms>~<cursor>`), those updated with them read on through the same
+// search; any other, as an older server gave (GitHub's), read from the
+// newest again.
+const POSITION = /^(\d{1,15})\.(\d{1,10})(?:~(\d{1,15})~([\w+/=-]{1,200}))?$/u
+const positionOf = (item: AgentPull) => `${item.updatedAt ?? 0}.${item.number}`
+// Those updated by a time, as GitHub's search takes it, to the second; any
+// where it names none.
+const updatedBy = (at: number) => Number.isFinite(at) ? ` updated:<=${new Date(at).toISOString().replace(/\.\d{3}Z$/u, '+00:00')}` : ''
 
-const nextCursor = (connection: Connection<unknown> | undefined, cursor = ISSUES_CURSOR) => {
-  const info = connection?.pageInfo
-  return info?.hasNextPage === true && typeof info.endCursor === 'string' && cursor.test(info.endCursor) ? info.endCursor : null
+// The repository's pull requests as kept (repository-pulls.ts PullList),
+// read as far back as their first page where none are, and those updated
+// since read as they are (http.ts keptPulls).
+export type KeptPulls = () => Promise<PullList>
+
+// A page of the repository's pull requests, the most recently updated
+// first, below the one `cursor` names (none: from the newest): of those kept
+// (`kept`), as far back as every one is read; past them, as GitHub's search
+// finds those updated before, a page a query. With where it reads on from,
+// null where none are left: past every one kept where all are.
+async function agentPulls(fullName: string, token: string, cursor: string | null, kept: KeptPulls, fetchImpl: typeof fetch) {
+  const at = cursor === null ? null : POSITION.exec(cursor)
+  const [time, past] = at ? [Number(at[1]), Number(at[2])] : [Number.POSITIVE_INFINITY, 0]
+  const below = (item: AgentPull) => (item.updatedAt ?? 0) < time || ((item.updatedAt ?? 0) === time && item.number < past)
+  const list = await kept()
+  // Since when every one updated is read (as repository-pulls.ts pullsReadTo
+  // tells, which reads its pages by these fields): all since the year's
+  // start, -∞.
+  const read = list.next ? list.next.to ?? Number.POSITIVE_INFINITY : list.reach ?? Number.NEGATIVE_INFINITY
+  // As far back as every one is read: the year's start, where all since are.
+  const bottom = Math.max(read, list.since)
+  const listed = list.pulls.filter(item => below(item) && (item.updatedAt ?? 0) >= bottom)
+  const whole = list.all === true && read === Number.NEGATIVE_INFINITY
+  if (listed.length > 0) {
+    const page = listed.slice(0, AGENT_PULLS_PAGE)
+    return { pulls: page, after: listed.length > page.length || !whole ? positionOf(page.at(-1)!) : null }
+  }
+  if (whole) return { pulls: [], after: null }
+  // Those updated by when the last was, those updated with it again among
+  // them (GitHub orders those by no number), the last itself left out; a
+  // page all updated together read on through the same search, past them.
+  const [by, through] = at?.[3] === undefined ? [Math.min(time, bottom), null] : [Number(at[3]), at[4]!]
+  const found = await githubGraphql(SEARCH_QUERY, { query: `repo:${fullName} is:pr sort:updated-desc${updatedBy(by)}`, after: through }, token, fetchImpl) as Found
+  const nodes = found?.search?.nodes ?? []
+  const rows = nodes.flatMap(node => pull(node) ?? [])
+  const last = rows.at(-1)
+  const ended = found?.search?.pageInfo?.endCursor
+  const together = Number.isFinite(by) && rows.every(item => item.updatedAt === last?.updatedAt) && typeof ended === 'string' && /^[\w+/=-]{1,200}$/u.test(ended)
+  const after = nodes.length >= AGENT_PULLS_PAGE && last ? `${positionOf(last)}${together ? `~${by}~${ended}` : ''}` : null
+  return { pulls: rows.filter(item => item.updatedAt !== time || item.number !== past), after: after === cursor ? null : after }
 }
 
-// A page of what the repository's agents left: its pull requests on from
-// the cursor `pulls` ends at, its default branch's commits on from
-// `commits` (the first page where neither is named, with its issues, its
+// A page of what the repository's agents left: its pull requests below the
+// one the cursor `pulls` names, as kept (`kept`, agentPulls), its default
+// branch's commits on from those `commits` names, as its history is kept
+// (`pages`, historyFrom: the first page from its head), whether a pull
+// request brought those marked kept (`pulled`) (the first page where
+// neither is named, with its issues, its
 // agents' branches and the commits the app agents' accounts authored, and
 // the app agents it may name), and the cursors reading on from each, null
 // where either is read whole.
-export async function repositoryAgents(fullName: string, token: string, cursors: { pulls: string | null; commits: string | null },
-  fetchImpl: typeof fetch = globalThis.fetch) {
+export async function repositoryAgents(fullName: string, token: string, cursors: { pulls: string | null; commits: string | null }, pages: HistoryPages,
+  pulled: CommitPulls, kept: KeptPulls, fetchImpl: typeof fetch = globalThis.fetch) {
   const [owner, name] = fullName.split('/') as [string, string]
   const first = cursors.pulls === null && cursors.commits === null
-  const [data, branches, authored] = await Promise.all([
-    githubGraphql(PAGE_QUERY, { owner, name, pulls: cursors.pulls, commits: cursors.commits, first,
-      readPulls: first || cursors.pulls !== null, readCommits: first || cursors.commits !== null }, token, fetchImpl) as Promise<Page>,
+  const [data, branches, authored, pulls] = await Promise.all([
+    first ? githubGraphql(PAGE_QUERY, { owner, name }, token, fetchImpl) as Promise<Page> : null,
     first ? Promise.all(AGENT_BRANCH_PREFIXES.map(prefix => agentBranches(owner, name, prefix, token, fetchImpl))) : [],
     first ? githubGraphql(AUTHORED_QUERY, { owner, name, emails: AGENT_EMAILS }, token, fetchImpl) as Promise<Page> : null,
+    first || cursors.pulls !== null ? agentPulls(fullName, token, cursors.pulls, kept, fetchImpl) : { pulls: [], after: null },
   ])
   const repository = data?.repository
-  if (!repository) throw new GithubApiError(404, 'github-not-found')
-  const history = repository.defaultBranchRef?.target?.history
-  const after = { pulls: nextCursor(repository.pullRequests), commits: nextCursor(history, COMMITS_CURSOR) }
-  const nodes = [...history?.nodes ?? [], ...authored?.repository?.defaultBranchRef?.target?.history?.nodes ?? []]
-  await linkNoreplyUsers(nodes.map(node => node?.author), token, fetchImpl)
-  const commits = nodes.flatMap(node => directCommit(node) ?? [])
+  if (data !== null && !repository) throw new GithubApiError(404, 'github-not-found')
+  const head = repository?.defaultBranchRef?.target?.oid
+  const named = cursors.commits === null ? first && typeof head === 'string' && SHA.test(head) ? [head] : [] : startsOf(cursors.commits)
+  const starts = named.slice(0, ALL_BRANCHES)
+  const history = starts.length > 0 ? (await historyFrom(fullName, token, starts, pages, fetchImpl)).commits : []
+  const marked = history.flatMap(commit => { const signals = historyMarks(commit); return signals ? [{ commit, signals }] : [] })
+  const nodes = authored?.repository?.defaultBranchRef?.target?.history?.nodes ?? []
+  const [brought] = await Promise.all([pulledCommits(fullName, token, marked.map(({ commit }) => commit.sha), pulled, fetchImpl),
+    linkNoreplyUsers(nodes.map(node => node?.author), token, fetchImpl)])
+  const commits = [...marked.flatMap(({ commit, signals }) => brought.has(commit.sha) ? [] : [keptCommit(commit, signals)]), ...nodes.flatMap(node => directCommit(node) ?? [])]
+  const after = { pulls: pulls.after, commits: frontier(history, named.slice(ALL_BRANCHES)) }
   return {
-    pulls: (repository.pullRequests?.nodes ?? []).flatMap(node => pull(node) ?? []),
+    pulls: pulls.pulls.map(({ merged: _merged, ...row }: AgentPull & { merged?: unknown }) => row),
     commits: commits.filter((commit, index) => commits.findIndex(other => other.oid === commit.oid) === index),
     ...first ? {
-      issues: (repository.issues?.nodes ?? []).flatMap(node => issue(node) ?? []),
+      issues: (repository?.issues?.nodes ?? []).flatMap(node => issue(node) ?? []),
       branches: branches.flat(),
       agents: APP_AGENTS.map(({ id, name: agent, avatar }): AppAgent => ({ id, name: agent, ...avatar ? { avatar } : {} })),
     } : {},

package/server-managed/repository-history.ts

@@ -9,7 +9,10 @@
 // read a page from a commit at a time, each page kept by the commit it starts
 // at (historyFrom): a commit's history never changes, and where a commit read
 // starts a page kept, that page glues on, and those after it.
-import { type Coauthor, MAX_COAUTHORS, type Maker, coauthorTrailers, coauthorsOf } from './commit-coauthors.ts'
+import { type AgentSignals, agentSignals } from '../common/managed/agent-tasks.ts'
+import { githubAgent } from '../common/managed/github-agents.ts'
+import { AGENT_MARKS_READ, APP_AGENTS } from './app-agents.ts'
+import { type CommitFacts, MAX_COAUTHORS, type Maker, coauthorFacts, coauthorTrailers } from './commit-coauthors.ts'
 import { GithubApiError, githubJson } from './github-app.ts'
 import { type GraphActor, accountOf, commitAccount, linkNoreplyUsers } from './github-accounts.ts'
 import { githubGraphql } from './github-graphql.ts'
@@ -33,14 +36,18 @@ const MAX_SUBJECT = 1000
 const MAX_NAME = 256
 const SHA = /^[a-f\d]{40}$/u
 
-// A commit, its author by name and by their account's login and numeric id
-// (`authorId`, absent from pages kept before it was read), its co-authors
-// (coauthorsOf, absent from pages kept before they were read), with the lines
-// it adds and removes and when it was authored in its author's own time zone
-// (`authorZone`, minutes east of UTC), where GitHub's GraphQL API tells them
-// (null where its REST API lists it).
-export interface HistoryCommit { sha: string; parents: string[]; subject: string; authorName: string | null; authorLogin: string | null; authorId?: number | null
-  coauthors?: Coauthor[]; committedAt: number | null; additions?: number | null; deletions?: number | null; authoredAt?: number | null; authorZone?: number | null }
+// A commit, its author by name, address (`authorEmail`) and their account's
+// login and numeric id (`authorId`), and who it names beside them
+// (commit-coauthors.ts coauthorFacts), each absent from pages kept before it
+// was read, with the lines it adds and removes and when it was authored in
+// its author's own time zone (`authorZone`, minutes east of UTC), where
+// GitHub's GraphQL API tells them (null where its REST API lists it); and the
+// marks an agent left in its message, where any (messageMarks), by the rules
+// they were read by (`marked`, AGENT_MARKS_READ; absent from pages kept
+// before). What of them is an agent's is told as they are answered
+// (coauthorsOf, historyMarks), never kept.
+export interface HistoryCommit extends CommitFacts { sha: string; parents: string[]; subject: string; committedAt: number | null; additions?: number | null
+  deletions?: number | null; authoredAt?: number | null; authorZone?: number | null; marks?: AgentSignals; marked?: number }
 export interface HistoryRef { name: string; sha: string }
 
 const textOf = (value: unknown, max: number) => typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : null
@@ -49,6 +56,32 @@ const timeOf = (value: unknown) => {
   return Number.isSafeInteger(at) ? at : null
 }
 
+// The address Claude's own commits are authored with.
+export const CLAUDE_EMAIL = 'noreply@anthropic.com'
+
+const marking = (marks: AgentSignals) => marks.claude || marks.codex || marks.agents.length > 0 || marks.sessions.length > 0 || marks.tasks.length > 0
+
+// The marks an agent left in a commit's message (agent-tasks.ts
+// agentSignals: sessions' and tasks' links, agents' lines and fingerprints),
+// as its history keeps them; null for one none marked.
+export function messageMarks(message: unknown): AgentSignals | null {
+  const marks = agentSignals([message], APP_AGENTS)
+  return marking(marks) ? marks : null
+}
+
+// The marks an agent left on a commit, as the Agents tab tells them: its
+// message's (`marks`, messageMarks), its author an app agent's account, by
+// the agents the app knows now, or Claude's address; null for one none marked.
+export function commitMarks(marks: AgentSignals | null | undefined, { email, account }: Maker): AgentSignals | null {
+  const authored = account.login !== null && account.id !== null ? githubAgent(account.login, account.id) : null
+  const all = { sessions: marks?.sessions ?? [], tasks: marks?.tasks ?? [], claude: (marks?.claude ?? false) || email === CLAUDE_EMAIL, codex: marks?.codex ?? false,
+    agents: APP_AGENTS.flatMap(({ id }) => marks?.agents.includes(id) || authored === id ? [id] : []) }
+  return marking(all) ? all : null
+}
+// A commit's marks as its history keeps it (commitMarks).
+export const historyMarks = (commit: HistoryCommit) => commitMarks(commit.marks,
+  { name: commit.authorName, email: commit.authorEmail, account: { login: commit.authorLogin, id: commit.authorId ?? null } })
+
 const lineCount = (value: unknown) => Number.isSafeInteger(value) && (value as number) >= 0 ? value as number : null
 // The minutes east of UTC an ISO 8601 time is given in: `Z` none.
 const zoneOf = (value: unknown) => {
@@ -58,24 +91,29 @@ const zoneOf = (value: unknown) => {
 
 // A commit as the Commits tab reads it, its subject the message's first
 // line, as `--oneline` shows, its author by name and account, and its
-// co-authors (coauthorsOf, `listed` as GitHub's GraphQL API lists them); null
-// for one GitHub names no commit id for. With `stats`, the GraphQL API's, its
-// lines and its author's time.
+// co-authors (coauthorsOf, `listed` as GitHub's GraphQL API lists them), and
+// the marks an agent left on it, as the Agents tab reads them from the pages
+// kept (commitMarks); null for one GitHub names no commit id for. With
+// `stats`, the GraphQL API's, its lines and its author's time.
 function historyCommit(sha: unknown, parents: unknown[], message: unknown, author: Maker, committedAt: unknown,
   stats: { additions?: unknown; deletions?: unknown; authoredAt?: unknown } | null = null, listed: Maker[] | null = null): HistoryCommit | null {
   if (typeof sha !== 'string' || !SHA.test(sha)) return null
   const lines = stats ? { additions: lineCount(stats.additions), deletions: lineCount(stats.deletions), authoredAt: timeOf(stats.authoredAt),
     authorZone: zoneOf(stats.authoredAt) } : { additions: null, deletions: null, authoredAt: null, authorZone: null }
+  const marks = messageMarks(message)
   return {
     sha,
     parents: parents.filter((parent): parent is string => typeof parent === 'string' && SHA.test(parent)).slice(0, MAX_PARENTS),
     subject: typeof message === 'string' ? message.replaceAll('\r\n', '\n').split('\n', 1)[0]!.trim().slice(0, MAX_SUBJECT) : '',
     authorName: textOf(author.name, MAX_NAME),
+    authorEmail: textOf(author.email, MAX_NAME),
     authorLogin: author.account.login,
     authorId: author.account.id,
-    coauthors: coauthorsOf(message, author, listed),
+    ...coauthorFacts(message, listed),
     committedAt: timeOf(committedAt),
     ...lines,
+    ...marks ? { marks } : {},
+    marked: AGENT_MARKS_READ,
   }
 }
 

package/server-managed/repository-pulls.ts

@@ -0,0 +1,156 @@
+// A repository's pull requests, the most recently updated first, as kept
+// once for both of those that read them so (http.ts keptPulls): the Pulse,
+// telling whose its year's commits are by those merged (agent-merges.ts
+// agentMerges), and the Agents tab, its pages of them (repository-agents.ts
+// agentPulls). Those updated since its year's start, a few queries an
+// answer, the rest read by the next, and those updated since read as they
+// are. Each kept as the Agents tab shows it (repository-agents.ts pull: the
+// marks an agent left in its texts, never the texts) and, one merged, what
+// it brought the default branch, as the Pulse tells it: an agent that
+// commits as whoever ran it (Codex's own) leaves its commits no mark, its
+// pull request's branch alone naming it (app-agents.ts
+// AGENT_BRANCH_PREFIXES), or a label one who ran it gave it naming the agent
+// (agent-tasks.ts labelAgents), as the Agents tab tells an agent's work; or
+// its author, an account agents work as (github-agents.ts AGENT_OPERATED),
+// or any GitHub App's bot.
+import { type AgentPull, labelAgents } from '../common/managed/agent-tasks.ts'
+import { GITHUB_AGENTS, agentOperated } from '../common/managed/github-agents.ts'
+import { AGENT_BRANCH_PREFIXES } from './app-agents.ts'
+import { AGENT_PULL_FIELDS, type PullNode, pull } from './repository-agents.ts'
+import { githubGraphql } from './repository-history.ts'
+
+// What the pull requests kept are read by, its version: bumped as what a
+// page reads, or how one is told, changes, its pull requests read again
+// (http.ts keptPulls keys them by AGENTS_READ_VERSION and the Pulse's
+// PULSE_YEAR_VERSION too, as either changes how it tells an agent's).
+export const PULLS_READ_VERSION = 1
+// The pull requests read an answer, a page a query, as many queries as
+// PULLS_QUERIES, the rest left for the next to ask; of each merged, as many
+// of its latest commits as MERGED_COMMITS.
+const PULLS_PAGE = 100
+const PULLS_QUERIES = 5
+const MERGED_COMMITS = 100
+const LABEL_AGENTS = Object.keys(GITHUB_AGENTS)
+const SHA = /^[a-f\d]{40}$/u
+
+const count = (value: unknown) => Number.isSafeInteger(value) && (value as number) >= 0 ? value as number : 0
+const timeOf = (value: unknown) => {
+  const at = typeof value === 'string' ? Date.parse(value) : Number.NaN
+  return Number.isSafeInteger(at) ? at : null
+}
+
+// A pull request as read: its row on the Agents tab, and one merged, what
+// it brought the default branch (`merged`).
+export type KeptPull = AgentPull & { merged?: Merged }
+// What a merged pull request brought: its merge commit (`sha`), when it was
+// merged (`at`) and whether it was an agent's (agentPull); an agent's merged
+// with a merge commit, which a year counts none of, its own commits too
+// (`own`, its latest MERGED_COMMITS); and of one of more commits whose merge
+// commit has one parent, its commits' subjects, the oldest first, for those
+// it was rebased as to be told by (agent-merges.ts agentCommits), those of
+// its empty commits left out, as a rebase leaves them, and how many more it
+// had than those read (`more`).
+export interface Merged { sha: string; at: number; agent: boolean; own?: string[]; subjects?: string[]; more?: number }
+// The pull requests updated since a year's start (`since`) as read so far
+// (readPulls), the most recently updated first; when the newest read was
+// last updated, those updated since read again (`through`, null till all
+// are read once), and where those read reach back no further than was
+// needed, when the oldest of them was updated (`reach`); whether every one
+// the repository has is read (`all`); and a read not finished: where it goes
+// on (`after`), when the newest it began with was updated (`from`), the
+// oldest it reads to (`stop`), how many it has read (`read`) and when the
+// oldest of them was updated (`to`).
+export interface PullList { pulls: KeptPull[]; since: number; through: number | null; reach?: number; all?: true
+  next: { after: string; from: number; stop: number; read: number; to?: number } | null }
+
+// Since when every pull request updated is read: all of them since the
+// year's start, -∞; none yet, ∞.
+export const pullsReadTo = (list: Pick<PullList, 'next' | 'reach'>) => list.next ? list.next.to ?? Number.POSITIVE_INFINITY : list.reach ?? Number.NEGATIVE_INFINITY
+
+const PULLS_QUERY = `query($owner: String!, $name: String!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(first: ${PULLS_PAGE}, after: $after, orderBy: { field: UPDATED_AT, direction: DESC }) {
+      pageInfo { hasNextPage endCursor }
+      nodes { ${AGENT_PULL_FIELDS} mergedAt mergeCommit { oid parents { totalCount } }
+        commits(last: ${MERGED_COMMITS}) { totalCount nodes { commit { oid messageHeadline changedFilesIfAvailable } } } }
+    }
+  }
+}`
+type MergedNode = PullNode & { mergedAt?: unknown; mergeCommit?: { oid?: unknown; message?: unknown; parents?: { totalCount?: unknown } | null } | null
+  author?: PullNode['author'] & { __typename?: unknown }
+  commits?: { totalCount?: unknown; nodes?: ({ commit?: { oid?: unknown; messageHeadline?: unknown; changedFilesIfAvailable?: unknown } | null } | null)[] } | null }
+type PullsPage = { repository?: { pullRequests?: { pageInfo?: { hasNextPage?: unknown; endCursor?: unknown }; nodes?: (MergedNode | null)[] } | null } | null }
+
+const agentBranch = (name: unknown) => typeof name === 'string' && AGENT_BRANCH_PREFIXES.some(prefix => name.startsWith(prefix))
+// Whether a pull request is an agent's: by its branch, a label naming one,
+// or its author, an account agents work as or a bot (GitHub's GraphQL API
+// naming a bot by its app's login alone, its type telling it).
+const agentPull = ({ headRefName, labels, author }: MergedNode) => agentBranch(headRefName)
+  || labelAgents((labels?.nodes ?? []).map(label => label?.name), LABEL_AGENTS).length > 0 || author?.__typename === 'Bot'
+  || agentOperated(typeof author?.login === 'string' ? author.login : null, Number.isSafeInteger(author?.databaseId) ? author!.databaseId as number : null)
+
+// What a pull request merged brought (Merged); null for one not merged.
+function mergedOf(node: MergedNode): Merged | null {
+  const [at, sha] = [timeOf(node.mergedAt), node.mergeCommit?.oid]
+  if (at === null || typeof sha !== 'string' || !SHA.test(sha)) return null
+  const commits = (node.commits?.nodes ?? []).map(item => item?.commit)
+  const merging = count(node.mergeCommit?.parents?.totalCount) > 1
+  const copied = commits.filter(commit => commit?.changedFilesIfAvailable !== 0)
+  // Of one of more commits than its latest read, how many more it had.
+  const more = Math.max(0, count(node.commits?.totalCount) - commits.length)
+  const subjects = !merging && (copied.length > 1 || more > 0) && copied.length > 0 && copied.every(commit => typeof commit?.messageHeadline === 'string')
+    ? copied.map(commit => commit!.messageHeadline as string) : null
+  const agent = agentPull(node)
+  const own = agent && merging ? commits.flatMap(commit => typeof commit?.oid === 'string' && SHA.test(commit.oid) ? [commit.oid] : []) : []
+  return { sha, at, agent, ...own.length > 0 ? { own } : {}, ...subjects ? { subjects, ...more > 0 ? { more } : {} } : {} }
+}
+
+// The most recently updated first, the higher number first of those
+// updated together.
+const newestFirst = (a: AgentPull, b: AgentPull) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0) || b.number - a.number
+
+// The pull requests updated since `since`, read the most recently updated
+// first (a pull request is updated when merged, or after), on from what was
+// `kept`: till one updated before the year, or before the newest read before
+// was, as many queries an answer as PULLS_QUERIES, a read not finished going
+// on from where it was left by the next, or once those updated since `need`
+// are all read; where those read reached no further back than they needed,
+// and `need` is further, read again from the newest on, as far back as it
+// needs. Each kept as last read, one updated before the year forgotten.
+export async function readPulls(fullName: string, token: string, since: number, kept: PullList | null,
+  fetchImpl: typeof fetch = globalThis.fetch, need = since): Promise<PullList> {
+  const [owner, name] = fullName.split('/') as [string, string]
+  const pulls = new Map((kept?.pulls ?? []).filter(item => (item.updatedAt ?? 0) >= since).map(item => [item.number, item]))
+  // Every one read, as long as none was forgotten, the year begun since.
+  const whole = kept?.all === true && pulls.size === kept.pulls.length
+  const further = !kept?.next && kept?.reach !== undefined && kept.reach > need
+  const stop = kept?.next?.stop ?? (further ? since : Math.max(since, kept?.through ?? since))
+  const result = (through: number | null, next: PullList['next'], reach: number | undefined, all = whole): PullList => ({
+    pulls: [...pulls.values()].toSorted(newestFirst), since, through, ...reach === undefined ? {} : { reach }, ...all ? { all: true as const } : {}, next })
+  let { after = null, from = null, read = 0, to = null }: { after?: string | null; from?: number | null; read?: number; to?: number | null } = kept?.next ?? {}
+  for (let queries = 0; queries < PULLS_QUERIES; queries++) {
+    const page = (await githubGraphql(PULLS_QUERY, { owner, name, after }, token, fetchImpl) as PullsPage | null)?.repository?.pullRequests
+    const end = page?.pageInfo?.hasNextPage !== true || typeof page.pageInfo.endCursor !== 'string'
+    let crossed = false
+    for (const node of page?.nodes ?? []) {
+      const updated = timeOf(node?.updatedAt)
+      if (!node || updated === null) continue
+      if (updated < stop) { crossed = true; break }
+      from ??= updated
+      to = updated
+      read++
+      const row = pull(node)
+      const merged = mergedOf(node)
+      if (row) pulls.set(row.number, merged ? { ...row, merged } : row)
+    }
+    // Read as far back as it reads to: the year's start, every one since
+    // read; else as far as those read before reached. Read to the last
+    // the repository has, every one of them.
+    if (crossed || end) return result(from ?? stop, null, stop > since ? kept?.reach : undefined, (end && !crossed) || (whole && stop > since))
+    after = page!.pageInfo!.endCursor as string
+    // Read as far back as `need`: finished, so far back, those updated
+    // since read by the next as ever.
+    if (need > since && to !== null && to < need) return result(Math.max(from ?? stop, kept?.through ?? Number.NEGATIVE_INFINITY), null, to)
+  }
+  return result(kept?.through ?? null, { after: after!, from: from ?? stop, stop, read, ...to === null ? {} : { to } }, kept?.reach)
+}