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

package/dist/agent/channels/github-reaction-feedback.js

@@ -0,0 +1,380 @@
+// THE GITHUB REACTION-FEEDBACK ARM (OPE-1502) — a reaction on the agent's own comment becomes a
+// durable feedback signal, the same way it already does on Slack and Discord.
+//
+// 🔴 GITHUB PUSHES NO REACTION WEBHOOK. Slack, Discord, Teams and Linear all DELIVER a reaction
+// event; GitHub delivers none for an issue, a pull request or a comment. That is the same vendor
+// fact the stop arm rests on (channels/github-stop.ts, which is a `stop` COMMENT for exactly this
+// reason). So the inbound half here is a READ, not a delivery — and every design choice below falls
+// out of that one difference.
+//
+// ── THE TRIGGER, AND WHAT IT COSTS
+//
+// The poll rides an inbound delivery this deployment already receives for the same conversation: an
+// `issue_comment` or `issues` webhook names an issue, and the arm then reads the reactions on the
+// agent's own comments in it. A reaction therefore reaches the seat on the NEXT delivery for that
+// conversation, not the instant somebody clicks. That is a real latency, it is the honest ceiling of
+// what GitHub offers, and it is what the bundle's parity declaration says out loud rather than
+// claiming a parity this surface does not have.
+//
+// 🔴 TWO GATES RUN BEFORE THE FIRST REST CALL (OPE-1540), and channels/github-reaction-scope.ts owns
+// both. The agent must be IN this conversation — a conversation it is not in can hold no reaction it
+// could record — and the repository must have hourly budget left. Only then does the arm read
+// anything. Before those gates every delivery paid the issue read and the comment page just to
+// discover there was nothing to look at.
+//
+// 🔴 READING THE NEWEST COMMENTS TAKES AN EXTRA REQUEST, and getting this wrong is silent.
+// `/issues/{n}/comments` returns OLDEST first and has no `direction` parameter — the measured vendor
+// fact this bundle's read adapter is built on (channels/github-read.ts, its header). Asking page 1
+// of a 250-comment thread would hand the poll the conversation's START, so the agent's recent
+// replies would never be examined and the arm would report nothing while looking perfectly healthy.
+// So the poll does what the read adapter does: it takes the issue's own `comments` COUNT, which
+// names the last page directly, and reads that page.
+//
+// THE COST, per ADMITTED delivery — one the two gates above let through: one issue read for the
+// count, one comment page (a second when that page is short and there is a page before it), plus one
+// reactions read per agent comment the page already says carries a reaction — capped by
+// {@link GITHUB_REACTION_POLL_COMMENT_BUDGET}. A conversation with no comments costs the issue read
+// and nothing more. A REFUSED delivery costs no read at all.
+//
+// ── WHY ONLY `added`
+//
+// The reactions route returns the reactions that EXIST. It cannot report one that was taken away, so
+// a poll can only ever see an add. The arm records `added` and never invents a `removed`: a
+// retraction this surface cannot observe is better absent than guessed at.
+//
+// ── THE DEDUPE IS A KEY (OPE-1535)
+//
+// A poll re-reads reactions it has already recorded, so it must not write a second row for each. The
+// arm therefore keeps a durable CLAIM per recorded reaction, keyed by the three fields that identify
+// one: the comment, the reactor and the glyph ({@link githubReactionKey}). A poll asks the store
+// about the exact reaction in front of it and skips the ones it already holds.
+//
+// 🔴 IT IS A `notice_claim`, AND THE LIFETIME IS THE WHOLE POINT. "This reaction was recorded" never
+// stops being true, and a reaction stays visible to the poll for as long as its comment stays in the
+// poll's view — which on a quiet conversation is forever. So the claim must never expire.
+// `claimNotice`/`noticeClaimed` (operational/store.ts) is the tree's at-most-once claim with no TTL
+// and no prune, which is exactly that shape. Growth is one row per recorded reaction — the same
+// number of rows the audit log already holds for them, so the marginal cost is a copy of a thing the
+// deployment already keeps.
+//
+// 🔴 WHY THE AUDIT LOG STOPPED BEING THE ANSWER. It was: the arm read back the newest reaction rows
+// for the surface and skipped what it found. That read is a WINDOW, not a key — `readAudit` takes a
+// LIMIT rather than a cursor, and the surface grain the rows carry is the REPOSITORY, so a repository
+// with more recorded reactions than the window held would re-record one whose row had aged out as
+// soon as a delivery brought the poll back to that conversation. The window's size decided
+// correctness, which is the property a key does not have.
+//
+// 🔴 THE DEDUPE FAILS CLOSED, AND SAYS SO. An unreadable claim reads as ALREADY RECORDED, which
+// bounds what the audit log claims happened — but a store that stays down then disables the feedback
+// signal entirely, with zero rows and no error to look at. So a poll that could not read the claim
+// store writes ONE `github.reaction_claim_unreadable` audit row naming how many reactions it skipped,
+// the same way the budget gate audits its trip (channels/github-reaction-scope.ts).
+//
+// 🔴 THAT ROW ANSWERS A PARTIAL FAULT, NOT EVERY ONE. It is written through `appendAudit`, into the
+// SAME operational store whose claim read just threw — so a whole-store outage loses the row as well,
+// and shows up as the audit DROP COUNTER and its warn instead. The row is what makes the partial case
+// legible: a missing `notice_claim` table, or a grant that covers `audit_log` and not it.
+//
+// 🔴 THE ORDER IS READ, RECORD, CLAIM — and it is chosen so nothing is ever LOST. The claim is
+// written only after `ingestReaction` reports the row recorded, so a sink that fails leaves no claim
+// and the next poll retries the reaction. Claiming first would make the dedupe a mutex across
+// concurrent deliveries, but a failed write would then swallow the reaction permanently — the claim
+// table has no release. Two cases stay open in the same benign direction, both of them a repeated
+// audit row that over-reports the count and corrupts nothing: two deliveries polling the same
+// conversation at the same instant, where both read "not recorded" before either writes; and a claim
+// WRITE that fails after the row landed, which the next poll answers by recording the reaction again.
+// The first was there before the key and is unchanged by it; the second is the price of the order.
+//
+// ── IDENTITY
+//
+// "The agent's own comment" is `<GITHUB_APP_SLUG>[bot]` — the login GitHub gives an App's comments,
+// and the same self-identity channels/github-supervisor.ts drops its own replies by. 🔴 IT FAILS
+// CLOSED: with no slug configured the arm polls nothing at all, because it cannot tell the agent's
+// comments from anybody else's and reading every comment's reactions would record strangers' reactions
+// to strangers' posts as feedback about the agent.
+import { buildIngestedReaction, deploymentOrg, getOperationalStore, ingestReaction, liveReactionSink, resolvePartition, } from "@open-everywhere/core/agent/adapter-api.js";
+import { buildGitHubAuth } from "./github-identity.js";
+import { GITHUB_API_BASE, installationTokenFor } from "./github-post-arm.js";
+import { getJson, liveGithubReadFetch } from "./github-read.js";
+import { auditGitHubReactionClaimUnreadable, githubConversationInScope, spendGitHubPollBudget } from "./github-reaction-scope.js";
+/** The webhook families that name a conversation this arm can poll. Both carry `repository` and an
+ *  issue number; a PR arrives as an `issue_comment` too, because GitHub models a PR as an issue for
+ *  timeline comments. */
+const POLL_EVENT_TYPES = new Set(["issue_comment", "issues"]);
+/** One poll examines at most this many of the agent's own comments, newest first. A conversation
+ *  with more agent comments than this is one where the older ones stopped attracting reactions. */
+export const GITHUB_REACTION_POLL_COMMENT_BUDGET = 10;
+function isObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function str(v) {
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+function pick(o, k) {
+    return isObject(o) ? o[k] : undefined;
+}
+/**
+ * The conversation one delivery names, or null when the delivery names none. NEVER THROWS.
+ *
+ * It reads the SAME body the stop leg and the ambient leg read, and it accepts a delivery those two
+ * refuse — an `issues` event, or an `issue_comment` the agent itself wrote. The poll is about the
+ * CONVERSATION, so any accepted delivery naming one is a valid occasion to look.
+ */
+export function parseGitHubReactionPollTarget(body, eventType) {
+    if (!POLL_EVENT_TYPES.has(eventType))
+        return null;
+    let ev;
+    try {
+        ev = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    if (!isObject(ev))
+        return null;
+    const repository = ev["repository"];
+    const owner = str(pick(pick(repository, "owner"), "login"));
+    const repo = str(pick(repository, "name"));
+    const number = num(pick(ev["issue"], "number")) ?? num(pick(ev["pull_request"], "number"));
+    if (!owner || !repo || number === undefined)
+        return null;
+    const installationId = num(pick(ev["installation"], "id"));
+    const repoPrivate = pick(repository, "private");
+    return {
+        owner,
+        repo,
+        number,
+        ...(installationId === undefined ? {} : { installationId }),
+        ...(typeof repoPrivate === "boolean" ? { repoPrivate } : {}),
+    };
+}
+/** Is this comment the agent's own? `user.type === "Bot"` AND the configured `<slug>[bot]` login —
+ *  both, because either alone is wrong: every App's comment is type `Bot`, and a human account may
+ *  legally be named to look like one. */
+export function githubCommentIsOwn(comment, botLogin) {
+    const login = botLogin?.trim().toLowerCase();
+    if (!login)
+        return false;
+    if (comment.authorType?.toLowerCase() !== "bot")
+        return false;
+    return comment.authorLogin?.toLowerCase() === login;
+}
+/** The identity of one recorded reaction — a comment, a reactor and a glyph. The dedupe key, and the
+ *  same three fields `liveReactionSink` writes into the audit row. */
+export function githubReactionKey(messageId, reactorId, emoji) {
+    return [messageId, reactorId, emoji].join("\u001f");
+}
+/**
+ * Poll one conversation and record every reaction on the agent's own comments that is not recorded
+ * yet. Returns one outcome per NEW reaction — an empty array when there is nothing new, which is the
+ * ordinary case on a busy conversation.
+ *
+ * NEVER THROWS: a failed read or a failed sink must never cost the ingress its ack. A comment whose
+ * reactions cannot be read is skipped, and the rest of the poll continues.
+ */
+export async function routeGitHubReactionFeedback(target, deps) {
+    // FAIL CLOSED on self-identity — see the header. Without it every reaction in the thread would
+    // read as feedback on the agent.
+    const botLogin = deps.botLogin?.trim().toLowerCase();
+    if (!botLogin)
+        return [];
+    // THE PARTITION IS RESOLVED FIRST, because the gates below are keyed by the same surface the rows
+    // are. It is PURE — no store, no network — so computing it ahead of a gate that may refuse costs
+    // nothing.
+    const partition = resolvePartition({
+        channel: { kind: "github" },
+        session: {
+            auth: {
+                current: buildGitHubAuth({
+                    owner: target.owner,
+                    repo: target.repo,
+                    issueNumber: target.number,
+                    // The POLL has no actor — it is the deployment looking, not a person acting. The reactor's
+                    // own login rides each ingested reaction instead, which is where it belongs.
+                    actorLogin: botLogin,
+                    ...(target.repoPrivate === undefined ? {} : { isPrivate: target.repoPrivate }),
+                }),
+            },
+        },
+    });
+    const coords = { org: partition.org, workspace: partition.workspace, surfaceKey: partition.surfaceKey };
+    // ── THE TWO SCOPE GATES (OPE-1540) ─────────────────────────────────────────────────────────────
+    //
+    // 🔴 BOTH RUN BEFORE THE FIRST REST CALL, which is the whole of the fix: the cost this bundle used
+    // to pay was paid to LEARN there was nothing to do. Gate 1 is the cheap one and the one that cuts
+    // the most, so it runs first — and a conversation it refuses spends no budget either, because a
+    // poll that never happens is not a poll this repository ran.
+    //
+    // Both FAIL OPEN on a throw, matching their live implementations: a gate that cannot answer costs
+    // REST calls, never a lost feedback signal. The `.catch` is also what keeps this function's
+    // never-throws contract true for an injected dep.
+    const atIso = deps.now?.() ?? new Date().toISOString();
+    if (!(await deps.inScope(target, coords).catch(() => true)))
+        return [];
+    if (!(await deps.spendBudget(target, coords, atIso).catch(() => true)))
+        return [];
+    const comments = await deps.listComments(target).catch(() => []);
+    const own = comments
+        .filter((c) => githubCommentIsOwn(c, botLogin) && (c.reactionCount ?? 0) > 0)
+        .slice(0, deps.commentBudget ?? GITHUB_REACTION_POLL_COMMENT_BUDGET);
+    if (own.length === 0)
+        return [];
+    // The keys this poll has already answered for. It is a memo over `deps.recorded`, not the dedupe
+    // itself: the durable claim is what decides, and this only stops one poll asking the store twice
+    // about a reaction the vendor happened to list twice.
+    const asked = new Set();
+    // How many reactions this poll skipped because the claim store could not answer. It is a COUNT,
+    // not a flag, because the row written at the end reports it — see below.
+    let claimUnreadable = 0;
+    const outcomes = [];
+    for (const comment of own) {
+        const reactions = await deps.listReactions(target, comment.id).catch(() => []);
+        for (const reaction of reactions) {
+            const reactorId = reaction.userLogin;
+            // The agent's OWN reactions ride the same route — its `react` verb places them. They are never
+            // feedback, and unlike the comment filter this one needs no type check: the login is exact.
+            if (!reactorId || reactorId.toLowerCase() === botLogin)
+                continue;
+            const messageId = String(comment.id);
+            const key = githubReactionKey(messageId, reactorId, reaction.content);
+            if (asked.has(key))
+                continue;
+            asked.add(key);
+            // FAIL-CLOSED on an unreadable claim: an unknown answer is treated as ALREADY RECORDED, so a
+            // store blip costs a delayed feedback row rather than a duplicate one. The opposite posture
+            // from the two scope gates above, and deliberately: those bound a COST, this one bounds what
+            // the audit log claims happened.
+            //
+            // 🔴 BUT IT IS NEVER SILENT. Failing closed on a store that stays down disables the whole
+            // feedback signal with zero rows and no error, which reads exactly like a week nobody reacted
+            // in. The throw is counted here and audited ONCE at the end of the poll.
+            const claimed = await deps.recorded(coords, key).catch(() => {
+                claimUnreadable++;
+                return true;
+            });
+            if (claimed)
+                continue;
+            const ingested = buildIngestedReaction({
+                surface: "github",
+                // Only ever an ADD — see the header. A poll cannot observe a retraction.
+                verb: "added",
+                reactorId,
+                emoji: reaction.content,
+                // The CONVERSATION is the channel grain a GitHub turn is keyed by; the COMMENT is the
+                // message the reaction landed on.
+                target: { channelId: `${target.owner}/${target.repo}#${target.number}`, messageId },
+                // Structurally true: the loop only ever reaches the agent's own comments.
+                onBotReply: true,
+                partition,
+            });
+            const outcome = await ingestReaction(ingested, deps.sink).catch(() => ({ recorded: false, onBotReply: true, reason: "sink failed" }));
+            outcomes.push(outcome);
+            // CLAIM ONLY WHAT LANDED — see the header's read/record/claim order. A sink that failed leaves
+            // no claim, so the next poll for this conversation tries the reaction again.
+            if (outcome.recorded)
+                await deps.markRecorded(coords, key, atIso).catch(() => undefined);
+        }
+    }
+    // ONE ROW PER POLL for an unreadable claim store, and only when one read actually threw. The count
+    // is what makes a single row as informative as the flood it replaces. Best-effort and swallowed,
+    // like every other write on this path — the never-throws contract holds through it.
+    if (claimUnreadable > 0)
+        await deps.auditClaimUnreadable?.(target, coords, atIso, claimUnreadable).catch(() => undefined);
+    return outcomes;
+}
+/** The durable claim key one recorded reaction occupies, namespaced by the SURFACE — `notice_claim`
+ *  is keyed by org alone, so two repositories in one deployment would otherwise share a key space and
+ *  a comment id collision across repos would read as a duplicate. */
+function githubReactionClaimKey(p, key) {
+    return `github-reaction:${p.surfaceKey}\u001f${key}`;
+}
+/** The live dedupe's read half: has this exact reaction already been recorded? */
+async function liveGitHubReactionRecorded(p, key) {
+    return getOperationalStore().noticeClaimed(deploymentOrg(), githubReactionClaimKey(p, key));
+}
+/** The live dedupe's write half. Idempotent — a re-claim of a held key answers false, which nothing
+ *  here reads: the question this store answers is "is it claimed", never "who claimed it". */
+async function liveGitHubReactionMarkRecorded(p, key, atIso) {
+    await getOperationalStore().claimNotice(deploymentOrg(), githubReactionClaimKey(p, key), atIso);
+}
+// --- THE LIVE READS ------------------------------------------------------------------------------
+//
+// Every GET below runs under the SAME short-lived installation token every other GitHub call in this
+// bundle mints, through the SAME `getJson` and the SAME transport the read adapter uses — so they
+// inherit its 429 backoff and add no second transport (channels/github-read.ts, and
+// `test:github-write-seam` §4). None of them reads a comment BODY: the poll needs an author, a count
+// and a glyph, and nothing else.
+/** GitHub's own page ceiling for the comment list. The read adapter pages by the same number. */
+const GITHUB_COMMENT_PAGE = 100;
+function tokenFor(target) {
+    return installationTokenFor({
+        platform: "github",
+        owner: target.owner,
+        repo: target.repo,
+        issueNumber: target.number,
+        ...(target.installationId === undefined ? {} : { installationId: target.installationId }),
+    });
+}
+/** Production deps for the poll. `botLogin` is `<GITHUB_APP_SLUG>[bot]` — absent when the slug is
+ *  unset, which is exactly the fail-closed case {@link routeGitHubReactionFeedback} refuses on. */
+export function liveGitHubReactionFeedbackDeps(appSlug, fetchFn = liveGithubReadFetch) {
+    const slug = appSlug?.trim();
+    return {
+        sink: liveReactionSink(),
+        ...(slug ? { botLogin: `${slug}[bot]` } : {}),
+        listComments: async (target) => {
+            const token = await tokenFor(target);
+            // 🔴 THE LAST PAGE, NOT THE FIRST. `/issues/{n}/comments` returns OLDEST first and honours no
+            // `direction` — see the header. The issue object's own `comments` count names the last page
+            // directly, which is the same two-request shape channels/github-read.ts uses and for the same
+            // reason. Reading page 1 here would examine the conversation's START and find nothing.
+            const issue = await getJson(fetchFn, `${GITHUB_API_BASE}/repos/${target.owner}/${target.repo}/issues/${target.number}`, token, "issues.get");
+            const total = typeof issue.comments === "number" && issue.comments > 0 ? issue.comments : 0;
+            if (total === 0)
+                return [];
+            const page = (nth) => `${GITHUB_API_BASE}/repos/${target.owner}/${target.repo}/issues/${target.number}/comments?per_page=${GITHUB_COMMENT_PAGE}&page=${nth}`;
+            const lastPage = Math.max(1, Math.ceil(total / GITHUB_COMMENT_PAGE));
+            let raw = await getJson(fetchFn, page(lastPage), token, "issues.comments.list");
+            if (!Array.isArray(raw))
+                return [];
+            // A short last page can hold fewer of the agent's comments than the budget wants, so the page
+            // before it is prepended — the same fallback the read adapter makes, and enough for any budget
+            // up to the page size.
+            if (raw.length < GITHUB_REACTION_POLL_COMMENT_BUDGET && lastPage > 1) {
+                const previous = await getJson(fetchFn, page(lastPage - 1), token, "issues.comments.list");
+                if (Array.isArray(previous))
+                    raw = [...previous, ...raw];
+            }
+            return raw
+                .filter((c) => typeof c.id === "number")
+                // NEWEST FIRST, so the budget's slice takes the agent's most recent comments — the ones a
+                // person is plausibly still reacting to.
+                .reverse()
+                .map((c) => ({
+                id: c.id,
+                ...(c.user?.login ? { authorLogin: c.user.login } : {}),
+                ...(c.user?.type ? { authorType: c.user.type } : {}),
+                ...(typeof c.reactions?.total_count === "number" ? { reactionCount: c.reactions.total_count } : {}),
+            }));
+        },
+        listReactions: async (target, commentId) => {
+            const token = await tokenFor(target);
+            const raw = await getJson(fetchFn, `${GITHUB_API_BASE}/repos/${target.owner}/${target.repo}/issues/comments/${commentId}/reactions?per_page=100`, token, "reactions.listForIssueComment");
+            return raw
+                .filter((r) => typeof r.content === "string" && r.content.length > 0)
+                .map((r) => ({
+                content: r.content,
+                ...(r.user?.login ? { userLogin: r.user.login } : {}),
+            }));
+        },
+        recorded: (partition, key) => liveGitHubReactionRecorded(partition, key),
+        markRecorded: (partition, key, atIso) => liveGitHubReactionMarkRecorded(partition, key, atIso),
+        inScope: (target, partition) => githubConversationInScope(partition.surfaceKey, target.owner, target.repo, target.number),
+        spendBudget: async (target, _partition, atIso) => (await spendGitHubPollBudget(target.owner, target.repo, atIso)).admitted,
+        auditClaimUnreadable: (target, _partition, atIso, skipped) => auditGitHubReactionClaimUnreadable(target.owner, target.repo, atIso, skipped),
+    };
+}
+//# sourceMappingURL=github-reaction-feedback.js.map

package/dist/agent/channels/github-reaction-feedback.js.map

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

package/dist/agent/channels/github-reaction-scope.d.ts

@@ -0,0 +1,102 @@
+/** How many reaction polls one repository may run in one clock hour. Sized so an ordinarily busy
+ *  repository never reaches it — the gate is a ceiling on a runaway conversation, not a throttle on
+ *  normal traffic. One ADMITTED poll costs up to 13 GETs (the issue read, one or two comment pages,
+ *  and up to `GITHUB_REACTION_POLL_COMMENT_BUDGET` reaction reads), so this bounds a repository's
+ *  worst hour to ~780 GETs on the installation token the reply path shares. The everyday cost is far
+ *  below that: most polls read three. */
+export declare const GITHUB_REACTION_POLL_HOURLY_BUDGET = 60;
+/** The audit action a tripped budget writes. Queryable over the control plane's audit route, the
+ *  same way `github.ambient_skipped` answers "why did the ambient leg stay quiet". */
+export declare const GITHUB_REACTION_POLL_BUDGET_ACTION = "github.reaction_poll_budget";
+/** The audit action an UNREADABLE CLAIM STORE writes, once per poll. The dedupe next door fails
+ *  CLOSED, so a store that cannot answer "is this recorded" stops every feedback row for as long as
+ *  it stays down — and a silent zero reads exactly like a quiet week. This row is the signal. It
+ *  carries the same audit ACTION shape as the budget trip above, so an operator reads both off the
+ *  control plane's audit route; the GRAIN differs, and {@link auditGitHubReactionClaimUnreadable}
+ *  says how. */
+export declare const GITHUB_REACTION_CLAIM_UNREADABLE_ACTION = "github.reaction_claim_unreadable";
+/** How long a reply may wait on the best-effort post claim below.
+ *
+ * 🔴 THE CEILING IS THE POINT, NOT THE NUMBER. `liveGitHubPost` marks the conversation AFTER the
+ * comment has already landed, so this write can only ever delay the reply tool's RETURN — and with
+ * no ceiling a slow store held that return for as long as it liked, on the turn path. Two seconds is
+ * far more than a keyed claim needs and far less than a turn can notice. */
+export declare const GITHUB_POSTED_MARK_TIMEOUT_MS = 2000;
+/** The hourly budget's key for one repository. The clock hour rides IN the key, so the counter needs
+ *  no reset and a stale bucket simply stops being read. */
+export declare function githubPollBudgetKey(owner: string, repo: string, atIso: string): string;
+/**
+ * Record that the agent has commented in this conversation. Best-effort and idempotent — a second
+ * post in the same conversation re-claims a key that is already claimed, which the store answers
+ * false to and this function ignores. NEVER THROWS: a lost mark costs a later poll, never a reply.
+ *
+ * 🔴 IT IS ALSO BOUNDED, WHICH IS THE OTHER HALF OF THAT CONTRACT. The one caller is
+ * `liveGitHubPost`, on the reply tool's own path, and it calls this AFTER the comment has landed. An
+ * unbounded await therefore could not lose a reply but could hold the tool's return for as long as
+ * the store took — a real hazard on a tree that already stalls in its post-turn closeout. So the
+ * write RACES {@link GITHUB_POSTED_MARK_TIMEOUT_MS}: a store slower than that is treated exactly
+ * like the store that throws, and costs a later poll rather than the turn.
+ *
+ * The abandoned write is not cancelled — nothing here can cancel a store call — so it carries its
+ * own settled handler and may still land after this returns. That is the harmless direction: the
+ * claim is idempotent and its only reader is the next poll.
+ */
+export declare function markGitHubConversationPosted(owner: string | undefined, repo: string | undefined, number: number | undefined, atIso: string): Promise<void>;
+/**
+ * Is the agent IN this conversation — has this bundle's reply path posted here, or did an @mention
+ * engage the container? Either answers yes; see the header for why both reads are needed.
+ *
+ * FAIL-OPEN on a store error, and on a delivery that names no container: an unanswerable question
+ * admits the poll, whose own parse then refuses a delivery that names nothing.
+ */
+export declare function githubConversationInScope(surfaceKey: string, owner: string | undefined, repo: string | undefined, number: number | undefined): Promise<boolean>;
+/** What one budget check decided, and what it counted. `polls` is the count INCLUDING this one when
+ *  the check admitted it, so a caller can log the pressure without a second read. */
+export interface GitHubPollBudgetVerdict {
+    readonly admitted: boolean;
+    readonly polls: number;
+}
+/**
+ * Spend one poll from this repository's hourly budget.
+ *
+ * Admits and counts while the hour has room; refuses once the budget is spent, and writes ONE
+ * {@link GITHUB_REACTION_POLL_BUDGET_ACTION} row for that hour rather than one per refused delivery —
+ * the refusals are the loud part of a busy hour, and an unthrottled row per delivery would be the
+ * same flood in the audit log that the budget exists to stop in GitHub's API.
+ *
+ * FAIL-OPEN on a store error: an unreadable counter admits the poll. A budget is a cost bound, so a
+ * store blip must never silence the feedback signal.
+ */
+export declare function spendGitHubPollBudget(owner: string, repo: string, atIso: string, budget?: number): Promise<GitHubPollBudgetVerdict>;
+/**
+ * Write the one row that says this poll's claim store could not be read.
+ *
+ * 🔴 WHY IT EXISTS. The reaction dedupe (channels/github-reaction-feedback.ts) fails CLOSED on an
+ * unreadable claim — an unknown answer counts as ALREADY RECORDED — which is the right posture for
+ * what the audit log claims happened, and a silent one. A store that stays unreadable therefore
+ * records nothing at all, forever, and the operator sees a feature that looks healthy and reports
+ * zero. This row is the difference between "nobody reacted" and "the store is down".
+ *
+ * ONE ROW PER POLL, never one per reaction: a busy comment page holds dozens of reactions and one
+ * broken store would write a row for each. `skipped` carries the count instead, so the row is as
+ * loud as the flood would have been. That is a DIFFERENT GRAIN from the budget trip below, which
+ * `markEventSeen` throttles to one row per repository per hour — this one has no throttle, because a
+ * poll that could not read the store is a distinct event and the count is the thing being reported.
+ *
+ * 🔴 WHAT BOUNDS THE VOLUME, HONESTLY. The poll reaches here only past gate 2, so an ordinary hour
+ * holds at most {@link GITHUB_REACTION_POLL_HOURLY_BUDGET} of these per repository — but only WHILE
+ * THE BUDGET COUNTER IS WRITABLE. Gate 2 fails open on a store error, so a fault that breaks the
+ * `task_result` write while `audit_log` inserts still land gives one row per delivery instead. That
+ * is the same trade the gate already made, and both directions of it are a cost, never a lost row.
+ *
+ * 🔴 AND IT IS NOT A SIGNAL FOR EVERY OUTAGE. `appendAudit` writes through the SAME operational
+ * store whose claim read just threw, so a whole-store outage loses this row too — best-effort, one
+ * retry, then a drop-counter tick and a `[open-everywhere:audit] dropped a …` warn (core
+ * agent/audit/audit.ts). This row is what makes a PARTIAL fault legible — a missing `notice_claim`
+ * table, a table-level grant — and the audit drop counter is what makes the total one legible. The
+ * operator doc states the same split.
+ *
+ * Best-effort, like every other write in this module: nothing here may cost the ingress its ack.
+ */
+export declare function auditGitHubReactionClaimUnreadable(owner: string, repo: string, atIso: string, skipped: number): Promise<void>;
+//# sourceMappingURL=github-reaction-scope.d.ts.map

package/dist/agent/channels/github-reaction-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-reaction-scope.d.ts","sourceRoot":"","sources":["../../../agent/channels/github-reaction-scope.ts"],"names":[],"mappings":"AAmFA;;;;;yCAKyC;AACzC,eAAO,MAAM,kCAAkC,KAAK,CAAC;AAMrD;sFACsF;AACtF,eAAO,MAAM,kCAAkC,gCAAgC,CAAC;AAEhF;;;;;gBAKgB;AAChB,eAAO,MAAM,uCAAuC,qCAAqC,CAAC;AAE1F;;;;;4EAK4E;AAC5E,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAclD;2DAC2D;AAC3D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BhK;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAgBrK;AAED;qFACqF;AACrF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,SAAqC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAsBrK;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,kCAAkC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAcnI"}