typeclaw 0.33.0 → 0.34.0

package/src/channels/manager.ts

@@ -4,12 +4,14 @@ import { join } from 'node:path'
 import type { PermissionService } from '@/permissions'
 import type { GithubSecretsBlock } from '@/secrets'
 import { SecretsKakaoCredentialStore } from '@/secrets/kakao-store'
+import { SecretsLineCredentialStore } from '@/secrets/line-store'
 import { SecretsBackend } from '@/secrets/storage'
 import type { Stream } from '@/stream'
 
 import { createDiscordBotAdapter, type DiscordBotAdapter } from './adapters/discord-bot'
 import { createGithubAdapter, type GithubAdapter } from './adapters/github'
 import { createKakaotalkAdapter, type KakaotalkAdapter } from './adapters/kakaotalk'
+import { createLineAdapter, type LineAdapter } from './adapters/line'
 import { createSlackBotAdapter, type SlackBotAdapter } from './adapters/slack-bot'
 import { createTelegramBotAdapter, type TelegramBotAdapter } from './adapters/telegram-bot'
 import type { GithubTokenBridge } from './github-token-bridge'
@@ -66,6 +68,7 @@ export type ChannelManagerOptions = {
   createDiscordAdapter?: typeof createDiscordBotAdapter
   createGithubAdapter?: typeof createGithubAdapter
   createKakaotalkAdapter?: typeof createKakaotalkAdapter
+  createLineAdapter?: typeof createLineAdapter
   createSlackAdapter?: typeof createSlackBotAdapter
   createTelegramAdapter?: typeof createTelegramBotAdapter
   // Wake-up gate: forwarded to the router, which calls
@@ -111,7 +114,13 @@ export type ChannelManager = {
   reload: () => Promise<{ started: string[]; stopped: string[]; restartRequired: string[] }>
 }
 
-type AnyAdapter = DiscordBotAdapter | GithubAdapter | KakaotalkAdapter | SlackBotAdapter | TelegramBotAdapter
+type AnyAdapter =
+  | DiscordBotAdapter
+  | GithubAdapter
+  | LineAdapter
+  | KakaotalkAdapter
+  | SlackBotAdapter
+  | TelegramBotAdapter
 
 // Credential signature is the comparison key for credential-rotation
 // detection on reload. Discord and Telegram each use a single bot token;
@@ -143,6 +152,7 @@ export function createChannelManager(options: ChannelManagerOptions): ChannelMan
   const createDiscordAdapter = options.createDiscordAdapter ?? createDiscordBotAdapter
   const createGithub = options.createGithubAdapter ?? createGithubAdapter
   const createKakaotalk = options.createKakaotalkAdapter ?? createKakaotalkAdapter
+  const createLine = options.createLineAdapter ?? createLineAdapter
   const createSlackAdapter = options.createSlackAdapter ?? createSlackBotAdapter
   const createTelegramAdapter = options.createTelegramAdapter ?? createTelegramBotAdapter
 
@@ -160,6 +170,7 @@ export function createChannelManager(options: ChannelManagerOptions): ChannelMan
   }
 
   const buildCredentialSignature = (name: AdapterId): { signature: string; missing: string[] } => {
+    if (name === 'line') return buildLineSignature(options.agentDir)
     if (name === 'kakaotalk') return buildKakaotalkSignature(options.agentDir)
     if (name === 'github') return buildGithubSignature(options.agentDir)
     const requiredEnvs = TOKEN_ENV[name]
@@ -198,6 +209,15 @@ export function createChannelManager(options: ChannelManagerOptions): ChannelMan
         selfAliasesRef: () => router.getSelfAliases(),
       })
     }
