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

package/agent/channels/github-engagement.ts

@@ -0,0 +1,381 @@
+// 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,
+  type EngagementRow,
+  type Partition,
+} from "@open-everywhere/core/agent/adapter-api.js";
+import { buildGitHubAuth, githubConversationKey } from "./github-identity.js";
+import type { GitHubAmbientAddressing } from "./github-supervisor.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: string | undefined, repo: string | undefined, num: number | undefined): string | undefined {
+  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: GitHubSeamFacts): Partition | null {
+  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;
+  }
+}
+
+/** The facts one comment delivery contributes to the seam. Both legs can build it — the native
+ *  handler from eve's inbound context, the ambient leg from the raw webhook event — so neither
+ *  re-states the policy below. */
+export interface GitHubSeamFacts {
+  readonly owner: string;
+  readonly repo: string;
+  /** The issue or pull-request number the comment landed on. */
+  readonly number: number | undefined;
+  readonly isPrivate?: boolean;
+  /** The comment author's login — the principal this delivery binds. It rides the facts rather than
+   *  being stubbed here so the partition the seam keys is built from the delivery's own identity. */
+  readonly actorLogin: string;
+  /** The comment @mentions this deployment's app (the caller's own `githubBotMentioned` verdict). */
+  readonly isMention: boolean;
+  /** The comment was written by a bot or by this app itself — never delivered (loop guard). */
+  readonly authorIsBot: boolean;
+  /** The container this comment landed in, in GitHub's own vocabulary — `issue`, `pull_request` or
+   *  `review_thread`. The seam reads it for one question, in
+   *  {@link githubEngagedFollowUpReach}: an INLINE review comment shares its pull request's anchor,
+   *  so a review thread is not a container of its own. Required rather than optional, because a
+   *  caller that forgets it would silently widen that arm. */
+  readonly conversationKind: string | undefined;
+}
+
+/**
+ * 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: GitHubSeamFacts): { readonly reachable: boolean; readonly reason: string } {
+  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" };
+}
+
+/**
+ * What the seam says about one inbound comment. Four outcomes, each naming what the CALLER owes:
+ *
+ *  • `unanchored` — the delivery names no container, so there is no row to address and the caller
+ *    keeps today's path exactly.
+ *  • `engage` — an @mention. The caller marks the container engaged ({@link markGitHubEngaged}); the
+ *    mention itself is answered by the caller's own path, never by the seam.
+ *  • `deliver` — a plain comment in an engaged container. The caller wakes a turn.
+ *  • `hold` — a plain comment the seam does not admit. `stopped` says WHY, and it is the one field a
+ *    caller must branch on: `stopped: true` means the agent was asked to stand down in this
+ *    container, so the comment must be SUPPRESSED outright — including on the ambient leg, which
+ *    does not otherwise read this registry. `stopped: false` means the container simply is not
+ *    engaged, which is not a suppression: the caller keeps today's path.
+ */
+export type GitHubEngagementVerdict =
+  | { readonly kind: "unanchored"; readonly reason: string }
+  | { readonly kind: "engage"; readonly anchor: string }
+  | { readonly kind: "deliver"; readonly anchor: string; readonly reason: string }
+  | { readonly kind: "hold"; readonly anchor: string; readonly reason: string; readonly stopped: boolean };
+
+/** Injectable seams so the whole verdict is unit-tested without a store. */
+export interface GitHubEngagementDeps {
+  readonly getEngagement?: (p: Partition, anchor: string) => Promise<EngagementRow | null>;
+  readonly markEngaged?: (p: Partition, anchor: string, atIso: string) => Promise<void>;
+  /** The mark's durable once-guard — see {@link markGitHubEngaged}. Injected so a test can drive a
+   *  redelivered @mention without an operational store. */
+  readonly markEventSeen?: (org: string, key: string, atIso: string) => Promise<boolean>;
+  readonly now?: () => string;
+}
+
+/**
+ * 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: GitHubSeamFacts, deps: GitHubEngagementDeps = {}): Promise<GitHubEngagementVerdict> {
+  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: GitHubSeamFacts, commentId: string | number | undefined, deps: GitHubEngagementDeps = {}): Promise<string | null> {
+  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: string, key: string, atIso: string): Promise<boolean> {
+  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: string | undefined, authorType: string | undefined, botSlug: string | undefined): boolean {
+  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: GitHubSeamFacts, deps: GitHubEngagementDeps = {}): Promise<boolean> {
+  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: GitHubAmbientAddressing,
+  engagedFollowUp: boolean | undefined,
+): GitHubAmbientAddressing | "thread-follow" {
+  return addressing === "channel-watch" && engagedFollowUp === true ? "thread-follow" : addressing;
+}