typeclaw 0.28.1 → 0.29.0

package/src/channels/adapters/github/index.ts

@@ -1,7 +1,7 @@
 import type { GithubTokenBridge } from '@/channels/github-token-bridge'
 import type { ChannelRouter } from '@/channels/router'
 import type { ChannelAdapterConfig, GithubAdapterConfig } from '@/channels/schema'
-import type { ChannelSelfIdentityResolver } from '@/channels/types'
+import type { ChannelSelfIdentityResolver, InboundMessage } from '@/channels/types'
 import { resolveSecret } from '@/secrets/resolve'
 import type { GithubSecretsBlock } from '@/secrets/schema'
 
@@ -21,6 +21,7 @@ import {
   parseListHooksPermissionStatus,
 } from './permission-guidance'
 import { createGithubReactionCallback, createGithubRemoveReactionCallback } from './reactions'
+import { reconcileOpenPrs } from './reconcile-open-prs'
 import { createGithubReviewStateResolver } from './review-state'
 import { createGithubReviewThreadResolver } from './review-thread-resolver'
 import { createTeamMembershipChecker } from './team-membership'
@@ -160,6 +161,19 @@ export function createGithubAdapter(options: GithubAdapterOptions): GithubAdapte
   const typing = async (): Promise<void> => {}
   const dedup = createDeliveryDedup()
   const isBotInTeam = createTeamMembershipChecker({ token: authToken, fetchImpl })
+  // Shared inbound entry. Both the live webhook handler and the startup
+  // reconciliation pass route through this so a replayed PR takes the exact
+  // same path a real delivery would.
+  const routeInbound = (message: InboundMessage): void => {
+    rememberWorkspace(message.workspace, message.chat)
+    // Ack-first: wrap in Promise.resolve so a synchronous throw inside
+    // router.route() cannot prevent the 200 response from being returned.
+    void Promise.resolve()
+      .then(() => options.router.route(message))
+      .catch((err: unknown) => {
+        logger.error(`[github] route failed: ${err instanceof Error ? err.message : String(err)}`)
+      })
+  }
   const handler = createGithubWebhookHandler({
     webhookSecret,
     dedup,
@@ -173,16 +187,7 @@ export function createGithubAdapter(options: GithubAdapterOptions): GithubAdapte
     authToken,
     fetchImpl,
     logger,
-    route: (message) => {
-      rememberWorkspace(message.workspace, message.chat)
-      // Ack-first: wrap in Promise.resolve so a synchronous throw inside
-      // router.route() cannot prevent the 200 response from being returned.
-      void Promise.resolve()
-        .then(() => options.router.route(message))
-        .catch((err: unknown) => {
-          logger.error(`[github] route failed: ${err instanceof Error ? err.message : String(err)}`)
-        })
-    },
+    route: routeInbound,
   })
 
   return {
@@ -330,6 +335,26 @@ export function createGithubAdapter(options: GithubAdapterOptions): GithubAdapte
         )
         logRegistrationOutcome(logger, registration, options.secrets.auth.type)
       }
