typeclaw 0.25.0 → 0.27.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeclaw",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "homepage": "https://github.com/typeclaw/typeclaw#readme",
   "bugs": {
     "url": "https://github.com/typeclaw/typeclaw/issues"

package/src/agent/session-origin.ts

@@ -123,14 +123,20 @@ export const PARTICIPANTS_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000
 type PlatformInfo = {
   displayName: string
   mentionMode: 'angle-id' | 'at-username' | 'alias'
+  // Whether this adapter registers a ReactionCallback, i.e. whether
+  // `channel_react` actually does anything here. Gates the proactive-reaction
+  // prompt guidance so we never tell a KakaoTalk/Telegram agent to react when
+  // the call would no-op. Keep in sync with the adapters that call
+  // `router.registerReaction` (github, slack-bot, discord-bot today).
+  supportsReactions: boolean
 }
 
 const PLATFORM_INFO: Record<AdapterId, PlatformInfo> = {
-  'slack-bot': { displayName: 'Slack', mentionMode: 'angle-id' },
-  'discord-bot': { displayName: 'Discord', mentionMode: 'angle-id' },
-  github: { displayName: 'GitHub', mentionMode: 'at-username' },
-  'telegram-bot': { displayName: 'Telegram', mentionMode: 'at-username' },
-  kakaotalk: { displayName: 'KakaoTalk', mentionMode: 'alias' },
+  'slack-bot': { displayName: 'Slack', mentionMode: 'angle-id', supportsReactions: true },
+  'discord-bot': { displayName: 'Discord', mentionMode: 'angle-id', supportsReactions: true },
+  github: { displayName: 'GitHub', mentionMode: 'at-username', supportsReactions: true },
+  'telegram-bot': { displayName: 'Telegram', mentionMode: 'at-username', supportsReactions: false },
+  kakaotalk: { displayName: 'KakaoTalk', mentionMode: 'alias', supportsReactions: false },
 }
 
 function getPlatformInfo(adapter: AdapterId): PlatformInfo {
@@ -291,6 +297,7 @@ function renderChannelOrigin(
     chat: string
     chatName?: string
     thread: string | null
+    reactionRef?: ReactionRef
     participants?: readonly ChannelParticipant[]
     membership?: MembershipCount
     self?: ChannelSelfIdentity
@@ -348,6 +355,30 @@ function renderChannelOrigin(
   const conversationLine = renderConversationLine(origin)
   if (conversationLine !== null) lines.push('', conversationLine)
 
+  // Gate on `reactionRef`, not just the static `supportsReactions` platform
+  // fact: a turn only has a message to react to when the triggering inbound
+  // carried one. Reminder-only turns (restart-resume, subagent-completion,
+  // idle/todo continuation) wake the session with no inbound, so
+  // `buildLiveOrigin` omits `reactionRef`. Prompting "react like a teammate"
+  // there made the model call `channel_react`, which then denied with "this
+  // conversation has no message to react to".
+  if (platformInfo.supportsReactions && origin.reactionRef !== undefined) {
+    lines.push(
+      '',
+      '**React like a teammate would.** You can drop an emoji on the message that',
+      'triggered this turn with `channel_react({ emoji })` — it posts no comment,',
+      'just a reaction. Read the message and pick what genuinely fits its tone:',
+      '`+1` to agree or approve, `rocket` for something shipping or exciting,',
+      '`tada` to celebrate, `heart` to show appreciation, `laugh` for something',
+      'funny, `eyes` to signal you are looking. Reach for it when a reaction adds',
+      'real warmth or signal — not on every message, and not just because you can.',
+      'A reaction does NOT satisfy the reply obligation below: when the message',
+      'needs a substantive answer, still send it via `channel_reply`. Think of',
+      'reactions as the lightweight, human layer on top of your words, not a',
+      'replacement for them.',
+    )
+  }
+
   lines.push(
     '',
     '**For every user message in this session, you MUST call `channel_reply`',

package/src/agent/subagent-completion-reminder.ts

@@ -16,6 +16,7 @@ export type CompletionReminderArgs = {
   durationMs: number
   error?: string
   channel?: boolean
+  adapter?: string
 }
 
 const CHANNEL_REPLY_NUDGE =
@@ -28,9 +29,23 @@ const CHANNEL_REPLY_NUDGE =
   'can see why the post-completion turn was silent. `NO_REPLY` is the legacy fallback only when ' +
   '`skip_response` is unavailable.'
 
+// Conditional carve-out for github channel sessions. The base nudge above
+// steers EVERY completion to `channel_reply`, which on github is a plain PR
+// comment — fine for most subagents, but wrong for a finished `reviewer`:
+// a verdict delivered as a comment leaves the PR "awaiting review" with no
+// formal approval. This reminder cannot tell a review turn from any other
+// completion, so the carve-out is phrased conditionally ("if this was a PR
+// review") to redirect only the review case without misleading the rest.
+const GITHUB_REVIEW_NUDGE =
+  'If this was a PR review, the verdict is a formal review, not a `channel_reply`: ' +
+  'post it via `gh api -X POST /repos/owner/repo/pulls/<N>/reviews` (APPROVE/REQUEST_CHANGES/COMMENT) ' +
+  'and end the turn with `skip_response`. A `channel_reply` that merely says "Approved" posts a ' +
+  'comment and leaves the PR awaiting review.'
+
 export function renderSubagentCompletionReminder(args: CompletionReminderArgs): string {
   const durationStr = formatReminderDuration(args.durationMs)
-  const channelTail = args.channel === true ? ` ${CHANNEL_REPLY_NUDGE}` : ''
+  const githubTail = args.channel === true && args.adapter === 'github' ? ` ${GITHUB_REVIEW_NUDGE}` : ''
+  const channelTail = args.channel === true ? ` ${CHANNEL_REPLY_NUDGE}${githubTail}` : ''
   if (args.ok) {
     return (
       `<system-reminder>\n` +

package/src/agent/tools/channel-react.ts

@@ -31,12 +31,19 @@ export function createChannelReactTool({
     name: 'channel_react',
     label: 'Channel React',
     description:
-      'Add an emoji reaction to the message that triggered this turn — a lightweight acknowledgment that does not post a comment. ' +
-      'On GitHub this reacts to the triggering issue/PR/comment (e.g. :eyes: to signal "I am looking at this"). ' +
-      'Use this instead of a textual "on it" reply when a reaction is enough. Pass the bare emoji name, no colons.',
+      'React to the message that triggered this turn with an emoji that fits its content or tone — a lightweight, ' +
+      'human touch that posts no comment. Works on GitHub (issue/PR/comment), Slack, and Discord. ' +
+      'Pick the reaction a thoughtful teammate would leave: :+1: to agree or approve, :rocket: for something ' +
+      'shipping or exciting, :tada: to celebrate, :heart: to show appreciation, :eyes: to signal "I am looking at this", ' +
+      ':laugh: for something funny. Use it when a reaction adds genuine social signal — not on every message. ' +
+      'A reaction does NOT replace `channel_reply`: when the message needs a substantive answer, still send one. ' +
+      'If a reaction alone is the whole response, call `skip_response` afterward so the turn ends cleanly. ' +
+      'Pass the bare emoji name, no colons.',
     parameters: Type.Object({
       emoji: Type.String({
-        description: 'Bare emoji name, no surrounding colons. e.g. "eyes", "+1", "rocket", "heart".',
+        description:
+          'Bare emoji name, no surrounding colons. Choose one that matches the message: ' +
+          'e.g. "+1", "rocket", "tada", "heart", "eyes", "laugh".',
         minLength: 1,
       }),
     }),

package/src/bundled-plugins/reviewer/skills/code-review.ts

@@ -66,7 +66,9 @@ Prioritize in this order:
 
 ### Re-reviews must re-decide, not observe
 
-When the payload tells you this is a **re-review** — you (or this agent) previously requested changes on this PR and the author has pushed fixes and asked again — your verdict's whole purpose is to **re-decide the blocking state**, so:
+When the payload tells you this is a **re-review** — you (or this agent) previously requested changes on this PR and the author has pushed fixes — your verdict's whole purpose is to **re-decide the blocking state**, so:
+
+This includes payloads where the parent says the author **addressed your prior blocking feedback** — "fixed both issues", "addressed your review", "pushed a fix" — even when the inbound was phrased conversationally rather than as an explicit "review again". An author responding to the blocker you raised IS the re-review trigger; the absence of the words "review again" does not downgrade it to a \`comment\`. Re-decide:
 
 - Return **approve** if the blockers that drove the prior \`request-changes\` are resolved (leftover nits do not block — \`approve\` with inline nits is correct).
 - Return **request-changes** if any blocker remains or a new one appeared.

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

@@ -8,6 +8,8 @@ import type {
 import type { ChannelAdapterConfig } from '@/channels/schema'
 import type { InboundAttachment, InboundMessage } from '@/channels/types'
 
+import { encodeDiscordReactionRef } from './discord-bot-reactions'
+
 export type InboundDropReason =
   | 'self_author' // event.author.id === botUserId; we never route our own messages back to ourselves
   | 'empty_content' // SDK delivered content: '' — usually missing MessageContent intent
@@ -87,6 +89,7 @@ export function classifyInbound(
       text,
       ...(attachments.length > 0 ? { attachments } : {}),
       externalMessageId: event.id,
+      reactionRef: encodeDiscordReactionRef({ channel: event.channel_id, message: event.id }),
       authorId: event.author.id,
       // Discord's post-2023 username system allows pure-numeric handles (e.g.
       // "1411531"); the human-facing display name lives on `global_name`. The

package/src/channels/adapters/discord-bot-reactions.ts

@@ -0,0 +1,164 @@
+import type { DiscordBotClient } from 'agent-messenger/discordbot'
+
+import type {
+  ReactionCallback,
+  ReactionErrorCode,
+  ReactionRef,
+  ReactionResult,
+  RemoveReactionCallback,
+} from '@/channels/types'
+
+// The reactable target on Discord: a message is addressed by its channel id
+// plus the message id. The classifier stamps this because both values are on
+// the gateway event but `chat`/`externalMessageId` are the only ones that
+// survive into the routed payload — keeping them paired in an opaque ref means
+// the router/tool never have to reassemble Discord's addressing.
+export type DiscordReactionTarget = { channel: string; message: string }
+
+// `RemoveReactionRequest` carries no emoji (the router only round-trips the
+// success ref), so removal needs the resolved unicode folded into the ref:
+// Discord's DELETE is keyed by (channel, message, emoji). Mirrors Slack's
+// removal-ref pattern; GitHub instead carries a per-reaction id.
+export type DiscordReactionRemovalTarget = { channel: string; message: string; emoji: string }
+
+export function encodeDiscordReactionRef(target: DiscordReactionTarget): ReactionRef {
+  return { adapter: 'discord-bot', value: JSON.stringify(target) }
+}
+
+export function decodeDiscordReactionRef(ref: ReactionRef): DiscordReactionTarget | null {
+  if (ref.adapter !== 'discord-bot') return null
+  const parsed = parseRecord(ref.value)
+  if (parsed === null || parsed.op !== undefined) return null
+  const channel = typeof parsed.channel === 'string' ? parsed.channel : null
+  const message = typeof parsed.message === 'string' ? parsed.message : null
+  if (channel === null || message === null) return null
+  return { channel, message }
+}
+
+export function encodeDiscordRemovalRef(target: DiscordReactionRemovalTarget): ReactionRef {
+  return { adapter: 'discord-bot', value: JSON.stringify({ op: 'remove', ...target }) }
+}
+
+export function decodeDiscordRemovalRef(ref: ReactionRef): DiscordReactionRemovalTarget | null {
+  if (ref.adapter !== 'discord-bot') return null
+  const parsed = parseRecord(ref.value)
+  if (parsed === null || parsed.op !== 'remove') return null
+  const channel = typeof parsed.channel === 'string' ? parsed.channel : null
+  const message = typeof parsed.message === 'string' ? parsed.message : null
+  const emoji = typeof parsed.emoji === 'string' ? parsed.emoji : null
+  if (channel === null || message === null || emoji === null) return null
+  return { channel, message, emoji }
+}
+
+// Discord's reaction endpoint takes the literal unicode emoji (URL-encoded by
+// the SDK), NOT a `:name:` shortcode — the agent passes adapter-generic bare
+// names (`+1`, `rocket`), so we translate here. The set mirrors GitHub's fixed
+// reaction vocabulary so the same `channel_react({ emoji })` call works on both
+// platforms, plus a few extra chat-native acks. An unmapped name is reported as
+// `unsupported` rather than forwarded, so a typo gets a clear signal instead of
+// Discord's opaque `10014 Unknown Emoji`.
+const EMOJI_UNICODE: Record<string, string> = {
+  eyes: '👀',
+  '+1': '👍',
+  thumbsup: '👍',
+  '-1': '👎',
+  thumbsdown: '👎',
+  laugh: '😄',
+  hooray: '🎉',
+  tada: '🎉',
+  confused: '😕',
+  heart: '❤️',
+  rocket: '🚀',
+  white_check_mark: '✅',
+  'white-check-mark': '✅',
+  check: '✅',
+  fire: '🔥',
+  eye: '👁️',
+  raised_hands: '🙌',
+}
+
+function resolveEmoji(emoji: string): string | null {
+  const name = emoji.replace(/^:|:$/g, '')
+  return EMOJI_UNICODE[name] ?? null
+}
+
+export function createDiscordReactionCallback(deps: {
+  client: Pick<DiscordBotClient, 'addReaction'>
+}): ReactionCallback {
+  return async (req): Promise<ReactionResult> => {
+    if (req.adapter !== 'discord-bot') {
+      return { ok: false, error: `unknown adapter: ${req.adapter}`, code: 'unsupported' }
+    }
+    const unicode = resolveEmoji(req.emoji)
+    if (unicode === null) {
+      return { ok: false, error: `discord does not support reaction "${req.emoji}"`, code: 'unsupported' }
+    }
+    const target = decodeDiscordReactionRef(req.reactionRef)
+    if (target === null) return { ok: false, error: 'unparseable discord reaction ref', code: 'unsupported' }
+    try {
+      await deps.client.addReaction(target.channel, target.message, unicode)
+    } catch (err) {
+      return { ok: false, error: describe(err), code: classifyDiscordError(err) }
+    }
+    return { ok: true, reactionRef: encodeDiscordRemovalRef({ ...target, emoji: unicode }) }
+  }
+}
+
+export function createDiscordRemoveReactionCallback(deps: {
+  client: Pick<DiscordBotClient, 'removeReaction'>
+}): RemoveReactionCallback {
+  return async (req): Promise<ReactionResult> => {
+    if (req.adapter !== 'discord-bot') {
+      return { ok: false, error: `unknown adapter: ${req.adapter}`, code: 'unsupported' }
+    }
+    const target = decodeDiscordRemovalRef(req.reactionRef)
+    if (target === null) return { ok: false, error: 'unparseable discord reaction removal ref', code: 'unsupported' }
+    try {
+      await deps.client.removeReaction(target.channel, target.message, target.emoji)
+    } catch (err) {
+      return { ok: false, error: describe(err), code: classifyDiscordError(err) }
+    }
+    return { ok: true }
+  }
+}
+
+// DiscordBotError exposes the Discord error code on `.code` as a string. We
+// read it structurally so a wrapped/re-thrown error still classifies. The
+// numeric codes are Discord's documented JSON error codes; `http_4xx` is the
+// SDK's fallback when no JSON code is present.
+function classifyDiscordError(err: unknown): ReactionErrorCode {
+  const code = typeof err === 'object' && err !== null && 'code' in err ? String((err as { code: unknown }).code) : ''
+  switch (code) {
+    case '10003': // Unknown Channel
+    case '10008': // Unknown Message
+    case 'http_404':
+      return 'not-found'
+    case '50001': // Missing Access
+    case '50013': // Missing Permissions
+    case 'http_403':
+    case 'http_401':
+      return 'permission-denied'
+    case '10014': // Unknown Emoji
+      return 'unsupported'
+    case 'http_429':
+      return 'rate-limited'
+    default:
+      return 'transient'
+  }
+}
+
+function parseRecord(value: string): Record<string, unknown> | null {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(value)
+  } catch {
+    return null
+  }
+  return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : null
+}
+
+function describe(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}

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

@@ -39,6 +39,7 @@ import {
   type InboundDropReason,
   renderPlaceholder,
 } from './discord-bot-classify'
+import { createDiscordReactionCallback, createDiscordRemoveReactionCallback } from './discord-bot-reactions'
 import { enrichDiscordMessageReferences } from './discord-bot-reference'
 import {
   ackInteraction,
@@ -863,6 +864,9 @@ export function createDiscordBotAdapter(options: DiscordBotAdapterOptions): Disc
 
   const fetchAttachmentCallback = createFetchAttachmentCallback({ token: options.token, logger })
 
+  const reactionCallback = createDiscordReactionCallback({ client })
+  const removeReactionCallback = createDiscordRemoveReactionCallback({ client })
+
   const interactionHandler = createInteractionHandler({
     router: options.router,
     knownCommandNames: SLASH_COMMAND_NAMES,
@@ -999,6 +1003,8 @@ export function createDiscordBotAdapter(options: DiscordBotAdapterOptions): Disc
       })
 
       options.router.registerOutbound('discord-bot', outboundCallback)
+      options.router.registerReaction('discord-bot', reactionCallback)
+      options.router.registerRemoveReaction('discord-bot', removeReactionCallback)
       options.router.registerTyping('discord-bot', typingCallback)
       options.router.registerChannelNameResolver('discord-bot', channelResolver)
       options.router.registerSelfIdentity('discord-bot', selfIdentityResolver)
@@ -1009,6 +1015,21 @@ export function createDiscordBotAdapter(options: DiscordBotAdapterOptions): Disc
       try {
         await listener.start()
       } catch (err) {
+        // Listener failed after registration — roll back every callback so a
+        // failed start leaves no router state behind (stop() returns early on
+        // !started and would otherwise skip cleanup), mirroring the github
+        // adapter's rollback path.
+        options.router.unregisterOutbound('discord-bot', outboundCallback)
+        options.router.unregisterReaction('discord-bot', reactionCallback)
+        options.router.unregisterRemoveReaction('discord-bot', removeReactionCallback)
+        options.router.unregisterTyping('discord-bot', typingCallback)
+        options.router.unregisterChannelNameResolver('discord-bot', channelResolver)
+        options.router.unregisterSelfIdentity('discord-bot', selfIdentityResolver)
+        options.router.unregisterHistory('discord-bot', historyCallback)
+        options.router.unregisterFetchAttachment('discord-bot', fetchAttachmentCallback)
+        options.router.unregisterMembership('discord-bot', membershipResolver)
+        listener = null
+        botUserId = null
         started = false
         logger.error(`[discord-bot] listener start failed: ${describe(err)}`)
         throw err
@@ -1019,6 +1040,8 @@ export function createDiscordBotAdapter(options: DiscordBotAdapterOptions): Disc
       if (!started) return
       started = false
       options.router.unregisterOutbound('discord-bot', outboundCallback)
+      options.router.unregisterReaction('discord-bot', reactionCallback)
+      options.router.unregisterRemoveReaction('discord-bot', removeReactionCallback)
       options.router.unregisterTyping('discord-bot', typingCallback)
       options.router.unregisterChannelNameResolver('discord-bot', channelResolver)
       options.router.unregisterSelfIdentity('discord-bot', selfIdentityResolver)

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

@@ -187,6 +187,7 @@ export function classifyGithubInbound(
 ): InboundMessage | null {
   const repository = readRepository(payload)
   if (repository === null) return null
+  const mention = resolveBotMentionLogins(selfLogin, options?.authType ?? 'pat')
   const base = {
     adapter: 'github' as const,
     workspace: `${repository.owner}/${repository.name}`,
@@ -209,7 +210,7 @@ export function classifyGithubInbound(
       comment.body,
       id,
       user,
-      selfLogin,
+      mention,
       comment.created_at,
       { kind: 'issue-comment', owner: repository.owner, repo: repository.name, commentId: id },
     )
@@ -228,7 +229,7 @@ export function classifyGithubInbound(
       comment.body,
       id,
       readUser(comment.user),
-      selfLogin,
+      mention,
       comment.created_at,
       { kind: 'pr-review-comment', owner: repository.owner, repo: repository.name, commentId: id },
     )
@@ -246,7 +247,7 @@ export function classifyGithubInbound(
       comment.body,
       id,
       readUser(comment.user),
-      selfLogin,
+      mention,
       comment.created_at,
       null,
     )
@@ -270,7 +271,7 @@ export function classifyGithubInbound(
       text,
       id,
       opener,
-      selfLogin,
+      mention,
       issue.created_at,
       { kind: 'issue', owner: repository.owner, repo: repository.name, issueNumber: number },
       action === 'opened' && !hasBody,
@@ -301,7 +302,12 @@ export function classifyGithubInbound(
         teamIsBotMember: options?.teamIsBotMember,
       })
     }
-    if (action === 'opened' && reviewOn === 'opened') {
+    // `ready_for_review` (draft→ready) is a fresh review opportunity, so it
+    // reuses the `opened` paths: same review trigger, same title-only awareness
+    // text. The draft skip in classifyOpenedReviewTrigger is a no-op here since
+    // the PR is non-draft once ready — preserving "review when no longer draft".
+    const isOpenLike = action === 'opened' || action === 'ready_for_review'
+    if (isOpenLike && reviewOn === 'opened') {
       const trigger = classifyOpenedReviewTrigger({
         payload,
         pr,
@@ -314,17 +320,16 @@ export function classifyGithubInbound(
     }
     const opener = readUser(pr.user)
     const hasBody = readString(pr, 'body')?.trim() ? true : false
-    const prText =
-      action === 'opened' ? bodyOrOpenedTitle(pr.body, opener, 'PR', number, readString(pr, 'title')) : pr.body
+    const prText = isOpenLike ? bodyOrOpenedTitle(pr.body, opener, 'PR', number, readString(pr, 'title')) : pr.body
     return buildInbound(
       { ...base, chat: `pr:${number}`, thread: null },
       prText,
       id,
       opener,
-      selfLogin,
+      mention,
       pr.created_at,
       { kind: 'issue', owner: repository.owner, repo: repository.name, issueNumber: number },
-      action === 'opened' && !hasBody,
+      isOpenLike && !hasBody,
     )
   }
 
@@ -348,7 +353,7 @@ export function classifyGithubInbound(
       text,
       id,
       reviewer,
-      selfLogin,
+      mention,
       review.submitted_at,
       null,
       !hasBody,
@@ -373,7 +378,7 @@ export function classifyGithubInbound(
       text,
       id,
       opener,
-      selfLogin,
+      mention,
       discussion.created_at,
       null,
       action === 'created' && !hasBody,
@@ -413,6 +418,48 @@ function resolveDecoyReviewerLogin(selfLogin: string, authType: 'pat' | 'app'):
   return slug !== '' ? slug : null
 }
 
+// The @-handles that count as "addressed to us" in inbound body text. Under
+// App auth `selfLogin` is the actor login `slug[bot]`, but GitHub renders a
+// human's mention of the App as `@slug` (the bare slug — the decoy account's
+// login), with no `[bot]` suffix and no way to type one. Matching only against
+// `selfLogin` therefore never sees `@typeey` for a `typeey[bot]` actor, so a
+// direct "@typeey review again" lands with isBotMention=false and falls through
+// the engagement mention gate. Include the decoy slug so the bare-slug mention
+// is recognized. Under PAT auth the bot IS a real user, so there is no decoy
+// and only `selfLogin` applies.
+export type BotMentionLogins = readonly string[]
+
+export function resolveBotMentionLogins(selfLogin: string | null, authType: 'pat' | 'app'): BotMentionLogins {
+  if (selfLogin === null) return []
+  const decoyLogin = resolveDecoyReviewerLogin(selfLogin, authType)
+  return decoyLogin !== null ? [selfLogin, decoyLogin] : [selfLogin]
+}
+
+// GitHub login chars are ASCII letters, digits, and hyphen. A `@login` token is
+// a real mention of `login` only when the char right after it is not one of
+// these — otherwise `@${login}` is a prefix of a longer, different login. This
+// matters for the App decoy slug: `resolveBotMentionLogins('typeclaw[bot]')`
+// yields the bare slug `typeclaw`, and a naive substring check would treat
+// `@typeclaw-bot` (a different user) as a self-mention. The trailing `[` of
+// `@typeclaw[bot]` is not a login char, so the full actor handle still matches.
+const LOGIN_CHAR = /[A-Za-z0-9-]/
+
+function textMentionsBot(text: string, mentionLogins: BotMentionLogins): boolean {
+  return mentionLogins.some((login) => mentionsLogin(text, login))
+}
+
+function mentionsLogin(text: string, login: string): boolean {
+  const token = `@${login}`
+  let from = 0
+  for (;;) {
+    const at = text.indexOf(token, from)
+    if (at === -1) return false
+    const next = text[at + token.length]
+    if (next === undefined || !LOGIN_CHAR.test(next)) return true
+    from = at + 1
+  }
+}
+
 function classifyReviewRequest(input: ReviewRequestInput): InboundMessage | null {
   const { action, payload, pr, number, base, selfLogin, authType, teamIsBotMember } = input
   if (selfLogin === null) return null
@@ -546,7 +593,7 @@ function buildInbound(
   rawText: unknown,
   id: number,
   user: GithubUser | null,
-  selfLogin: string | null,
+  mention: BotMentionLogins,
   rawTs: unknown,
   reactionTarget: GithubReactionTarget | null,
   synthesizedAwareness = false,
@@ -563,7 +610,7 @@ function buildInbound(
   // Synthesized awareness lines carry an `@author` prefix describing who acted;
   // that handle is the author, never a third-party mention of the bot, so the
   // body-text mention heuristic must not fire on it.
-  const isBotMention = !synthesizedAwareness && selfLogin !== null && text.includes(`@${selfLogin}`)
+  const isBotMention = !synthesizedAwareness && textMentionsBot(text, mention)
   return {
     ...key,
     text,

package/src/channels/adapters/github/review-thread-resolver.ts

@@ -9,7 +9,7 @@ const GRAPHQL_ENDPOINT = `${GITHUB_API_BASE}/graphql`
 // carry more, so the resolver paginates until it matches the root comment id
 // or exhausts the pages — stopping early on a 404-equivalent (thread absent)
 // rather than fabricating a node id.
-const THREADS_QUERY = `query($owner:String!,$name:String!,$number:Int!,$after:String){repository(owner:$owner,name:$name){pullRequest(number:$number){reviewThreads(first:100,after:$after){pageInfo{hasNextPage endCursor}nodes{id isResolved comments(first:1){nodes{databaseId author{login}}}}}}}}`
+const THREADS_QUERY = `query($owner:String!,$name:String!,$number:Int!,$after:String){repository(owner:$owner,name:$name){pullRequest(number:$number){reviewThreads(first:100,after:$after){pageInfo{hasNextPage endCursor}nodes{id isResolved comments(first:1){nodes{databaseId author{__typename login}}}}}}}}`
 
 const RESOLVE_MUTATION = `mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{id isResolved}}}`
 
@@ -18,6 +18,7 @@ type ReviewThreadNode = {
   isResolved: boolean
   rootCommentId: number | null
   rootAuthorLogin: string | null
+  rootAuthorIsBot: boolean
 }
 
 type ThreadLookup =
@@ -66,7 +67,7 @@ export function createGithubReviewThreadResolver(deps: {
     const thread = lookup.thread
     // The load-bearing guard: only the bot may resolve the bot's own thread.
     // Resolving a human reviewer's thread would erase their open question.
-    if (thread.rootAuthorLogin !== selfLogin) {
+    if (!isSelfAuthor(thread, selfLogin)) {
       return {
         ok: false,
         error: `refusing to resolve thread authored by @${thread.rootAuthorLogin ?? 'unknown'} (not @${selfLogin})`,
@@ -79,6 +80,29 @@ export function createGithubReviewThreadResolver(deps: {
   }
 }
 
+// A GitHub App's own login differs across the two APIs this guard straddles:
+// REST `getSelf` returns `slug[bot]` (selfLogin) but GraphQL's `Bot` author node
+// returns the bare `slug` (rootAuthorLogin). Strict `===` thus refused the App's
+// OWN thread (production: "refusing to resolve thread authored by @typeey (not
+// @typeey[bot])"). The bare-slug match is gated on the GraphQL author actually
+// being a `Bot`: a human `User` can legitimately own the bare slug as a login
+// (e.g. the user `typeey` exists alongside the App `typeey[bot]`), so a User
+// author must still match `selfLogin` exactly — otherwise the suffix-strip would
+// let the bot close a human reviewer's thread, defeating the guard above.
+const BOT_LOGIN_SUFFIX = '[bot]'
+
+function isSelfAuthor(thread: ReviewThreadNode, selfLogin: string): boolean {
+  if (thread.rootAuthorLogin === null) return false
+  if (thread.rootAuthorIsBot) {
+    return normalizeBotLogin(thread.rootAuthorLogin) === normalizeBotLogin(selfLogin)
+  }
+  return thread.rootAuthorLogin === selfLogin
+}
+
+function normalizeBotLogin(login: string): string {
+  return login.endsWith(BOT_LOGIN_SUFFIX) ? login.slice(0, -BOT_LOGIN_SUFFIX.length) : login
+}
+
 type ResolveTarget = { owner: string; repo: string; prNumber: number; rootCommentId: number }
 
 function parseTarget(req: ReviewThreadResolveRequest): ResolveTarget | null {
@@ -175,6 +199,7 @@ async function parseThreadsPage(response: Response): Promise<ThreadsPage> {
       isResolved: n.isResolved,
       rootCommentId: root?.databaseId ?? null,
       rootAuthorLogin: root?.author?.login ?? null,
+      rootAuthorIsBot: root?.author?.__typename === 'Bot',
     }
   })
   return { kind: 'ok', nodes, hasNextPage: connection.pageInfo.hasNextPage, endCursor: connection.pageInfo.endCursor }
@@ -231,7 +256,7 @@ type GraphqlThreadsResponse = {
           nodes: Array<{
             id: string
             isResolved: boolean
-            comments: { nodes: Array<{ databaseId?: number; author?: { login?: string } }> }
+            comments: { nodes: Array<{ databaseId?: number; author?: { __typename?: string; login?: string } }> }
           }>
         }
       }

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

@@ -4,6 +4,7 @@ import { matchesAnyAlias } from '@/channels/engagement'
 import type { ChannelAdapterConfig } from '@/channels/schema'
 import type { InboundAttachment, InboundMessage } from '@/channels/types'
 
+import { encodeSlackReactionRef } from './slack-bot-reactions'
 import { hasSlackMessageShareAttachments } from './slack-bot-reference'
 import { slackTsToMillis } from './slack-bot-time'
 
@@ -141,6 +142,7 @@ export function classifyInbound(
       text,
       ...(attachments.length > 0 ? { attachments } : {}),
       externalMessageId: event.ts,
+      reactionRef: encodeSlackReactionRef({ channel: event.channel, ts: event.ts }),
       authorId: event.user,
       authorName: event.user,
       authorIsBot,