+    if (name === 'line') {
+      return createLine({
+        router,
+        configRef: () => options.channelsConfigRef()[name] ?? cfg,
+        logger,
+        selfAliasesRef: () => router.getSelfAliases(),
+        credentialsStore: createContainerLineCredentialStore(options.agentDir, env),
+      })
+    }
     if (name === 'kakaotalk') {
       return createKakaotalk({
         router,
@@ -335,7 +355,7 @@ export function createChannelManager(options: ChannelManagerOptions): ChannelMan
             await runSerially(name, () => stopAdapter(name))
             stopped.push(name)
           } else if (signature !== current.credentialSignature) {
-            const reason = name === 'kakaotalk' ? 'credential rotation' : 'token rotation'
+            const reason = name === 'kakaotalk' || name === 'line' ? 'credential rotation' : 'token rotation'
             restartRequired.push(`${name} (${reason})`)
           }
         }
@@ -346,10 +366,10 @@ export function createChannelManager(options: ChannelManagerOptions): ChannelMan
   }
 }
 
-// Token-based adapters only. KakaoTalk's credentials live in
-// secrets.json#channels.kakaotalk, not in env, so it goes through
-// buildKakaotalkSignature instead.
-const TOKEN_ENV: Record<Exclude<AdapterId, 'kakaotalk' | 'github'>, readonly string[]> = {
+// Token-based adapters only. KakaoTalk's and LINE's credentials live in
+// secrets.json#channels.<adapter>, not in env, so they go through
+// buildKakaotalkSignature / buildLineSignature instead.
+const TOKEN_ENV: Record<Exclude<AdapterId, 'kakaotalk' | 'line' | 'github'>, readonly string[]> = {
   'discord-bot': ['DISCORD_BOT_TOKEN'],
   'slack-bot': ['SLACK_BOT_TOKEN', 'SLACK_APP_TOKEN'],
   'telegram-bot': ['TELEGRAM_BOT_TOKEN'],
@@ -387,6 +407,36 @@ function buildKakaotalkSignature(agentDir: string): { signature: string; missing
   }
 }
 
+function createContainerLineCredentialStore(agentDir: string, env: NodeJS.ProcessEnv): SecretsLineCredentialStore {
+  const hostdUrl = env.TYPECLAW_HOSTD_URL
+  const restartToken = env.TYPECLAW_HOSTD_TOKEN
+  const containerName = env.TYPECLAW_CONTAINER_NAME
+  if (!hostdUrl || !restartToken || !containerName) {
+    throw new Error('LINE credentials require TYPECLAW_HOSTD_URL, TYPECLAW_HOSTD_TOKEN, and TYPECLAW_CONTAINER_NAME')
+  }
+  return new SecretsLineCredentialStore({
+    mode: 'container',
+    secretsPath: join(agentDir, 'secrets.json'),
+    hostdUrl,
+    restartToken,
+    containerName,
+  })
+}
+
+function buildLineSignature(agentDir: string): { signature: string; missing: string[] } {
+  const path = join(agentDir, 'secrets.json')
+  try {
+    const block = new SecretsBackend(path).tryReadChannelsSync()?.line
+    if (!isLineCredentialBlock(block)) {
+      return { signature: '', missing: ['secrets.json#channels.line'] }
+    }
+    const digest = createHash('sha256').update(JSON.stringify(block)).digest('hex')
+    return { signature: `secrets.json#channels.line@sha256:${digest}`, missing: [] }
+  } catch (err) {
+    return { signature: '', missing: [`secrets.json#channels.line (${describe(err)})`] }
+  }
+}
+
 function buildGithubSignature(agentDir: string): { signature: string; missing: string[] } {
   const block = readGithubSecrets(agentDir)
   if (block === null) return { signature: '', missing: ['secrets.json#channels.github'] }
@@ -422,6 +472,15 @@ function isKakaoCredentialBlock(value: unknown): value is { accounts: Record<str
   )
 }
 
+function isLineCredentialBlock(value: unknown): value is { accounts: Record<string, unknown> } {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false
+  if (!('accounts' in value)) return false
+  const accounts = value.accounts
+  return (
+    typeof accounts === 'object' && accounts !== null && !Array.isArray(accounts) && Object.keys(accounts).length > 0
+  )
+}
+
 function describe(err: unknown): string {
   return err instanceof Error ? err.message : String(err)
 }

package/src/channels/router.ts

@@ -595,6 +595,16 @@ type LiveSession = {
   // send was attempted. Compared by `turnSeq` so a stale value can't leak across
   // turns.
   skipLockedSendTurn: number | null
+  // Stamped with the current `turnSeq` by `clearSticky` (called from the
+  // `channel_disengage` tool). Read in `send()`'s post-delivery grant block: a
+  // successful outbound normally re-grants sticky credit to the turn's authors,
+  // which would silently re-arm the engagement the model just dropped if it
+  // acks ("ok, backing off") via `channel_reply` in the same turn. When this
+  // matches the live `turnSeq`, the grant is suppressed so disengage stays
+  // binding for the rest of the turn — the same "commit to it within the turn"
+  // shape as the skip lock. `null` when no disengage has been recorded.
+  // Compared by `turnSeq` so a stale value can't leak across turns.
+  disengagedTurn: number | null
   // Captured by drain() at batch dequeue; read+cleared by send() on the
   // first tool-source send of the turn. The anchor decision (delay
   // threshold + intervening-observed check) is evaluated at SEND time
@@ -618,6 +628,16 @@ type LiveSession = {
   // "is this a multi-human group". Read by composeTurnPrompt().
   multiHumanGroup: boolean
   membershipFetch: Promise<MembershipCount | null> | null
+  // Provider soft-error (`stopReason: 'error'`) captured during the current
+  // turn, deferred to turn-end. Upstream surfaces transient errors (e.g.
+  // `server_is_overloaded`) MID-turn and the turn often recovers, replying
+  // seconds later — posting the "⚠️ provider failed" notice on the spot strands
+  // a false failure above the eventual real reply. So the listener only RECORDS
+  // here (stamped with the firing turnSeq; raw text logged for operators); the
+  // turn-end finally posts `safeMessage` ONLY if no reply landed, else discards.
+  // First error per turn wins. Keyed by `turnSeq` so a stale record from a
+  // crashed prior turn can't leak into the next.
+  pendingProviderError: { turnSeq: number; safeMessage: string } | null
   destroyed: boolean
   unsubProviderErrors: (() => void) | null
   unsubTypingActivity: (() => void) | null
@@ -807,6 +827,14 @@ export type ChannelRouter = {
     | { kind: 'recorded'; keyId: string }
     | { kind: 'recorded-after-send'; keyId: string }
     | { kind: 'no-live-session' }
+  // Force-clear every sticky credit for one channel key. Stickiness normally
+  // expires on TTL or is consumed on the next inbound, but in a busy group each
+  // reply re-grants a fresh credit, so the bot can stay force-engaged turn after
+  // turn even after being told to stop. This is the escape hatch the
+  // `channel_disengage` tool calls to drop back to strict mention/reply/dm
+  // engagement without waiting out the window. In-memory only,
+  // so a later reply re-grants. `cleared` counts the author credits dropped.
+  clearSticky: (key: ChannelKey) => { keyId: string; cleared: number }
   // Two-phase boot restart-resume. Call `reserveRestartHandoff(handoff)` BEFORE
   // `channelManager.start()` to install a per-key gate so an inbound that races
   // the adapters coming online coalesces onto the resume instead of competing
@@ -1466,55 +1494,31 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
         nextPromptMaxTokens: undefined,
         skippedTurn: null,
         skipLockedSendTurn: null,
+        disengagedTurn: null,
         pendingQuoteCandidate: null,
         recentEngagedPeerBotTurns: [],
         consecutiveEngagedPeerBotTurns: 0,
         loopGuardActive: false,
         multiHumanGroup: false,
         membershipFetch,
+        pendingProviderError: null,
         destroyed: false,
         unsubProviderErrors: null,
         unsubTypingActivity: null,
         unsubTodoOutcome: null,
       }
-      // Tracks the `turnSeq` a provider-error notice was last POSTED for, so the
-      // channel surfaces at most one notice per turn. The upstream SDK retries
-      // internally, and each retry emits its own `message_end` with
-      // `stopReason: 'error'` — without this gate a single failing turn posts N
-      // identical "⚠️ upstream provider failed" notices (one per retry). Logs
-      // still record every attempt; only the user-facing notice is deduped.
-      let lastProviderErrorNoticeTurn: number | undefined
+      // Raw text is logged on EVERY attempt for operators; the user-facing
+      // notice is deferred. The upstream SDK retries internally, and each retry
+      // emits its own `message_end` with `stopReason: 'error'` — but the turn
+      // frequently recovers and replies anyway. Recording the first error per
+      // turn (keyed by `turnSeq`) lets drain()'s turn-end decide: post the
+      // notice only if no reply landed, suppress it if the turn recovered. This
+      // both dedupes the retry storm AND prevents a stranded false-failure
+      // notice above a successful reply. See `pendingProviderError`.
       live.unsubProviderErrors = subscribeProviderErrors(created.session, (err) => {
         logger.error(`[channels] ${live.keyId}: LLM call failed: ${err.message}`)
-        // Suppress duplicate notices for the SAME turn (retry storm). Set the
-        // marker BEFORE the async send so a synchronous burst of retry events
-        // can't each slip past the check and enqueue their own notice.
-        if (lastProviderErrorNoticeTurn === live.turnSeq) return
-        lastProviderErrorNoticeTurn = live.turnSeq
-        // A provider soft-error (rate/usage limit, billing, malformed response)
-        // ends the turn with no assistant text, so the human otherwise sees
-        // silence. Surface the REDACTED `safeMessage` (never the raw provider
-        // text, which can carry response bodies / URLs / tokens) via a 'system'
-        // send — the same one-shot bypass path validateChannelTurn uses, so it
-        // lands regardless of per-turn send caps and skips the duplicate guard.
-        void send(
-          {
-            adapter: live.key.adapter,
-            workspace: live.key.workspace,
-            chat: live.key.chat,
-            thread: live.key.thread,
-            text: `⚠️ ${err.safeMessage}`,
-          },
-          { source: 'system' },
-        )
-          .then((result) => {
-            if (!result.ok) {
-              logger.warn(`[channels] ${live.keyId}: provider-error notice send failed: ${result.error}`)
-            }
-          })
-          .catch((sendErr) => {
-            logger.warn(`[channels] ${live.keyId}: provider-error notice send threw: ${describe(sendErr)}`)
-          })
+        if (live.pendingProviderError?.turnSeq === live.turnSeq) return
+        live.pendingProviderError = { turnSeq: live.turnSeq, safeMessage: err.safeMessage }
       })
       live.unsubTodoOutcome = created.session.subscribe((event: unknown) => {
         const usage = extractTurnUsage(event)
@@ -1931,6 +1935,56 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
     }
   }
 
+  const maybePostDeferredProviderError = async (
+    live: LiveSession,
+    sentReplyThisTurn: boolean,
+    retryQueued: boolean,
+  ): Promise<void> => {
+    const pending = live.pendingProviderError
+    if (pending === null || pending.turnSeq !== live.turnSeq) {
+      live.pendingProviderError = null
+      return
+    }
+    // The turn recovered and replied — the provider blip was transient, so a
+    // failure notice would be a false alarm stranded above the real reply.
+    if (sentReplyThisTurn) {
+      live.pendingProviderError = null
+      return
+    }
+    // An empty-turn retry was queued (validateChannelTurn pushed
+    // EMPTY_TURN_RETRY_NUDGE): the same logical turn re-prompts in the next
+    // drain iteration and may yet recover. Carry the pending error forward,
+    // re-stamping to that iteration's turnSeq (drain does `turnSeq++` once per
+    // iteration, so it will be exactly `turnSeq + 1`). Posting now would strand
+    // a false-failure notice above the retry's eventual reply — the same defect
+    // one logical turn later.
+    if (retryQueued) {
+      live.pendingProviderError = { turnSeq: live.turnSeq + 1, safeMessage: pending.safeMessage }
+      return
+    }
+    live.pendingProviderError = null
+    // Genuinely empty turn with no retry left: surface the REDACTED
+    // `safeMessage` (never raw provider text, which can carry response bodies /
+    // URLs / tokens) via a 'system' send — the one-shot bypass path that lands
+    // regardless of per-turn send caps — so the human doesn't just see silence.
+    const result = await send(
+      {
+        adapter: live.key.adapter,
+        workspace: live.key.workspace,
+        chat: live.key.chat,
+        thread: live.key.thread,
+        text: `⚠️ ${pending.safeMessage}`,
+      },
+      { source: 'system' },
+    ).catch((sendErr) => {
+      logger.warn(`[channels] ${live.keyId}: provider-error notice send threw: ${describe(sendErr)}`)
+      return null
+    })
+    if (result !== null && !result.ok) {
+      logger.warn(`[channels] ${live.keyId}: provider-error notice send failed: ${result.error}`)
+    }
+  }
+
   const drain = async (live: LiveSession): Promise<void> => {
     if (live.draining || live.destroyed) return
     live.draining = true
@@ -1948,6 +2002,16 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
         live.currentTurnAttachments = collectTurnAttachments(observed, batch)
 
         if (batch.length > 0) {
+          // A fresh user batch starts a NEW logical turn. Drop any provider
+          // error carried forward from a prior turn's empty-turn retry: the
+          // drain loop splices promptQueue AND pendingSystemReminders together,
+          // so a user message arriving while a retry nudge is pending coalesces
+          // into this iteration. Without this clear, the carried error (stamped
+          // `turnSeq + 1`) would match this fresh turn and post the prior turn's
+          // notice misattributed to an unrelated new message. Carry-forward stays
+          // intact for genuinely reminder-only iterations (batch.length === 0),
+          // which skip this branch.
+          live.pendingProviderError = null
           live.currentTurnAuthorId = batch[batch.length - 1]!.authorId
           live.currentTurnAuthorIds = new Set(batch.map((m) => m.authorId))
           live.currentTurnReactionRef = batch[batch.length - 1]!.reactionRef ?? null
@@ -2010,10 +2074,12 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
         logger.info(`[channels] ${live.keyId} prompting batch=${batch.length} text_len=${text.length}`)
         const promptStart = now()
         const successfulSendsBeforePrompt = live.successfulChannelSends
+        const emptyTurnRetriesBeforePrompt = live.emptyTurnRetries
         const engageAddPromises = live.currentTurnEngageReactions
         live.turnSeq++
         live.successfulSendsAtTurnStart = successfulSendsBeforePrompt
         live.skipLockedSendTurn = null
+        live.disengagedTurn = null
         live.policyDeniedToolSendsThisTurn.clear()
         resetReviewTurn(live.sessionId)
         const isRealUserTurn = batch.length > 0
@@ -2030,6 +2096,8 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
         } finally {
           const sentReplyThisTurn = live.successfulChannelSends > successfulSendsBeforePrompt
           if (sentReplyThisTurn) dropEngageReactionsAfterReply(live, engageAddPromises)
+          const emptyTurnRetryQueued = live.emptyTurnRetries > emptyTurnRetriesBeforePrompt
+          await maybePostDeferredProviderError(live, sentReplyThisTurn, emptyTurnRetryQueued)
           await fireSessionTurnEnd(live)
         }
         await fireSessionIdle(live)
@@ -2389,8 +2457,16 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
 
   const hasBotParticipated = (live: LiveSession): boolean => {
     if (live.successfulChannelSends > 0) return true
+    // Only OUR own prefetched history counts as participation — matching any
+    // bot here let a PEER bot's buffered message flip botInThread=true,
+    // neutralizing the replyToOtherMessageId suppressor and engaging us in a
+    // thread aimed at another bot. Self id is unavailable during the startup
+    // identity race; then this falls back to successfulChannelSends, which is
+    // safe (conservative: we just don't claim participation we can't prove).
+    const selfId = resolveSelfIdentity(live.key)?.id
+    if (selfId === undefined) return false
     for (const item of live.contextBuffer) {
-      if (item.authorIsBot) return true
+      if (item.authorId === selfId) return true
     }
     return false
   }
@@ -2847,7 +2923,16 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
       return { ok: false, error: `no adapter registered for "${msg.adapter}"`, code: 'no-adapter' }
     }
 
-    const authoredText = normalizeSendText(msg.text)
+    // Strip leaked `<think>` reasoning off the message itself, up front, so the
+    // stripped text flows through EVERY downstream consumer: the flood check,
+    // the duplicate guard, the quote-anchor prepend, and the adapter callback.
+    // A body that was nothing but a think block collapses to undefined and is
+    // delivered as a text-less send (attachments, if any, still go through).
+    if (msg.text !== undefined) {
+      msg = { ...msg, text: normalizeSendText(msg.text) }
+    }
+
+    const authoredText = msg.text
     if (authoredText !== undefined) {
       const flood = checkOutboundFlood(authoredText)
       if (!flood.ok) return { ok: false, error: OUTBOUND_FLOOD_ERROR, code: 'outbound-flood' }
@@ -3023,8 +3108,13 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
       // land after it. Discord and Telegram treat the extra tick as a
       // no-op refresh of their already-armed (auto-expiring) indicators.
       if (live.typingTimer) void fireTyping(live, 'tick')
+      // Disengage is binding for the rest of the turn: if the model dropped
+      // sticky via `channel_disengage` this turn, a same-turn ack reply must NOT
+      // silently re-grant the credit it just cleared. Skipped only for the live
+      // turn (matched by `turnSeq`); the next turn re-grants normally.
+      const disengagedThisTurn = live.disengagedTurn !== null && live.disengagedTurn === live.turnSeq
       const adapterConfig = options.configForAdapter(msg.adapter)
-      if (adapterConfig) {
+      if (adapterConfig && !disengagedThisTurn) {
         const targetIds = Array.from(
           live.currentTurnAuthorIds.size > 0 ? live.currentTurnAuthorIds : live.lastTurnAuthorIds,
         )
@@ -3632,6 +3722,7 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
       ok: boolean
       durationMs: number
       error?: string
+      hasRecoverableOutput?: boolean
     },
   ): { kind: 'delivered'; keyId: string } => {
     const adapter = live.keyId.split(':', 1)[0] ?? ''
@@ -3641,6 +3732,7 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
       ok: args.ok,
       durationMs: args.durationMs,
       ...(args.error !== undefined ? { error: args.error } : {}),
+      ...(args.hasRecoverableOutput === true ? { hasRecoverableOutput: true } : {}),
       channel: true,
       adapter,
     })
@@ -3673,6 +3765,7 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
     ok: boolean
     durationMs: number
     error?: string
+    hasRecoverableOutput?: boolean
     channelKey?: { adapter: string; workspace: string; chat: string; thread: string | null }
   }): { kind: 'delivered'; keyId: string } | { kind: 'no-live-session' } => {
     for (const live of liveSessions.values()) {
@@ -3727,6 +3820,18 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
     return { kind: 'no-live-session' }
   }
 
+  const clearSticky = (key: ChannelKey): { keyId: string; cleared: number } => {
+    const keyId = channelKeyId(key)
+    const cleared = stickyLedger.clear(keyId)
+    // Arm the same-turn re-grant guard so a subsequent ack reply this turn does
+    // not re-grant the credit just cleared (see `disengagedTurn`). No-op when
+    // the key has no live session — the ledger clear above still stands.
+    const live = liveSessions.get(keyId)
+    if (live && !live.destroyed) live.disengagedTurn = live.turnSeq
+    logger.info(`[channels] ${keyId} sticky cleared count=${cleared}`)
+    return { keyId, cleared }
+  }
+
   return {
     route,
     send,
@@ -3768,6 +3873,7 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
     getSelfAliases: computeSelfAliases,
     injectSubagentCompletionReminder,
     markTurnSkipped,
+    clearSticky,
     reserveRestartHandoff,
     resumeRestartHandoff,
     stop,
@@ -3987,6 +4093,22 @@ function composeTurnPrompt(
   // the `## Recent context (not addressed to you …)` header — mislabeling the
   // one line the model is supposed to answer as context it should ignore.
   if (batch.length > 0) {
+    // The `## Current message` header is a WITHIN-turn label, but it also gets
+    // persisted into the transcript — so after many turns the model sees a
+    // chain of turns each headed "addressed to you" and a weak model collapses
+    // that into "only the latest turn exists", denying it can see what the user
+    // said earlier (those turns are in its own message history). This note
+    // re-anchors the header as turn-local. Conditional "if earlier turns
+    // appear" wording so it is not a false premise on turn 1 (a fresh session
+    // has no history). No leading `>` — that is this repo's quote-anchor syntax
+    // and would read as quoted content. Worded to NOT contain the literal
+    // `## Current message` heading — a pinned test asserts its absence on
+    // reminder-only drains, so it must stay batch-gated and substring-free.
+    parts.push(
+      'Note: if earlier turns appear above, they are real conversation history you can use.',
+      "The heading below marks this turn's new message, not the only message that may exist.",
+      '',
+    )
     parts.push(batch.length === 1 ? '## Current message (addressed to you)' : '## Current messages (addressed to you)')
     for (const b of batch) {
       parts.push(formatInboundPromptLines(b, adapter))
@@ -4050,6 +4172,7 @@ function formatAuthorReference(adapter: AdapterId, authorId: string, authorName:
     case 'github':
       return displayName.startsWith('@') ? displayName : `@${displayName}`
     case 'telegram-bot':
+    case 'line':
     case 'kakaotalk':
       return displayName
   }
@@ -4316,10 +4439,32 @@ export function resolveLiveSessionForCommand(
   return { kind: 'none' }
 }
 
+// Strips leaked `<think>…</think>` reasoning from outbound message text. Some
+// models (DeepSeek-R1 / Qwen-QwQ family) emit chain-of-thought inline as a
+// literal `<think>` span in `delta.content` rather than a dedicated `thinking`
+// content block, so it lands verbatim in the assistant body and — without this
+// — gets posted to the channel (production: a reasoning paragraph leaked into a
+// Slack thread). The whole block is removed, not just the tags.
+//
+// THINK_BLOCK_RE matches closed blocks (case-insensitive, attribute-tolerant,
+// multi-line). DANGLING_THINK_RE catches an UNCLOSED trailing `<think>` (model
+// ran out of budget mid-reasoning) by dropping open-tag-to-end. The final pass
+// collapses excision-left blank-line runs and trims.
+const THINK_BLOCK_RE = /<think\b[^>]*>[\s\S]*?<\/think\s*>/gi
+const DANGLING_THINK_RE = /<think\b[^>]*>[\s\S]*$/i
+
+export function stripThinkBlocks(text: string): string {
+  const withoutBlocks = text.replace(THINK_BLOCK_RE, '').replace(DANGLING_THINK_RE, '')
+  return withoutBlocks.replace(/\n{3,}/g, '\n\n').trim()
+}
+
 function normalizeSendText(text: string | undefined): string | undefined {
   if (text === undefined) return undefined
-  if (text === '') return undefined
-  return text
+  // Strip before the empty-collapse so a turn that was ONLY a think block
+  // resolves to `undefined` (suppressed) instead of posting an empty shell.
+  const stripped = stripThinkBlocks(text)
+  if (stripped === '') return undefined
+  return stripped
 }
 
 function recordSendTimestamp(live: LiveSession, sendKey: string, ts: number): number {

package/src/channels/schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 
-export const ADAPTER_IDS = ['discord-bot', 'github', 'kakaotalk', 'slack-bot', 'telegram-bot'] as const
+export const ADAPTER_IDS = ['discord-bot', 'github', 'line', 'kakaotalk', 'slack-bot', 'telegram-bot'] as const
 
 export type AdapterId = (typeof ADAPTER_IDS)[number]
 
@@ -254,6 +254,11 @@ export const channelsSchema = z
   .object({
     'discord-bot': adapterSchema.optional(),
     github: githubChannelSchema.optional(),
+    // LINE is a personal-account channel like KakaoTalk: plain-text only,
+    // alias-only engagement (no native @-mention), credentials in
+    // secrets.json#channels.line (not env). Unlike KakaoTalk it has no
+    // token-renewal cron — it persists a long-lived auth token + certificate.
+    line: adapterSchema.optional(),
     kakaotalk: adapterSchema.optional(),
     'slack-bot': adapterSchema.optional(),
     'telegram-bot': adapterSchema.optional(),