+      // Catch up on PRs whose opened/ready_for_review/review_requested delivery
+      // was missed (tunnel-URL churn, dropped delivery, downtime). Best-effort
+      // and last so a failure here never blocks the adapter from coming up; the
+      // helper swallows per-repo errors internally. Runs on every start(), so a
+      // tunnel-driven restart re-checks too. `off` short-circuits inside.
+      if (repos.length > 0) {
+        await reconcileOpenPrs({
+          repos,
+          reviewOn: cfg.review.on,
+          selfLogin,
+          authType: options.secrets.auth.type,
+          token: authToken,
+          route: routeInbound,
+          logger,
+          isBotInTeam,
+          fetchImpl,
+        }).catch((err: unknown) => {
+          logger.warn(`[github] reconcile pass failed: ${err instanceof Error ? err.message : String(err)}`)
+        })
+      }
     },
     async stop(): Promise<void> {
       if (!started) return

package/src/channels/adapters/github/reconcile-open-prs.ts

@@ -0,0 +1,306 @@
+import type { GithubReviewOn } from '@/channels/schema'
+import type { InboundMessage } from '@/channels/types'
+
+import type { GithubAuthContext } from './auth'
+import { GITHUB_API_BASE, githubJsonHeaders } from './auth-pat'
+import type { TeamMembershipChecker } from './team-membership'
+
+// Catches up on review work that a live webhook delivery missed. The github
+// adapter only acts on deliveries it receives, so a `pull_request.opened` /
+// `ready_for_review` dropped while the tunnel URL was churning (cloudflare-quick
+// mints a fresh host every restart) leaves an open PR permanently un-reviewed —
+// nothing wakes the bot for it again. This pass runs on every adapter start()
+// (cold boot AND tunnel-driven restart) and replays the PRs that still need a
+// review as synthetic inbounds through the same router path a real webhook uses.
+//
+// It is intentionally NOT a substitute for webhooks: it is a floor, not the
+// primary path. Drift between a missed delivery and the next start() is the
+// reconciliation window; webhooks remain the low-latency path when delivery
+// works.
+
+export type ReconcileOpenPrsOptions = {
+  repos: readonly string[]
+  reviewOn: GithubReviewOn
+  selfLogin: string | null
+  authType: 'pat' | 'app'
+  token: (context?: GithubAuthContext) => Promise<string>
+  route: (message: InboundMessage) => void
+  logger: { info: (m: string) => void; warn: (m: string) => void }
+  // Resolves whether the bot is a member of a requested team, gating
+  // team-requested reviews under review.on 'review_requested' (mirrors the
+  // live webhook path's isMyTeam check in classifyReviewRequest). Omitted in
+  // tests that don't exercise team requests; treated as "not a member".
+  isBotInTeam?: TeamMembershipChecker
+  fetchImpl?: typeof fetch
+}
+
+export type ReconcileOutcome = { repo: string; scanned: number; replayed: number } | { repo: string; error: string }
+
+const BOT_LOGIN_SUFFIX = '[bot]'
+
+export async function reconcileOpenPrs(options: ReconcileOpenPrsOptions): Promise<ReconcileOutcome[]> {
+  // `off` disables code review entirely, so there is nothing to catch up on.
+  if (options.reviewOn === 'off') return []
+  if (options.selfLogin === null) return []
+  const fetchImpl = options.fetchImpl ?? fetch
+  const selfLogin = options.selfLogin
+  const decoyLogin = resolveDecoyLogin(selfLogin, options.authType)
+
+  const outcomes: ReconcileOutcome[] = []
+  for (const repo of new Set(options.repos)) {
+    const target = parseRepo(repo)
+    if (target === null) {
+      outcomes.push({ repo, error: 'malformed repo slug' })
+      continue
+    }
+    try {
+      const outcome = await reconcileRepo(target, options, selfLogin, decoyLogin, fetchImpl)
+      outcomes.push(outcome)
+      if (outcome.replayed > 0) {
+        options.logger.info(`[github] reconcile ${repo}: replayed ${outcome.replayed}/${outcome.scanned} open PR(s)`)
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      options.logger.warn(`[github] reconcile ${repo} failed: ${message}`)
+      outcomes.push({ repo, error: message })
+    }
+  }
+  return outcomes
+}
+
+async function reconcileRepo(
+  target: RepoTarget,
+  options: ReconcileOpenPrsOptions,
+  selfLogin: string,
+  decoyLogin: string | null,
+  fetchImpl: typeof fetch,
+): Promise<{ repo: string; scanned: number; replayed: number }> {
+  const repo = `${target.owner}/${target.repo}`
+  const token = await options.token({ repoSlug: repo })
+  const prs = await fetchOpenPrs(fetchImpl, token, target)
+
+  let replayed = 0
+  for (const pr of prs) {
+    const needs = await prNeedsReview({ pr, options, target, token, selfLogin, decoyLogin, fetchImpl })
+    if (!needs) continue
+    options.route(buildSyntheticInbound(pr, target))
+    replayed += 1
+  }
+  return { repo, scanned: prs.length, replayed }
+}
+
+async function prNeedsReview(input: {
+  pr: OpenPr
+  options: ReconcileOpenPrsOptions
+  target: RepoTarget
+  token: string
+  selfLogin: string
+  decoyLogin: string | null
+  fetchImpl: typeof fetch
+}): Promise<boolean> {
+  const { pr, options, target, token, selfLogin, decoyLogin, fetchImpl } = input
+  if (isSelfAuthored(pr, selfLogin, decoyLogin)) return false
+
+  if (options.reviewOn === 'review_requested') {
+    // Only the explicit request wakes a review under this mode. A draft can
+    // still carry a request, so draft state is irrelevant here. Mirrors the
+    // live path's `isMeAsUser || isMyTeam`: a direct user request, OR a team
+    // request the bot is a member of.
+    if (isUserReviewRequestedFromSelf(pr, selfLogin, decoyLogin)) return true
+    return await isTeamReviewRequestedFromSelf(pr, target, selfLogin, options.isBotInTeam)
+  }
+
+  // reviewOn === 'opened': a non-draft PR the bot has not yet reviewed. Draft
+  // PRs wait for the ready_for_review trigger, matching the live-webhook path.
+  if (pr.draft) return false
+  return !(await botAlreadyReviewed(fetchImpl, token, target, pr.number, selfLogin))
+}
+
+async function isTeamReviewRequestedFromSelf(
+  pr: OpenPr,
+  target: RepoTarget,
+  selfLogin: string,
+  isBotInTeam: TeamMembershipChecker | undefined,
+): Promise<boolean> {
+  if (isBotInTeam === undefined || pr.requestedTeamSlugs.length === 0) return false
+  for (const slug of pr.requestedTeamSlugs) {
+    if (await isBotInTeam({ org: target.owner, slug, login: selfLogin })) return true
+  }
+  return false
+}
+
+function buildSyntheticInbound(pr: OpenPr, target: RepoTarget): InboundMessage {
+  const branchSegment = pr.headRef !== null && pr.baseRef !== null ? ` Branch: ${pr.headRef} → ${pr.baseRef}.` : ''
+  const text =
+    `@${pr.authorLogin} opened PR #${pr.number}: "${pr.title}".${branchSegment}` +
+    ' Please review the changes line-by-line and post your feedback.'
+  // Distinct from the live `pr-<id>-opened-<updatedAt>` id so a replay never
+  // collides with a real opened delivery, while repeated reconciles for the
+  // same unchanged PR dedupe against each other (same updatedAt).
+  const externalMessageId = `pr-${pr.id}-reconcile-${pr.updatedAt}`
+  return {
+    adapter: 'github',
+    workspace: `${target.owner}/${target.repo}`,
+    chat: `pr:${pr.number}`,
+    thread: null,
+    text,
+    externalMessageId,
+    authorId: String(pr.authorId),
+    authorName: pr.authorLogin,
+    authorIsBot: pr.authorIsBot,
+    isBotMention: true,
+    replyToBotMessageId: null,
+    mentionsOthers: false,
+    replyToOtherMessageId: null,
+    isDm: false,
+    ts: pr.updatedAt !== '' ? Date.parse(pr.updatedAt) || 0 : 0,
+  }
+}
+
+type RepoTarget = { owner: string; repo: string }
+
+type OpenPr = {
+  number: number
+  id: number
+  title: string
+  draft: boolean
+  authorLogin: string
+  authorId: number
+  authorIsBot: boolean
+  headRef: string | null
+  baseRef: string | null
+  updatedAt: string
+  requestedReviewerLogins: string[]
+  requestedTeamSlugs: string[]
+}
+
+function parseRepo(slug: string): RepoTarget | null {
+  const [owner, repo, ...rest] = slug.trim().split('/')
+  if (owner === undefined || owner === '' || repo === undefined || repo === '' || rest.length > 0) return null
+  return { owner, repo }
+}
+
+async function fetchOpenPrs(fetchImpl: typeof fetch, token: string, target: RepoTarget): Promise<OpenPr[]> {
+  const prs: OpenPr[] = []
+  let url: string | null = `${GITHUB_API_BASE}/repos/${target.owner}/${target.repo}/pulls?state=open&per_page=100`
+  while (url !== null) {
+    const response = await fetchImpl(url, { headers: githubJsonHeaders(token) })
+    if (!response.ok) {
+      const body = await response.text().catch(() => '')
+      throw new Error(`GitHub pulls ${response.status}${body !== '' ? `: ${body}` : ''}`)
+    }
+    const page = (await response.json().catch(() => null)) as PrRow[] | null
+    if (page === null) throw new Error('GitHub pulls returned non-JSON')
+    for (const row of page) {
+      const parsed = parsePrRow(row)
+      if (parsed !== null) prs.push(parsed)
+    }
+    url = nextLink(response.headers.get('link'))
+  }
+  return prs
+}
+
+async function botAlreadyReviewed(
+  fetchImpl: typeof fetch,
+  token: string,
+  target: RepoTarget,
+  prNumber: number,
+  selfLogin: string,
+): Promise<boolean> {
+  let url: string | null =
+    `${GITHUB_API_BASE}/repos/${target.owner}/${target.repo}/pulls/${prNumber}/reviews?per_page=100`
+  while (url !== null) {
+    const response = await fetchImpl(url, { headers: githubJsonHeaders(token) })
+    if (!response.ok) {
+      const body = await response.text().catch(() => '')
+      throw new Error(`GitHub reviews ${response.status}${body !== '' ? `: ${body}` : ''}`)
+    }
+    const page = (await response.json().catch(() => null)) as ReviewRow[] | null
+    if (page === null) throw new Error('GitHub reviews returned non-JSON')
+    for (const row of page) {
+      const login = row.user?.login ?? null
+      if (login === null) continue
+      if (isSelfLogin(login, row.user?.type === 'Bot', selfLogin)) return true
+    }
+    url = nextLink(response.headers.get('link'))
+  }
+  return false
+}
+
+function isUserReviewRequestedFromSelf(pr: OpenPr, selfLogin: string, decoyLogin: string | null): boolean {
+  return pr.requestedReviewerLogins.some(
+    (login) => isSelfLogin(login, login.endsWith(BOT_LOGIN_SUFFIX), selfLogin) || login === decoyLogin,
+  )
+}
+
+function isSelfAuthored(pr: OpenPr, selfLogin: string, decoyLogin: string | null): boolean {
+  return isSelfLogin(pr.authorLogin, pr.authorIsBot, selfLogin) || pr.authorLogin === decoyLogin
+}
+
+// Mirrors review-state.ts isSelfReviewer: a GitHub App's REST login is
+// `slug[bot]`, so the `[bot]` suffix-strip comparison is gated on the actor
+// actually being a Bot to avoid attributing a human who owns the bare slug.
+function isSelfLogin(login: string, isBot: boolean, selfLogin: string): boolean {
+  if (isBot) return normalizeBotLogin(login) === normalizeBotLogin(selfLogin)
+  return login === selfLogin
+}
+
+function normalizeBotLogin(login: string): string {
+  return login.endsWith(BOT_LOGIN_SUFFIX) ? login.slice(0, -BOT_LOGIN_SUFFIX.length) : login
+}
+
+// A GitHub App actor's REST login is `slug[bot]`; the decoy account an operator
+// requests for App-auth reviews is the bare slug. PAT auth has no decoy.
+function resolveDecoyLogin(selfLogin: string, authType: 'pat' | 'app'): string | null {
+  if (authType !== 'app') return null
+  if (!selfLogin.endsWith(BOT_LOGIN_SUFFIX)) return null
+  const slug = selfLogin.slice(0, -BOT_LOGIN_SUFFIX.length)
+  return slug !== '' ? slug : null
+}
+
+function nextLink(linkHeader: string | null): string | null {
+  if (linkHeader === null) return null
+  for (const part of linkHeader.split(',')) {
+    const m = /<([^>]+)>;\s*rel="next"/.exec(part)
+    if (m !== null) return m[1] ?? null
+  }
+  return null
+}
+
+type PrRow = {
+  number?: unknown
+  id?: unknown
+  title?: unknown
+  draft?: unknown
+  updated_at?: unknown
+  user?: { login?: unknown; id?: unknown; type?: unknown }
+  head?: { ref?: unknown }
+  base?: { ref?: unknown }
+  requested_reviewers?: Array<{ login?: unknown }>
+  requested_teams?: Array<{ slug?: unknown }>
+}
+
+type ReviewRow = { user?: { login?: string; type?: string } }
+
+function parsePrRow(row: PrRow): OpenPr | null {
+  const number = typeof row.number === 'number' ? row.number : null
+  const id = typeof row.id === 'number' ? row.id : null
+  const authorLogin = typeof row.user?.login === 'string' ? row.user.login : null
+  if (number === null || id === null || authorLogin === null) return null
+  return {
+    number,
+    id,
+    title: typeof row.title === 'string' ? row.title : `#${number}`,
+    draft: row.draft === true,
+    authorLogin,
+    authorId: typeof row.user?.id === 'number' ? row.user.id : 0,
+    authorIsBot: row.user?.type === 'Bot',
+    headRef: typeof row.head?.ref === 'string' ? row.head.ref : null,
+    baseRef: typeof row.base?.ref === 'string' ? row.base.ref : null,
+    updatedAt: typeof row.updated_at === 'string' ? row.updated_at : '',
+    requestedReviewerLogins: (row.requested_reviewers ?? []).flatMap((r) =>
+      typeof r.login === 'string' ? [r.login] : [],
+    ),
+    requestedTeamSlugs: (row.requested_teams ?? []).flatMap((t) => (typeof t.slug === 'string' ? [t.slug] : [])),
+  }
+}

package/src/channels/adapters/github/review-state.ts

@@ -31,11 +31,20 @@ export function createGithubReviewStateResolver(deps: {
     }
 
     const token = await deps.token({ repoSlug: `${target.owner}/${target.repo}` })
-    const reviews = await fetchSelfReviews(fetchImpl, token, target, selfLogin)
+    const [reviews, reviewDecision] = await Promise.all([
+      fetchSelfReviews(fetchImpl, token, target, selfLogin),
+      fetchReviewDecision(fetchImpl, token, target),
+    ])
     if (!reviews.ok) return { ok: false, error: reviews.error, code: reviews.code }
+    if (!reviewDecision.ok) return { ok: false, error: reviewDecision.error, code: reviewDecision.code }
 
     const lastDecisive = reviews.states.filter(isDecisive).at(-1) ?? null
-    return { ok: true, selfBlocking: lastDecisive === 'CHANGES_REQUESTED', approve }
+    return {
+      ok: true,
+      selfBlocking: lastDecisive === 'CHANGES_REQUESTED',
+      approve,
+      ...(reviewDecision.reviewDecision !== null ? { reviewDecision: reviewDecision.reviewDecision } : {}),
+    }
   }
 }
 
@@ -55,6 +64,12 @@ type SelfReviewsResult =
   | { ok: true; states: string[] }
   | { ok: false; error: string; code: 'not-found' | 'permission-denied' | 'transient' }
 
+type ReviewDecision = 'APPROVED' | 'CHANGES_REQUESTED' | 'REVIEW_REQUIRED'
+
+type ReviewDecisionResult =
+  | { ok: true; reviewDecision: ReviewDecision | null }
+  | { ok: false; error: string; code: 'not-found' | 'permission-denied' | 'transient' }
+
 async function fetchSelfReviews(
   fetchImpl: typeof fetch,
   token: string,
@@ -94,6 +109,47 @@ async function fetchSelfReviews(
   return { ok: true, states }
 }
 
+async function fetchReviewDecision(
+  fetchImpl: typeof fetch,
+  token: string,
+  target: Target,
+): Promise<ReviewDecisionResult> {
+  let response: Response
+  try {
+    response = await fetchImpl(`${GITHUB_API_BASE}/graphql`, {
+      method: 'POST',
+      headers: githubJsonHeaders(token),
+      body: JSON.stringify({
+        query:
+          'query($owner:String!,$repo:String!,$number:Int!){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewDecision}}}',
+        variables: { owner: target.owner, repo: target.repo, number: target.prNumber },
+      }),
+    })
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err), code: 'transient' }
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => '')
+    return {
+      ok: false,
+      error: `GitHub reviewDecision ${response.status}${text !== '' ? `: ${text}` : ''}`,
+      code: classifyStatus(response.status),
+    }
+  }
+  const raw = (await response.json().catch(() => null)) as ReviewDecisionResponse | null
+  if (raw === null) return { ok: false, error: 'GitHub reviewDecision returned non-JSON', code: 'transient' }
+  if (Array.isArray(raw.errors) && raw.errors.length > 0) {
+    return {
+      ok: false,
+      error: `GitHub reviewDecision errors: ${raw.errors.map(describeGraphqlError).join('; ')}`,
+      code: 'transient',
+    }
+  }
+  const value = raw.data?.repository?.pullRequest?.reviewDecision ?? null
+  if (value === null || isReviewDecision(value)) return { ok: true, reviewDecision: value }
+  return { ok: false, error: `GitHub reviewDecision returned unknown value: ${String(value)}`, code: 'transient' }
+}
+
 // A formal CHANGES_REQUESTED is sticky until a later APPROVED/DISMISSED; only
 // these three states decide the block. COMMENTED and PENDING are non-deciding
 // noise that must NOT shadow an earlier CHANGES_REQUESTED.
