@volter/twin-github 0.1.2 → 2.0.0

package/src/github-conformance.ts

@@ -8,7 +8,8 @@
 // NOT declared fails CI. The companion coverage report says what we emit vs what the
 // vendor declares. Standing gate: wrong types, undeclared omissions, fabricated
 // surface, or enum violations all fail.
-import { specConformance } from '@volter/twin-tooling';
+import { readFile } from 'node:fs/promises';
+import { specConformance } from '@volter/world-tooling';
 import { githubState, toGithubComment, toGithubRest, toGithubReview } from './github-twin.ts';
 
 type JsonSchema = specConformance.JsonSchema;
@@ -29,22 +30,22 @@ const fixturePath = (name: string): string => new URL(`../test-fixtures/${name}`
 
 /** Load the vendored full GitHub pull-request JSON Schema (dereferenced OpenAPI). */
 export async function loadGithubPrSchema(): Promise<JsonSchema> {
-  return JSON.parse(await Bun.file(fixturePath('github-pull-schema.json')).text()) as JsonSchema;
+  return JSON.parse(await readFile(fixturePath('github-pull-schema.json'), 'utf8')) as JsonSchema;
 }
 
 /** Load the vendored GitHub pull-request-review JSON Schema. */
 export async function loadGithubReviewSchema(): Promise<JsonSchema> {
-  return JSON.parse(await Bun.file(fixturePath('github-review-schema.json')).text()) as JsonSchema;
+  return JSON.parse(await readFile(fixturePath('github-review-schema.json'), 'utf8')) as JsonSchema;
 }
 
 /** Load the vendored GitHub issue-comment JSON Schema. */
 export async function loadGithubCommentSchema(): Promise<JsonSchema> {
-  return JSON.parse(await Bun.file(fixturePath('github-comment-schema.json')).text()) as JsonSchema;
+  return JSON.parse(await readFile(fixturePath('github-comment-schema.json'), 'utf8')) as JsonSchema;
 }
 
 /** Load the declared evidence-twin scope (fields deliberately not modeled, + reasons). */
 export async function loadGithubKnownDeviations(): Promise<KnownDeviation[]> {
-  const doc = JSON.parse(await Bun.file(fixturePath('github-known-deviations.json')).text()) as { deviations: KnownDeviation[] };
+  const doc = JSON.parse(await readFile(fixturePath('github-known-deviations.json'), 'utf8')) as { deviations: KnownDeviation[] };
   return doc.deviations;
 }
 
@@ -58,14 +59,18 @@ export function checkGithubConformance(schema: JsonSchema, opts: { root?: string
   const violations: GithubViolation[] = [];
   let fieldsChecked = 0;
   let knownIgnored = 0;
-  for (const pr of state.prs) {
+  // "Every PR the twin SERVES" — which is the rows marked as pull-request evidence, not the
+  // counter shells `ensure()` materializes for issue numbers. Checking a shell measures an
+  // object no door answers with, and its emptiness would read as the twin's conformance.
+  const served = state.prs.filter((p) => p.is_pull_request);
+  for (const pr of served) {
     const rest = toGithubRest(pr);
     const rep = specConformance.checkSpecConformance(rest, schema, { exemptKey: isTwinExtra, known: opts.known ?? [] });
     fieldsChecked += rep.fieldsChecked;
     knownIgnored += rep.knownIgnored;
     for (const v of rep.violations) violations.push({ ...v, prId: pr.id });
   }
-  return { ok: violations.length === 0, prsChecked: state.prs.length, fieldsChecked, violations, knownIgnored };
+  return { ok: violations.length === 0, prsChecked: served.length, fieldsChecked, violations, knownIgnored };
 }
 
 export type GithubCoverageReport = specConformance.SpecCoverageReport;

package/src/github-connector.ts

@@ -18,16 +18,11 @@
 // text it didn't receive; the one excluded thing is the Non-goal — actual repository
 // file CONTENTS (git blob bytes) — which the pull does not fetch. Content-bearing twin
 // state thus comes from BOTH the observed fold and LOCAL writes, which push reconciles.
-//
-// THE CONVERSATION IS A SET OF SUBJECTS (not a fold on the PR): every review and every issue
-// comment pulls as its OWN SyncResource, because the shadow diff emits one delta per SUBJECT.
-// Folded onto the PR as `reviewCount`/`latestReview`, two reviews between two polls collapsed
-// into one delta (the second overwrote the first), and nothing said WHO reviewed. A review
-// carries its inline (diff-anchored) comments, since GitHub wraps every inline comment in a
-// review — `pull_request_review_id` on each `/pulls/{n}/comments` row is the join.
-import { appendEvent, assertBudgetGuardIntact, buildShadowState, confirmAction, pendingActions, syncPull } from '@volter/twin';
-import type { RemoteExecute, SyncResource, WorldServiceEvent } from '@volter/twin';
-import { GithubBudget, githubCallWeight, type GithubBudgetOptions } from './github-budget.ts';
+import { assertBudgetGuardIntact } from '@volter/world-core';
+import { observeResource, toEntry } from '@volter/world-core';
+import type { PerformContext, PushOutcome, RemoteExecute, SyncResource, TwinAction, WorldServiceEvent } from '@volter/world-core';
+import { twinResources, ownFields } from '@volter/world-core';
+import { GithubBudget, GithubBudgetError, githubCallWeight, type GithubBudgetOptions } from './github-budget.ts';
 import { githubState } from './github-twin.ts';
 
 const SERVICE = 'github';
@@ -149,7 +144,14 @@ export function liveGithubExecute(
       // first either way, so the refusal survives the throw. GitHub answers a tripped SECONDARY
       // limit with 403 + `Retry-After` rather than 429, which is why the header is read on every
       // response and not only on a 429.
-      budget.recordCall(weight, resHeaders, { status: res.status, reservation });
+      // recordCall may THROW after arming the cooldown (a back-off beyond the cap). On a refused
+      // call that louder refusal wins; an answer GitHub ACCEPTED is kept, so a write that landed is
+      // never recorded as failed and performed again on retry.
+      try {
+        budget.recordCall(weight, resHeaders, { status: res.status, reservation });
+      } catch (error) {
+        if (!(error instanceof GithubBudgetError) || !res.ok) throw error;
+      }
       return { status: res.status, data };
     },
   };
@@ -226,7 +228,8 @@ type ObservedPr = {
   headSha?: string;
   changedFiles?: number;
   commitsCount?: number;
-  authorLogin?: string;
+  authorLogin?: string | null;
+  authorType?: string;
   /** The PR's own `updated_at` — the provider instant that dates its delta AND the stamp
    *  the next pull compares against to decide whether its conversation is worth buying. */
   updatedAt?: string;
@@ -279,6 +282,8 @@ type ObservedIssue = {
   title?: string;
   body?: string;
   state?: string;
+  created_at?: string;
+  updated_at?: string;
 };
 
 /**
@@ -476,7 +481,9 @@ export async function pullGithubPrs(
       });
       pr.commentCount = commentNodes.length;
     }
-    if (n.user?.login !== undefined && n.user?.login !== null) pr.authorLogin = String(n.user.login);
+    if (n.user === null) pr.authorLogin = null;
+    else if (n.user?.login !== undefined && n.user?.login !== null) pr.authorLogin = String(n.user.login);
+    if (n.user?.type !== undefined && n.user?.type !== null) pr.authorType = String(n.user.type);
     // CONTENT: title/body/state are real text the REST PR object returns — fold them.
     if (n.title !== undefined && n.title !== null) pr.title = String(n.title);
     if (n.body !== undefined && n.body !== null) pr.body = String(n.body);
@@ -526,6 +533,9 @@ export async function pullGithubIssues(
     if (n.title !== undefined && n.title !== null) iss.title = String(n.title);
     if (n.body !== undefined && n.body !== null) iss.body = String(n.body);
     if (n.state !== undefined && n.state !== null) iss.state = String(n.state);
+    // the timestamps the write handler stores: shape parity between a written and an observed issue
+    if (typeof n.created_at === 'string') iss.created_at = n.created_at;
+    if (typeof n.updated_at === 'string') iss.updated_at = n.updated_at;
     out.push(iss);
   }
   return out;
@@ -559,7 +569,8 @@ export function observedPrsToResources(prs: ObservedPr[]): SyncResource[] {
     // WHO opened it, and when GitHub last saw it change — the stamp the next pull's budget
     // compares against, kept on the subject rather than in a cache beside it.
     if (p.authorLogin !== undefined) fields.authorLogin = p.authorLogin;
-    if (p.updatedAt !== undefined) fields.updatedAt = p.updatedAt;
+    if (p.authorType !== undefined) fields.user_type = p.authorType;
+    if (p.updatedAt !== undefined) { fields.updatedAt = p.updatedAt; fields.observedUpdatedAt = p.updatedAt; }
     // The reviewers' WORDS ride the observation: how many reviews, and the newest one's
     // verdict and body, so a delta on the feed says what a reviewer said (a consumer decides
     // from the words, never from a bare count moving). The reviews themselves are subjects
@@ -649,11 +660,11 @@ export function observedPrsToResources(prs: ObservedPr[]): SyncResource[] {
  * conversation gets bought.
  */
 export function lastObservedPrUpdates(root?: string): Record<string, string> {
-  const shadow = buildShadowState(SERVICE, () => null, root);
   const out: Record<string, string> = {};
-  for (const subject of Object.values(shadow.subjects)) {
+  for (const resource of twinResources(SERVICE, root)) {
+    const subject = { subject: resource, fields: ownFields(resource) };
     if (subject.subject.type !== 'pull_request') continue;
-    const updatedAt = subject.fields.updatedAt;
+    const updatedAt = subject.fields.observedUpdatedAt ?? subject.fields.updatedAt;
     if (typeof updatedAt === 'string' && updatedAt !== '') out[subject.subject.id] = updatedAt;
   }
   return out;
@@ -666,6 +677,8 @@ export function observedIssuesToResources(issues: ObservedIssue[]): SyncResource
     if (i.title !== undefined) fields.title = i.title;
     if (i.body !== undefined) fields.body = i.body;
     if (i.state !== undefined) fields.state = i.state;
+    if (i.created_at !== undefined) fields.created_at = i.created_at;
+    if (i.updated_at !== undefined) fields.updated_at = i.updated_at;
     return { type: 'issue', id: i.id, fields };
   });
 }
@@ -698,14 +711,13 @@ type AppendOutcome = { appended: boolean; conflictId?: string };
 // resources in the same pull, so it must NOT abort the whole repo's fold: skip the row,
 // surface its stable id, keep folding. Every OTHER error stays fatal (re-thrown).
 function appendTolerant(event: WorldServiceEvent, root?: string): AppendOutcome {
-  try {
-    return { appended: appendEvent(event, root).appended };
-  } catch (error) {
-    if (error instanceof Error && error.message.includes('Conflicting duplicate')) {
-      return { appended: false, conflictId: (event as unknown as { id: string }).id };
-    }
-    throw error;
-  }
+  // PROTOCOL 2: the pack OBSERVES a resource; the kernel diffs it against the tree and folds what
+  // changed onto the root's log (observe.ts). The v1 row shape is read for its subject and fields.
+  const entry = toEntry(event as unknown as Record<string, unknown>);
+  // Observations are field patches. Copying the pre-refresh tree here would reintroduce
+  // stale fields after earlier observations in the same collected batch update them.
+  const report = observeResource(event.service, { type: entry.subject.type, id: entry.subject.id, fields: entry.fields ?? {} }, { ...(root !== undefined ? { root } : {}), at: entry.occurredAt });
+  return { appended: report.appended > 0 || report.observed > 0 && report.unchanged === 0 && report.appended === 0 };
 }
 
 // A content-hashed, deterministic id for a folded evidence snapshot — never random,
@@ -736,6 +748,8 @@ function foldObservedPr(pr: ObservedPr, occurredAt: string, root?: string): Appe
     },
   };
   if (pr.title !== undefined) data.title = pr.title;
