@open-everywhere/provider-github 0.0.0-stage → 0.1.0

package/dist/agent/channels/github-engagement.js

@@ -0,0 +1,317 @@
+// THE GITHUB AMBIENT ENGAGEMENT SEAM (chat-surface contract §2.5) — the GitHub wiring over core's
+// pure engagement policy (`packages/core/agent/channels/engagement.ts`). It gives GitHub the middle
+// posture Slack, Discord and Teams already have: an @mention marks the issue or pull-request thread
+// ENGAGED, a later PLAIN comment in that thread wakes the agent, and `stand_down` stores the stop.
+//
+// THE ANCHOR is `githubConversationKey(owner, repo, number)` — `owner/repo#N`, the same string the
+// mapper already publishes as `anchorChannelId` for the stop registry. One issue or pull request IS
+// the GitHub conversation, so that is the grain a person can address a stop to, and it is the grain
+// engagement is kept per. The surface partition stays the REPO (`github/<owner>/<repo>`), so the
+// anchor distinguishes the containers inside it.
+//
+// 🔴 WHICH LEG OWNS AN ENGAGED FOLLOW-UP IS THE SAME QUESTION AS WHICH LEG OWNS A MENTION, AND IT
+// GETS THE SAME ANSWER. GitHub runs two legs over one webhook: the NATIVE mention session
+// (`githubOnComment`) and the ambient supervisor (`ambientDelivery`). Today a mention goes to
+// exactly one of them — the native leg, unless the repo is single-window and operator-vouched, where
+// the native session is suppressed and the unified window answers instead. This seam follows that
+// split rather than inventing a second one: on a repo where the native leg owns mentions it also
+// owns engaged follow-ups, and the ambient leg drops them; on a single-window vouched repo the
+// ambient leg owns them, because the native handler stands down for EVERY comment there
+// (`shouldSuppressNativeMention` asks `singleWindowMentionPolicy` with `isMention` pinned true).
+// Two legs answering one comment is the failure this ordering exists to prevent.
+//
+// 🔴 "THE WINDOW ALREADY ANSWERS EVERY COMMENT" WAS THE CLAIM THAT BROKE IT (OPE-1740/OPE-1745). It
+// held only while a seat REQUIRED `ambientSupervisor`. Seats are universal since OPE-1695, so a
+// seated, vouched repo on an ADDRESSED-ONLY domain answers addressed comments and nothing else — and
+// an engaged follow-up there reached neither leg: the native handler stood down, and the ambient
+// leg's chattiness gate refused the comment as `domain-refused` before this seam was read. Deploy
+// #201 measured exactly that on `oe-e2e-addressed-github`. The ambient leg now reads the seam FIRST
+// and feeds its verdict to the gate (`githubAmbientLegAdmission`, github.ts): enrolment is an
+// address, and the domain opt-in governs UNINVITED talk only.
+//
+// 🔴 HOW FAR THE NON-MENTION ARM REACHES — PRIVATE REPOS, AND NEVER AN INLINE REVIEW COMMENT.
+// `githubEngagedFollowUpReach` is the one predicate for it, and BOTH legs ask it. A plain follow-up
+// wakes a native turn (a sandbox checkout, a judged spend), so it is refused on a public or
+// unknown-privacy repo, and refused inside a review thread because the anchor is the pull request
+// rather than the thread. An @mention is unaffected by either floor.
+//
+// 🔴 IT IS A STRICTER FLOOR THAN THE AMBIENT LEG'S, NOT THE SAME ONE. `classifyGitHubAmbientComment`
+// step 5 admits a VOUCHED public repo (`repoPrivate !== true && !vouched ⇒ drop`); this one is
+// vouch-blind and refuses every public repo. Do not "align" the two by adding the vouch here — that
+// re-opens an uninvited native turn on a public repo, which is the thing this floor exists to close.
+//
+// 🔴 WHAT NO TEST REACHES, STATED RATHER THAN IMPLIED, AND ONE OF THE THREE IS COVERED BY NOTHING.
+// `github.ts`'s `ambientDelivery` is module-private and only runs behind the route's `waitUntil`, so
+// no in-repo test drives the LEG itself. Obligation by obligation:
+//   • THE CHATTINESS GATE reading the enrolment fact IS driven offline, over the real store and a
+//     real declared addressed-only domain, because `githubAmbientLegAdmission` is exported for it
+//     (`scripts/engaged-seam-wiring-test.ts`, the addressed-only block) — reach floors included.
+//     That the leg CALLS it is `J-ENGAGED-github`'s to prove: step (b)'s follow-up reaches a turn on
+//     that journey's repo only through this gate.
+//   • THE STOOD-DOWN SUPPRESSION is covered by NOTHING, and the gate above it is why. On an
+//     ADDRESSED-ONLY repo a stopped row resolves `hold`, never `deliver`, so the gate refuses the
+//     comment first and this branch never runs — `J-ENGAGED-github`'s stand-down step passes on the
+//     domain flag, not on the stop. The branch is reachable only on an ambient-ON repo, and no
+//     journey drives a `stand_down` on one. Deleting it would red nothing.
+//   • THE `!shouldSuppressNativeMention(singleWindow, vouched)` DROP GUARD is covered on its
+//     NON-FIRING side only: `J-ENGAGED-github`'s repo stands the native leg down, so a guard that
+//     wrongly dropped there reds the journey. Its FIRING side — a repo the native leg owns, where
+//     the guard is what stops two legs answering one comment — is covered by nothing.
+// `scripts/github-external-policy-room-test.ts` records the same limit for its own leg.
+// What IS pinned: this module's decision table
+// (`packages/providers/github/scripts/github-engagement-test.ts`), the NATIVE leg's whole loop over
+// the real store — mark, deliver, stop, the way back in, and the redelivery guard
+// (`scripts/engaged-seam-wiring-test.ts`), and the anchor round trip through `stand_down`
+// (`scripts/stand-down-anchor-test.ts` LEG 17). On the AMBIENT leg, the `J-ENGAGED-github` e2e
+// journey covers exactly what the three bullets above say it covers, and no more.
+import { getOperationalStore, getThreadEngagement, markThreadEngaged, resolvePartition, shouldDeliverReply, } from "@open-everywhere/core/agent/adapter-api.js";
+import { buildGitHubAuth, githubConversationKey } from "./github-identity.js";
+/**
+ * The engagement-registry anchor for one GitHub container, or `undefined` when the delivery names
+ * no container number.
+ *
+ * 🔴 IT IS THE ONE PREDICATE THE MAPPER AND THE SEAM SHARE. `bindGitHub` publishes exactly this as
+ * `engagementKey`, so `stand_down`'s mark and this seam's read address the same row. Two spellings
+ * of "which container this is" is how a stop comes to mark a row no gate reads.
+ */
+export function githubEngagementAnchor(owner, repo, num) {
+    return githubConversationKey(owner, repo, num);
+}
+/** The partition one container's engagement row lives in — the REPO grain
+ *  (`github/<owner>/<repo>`), which is what `resolvePartition` gives a bound GitHub session and
+ *  therefore what `stand_down` writes under. It is built from THIS delivery's own facts, through the
+ *  same `buildGitHubAuth` the wake dispatches, so the seam can never key a row the turn would not.
+ *  Null on an unresolvable identity: the caller then keeps today's path, the fail-open posture every
+ *  carriage leg on this surface takes. */
+export function githubSeamPartition(f) {
+    try {
+        const auth = buildGitHubAuth({
+            owner: f.owner,
+            repo: f.repo,
+            isPrivate: f.isPrivate,
+            actorLogin: f.actorLogin,
+        });
+        return resolvePartition({ channel: { kind: "github" }, session: { auth: { current: auth } } });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * May the NON-MENTION arm of the seam reach this delivery at all? Read BEFORE any registry read, by
+ * both legs, so the two never disagree about which comments the native leg owns.
+ *
+ * TWO FLOORS. Each refuses on an unknown rather than admitting, and each is about REACH — whether
+ * this kind of delivery may wake at all — never about whether the container is engaged.
+ *
+ *  • 🔴 THE REPO MUST BE POSITIVELY PRIVATE. An engaged container's plain comment wakes a FULL
+ *    native turn: a sandbox checkout and a judged spend. On a public repo that lets ANY GitHub
+ *    account buy one, by writing in an issue somebody once @mentioned the app in — the same
+ *    drive-by spend and prompt-injection surface `classifyGitHubAmbientComment` step 5 refuses for,
+ *    on the louder of the two legs. 🔴 THIS FLOOR IS STRICTER THAN THAT ONE, deliberately: step 5
+ *    admits a VOUCHED public repo, and this one refuses every public repo. A vouch widens the
+ *    ambient supervisor's judged reply; widening an uninvited NATIVE turn to a public repo is a
+ *    bigger step that needs its own ruling.
+ *  • 🔴 A REVIEW THREAD IS NOT A CONTAINER OF ITS OWN. {@link githubEngagementAnchor} collapses to
+ *    `owner/repo#N`, so every INLINE review comment on a pull request reads the row that one
+ *    @mention anywhere on that pull request engaged — and one review leaves dozens of them.
+ *
+ * AN @MENTION IS UNAFFECTED BY BOTH, on a public repo and inside a review thread alike: it is
+ * answered by the caller's own mention gate, which this seam never narrows.
+ */
+export function githubEngagedFollowUpReach(f) {
+    if (f.isPrivate !== true) {
+        return { reachable: false, reason: "the repo is public or of unknown privacy — an engaged follow-up wakes a native turn, which is private-repo only" };
+    }
+    if (f.conversationKind === "review_thread") {
+        return { reachable: false, reason: "an inline review comment shares its pull request's anchor — a review thread is not a container of its own" };
+    }
+    return { reachable: true, reason: "a private repo, and not an inline review comment" };
+}
+/**
+ * Resolve the seam for one comment — READ-ONLY. The mark is a separate call
+ * ({@link markGitHubEngaged}) so exactly one caller writes the row: two writers is how one comment
+ * comes to engage a container twice, once on each leg.
+ *
+ * ORDERING. A mention is settled before any read: it is always answered by the caller's own path, so
+ * its verdict costs no store round-trip. Only a plain comment pays for a read, and it pays for
+ * exactly one — the ROW, not a boolean, because the row carries both facts the decision needs (is
+ * this engaged, and was the agent asked to stand down here) and two reads could disagree.
+ *
+ * THE DECISION ITSELF IS CORE'S. `shouldDeliverReply` owns the disqualifier order and the reasons;
+ * this function only translates GitHub facts into its input. Nothing here re-states the policy.
+ *
+ * FAIL-CLOSED on a store error: `getThreadEngagement` reads a failure as `null`, so an unreadable
+ * registry holds rather than delivers — the agent does not barge into a conversation it cannot prove
+ * it was invited to.
+ */
+export async function resolveGitHubEngagement(f, deps = {}) {
+    const anchor = githubEngagementAnchor(f.owner, f.repo, f.number);
+    if (!anchor)
+        return { kind: "unanchored", reason: "the delivery names no issue or pull-request number — no row to address" };
+    const partition = githubSeamPartition(f);
+    if (!partition)
+        return { kind: "unanchored", reason: "the delivery has no resolvable partition — no row to address" };
+    if (f.isMention)
+        return { kind: "engage", anchor };
+    const read = deps.getEngagement ?? ((p, key) => getThreadEngagement(p, key));
+    const row = await read(partition, anchor);
+    const decision = shouldDeliverReply({
+        isEngaged: row !== null,
+        stopped: row?.stopped ?? false,
+        authorIsBot: f.authorIsBot,
+        isAppMention: false, // settled above — a mention never reaches this branch
+        inThread: true, // an anchored GitHub container IS the thread engagement is kept per
+    });
+    if (decision.deliver)
+        return { kind: "deliver", anchor, reason: decision.reason };
+    return { kind: "hold", anchor, reason: decision.reason, stopped: row?.stopped === true };
+}
+/**
+ * Mark one container ENGAGED on an @mention, ONCE PER COMMENT.
+ *
+ * `participating: true` is the re-invitation: it promotes the row and CLEARS a previous stand-down,
+ * which is what "an @mention brings the agent back" means on every surface that wires this seam.
+ *
+ * 🔴 THE MARK IS DEDUPED, AND THE STOP IS WHY. Clearing the flag is right for a person's second
+ * @mention and WRONG for GitHub redelivering the first one — a redelivered webhook would quietly
+ * lift a stand-down nobody asked to lift. `commentId` is the comment's own id, so the guard keys on
+ * the thing that must happen once. It is the DURABLE layer only, unlike Teams' front: this route
+ * holds no in-process dedupe object, and a serverless invocation is a fresh process, so an
+ * in-memory layer would catch almost nothing here. FAIL-OPEN on a store error, the same posture
+ * every dedupe in this repository takes — a dedupe prevents a double write, not a security hole.
+ *
+ * Best-effort throughout — `markThreadEngaged` swallows a store failure, because engagement
+ * bookkeeping must never fail a turn. Returns the anchor it marked, or null when it marked nothing.
+ */
+export async function markGitHubEngaged(f, commentId, deps = {}) {
+    const anchor = githubEngagementAnchor(f.owner, f.repo, f.number);
+    if (!anchor)
+        return null;
+    const partition = githubSeamPartition(f);
+    if (!partition)
+        return null;
+    const now = deps.now ?? (() => new Date().toISOString());
+    const atIso = now();
+    if (commentId !== undefined) {
+        const seen = deps.markEventSeen ?? liveMarkEngageSeen;
+        if (!(await seen(partition.org, `github-engage:${anchor}:${String(commentId)}`, atIso)))
+            return null;
+    }
+    const mark = deps.markEngaged ?? ((p, key, at) => markThreadEngaged(p, key, at, { participating: true }));
+    await mark(partition, anchor, atIso);
+    return anchor;
+}
+/** The durable half of the mark dedupe. FAIL-OPEN: an unreachable store answers "not seen", so a
+ *  store outage costs a redundant mark rather than a lost engagement. */
+const ENGAGE_DEDUPE_TTL_MS = 10 * 60_000;
+let warnedEngageDedupe = false;
+async function liveMarkEngageSeen(org, key, atIso) {
+    try {
+        return await getOperationalStore().markEventSeen(org, key, atIso, ENGAGE_DEDUPE_TTL_MS);
+    }
+    catch (err) {
+        if (!warnedEngageDedupe) {
+            warnedEngageDedupe = true;
+            console.warn(`[open-everywhere:github-engagement] engage dedupe unavailable — a redelivered @mention may re-mark: ${String(err)}`);
+        }
+        return true;
+    }
+}
+/**
+ * Is this comment MACHINE-AUTHORED — a GitHub App, a bot account, or this deployment's own reply?
+ *
+ * 🔴 ONE PREDICATE, AND IT MUST FAIL CLOSED ON AN UNRESOLVED SLUG. `githubBotMentioned` needs the
+ * app slug to recognise a mention at all, so before this seam a deployment with no `GITHUB_APP_SLUG`
+ * simply never woke natively. A plain comment now reaches the seam, and without the slug the app
+ * cannot tell its OWN reply from a person's — so "unknown" answers `true` and nothing is delivered,
+ * the same posture `classifyGitHubAmbientComment` takes with its own no-slug drop.
+ */
+export function githubMachineAuthored(authorLogin, authorType, botSlug) {
+    const slug = botSlug?.trim();
+    if (!slug)
+        return true; // cannot identify self ⇒ cannot prove a human wrote this
+    if (authorType === "Bot")
+        return true;
+    return authorLogin !== undefined && authorLogin.toLowerCase() === `${slug}[bot]`.toLowerCase();
+}
+/**
+ * The NATIVE leg's one-line admission (`github.ts`'s mention gate): may this plain, non-mention
+ * comment run a turn?
+ *
+ * It exists because the native channel is where a GitHub turn is minted — the wake is the webhook
+ * itself, so admitting the comment through the mention gate IS the wake. The ambient leg owns the
+ * complementary halves above it (the STOP suppression, and dropping a comment this leg now owns), so
+ * this call only ever answers the delivery question, and it never writes.
+ *
+ * 🔴 THE REACH FLOORS RUN FIRST, above the registry read: a public repo and an inline review comment
+ * are refused whatever the row says ({@link githubEngagedFollowUpReach}). Putting them here rather
+ * than in {@link resolveGitHubEngagement} is deliberate — the ambient leg reads that function for the
+ * STOP, and a stood-down container must stay suppressed on a public repo too.
+ */
+export async function githubEngagedAdmits(f, deps = {}) {
+    if (f.isMention)
+        return true; // the caller's own mention gate already admitted it
+    if (!githubEngagedFollowUpReach(f).reachable)
+        return false;
+    const verdict = await resolveGitHubEngagement(f, deps);
+    return verdict.kind === "deliver";
+}
+/**
+ * WHAT WOKE ONE AMBIENT-LEG DELIVERY, for the `github.dispatched` audit row (OPE-1752).
+ *
+ * 🔴 THE CLASSIFIER'S OWN WORD CANNOT ANSWER THIS, AND WRITING IT WAS THE DEFECT.
+ * `classifyGitHubAmbientComment` answers a narrower question — did this comment ADDRESS the agent —
+ * and an engaged follow-up did not, so it stays `channel-watch`. That is the right answer to its own
+ * question, and `channel-watch` is what makes the turn a JUDGED one. But `channel-watch` ALSO names
+ * unowned chatter in an un-enrolled issue, and the audit row is the one place those two must not
+ * read alike. This is the same promotion OPE-1510 made on Notion (`notionWakeAddressing`) and
+ * OPE-1578 made on Linear (`linearWakeAddressing`) — one concept, one spelling, across three
+ * surfaces.
+ *
+ * 🔴 THE MAPPING IS THE ROW'S ALONE, and nothing else has to be re-derived from it. The classifier's
+ * value reaches five places in `github.ts`, and TWO of them are behavioural: the `drop` return, the
+ * `githubAmbientLegAdmission` gate input, the seam facts' `isMention`, `directMention` — which is
+ * what the wake envelope and `singleWindowMentionPolicy` are built from — and this row. The gate
+ * input and `directMention` are the behavioural two, and NEITHER reads the PROMOTED value: both take
+ * the classifier's word directly, above this mapping. `github-supervisor.ts` derives the wake
+ * envelope's own `addressing`
+ * from `directMention` (`directMention ? "direct-mention" : "channel-watch"`), and the
+ * unified-window wake takes `singleWindowMentionPolicy(singleWindow, directMention, vouched)`.
+ * Neither reads this value. So the turn is judged the same, and the SILENCE BAR is what it always
+ * was, whatever this function returns.
+ *
+ * 🔴 A ROW THAT CANNOT TELL THEM APART REDS `J-ENGAGED-github` STEP (b) AGAINST A HEALTHY
+ * DEPLOYMENT. `gateEngagedWake` (packages/core/scripts/e2e/scenarios.ts) skips on an EMPTY dispatch
+ * read only, so a non-empty read carrying `channel-watch` is a hard gate failure, not an ignored
+ * value. Measured on deploy #203: the follow-up woke, dispatched and was ANSWERED (`reply.post`,
+ * 2026-09-12T20:27:25Z), and only the label disagreed. What the promotion DOES oblige is every
+ * reader that filtered the ambient leg by the literal `"channel-watch"` — `AMBIENT_LEG_ADDRESSINGS`
+ * (packages/core/scripts/e2e/engaged-rows.ts) is the pair such a reader takes.
+ *
+ * 🔴 IT REPORTS THE ENGAGED DOOR, AND THAT DOOR CARRIES A REACH FLOOR LINEAR'S DOES NOT. Linear's
+ * input is the bare seam verdict; GitHub's is `admission.engagedFollowUp`, which is
+ * `seam.kind === "deliver" && githubEngagedFollowUpReach(f).reachable`. So the promotion needs BOTH
+ * an enrolled container and a reachable one, and {@link githubEngagedFollowUpReach} refuses a public
+ * or unknown-privacy repo and an inline review comment. An engaged issue on a VOUCHED PUBLIC repo
+ * with ambient ON therefore still writes `channel-watch`: the classifier keeps that comment, but the
+ * engaged door is shut and the native leg would not have woken a turn for it either. That is the
+ * right answer — the row reports the door the delivery actually came through — and it is a narrower
+ * claim than Linear's, so do not read the two mappings as identical in reach.
+ *
+ * 🔴 IT REPORTS THE REGISTRY, NOT THE AMBIENT OPT-IN. `githubAmbientLegAdmission` resolves the seam
+ * for every kept comment, ABOVE the `githubAmbientEnabled` gate and independently of it, so on an
+ * ambient-ENABLED private repo an engaged issue's plain comment also reads `thread-follow` — the
+ * opt-in would have admitted it either way. The value therefore separates an engaged wake from an
+ * ambient one only where the domain has ambient OFF, which is the addressed-only posture the
+ * journeys drive.
+ *
+ * `engagedFollowUp` is the caller's own admission verdict, and it is the only door a plain comment
+ * has on a repo that never opted in. The `channel-watch` guard is belt-and-braces:
+ * `drop` returns before the row is written and can never reach here, and `direct` is an address
+ * rather than a follow-up.
+ */
+export function githubWakeAddressing(addressing, engagedFollowUp) {
+    return addressing === "channel-watch" && engagedFollowUp === true ? "thread-follow" : addressing;
+}
+//# sourceMappingURL=github-engagement.js.map

package/dist/agent/channels/github-engagement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-engagement.js","sourceRoot":"","sources":["../../../agent/channels/github-engagement.ts"],"names":[],"mappings":"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"}

package/dist/agent/channels/github-identity.d.ts

@@ -0,0 +1,164 @@
+import type { BindableContext, IdentityMapper, IngestedChatMessage } from "@open-everywhere/core/agent/adapter-api.js";
+/** Structural match for eve's SessionAuthContext (attributes + principal). */
+export interface OpenEverywhereGitHubAuth {
+    readonly authenticator: string;
+    readonly principalId: string;
+    readonly principalType: string;
+    readonly attributes: Record<string, string>;
+}
+export interface GitHubIdentityInput {
+    /** Repo owner (org/user login) — becomes the OpenEverywhere `workspace`, the org boundary. */
+    readonly owner: string;
+    /** Repo name — becomes the OpenEverywhere `surface` (the silo grain: one repo, many issues/PRs). */
+    readonly repo: string;
+    /** "owner/name" — carried for reference/logging (not a partition key on its own). */
+    readonly repositoryFullName?: string;
+    readonly repositoryId?: number;
+    /** Repo visibility, when positively known (off ctx.repository.private); absent → fail closed. */
+    readonly isPrivate?: boolean;
+    /** "issue" | "pull_request" | "review_thread" — picks the post-back anchor (issue vs PR number). */
+    readonly conversationKind?: string;
+    /** Issue number for the conversation, when it's an issue thread (post-back anchor). */
+    readonly issueNumber?: number;
+    /** PR number for the conversation, when it's a PR/review thread (post-back anchor). */
+    readonly pullRequestNumber?: number;
+    /**
+     * The ROOT comment id of the review thread this turn arrived in (OPE-958) — present only on a
+     * `review_thread` conversation. It is the id `read_thread` fetches the thread by, and the binding
+     * is the only place it can ride: `ReadAdapter.wakeAddress` is pure and synchronous and reads the
+     * binding, while eve carries the root on its own channel STATE, which the mapper never sees.
+     *
+     * GitHub sends `in_reply_to_id` on a REPLY and omits it on the comment that OPENED the thread, so
+     * the root is `in_reply_to_id ?? comment.id` and github.ts derives it there, once.
+     */
+    readonly reviewThreadRootCommentId?: number;
+    /** GitHub App installation id (needed to mint tokens for proactive post-back). */
+    readonly installationId?: number;
+    /** The acting GitHub user (comment author) — the OpenEverywhere principal. */
+    readonly actorLogin: string;
+    readonly actorId?: number;
+    /** "User" | "Bot" | "Organization" — a Bot actor maps to a `service` principal. */
+    readonly actorType?: string;
+    /**
+     * The actor's relationship to the repo, as GitHub reports it on the comment payload
+     * (`author_association`): OWNER | MEMBER | COLLABORATOR | CONTRIBUTOR |
+     * FIRST_TIME_CONTRIBUTOR | FIRST_TIMER | MANNEQUIN | NONE. A verifiable trust signal.
+     */
+    readonly authorAssociation?: string;
+}
+/** Build the auth context OpenEverywhere dispatches with — raw facts as string attributes. */
+export declare function buildGitHubAuth(input: GitHubIdentityInput): OpenEverywhereGitHubAuth;
+/**
+ * A comment @mentions the bot and should wake a turn. Faithfully mirrors eve's
+ * internal gate (shouldDispatchGitHubComment: isIgnoredGitHubComment +
+ * extractGitHubCommentTrigger), which is NOT on eve's public export surface — so we
+ * replicate it here (small, deterministic, and unit-tested) rather than reach into a
+ * package-internal path. Kept byte-consistent with eve because the channel's message
+ * layer still strips the mention token via eve's own extractGitHubCommentTrigger; a
+ * divergent gate here would fire turns eve then can't strip. FAIL CLOSED: no botName,
+ * a bot author, the bot's own comments, or eve's marker → no wake.
+ */
+export declare function githubBotMentioned(body: string | undefined, botName: string | undefined, author: {
+    readonly login?: string;
+    readonly type?: string;
+} | undefined): boolean;
+/**
+ * GitHub repo privacy → visibility. FAIL CLOSED, mirroring slackVisibility/
+ * linearVisibility: only an explicitly PUBLIC repo (`repo_private="false"`) yields
+ * `public`; a private repo (`"true"`) or an unknown signal → `private`, so an
+ * under-identified session or a private repo never writes its learnings up to shared
+ * (workspace) memory. A public repo's issue/PR threads are world-readable, so treating
+ * them as a public surface (learnings may flow to the workspace brain across the org's
+ * repos) is correct; anything we can't confirm public stays surface-tier private.
+ */
+export declare function githubVisibility(repoPrivate: string | undefined): Visibility;
+/**
+ * GitHub actor + repo privacy → trust (the shared-memory gate). FAIL CLOSED — only a
+ * POSITIVE in-boundary fact yields a verdict:
+ *   - A PRIVATE repo (only org members + invited collaborators can see it) touched by an
+ *     org OWNER or MEMBER → `internal`. OWNER/MEMBER are GitHub's strong "part of the org
+ *     that owns this repo" signals (`author_association`); on a private repo that means an
+ *     insider acting inside the boundary, so shared/org memory is safe to read.
+ *   - ANYTHING ELSE → `undefined`, so bindFrom FAILS CLOSED to `external`:
+ *       · a PUBLIC repo — world-readable, anyone (external contributors) can comment, so it
+ *         must never light up the org brain regardless of who this particular actor is;
+ *       · a private repo touched by a COLLABORATOR (may be an OUTSIDE collaborator),
+ *         CONTRIBUTOR, first-timer, mannequin, NONE, or a missing/unknown association;
+ *       · a missing repo-privacy signal.
+ * The operator can still vouch for a deployment with OE_TRUST=internal — the same layer
+ * Slack-DM/Teams/Discord/Linear use. An ambiguous GitHub event must never reach
+ * the shared org brain. (Per-repo collaborator-membership enrichment — GET
+ * /repos/{o}/{r}/collaborators/{u}/permission — is the future layer-2 gate that could
+ * promote a verified internal collaborator; until then, only OWNER/MEMBER on a private
+ * repo is trusted.)
+ */
+export declare function githubTrust(repoPrivate: string | undefined, authorAssociation: string | undefined): Trust | undefined;
+/** Local copies of the binding's unions (kept eve-free + import-cycle-free). */
+type Visibility = "public" | "private";
+type Trust = "internal" | "external";
+/** `author_association` values that carry a deliberate access grant on the repo — the INTERNAL set. */
+export declare const GITHUB_INTERNAL_ASSOCIATIONS: readonly string[];
+/** `author_association` values that carry NO access grant — the EXCLUDED (external) set. This is
+ *  GitHub's whole documented enum minus {@link GITHUB_INTERNAL_ASSOCIATIONS}, written out rather
+ *  than derived by negation: see {@link githubAssociationRefutes} for why the difference matters. */
+export declare const GITHUB_EXTERNAL_ASSOCIATIONS: readonly string[];
+/**
+ * Does this `author_association` POSITIVELY refute the author's membership?
+ *
+ * 🔴 IT MATCHES THE EXCLUDED SET, IT DOES NOT NEGATE THE INTERNAL ONE, and the difference is the
+ * whole fail-open posture. An ABSENT association (a payload shape GitHub changed, a synthesised
+ * event) and an UNRECOGNISED one (a value GitHub adds later) both answer `false` — "not refuted",
+ * which is what `IngestedChatMessage.refuted` means by absence of evidence. Negating the internal
+ * set would read every unknown as external and take the agent off the air on a payload change.
+ *
+ * Case-sensitive on purpose: GitHub sends these values upper-case, and accepting a lower-case
+ * variant would be inventing a second spelling of a vendor enum.
+ */
+export declare function githubAssociationRefutes(authorAssociation: string | undefined): boolean;
+/**
+ * The author grain's evidence for one GitHub comment, in the core's own vocabulary
+ * (`IngestedChatMessage`) so access/external-policy.ts answers the exclusion question — this bundle
+ * never re-derives it.
+ *
+ * A `Bot` actor grades as the machine floor `relay` and is therefore NEVER excluded, which is the
+ * core's own ruling (access/taint-signal.ts `nonMemberChatTrust`): a bot is below peer standing but
+ * it is not a person outside the organisation, and withholding every app's comments would be an
+ * outage. Stating it as the tier rather than as a local `if` keeps ONE place deciding.
+ *
+ * A human author carries `refuted` only when {@link githubAssociationRefutes} says so. `trust` is
+ * left ABSENT for a human on purpose: this runs before the per-wake trust resolution, so naming a
+ * tier here would be a guess, and the refutation leg needs no tier.
+ */
+export declare function githubAuthorFacts(input: {
+    readonly authorAssociation?: string;
+    readonly actorType?: string;
+}): IngestedChatMessage;
+/**
+ * The CONVERSATION key the stop registry keys a GitHub turn by (OPE-898) — `owner/repo#number`.
+ *
+ * ONE derivation, used by BOTH sides of the affordance: {@link bindGitHub} writes it onto the anchor
+ * row at turn start, and the stop-comment leg (channels/github-stop.ts) rebuilds it from the webhook
+ * that carries the directive. Two spellings of this key would make the whole arm silently miss.
+ *
+ * It is NOT a surface key and never becomes one — the GitHub surface grain is the REPO, and this
+ * value names one issue or PR inside it. Returns undefined on any missing part: a partial key would
+ * collide across repos.
+ */
+export declare function githubConversationKey(owner: string | undefined, repo: string | undefined, number: number | undefined): string | undefined;
+/**
+ * The ROOT comment id of the review thread this turn arrived in, or `undefined` (OPE-958). The read
+ * side of {@link GitHubIdentityInput.reviewThreadRootCommentId} — this file owns the attribute
+ * spelling on BOTH sides, so a rename cannot leave the reader looking for a key nobody writes.
+ *
+ * It reads the AUTH ATTRIBUTES rather than the composed binding on purpose. `RawIdentity.target` is
+ * eve's `GitHubReceiveTarget` and throws on a member it does not know, so the root cannot ride
+ * there, and no other binding field names a comment.
+ *
+ * Returns the id as a STRING of digits, which is what `ReadAdapter.readThread` takes as its thread
+ * id. A non-numeric value is treated as absent: a review thread id that is not a comment id would
+ * fetch nothing, and refusing honestly beats reading an empty thread.
+ */
+export declare function githubReviewThreadRoot(ctx: BindableContext): string | undefined;
+export declare const bindGitHub: IdentityMapper;
+export {};
+//# sourceMappingURL=github-identity.d.ts.map

package/dist/agent/channels/github-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-identity.d.ts","sourceRoot":"","sources":["../../../agent/channels/github-identity.ts"],"names":[],"mappings":"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"}