@@ -135,3 +191,16 @@ function classifyStatus(status: number): 'not-found' | 'permission-denied' | 'tr
 }
 
 type ReviewRow = { id?: number; state?: unknown; user?: { login?: string; type?: string } }
+
+type ReviewDecisionResponse = {
+  data?: { repository?: { pullRequest?: { reviewDecision?: unknown } | null } | null }
+  errors?: Array<{ message?: unknown }>
+}
+
+function isReviewDecision(value: unknown): value is ReviewDecision {
+  return value === 'APPROVED' || value === 'CHANGES_REQUESTED' || value === 'REVIEW_REQUIRED'
+}
+
+function describeGraphqlError(error: { message?: unknown }): string {
+  return typeof error.message === 'string' ? error.message : JSON.stringify(error)
+}

package/src/channels/adapters/kakaotalk-classify.ts

@@ -7,8 +7,8 @@ import type { InboundAttachment, InboundMessage, InboundReferenceContext } from
 export type InboundDropReason = 'self_author' | 'empty_text' | 'unknown_chat' | 'pre_connect' | 'bot_message'
 
 // LOCO message_type 71 is KakaoTalk's notification/feed channel — official
-// accounts like "카카오 고객센터" and "카카오계정" (login alerts, security
-// notices, system messages). These arrive in @kakao-group buckets because
+// accounts like "KakaoTalk Customer Center" and "Kakao Account" (login alerts,
+// security notices, system messages). These arrive in @kakao-group buckets because
 // they aren't normal user chats, but they are not human conversation and
 // the agent should never reply to them. Not enumerated in
 // agent-messenger's `KAKAO_MESSAGE_TYPE` because that const only covers