+  if (pr.authorLogin !== undefined) data.user_login = pr.authorLogin;
+  if (pr.authorType !== undefined) data.user_type = pr.authorType;
   if (pr.body !== undefined) data.body = pr.body;
   if (pr.state !== undefined) data.state = pr.state;
   if (pr.draft !== undefined) data.draft = pr.draft;
@@ -745,7 +759,7 @@ function foldObservedPr(pr: ObservedPr, occurredAt: string, root?: string): Appe
   if (pr.commitsCount !== undefined) data.commitsCount = pr.commitsCount;
   // draft/merged/mergeCommit are in the hash so a draft→ready or open→merged transition
   // re-folds (a new event) rather than being deduped away as an unchanged observation.
-  const hash = evidenceHash([pr.number, pr.repository, pr.title, pr.body, pr.state, pr.draft, pr.merged, pr.mergeCommit, pr.baseRef, pr.headSha, pr.changedFiles, pr.commitsCount]);
+  const hash = evidenceHash([pr.number, pr.repository, pr.title, pr.body, pr.state, pr.draft, pr.merged, pr.mergeCommit, pr.baseRef, pr.headSha, pr.changedFiles, pr.commitsCount, pr.authorLogin, pr.authorType]);
   const id = `github:pull_request:${pr.id}:${hash}`;
   const event = {
     id,
@@ -832,7 +846,7 @@ function foldObservedExistence(pr: ObservedPr, occurredAt: string, root?: string
       });
     }
   });
-  (pr.comments ?? []).forEach((c, i) => emit('issue_comment', `c${i}`, {
+  (pr.comments ?? []).forEach((c, i) => emit('issue_comment', c.id === undefined ? `c${i}` : `ic:${c.id}`, {
     ...(c.body !== undefined ? { body: c.body } : {}),
     ...(c.createdAt !== undefined ? { created_at: c.createdAt } : {}),
   }));
@@ -897,12 +911,13 @@ export async function syncGithubFromReal(
   const prs = await pullGithubPrs(execute, { ...pullOpts, lastUpdatedAt: lastObservedPrUpdates(opts.root) });
   const issues = await pullGithubIssues(execute, pullOpts);
   // Generic shadow-diff fold (content-bearing resources: title/body/state + refs).
-  const pull = syncPull({
-    service: SERVICE,
-    resources: [...observedPrsToResources(prs), ...observedIssuesToResources(issues), ...(await observeRepositoryAndBranches(execute, opts.owner, opts.repo))],
-    occurredAt: opts.occurredAt,
-    ...(opts.root !== undefined ? { root: opts.root } : {}),
-  });
+  // PROTOCOL 2: the pack OBSERVES each resource; the kernel diffs it against the tree and folds what
+  // changed onto the root's log (observe.ts) — inside a refresh, collected and folded as a batch.
+  const pull = { observed: 0, deltasAppended: 0, unchanged: 0 };
+  for (const r of [...observedPrsToResources(prs), ...observedIssuesToResources(issues), ...(await observeRepositoryAndBranches(execute, opts.owner, opts.repo))]) {
+    const report = observeResource(SERVICE, { type: r.type, id: r.id, fields: r.fields }, { ...(opts.root !== undefined ? { root: opts.root } : {}), at: r.occurredAt ?? opts.occurredAt });
+    pull.observed += 1; pull.deltasAppended += report.appended; pull.unchanged += report.unchanged;
+  }
   // GitHub fold (carries counts + review/comment content the delta drops, plus issues).
   // A per-row `Conflicting duplicate` is tolerated (skipped + recorded), never fatal, so a
   // single diverged row can't stop later resources in the same pull from folding.
@@ -999,8 +1014,12 @@ export async function pushGithubAction(
     // endpoint applyGithubWrite routes a PR edit through; GitHub accepts these on the issue
     // PATCH. The PR PATCH itself ignores labels/assignees/milestone, so route those on the
     // matching issue PATCH (PRs ARE issues for that endpoint) to faithfully persist them.
-    const res = await execute.request('PATCH /repos/{owner}/{repo}/pulls/{pull_number}', params);
-    ensureOk(res, 'pulls.update');
+    let externalId = String(number);
+    if (Object.keys(params).length > 3 || f.draft === undefined) {
+      const res = await execute.request('PATCH /repos/{owner}/{repo}/pulls/{pull_number}', params);
+      ensureOk(res, 'pulls.update');
+      externalId = String(res.data?.number ?? number);
+    }
     if (f.labels !== undefined || f.assignees !== undefined || f.milestone !== undefined) {
       const issueParams: Record<string, unknown> = { owner, repo, issue_number: number };
       if (f.labels !== undefined) issueParams.labels = f.labels;
@@ -1009,7 +1028,24 @@ export async function pushGithubAction(
       const issueRes = await execute.request('PATCH /repos/{owner}/{repo}/issues/{issue_number}', issueParams);
       ensureOk(issueRes, 'pulls.update.issue_fields');
     }
-    return { externalId: String(res.data?.number ?? number) };
+    if (f.draft !== undefined) {
+      if (typeof f.draft !== 'boolean') throw new Error('github push failed (pulls.draft): expected boolean');
+      // Resolve the vendor's node, never send the local twin's synthetic GraphQL ID.
+      const current = await execute.request('GET /repos/{owner}/{repo}/pulls/{pull_number}', { owner, repo, pull_number: number });
+      ensureOk(current, 'pulls.draft.read');
+      if (typeof current.data?.node_id !== 'string' || typeof current.data?.draft !== 'boolean') throw new Error('github push failed (pulls.draft): vendor PR identity/state missing');
+      if (current.data.draft !== f.draft) {
+        const mutation = f.draft ? 'convertPullRequestToDraft' : 'markPullRequestReadyForReview';
+        const res = await execute.request('POST /graphql', {
+          query: `mutation($id:ID!){${mutation}(input:{pullRequestId:$id}){pullRequest{id isDraft}}}`,
+          variables: { id: current.data.node_id },
+        });
+        ensureOk(res, 'pulls.draft');
+        const changed = res.data?.data?.[mutation]?.pullRequest;
+        if (res.data?.errors?.length || changed?.id !== current.data.node_id || changed?.isDraft !== f.draft) throw new Error('github push failed (pulls.draft): GraphQL transition was not confirmed');
+      }
+    }
+    return { externalId };
   }
   if (op === 'pull_request.merge') {
     const number = Number(f.number ?? action.subject.id.split('#').pop());
@@ -1220,57 +1256,6 @@ function knownReviewCommentExternalIds(root?: string): Record<string, string> {
   return out;
 }
 
-/**
- * PUSH (all): push every pending LOCAL GitHub action to real GitHub via the injected
- * executor and CONFIRM each on success — `confirmAction` records the confirmed fields
- * as an observed event and maps the action → that event, SUPPRESSING the local
- * projection (the fact now lives in the observed log; counted exactly once). Closes
- * the action → push → observed loop (R18). Idempotency: a confirmed action is no
- * longer pending, so a re-push calls the executor for it again ZERO times.
- *
- * PER-ACTION TOLERANCE, the same doctrine the pull's per-row conflict skip follows: one
- * action the connector cannot enact (a reply whose root has no id on the real repo) or that
- * the vendor rejected must NOT abort the other pending writes in the sweep — it is skipped
- * with its reason, left PENDING so a later sweep retries it, and REPORTED in `skipped` so a
- * poller can log it loudly instead of it being swallowed. Nothing is confirmed on a failure,
- * so a skipped action is never mistaken for a written one.
- */
-export async function pushPendingGithubActions(
-  execute: GithubExecute,
-  opts: { root?: string; occurredAt: string },
-): Promise<{ pushed: number; confirmed: string[]; externalIds: Record<string, string>; skipped: Array<{ actionId: string; operation: string; reason: string }> }> {
-  const confirmed: string[] = [];
-  const externalIds: Record<string, string> = {};
-  const skipped: Array<{ actionId: string; operation: string; reason: string }> = [];
-  // Seeded from what the world already knows, then GROWN as the sweep confirms writes — a
-  // root comment created and replied to between two pushes resolves within one sweep.
-  const commentExternalIds = knownReviewCommentExternalIds(opts.root);
-  for (const action of pendingActions(SERVICE, opts.root)) {
-    let externalId: string;
-    try {
-      ({ externalId } = await pushGithubAction(execute, action, { externalIds: commentExternalIds }));
-    } catch (error) {
-      skipped.push({ actionId: action.id, operation: action.operation ?? '', reason: error instanceof Error ? error.message : String(error) });
-      continue;
-    }
-    confirmAction({
-      service: SERVICE,
-      actionId: action.id,
-      subject: action.subject,
-      fields: action.fields ?? {},
-      occurredAt: opts.occurredAt,
-      ...(opts.root !== undefined ? { root: opts.root } : {}),
-    });
-    confirmed.push(action.id);
-    externalIds[action.id] = externalId;
-    // A review comment the vendor just accepted is now addressable, so a reply LATER in this
-    // same sweep can name it. Keyed by the twin's own comment id, which is what the reply's
-    // `in_reply_to` carries.
-    const local = /^comment:(\d+)$/.exec(action.subject.id);
-    if (local !== null && action.operation === 'pull_request_review_comment.create' && externalId !== '') commentExternalIds[local[1]!] = externalId;
-  }
-  return { pushed: confirmed.length, confirmed, externalIds, skipped };
-}
 
 /**
  * THE R14 PUSH ADAPTER for github (jira's `pushJiraToRemote` is the reference; this
@@ -1281,10 +1266,8 @@ export async function pushPendingGithubActions(
  * loudly. The route grammar is the one `pushGithubAction` speaks (`METHOD /path/{param}`,
  * templated params in the path, the rest as the JSON body).
  */
-export async function pushGithubToRemote(
-  execute: RemoteExecute,
-  opts: { root?: string; origin?: string } = {},
-): Promise<{ pushed: number; confirmed: string[]; skipped: Array<{ actionId: string; operation: string; reason: string }> }> {
+/** This pack's vendor executor over the kernel's ONE RemoteExecute (push plane). */
+export function githubPushExecutor(execute: RemoteExecute): GithubExecute {
   const executor: GithubExecute = {
     async request(route, params = {}) {
       const sp = route.indexOf(' ');
@@ -1316,12 +1299,40 @@ export async function pushGithubToRemote(
       return { status: res.status, data: res.body === '' ? undefined : JSON.parse(res.body) };
     },
   };
-  const pushed = await pushPendingGithubActions(executor, { ...(opts.root === undefined ? {} : { root: opts.root }), occurredAt: new Date().toISOString() });
-  // The refusals ride out with the successes: a link that pushed nothing because every action
-  // was refused must not read as a clean sweep.
-  return { pushed: pushed.pushed, confirmed: pushed.confirmed, skipped: pushed.skipped };
+  return executor;
+}
+
+/** THE ANCHORED PUSH SEAM (contract "The push arm is the kernel's transaction; a pack performs one
+ *  action"): perform ONE pending action against GitHub over the kernel executor; the vendor's id comes back. */
+/** The vendor's id in the pack's own subject grammar: a number replaces the trailing number of the
+ *  local id (`acme/web#issue:1` → `acme/web#issue:57`, `acme/web#3` → `acme/web#9`, `comment:2` →
+ *  `comment:184`); anything else (a sha, a ref, a path, an owner/name) leaves the address as it is
+ *  and rides on the receipt as `vendorId`. The kernel rebinds the subject to what comes back
+ *  (contract "A pushed write adopts the vendor's id"). */
+export function adoptGithubId(localId: string, vendorId: string | undefined): string {
+  if (!vendorId) return localId;
+  if (/^\d+$/.test(vendorId) && /\d+$/.test(localId)) return localId.replace(/\d+$/, vendorId);
+  if (vendorId === localId || vendorId.includes('#') || vendorId.startsWith('comment:') || vendorId.startsWith('review:')) return vendorId;
+  return localId;
 }
 
+export async function performGithubAction(execute: RemoteExecute, action: TwinAction, ctx: PerformContext): Promise<PushOutcome> {
+  const externalIds = knownReviewCommentExternalIds(ctx.root);
+  const replyTo = action.fields?.in_reply_to;
+  if (replyTo !== undefined) {
+    const local = `comment:${replyTo}`;
+    const adopted = ctx.resolve('pull_request_review_comment', local);
+    if (adopted !== local && /^comment:\d+$/.test(adopted)) externalIds[String(replyTo)] = adopted.slice('comment:'.length);
+  }
+  const out = await pushGithubAction(githubPushExecutor(execute), action, { externalIds });
+  const adopted = adoptGithubId(action.subject.id, out.externalId);
+  // what the vendor minted rides on the receipt as fields: the number under which the row now lives
+  const numeric = out.externalId !== undefined && /^\d+$/.test(out.externalId) && adopted !== action.subject.id;
+  const data = { ...(numeric ? { number: Number(out.externalId) } : {}), ...(out.externalId && out.externalId !== adopted ? { vendorId: out.externalId } : {}) };
+  return { externalId: adopted, ...(Object.keys(data).length ? { data } : {}) };
+}
+
+
 /**
  * THE REPOSITORY AND ITS BRANCHES are observed with the PRs and issues: a working copy's
  * confirmed writes (a branch it cut, the repo it declared) survive only as what reality
@@ -1369,7 +1380,8 @@ export async function syncGithubFromRemote(
   execute: RemoteExecute,
   opts: { root?: string; origin?: string; state?: 'open' | 'closed' | 'all'; perPage?: number } = {},
 ): Promise<{ observed: number; deltasAppended: number; eventsAppended: number; issues: number; conflictsSkipped: number; conflictingIds: string[] }> {
-  const match = /^\/repos\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(opts.origin === undefined ? '' : new URL(opts.origin).pathname);
+  // the repository is the end of the path: a served world's twin lives under /<org>/<world>/github
+  const match = /\/repos\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(opts.origin === undefined ? '' : new URL(opts.origin).pathname);
   if (match === null) {
     throw new Error('github remote pull: the link origin must name the repo — https://api.github.com/repos/{owner}/{repo}');
   }