package/src/channels/adapters/kakaotalk.ts

@@ -436,7 +436,7 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
       )
 
       // Ack the message BEFORE classify/route so the sender's unread "1"
-      // (노란숫자) clears even when we drop the message (self-author,
+      // (the yellow unread badge) clears even when we drop the message (self-author,
       // unknown chat, empty text, etc.). The receiver of a kakao adapter is
       // expected to behave like a "read it as soon as it arrives" client —
       // the agent has observed the bytes, so the user should see the read
@@ -729,7 +729,7 @@ function dropHint(reason: InboundDropReason): string {
     case 'unknown_chat':
       return ' (chat not in cache after refresh and provisional registration; check earlier resolver-refresh-failed warnings)'
     case 'bot_message':
-      return ' (LOCO message_type=71 is KakaoTalk notification/feed; official accounts like 카카오 고객센터 / 카카오계정 / login alerts)'
+      return ' (LOCO message_type=71 is KakaoTalk notification/feed; official accounts like KakaoTalk Customer Center / Kakao Account / login alerts)'
     case 'empty_text':
     case 'pre_connect':
     case 'self_author':

package/src/channels/adapters/slack-bot-classify.ts

@@ -86,7 +86,7 @@ export function classifyInbound(
   // without any new config surface.
   const hasGroupMention = GROUP_MENTION_PATTERN.test(rawText)
   const isBotMention = hasGroupMention || rawText.includes(`<@${context.botUserId}>`)
-  // Top-level alias addressing (e.g. "윙키야") is engagement-equivalent
+  // Top-level alias addressing (e.g. "Momo!" / "@Momo" by name) is engagement-equivalent
   // to a `<@bot>` mention (see engagement.ts: alias is unconditional and
   // ranks alongside explicit triggers). Anchor `thread` on the inbound
   // ts in that case too, so the bot's reply threads under the user's

package/src/channels/adapters/slack-bot.ts

@@ -1213,6 +1213,7 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
       options.router.registerReaction('slack-bot', reactionCallback)
       options.router.registerRemoveReaction('slack-bot', removeReactionCallback)
       options.router.registerTyping('slack-bot', typingCallback)
+      options.router.setTypingCapability('slack-bot', true)
       options.router.registerChannelNameResolver('slack-bot', channelResolver)
       options.router.registerSelfIdentity('slack-bot', selfIdentityResolver)
       options.router.registerHistory('slack-bot', historyCallback)
@@ -1230,6 +1231,7 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
         options.router.unregisterReaction('slack-bot', reactionCallback)
         options.router.unregisterRemoveReaction('slack-bot', removeReactionCallback)
         options.router.unregisterTyping('slack-bot', typingCallback)
+        options.router.setTypingCapability('slack-bot', false)
         options.router.unregisterChannelNameResolver('slack-bot', channelResolver)
         options.router.unregisterSelfIdentity('slack-bot', selfIdentityResolver)
         options.router.unregisterHistory('slack-bot', historyCallback)
@@ -1251,6 +1253,7 @@ export function createSlackBotAdapter(options: SlackBotAdapterOptions): SlackBot
       options.router.unregisterReaction('slack-bot', reactionCallback)
       options.router.unregisterRemoveReaction('slack-bot', removeReactionCallback)
       options.router.unregisterTyping('slack-bot', typingCallback)
+      options.router.setTypingCapability('slack-bot', false)
       options.router.unregisterChannelNameResolver('slack-bot', channelResolver)
       options.router.unregisterSelfIdentity('slack-bot', selfIdentityResolver)
       options.router.unregisterHistory('slack-bot', historyCallback)

package/src/channels/adapters/telegram-bot.ts

@@ -529,6 +529,7 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
 
       options.router.registerOutbound('telegram-bot', outboundCallback)
       options.router.registerTyping('telegram-bot', typingCallback)
+      options.router.setTypingCapability('telegram-bot', true)
       options.router.registerChannelNameResolver('telegram-bot', channelResolver)
       options.router.registerSelfIdentity('telegram-bot', selfIdentityResolver)
       options.router.registerFetchAttachment('telegram-bot', fetchAttachmentCallback)
@@ -537,6 +538,7 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
       const rollbackStart = (reason: string, cause: Error): never => {
         options.router.unregisterOutbound('telegram-bot', outboundCallback)
         options.router.unregisterTyping('telegram-bot', typingCallback)
+        options.router.setTypingCapability('telegram-bot', false)
         options.router.unregisterChannelNameResolver('telegram-bot', channelResolver)
         options.router.unregisterSelfIdentity('telegram-bot', selfIdentityResolver)
         options.router.unregisterFetchAttachment('telegram-bot', fetchAttachmentCallback)
@@ -565,6 +567,7 @@ export function createTelegramBotAdapter(options: TelegramBotAdapterOptions): Te
       started = false
       options.router.unregisterOutbound('telegram-bot', outboundCallback)
       options.router.unregisterTyping('telegram-bot', typingCallback)
+      options.router.setTypingCapability('telegram-bot', false)
       options.router.unregisterChannelNameResolver('telegram-bot', channelResolver)
       options.router.unregisterSelfIdentity('telegram-bot', selfIdentityResolver)
       options.router.unregisterFetchAttachment('telegram-bot', fetchAttachmentCallback)

package/src/channels/engagement.ts

@@ -89,6 +89,8 @@ export function decideEngagement(input: EngagementInput): EngagementDecision {
   if (config.trigger.includes('mention') && message.isBotMention) return 'engage'
   if (config.trigger.includes('reply') && message.replyToBotMessageId !== null) return 'engage'
 
+  const explicitOnly = message.suppressSticky === true
+
   // Multi-human pre-sticky target check. In a busy group the conversational
   // target shifts every message: the author we're mid-exchange with (and hold
   // a sticky credit for) may, on THIS turn, structurally address a third party
@@ -112,12 +114,13 @@ export function decideEngagement(input: EngagementInput): EngagementDecision {
   // The `!matchesAnyAlias` guard preserves the ladder invariant "explicit
   // address to us beats structural targeting of others": a message that names
   // us by alias engages on the alias rule below even when it ALSO tags a third
-  // party (the "봉봉아 펭펭아 둘 다 봐" multi-bot case), so we must not pre-empt
+  // party (the "Toto, Lala, both take a look" multi-bot case), so we must not pre-empt
   // it here. We only step aside for a credited author whose message is aimed
   // PURELY elsewhere.
   if (
     effectiveHumans > 1 &&
     config.stickiness !== 'off' &&
+    !explicitOnly &&
     !matchesAnyAlias(message.text, selfAliases) &&
     targetsSomeoneElse(message, participants, botInThread)
   ) {
@@ -134,7 +137,9 @@ export function decideEngagement(input: EngagementInput): EngagementDecision {
   // groups wholesale (the prior approach) dropped genuine follow-ups outright;
   // the pre-check above is narrower — it only steps aside when the message is
   // STRUCTURALLY addressed elsewhere, leaving plain follow-ups engaged.
-  if (config.stickiness !== 'off' && ledger.consume(key, message.authorId, now)) {
+  // GitHub review-thread traffic must not spend content-blind sticky credit
+  // unless the bot was explicitly addressed.
+  if (!explicitOnly && config.stickiness !== 'off' && ledger.consume(key, message.authorId, now)) {
     return 'engage'
   }
 
@@ -143,12 +148,12 @@ export function decideEngagement(input: EngagementInput): EngagementDecision {
   // same priority as an explicit mention — operators add aliases
   // precisely because they expect the bot to respond when called by
   // name. Suppression on `mentionsOthers` would defeat the point: the
-  // user can address two bots by name in one message ("봉봉아 펭펭아 둘
-  // 다 봐") and both should engage. Each bot only knows its own
+  // user can address two bots by name in one message ("Toto, Lala, both
+  // take a look") and both should engage. Each bot only knows its own
   // aliases, so cross-bot suppression isn't possible at this layer
   // anyway — the router-side peer-name suppression in the solo-human
   // fallback handles that case (follow-up).
-  if (matchesAnyAlias(message.text, selfAliases)) return 'engage'
+  if (!explicitOnly && matchesAnyAlias(message.text, selfAliases)) return 'engage'
 
   // Solo-human fallback: the strict mention/reply/dm gate keeps the bot
   // quiet in multi-human conversations, but in a 1-human channel that
@@ -176,8 +181,8 @@ export function decideEngagement(input: EngagementInput): EngagementDecision {
   // who don't want to type `@bot` in their own DM-like channel; peer bots
   // have no such ergonomic excuse. Letting peer bots ride the fallback
   // produced bot-to-bot conversations in 1-human-N-bot channels (observed:
-  // Winky and 돌쇠 introducing themselves to each other after a single
-  // "얘들아" from the human, then continuing to address each other for
+  // Momo and Kiki introducing themselves to each other after a single
+  // "hey folks" from the human, then continuing to address each other for
   // ~6 turns). The router's loop guard only trips after 5 consecutive
   // peer engagements, which is too late to prevent the embarrassment.
   //