agent-messenger 2.15.0 → 2.16.0

package/src/platforms/kakaotalk/index.ts

@@ -12,8 +12,10 @@ export type {
   KakaoDeviceType,
   KakaoEmoticonKind,
   KakaoEmoticonMessageType,
+  KakaoFileExtra,
   KakaoMember,
   KakaoMessage,
+  KakaoPhotoExtra,
   KakaoProfile,
   KakaoSendResult,
   KakaoTalkListenerEventMap,
@@ -27,6 +29,7 @@ export type {
 export {
   KAKAO_EMOTICON_KIND_BY_TYPE,
   KAKAO_EMOTICON_MESSAGE_TYPES,
+  KAKAO_MESSAGE_TYPE,
   KakaoAccountCredentialsSchema,
   KakaoChatSchema,
   KakaoConfigSchema,
@@ -39,3 +42,7 @@ export {
   KakaoTalkPushMessageEventSchema,
   KakaoTalkPushReadEventSchema,
 } from './types'
+export { sha1Hex } from './media-upload'
+export { detectImageDimensions } from './image-meta'
+export type { AttachmentInput, AttachmentPlan, ResolvedAttachment, SingleAttachmentKind } from './attachment-router'
+export { planAttachments, resolveAttachment } from './attachment-router'

package/src/platforms/kakaotalk/media-upload.ts

@@ -0,0 +1,44 @@
+// SHA-1 hex (uppercase, 40 chars) — required as the `cs` (checksum) field
+// on SHIP requests and on the inbound photo `extra` JSON. Verified by inbound
+// capture of a real KakaoTalk client photo (2026-05).
+export async function sha1Hex(data: Uint8Array): Promise<string> {
+  const hashBuf = await crypto.subtle.digest('SHA-1', data)
+  return Array.from(new Uint8Array(hashBuf))
+    .map((b) => b.toString(16).padStart(2, '0').toUpperCase())
+    .join('')
+}
+
+const MIME_BY_EXT: Record<string, string> = {
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  png: 'image/png',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  mp4: 'video/mp4',
+  mov: 'video/quicktime',
+  webm: 'video/webm',
+  mkv: 'video/x-matroska',
+  m4v: 'video/x-m4v',
+  m4a: 'audio/m4a',
+  mp3: 'audio/mpeg',
+  wav: 'audio/wav',
+  ogg: 'audio/ogg',
+  pdf: 'application/pdf',
+  csv: 'text/csv',
+  txt: 'text/plain',
+  json: 'application/json',
+  zip: 'application/zip',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+}
+
+export function guessMimeFromFilename(filename: string): string {
+  const dot = filename.lastIndexOf('.')
+  if (dot < 0 || dot === filename.length - 1) return 'application/octet-stream'
+  const ext = filename.slice(dot + 1).toLowerCase()
+  return MIME_BY_EXT[ext] ?? 'application/octet-stream'
+}

package/src/platforms/kakaotalk/protocol/connection.ts

@@ -50,6 +50,17 @@ export class LocoConnection {
     await this.write(handshakePacket)
   }
 
+  // Writes raw bytes onto the LOCO stream after applying the same AES-128-GCM
+  // framing as encrypted packets — used by the media-upload POST step where
+  // the protocol expects the file payload to follow the POST request inside
+  // the same encrypted channel (chunked into N frames automatically by the
+  // crypto layer's 4-byte-size + nonce + ciphertext + tag wrapping).
+  async writeRaw(data: Buffer): Promise<void> {
+    if (!this.crypto) throw new Error('crypto not initialised')
+    const encrypted = this.crypto.encrypt(data)
+    await this.write(encrypted)
+  }
+
   async sendPacket(method: string, body: Record<string, unknown> = {}): Promise<LocoPacket> {
     const packetId = ++this.packetIdCounter
     const packet: LocoPacket = {

package/src/platforms/kakaotalk/protocol/media-uploader.ts

@@ -0,0 +1,129 @@
+import { Long } from 'bson'
+
+import type { KakaoDeviceType } from '../types'
+import { MCCMNC, getLocoDeviceConfig } from './config'
+import { LocoConnection } from './connection'
+import type { LocoPacket } from './types'
+
+export interface UploadToLocoOptions {
+  shipToken: string
+  shipHost: string
+  shipPort: number
+  chatId: Long
+  msgType: number
+  userId: string
+  filename: string
+  data: Uint8Array
+  width?: number
+  height?: number
+  deviceType: KakaoDeviceType
+  onProgress?: (sent: number, total: number) => void
+}
+
+export interface UploadToLocoResult {
+  completePacket: LocoPacket | null
+  postStatusCode: number
+  postOffset: number
+}
+
+const DEFAULT_NETWORK_TYPE = 0
+const DEFAULT_COMPLETE_TIMEOUT_MS = 60_000
+
+// Drives the SHIP → connect → POST → stream → COMPLETE pipeline that KakaoTalk
+// uses for chat-media uploads. The caller has already done SHIP on the main
+// session and received {k, vh, p}; this opens a dedicated TCP+LOCO connection
+// to (vh, p), sends POST with the ticket + chat metadata, streams the raw file
+// bytes, and waits for the server's COMPLETE push that triggers the actual
+// chat-message registration.
+//
+// Field names (u/k/t/s/c/mid/w/h/mm/nt/os/av/f/ns) match the APK's
+// `SR/g0.java` (PostJob) verbatim. The COMPLETE handshake is a server-pushed
+// packet whose body contains the resulting chatLog struct.
+export async function uploadMediaToLoco(opts: UploadToLocoOptions): Promise<UploadToLocoResult> {
+  return runPostStreamComplete(opts, 'POST')
+}
+
+// Single-entry MPOST upload — runs the same connect → POST → stream → COMPLETE
+// pipeline as uploadMediaToLoco but with MPOST as the opcode (used after MSHIP
+// for each entry in a multi-photo batch). Callers fan-out across all entries
+// in parallel and then issue one FORWARD to register the gallery message.
+export async function uploadMultiMediaEntry(opts: UploadToLocoOptions): Promise<UploadToLocoResult> {
+  return runPostStreamComplete(opts, 'MPOST')
+}
+
+async function runPostStreamComplete(opts: UploadToLocoOptions, opcode: 'POST' | 'MPOST'): Promise<UploadToLocoResult> {
+  const device = getLocoDeviceConfig(opts.deviceType)
+
+  const conn = new LocoConnection()
+  await conn.connectSecure(opts.shipHost, opts.shipPort)
+
+  const totalSize = opts.data.byteLength
+  let completeResolve: ((p: LocoPacket | null) => void) | null = null
+  let completeTimeout: ReturnType<typeof setTimeout> | null = null
+  const completePromise = new Promise<LocoPacket | null>((resolve) => {
+    completeResolve = resolve
+    completeTimeout = setTimeout(() => {
+      completeTimeout = null
+      resolve(null)
+    }, DEFAULT_COMPLETE_TIMEOUT_MS)
+  })
+  conn.onPush((push) => {
+    if (push.method === 'COMPLETE' && completeResolve) {
+      if (completeTimeout) {
+        clearTimeout(completeTimeout)
+        completeTimeout = null
+      }
+      completeResolve(push)
+      completeResolve = null
+    }
+  })
+
+  try {
+    const postBody: Record<string, unknown> = {
+      k: opts.shipToken,
+      s: totalSize,
+      t: opts.msgType,
+      u: Long.fromString(opts.userId),
+      os: device.os,
+      av: device.appVersion,
+      nt: DEFAULT_NETWORK_TYPE,
+      mm: MCCMNC,
+    }
+    if (opcode === 'POST') {
+      postBody.f = opts.filename
+      postBody.c = opts.chatId
+      postBody.mid = Long.ONE
+      postBody.ns = true
+      if (typeof opts.width === 'number') postBody.w = opts.width
+      if (typeof opts.height === 'number') postBody.h = opts.height
+    } else {
+      postBody.dt = 0
+      postBody.scp = 0
+    }
+
+    const postResp = await conn.sendPacket(opcode, postBody)
+    const postOffsetRaw = (postResp.body as Record<string, unknown>).o
+    const postOffset = typeof postOffsetRaw === 'number' ? postOffsetRaw : 0
+
+    const bytesToSend = opts.data.subarray(postOffset)
+    if (bytesToSend.length > 0) {
+      await conn.writeRaw(Buffer.from(bytesToSend))
+      opts.onProgress?.(totalSize, totalSize)
+    }
+
+    const completePacket = await completePromise
+    const postStatusCode = postResp.statusCode
+
+    return {
+      completePacket,
+      postStatusCode,
+      postOffset,
+    }
+  } finally {
+    if (completeTimeout) {
+      clearTimeout(completeTimeout)
+      completeTimeout = null
+    }
+    conn.close()
+  }
+}

package/src/platforms/kakaotalk/protocol/session.ts

@@ -126,6 +126,73 @@ export class LocoSession {
     })
   }
 
+  // Sends a WRITE with non-text message_type plus the JSON-stringified `extra`
+  // payload that KakaoTalk clients render as the attachment (photo, file, etc).
+  // See types.ts → KakaoPhotoExtra / KakaoFileExtra for the per-type shape.
+  async sendAttachment(chatId: Long, type: number, extra: Record<string, unknown>, caption = ''): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('WRITE', {
+      chatId,
+      msg: caption,
+      type,
+      noSeen: false,
+      extra: JSON.stringify(extra),
+    })
+  }
+
+  // SHIP — request a media-upload ticket. Reserves a slot on a media LOCO
+  // server and returns the token (k), host (vh), and port (p) the client must
+  // connect to next. Sent on the main session.
+  async shipMedia(chatId: Long, type: number, size: number, checksum: string, extension: string): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    const body: Record<string, unknown> = {
+      c: chatId,
+      t: type,
+      s: Long.fromNumber(size),
+      cs: checksum,
+    }
+    if (extension.length > 0) body.e = extension
+    return this.connection.sendPacket('SHIP', body)
+  }
+
+  // MSHIP — multi-file equivalent of SHIP. Per-file fields become parallel
+  // arrays (sl/csl/el) and the response carries kl/vhl/pl arrays the caller
+  // must fan out across — one MPOST connection per entry.
+  async shipMultiMedia(
+    chatId: Long,
+    type: number,
+    sizes: number[],
+    checksums: string[],
+    extensions: string[],
+  ): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('MSHIP', {
+      c: chatId,
+      t: type,
+      sl: sizes.map((s) => Long.fromNumber(s)),
+      csl: checksums,
+      el: extensions,
+    })
+  }
+
+  // FORWARD — used after MPOST: registers a multi-attachment chatlog as one
+  // message. Same shape as WRITE but the server routes the attachment to
+  // multi-media rendering (galleries, multi-photo posts).
+  async forwardChat(chatId: Long, type: number, extra: Record<string, unknown>, caption = ''): Promise<LocoPacket> {
+    if (!this.connection) throw new Error('Not connected')
+    return this.connection.sendPacket('FORWARD', {
+      chatId,
+      msg: caption,
+      type,
+      noSeen: false,
+      extra: JSON.stringify(extra),
+    })
+  }
+
+  getConnection(): LocoConnection | null {
+    return this.connection
+  }
+
   async syncMessages(chatId: Long, count = 20, cursor?: Long, maxLogId?: Long): Promise<LocoPacket> {
     if (!this.connection) throw new Error('Not connected')
     return this.connection.sendPacket('SYNCMSG', {

package/src/platforms/kakaotalk/types.ts

@@ -119,6 +119,63 @@ export interface KakaoSendResult {
   sent_at: number
 }
 
+// LOCO message_type values. Source: KakaoTalk APK 26.4.2 + typeclaw inbound parser.
+export const KAKAO_MESSAGE_TYPE = {
+  TEXT: 1,
+  PHOTO: 2,
+  VIDEO: 3,
+  AUDIO: 5,
+  FILE: 18,
+  MULTIPHOTO: 27,
+} as const
+
+// PHOTO `extra` keys verified by inbound capture of a real KakaoTalk client
+// photo message (2026-05). The bare minimum the receiver needs to render
+// the inline preview is k/s/w/h/mt/cs — url and thumbnailUrl are server-issued
+// pre-signed URLs that the recipient regenerates locally from k, so we don't
+// supply them on outbound.
+export interface KakaoPhotoExtra {
+  k: string
+  s: number
+  w: number
+  h: number
+  mt: string
+  cs: string
+  url?: string
+  thumbnailUrl?: string
+  thumbnailWidth?: number
+  thumbnailHeight?: number
+  expire?: number
+}
+
+export interface KakaoFileExtra {
+  k: string
+  s: number
+  name: string
+  mt: string
+  cs: string
+  expire?: number
+  url?: string
+}
+
+// MULTIPHOTO extra — each per-file field of KakaoPhotoExtra becomes a
+// parallel array. Verified by inbound capture of a real multi-photo message
+// (2026-05). csl uses lowercase hex (unlike PHOTO's cs which is uppercase).
+export interface KakaoMultiPhotoExtra {
+  kl: string[]
+  wl: number[]
+  hl: number[]
+  mtl: string[]
+  sl: number[]
+  csl: string[]
+  cmtl?: string[]
+  imageUrls?: string[]
+  thumbnailUrls?: string[]
+  thumbnailWidths?: number[]
+  thumbnailHeights?: number[]
+  expire?: number
+}
+
 export interface KakaoMarkReadResult {
   success: boolean
   status_code: number

package/src/platforms/slack/commands/auth.ts

@@ -106,19 +106,21 @@ async function extractAction(options: {
 
         if (options.debug) {
           const domain = workspaceDomains[ws.workspace_id]
-          debug(
-            `[debug] Attempting web token refresh for ${ws.workspace_id}${domain ? ` (${domain}.slack.com)` : ''}...`,
-          )
+          const target = domain
+            ? `${ws.workspace_id} (${domain}.slack.com)`
+            : `${ws.workspace_id} (trying all known domains)`
+          debug(`[debug] Attempting web token refresh for ${target}...`)
         }
         const refreshed = await tryWebTokenRefresh(ws, workspaceDomains)
         if (refreshed) {
           ws.token = refreshed.token
+          ws.workspace_id = refreshed.workspace_id
           ws.workspace_name = refreshed.workspace_name
           validWorkspaces.push(ws)
           await credManager.setWorkspace(ws)
 
           if (options.debug) {
-            debug(`[debug] ✓ Web refresh succeeded: ${refreshed.workspace_name}`)
+            debug(`[debug] ✓ Web refresh succeeded: ${refreshed.workspace_id}/${refreshed.workspace_name}`)
           }
         } else if (options.debug) {
           debug('[debug] ✗ Web refresh failed')

package/src/platforms/slack/ensure-auth.test.ts

@@ -10,10 +10,12 @@ let extractSpy: ReturnType<typeof spyOn>
 let extractCookieSpy: ReturnType<typeof spyOn>
 let getWorkspaceDomainsSpy: ReturnType<typeof spyOn>
 let testAuthSpy: ReturnType<typeof spyOn>
+let loginSpy: ReturnType<typeof spyOn>
 let setWorkspaceSpy: ReturnType<typeof spyOn>
 let loadSpy: ReturnType<typeof spyOn>
 let setCurrentWorkspaceSpy: ReturnType<typeof spyOn>
 let fetchSpy: ReturnType<typeof spyOn>
+let activeToken: string | null = null
 
 beforeEach(() => {
   getWorkspaceSpy = spyOn(CredentialManager.prototype, 'getWorkspace').mockResolvedValue(null)
@@ -31,6 +33,15 @@ beforeEach(() => {
 
   getWorkspaceDomainsSpy = spyOn(TokenExtractor.prototype, 'getWorkspaceDomains').mockReturnValue({})
 
+  activeToken = null
+  loginSpy = spyOn(SlackClient.prototype, 'login').mockImplementation(function (
+    this: SlackClient,
+    credentials?: { token: string; cookie: string },
+  ) {
+    activeToken = credentials?.token ?? null
+    return Promise.resolve(this)
+  })
+
   testAuthSpy = spyOn(SlackClient.prototype, 'testAuth').mockResolvedValue({
     user_id: 'U123',
     team_id: 'T123',
@@ -55,6 +66,7 @@ afterEach(() => {
   extractSpy?.mockRestore()
   extractCookieSpy?.mockRestore()
   getWorkspaceDomainsSpy?.mockRestore()
+  loginSpy?.mockRestore()
   testAuthSpy?.mockRestore()
   setWorkspaceSpy?.mockRestore()
   loadSpy?.mockRestore()
@@ -62,6 +74,16 @@ afterEach(() => {
   fetchSpy?.mockRestore()
 })
 
+function authResponseByToken(map: Record<string, { team_id: string; team?: string } | Error>) {
+  testAuthSpy.mockImplementation(() => {
+    const token = activeToken ?? '<no-token>'
+    const result = map[token]
+    if (!result) throw new Error('invalid_auth')
+    if (result instanceof Error) throw result
+    return Promise.resolve({ user_id: 'U1', user: 'user', team: result.team, team_id: result.team_id })
+  })
+}
+
 describe('ensureSlackAuth', () => {
   it('skips extraction when stored credentials are valid', async () => {
     // given
@@ -278,7 +300,7 @@ describe('ensureSlackAuth', () => {
     )
   })
 
-  it('skips web refresh when no domain is known for workspace', async () => {
+  it('skips web refresh when domain map is empty', async () => {
     // given — domain mapping is empty
     extractSpy.mockResolvedValue([
       { workspace_id: 'T-stale', workspace_name: 'stale-ws', token: 'xoxc-stale', cookie: 'xoxd-valid' },
@@ -294,6 +316,206 @@ describe('ensureSlackAuth', () => {
     expect(setWorkspaceSpy).not.toHaveBeenCalled()
   })
 
+  it('falls back to other known domains when workspace_id has no domain mapping', async () => {
+    // given — workspace_id 'unknown' (extractor couldn't resolve team id); cookie is valid
+    // for the second candidate domain in root-state.json
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({
+      T_OTHER_A: 'other-a',
+      T_OTHER_B: 'other-b',
+    })
+
+    fetchSpy.mockImplementation((url: string) => {
+      if (url.startsWith('https://other-a.slack.com/')) {
+        return Promise.resolve(new Response('<html>"api_token":"xoxc-fresh-a"</html>', { status: 200 }))
+      }
+      if (url.startsWith('https://other-b.slack.com/')) {
+        return Promise.resolve(new Response('<html>"api_token":"xoxc-fresh-b"</html>', { status: 200 }))
+      }
+      return Promise.resolve(new Response('', { status: 500 }))
+    })
+
+    authResponseByToken({
+      'xoxc-fresh-b': { team_id: 'T_OTHER_B', team: 'Other B' },
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then — both candidate domains were tried; the workspace saves with the resolved team_id
+    expect(fetchSpy).toHaveBeenCalledWith(
+      'https://other-a.slack.com/ssb/redirect',
+      expect.objectContaining({ headers: { Cookie: 'd=xoxd-valid' } }),
+    )
+    expect(fetchSpy).toHaveBeenCalledWith(
+      'https://other-b.slack.com/ssb/redirect',
+      expect.objectContaining({ headers: { Cookie: 'd=xoxd-valid' } }),
+    )
+    expect(setWorkspaceSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ workspace_id: 'T_OTHER_B', token: 'xoxc-fresh-b', workspace_name: 'Other B' }),
+    )
+  })
+
+  it('stops trying domains once a refresh+verify succeeds', async () => {
+    // given — exact-match domain succeeds on first attempt; the fallback domain must not be fetched
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'T_TARGET', workspace_name: 'target', token: 'xoxc-stale', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({
+      T_TARGET: 'target-domain',
+      T_OTHER: 'other-domain',
+    })
+
+    fetchSpy.mockResolvedValue(new Response('<html>"api_token":"xoxc-fresh"</html>', { status: 200 }))
+
+    authResponseByToken({
+      'xoxc-fresh': { team_id: 'T_TARGET', team: 'Target' },
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then — the exact-match domain is tried, fallback domain is not
+    expect(fetchSpy).toHaveBeenCalledWith(
+      'https://target-domain.slack.com/ssb/redirect',
+      expect.objectContaining({ headers: { Cookie: 'd=xoxd-valid' } }),
+    )
+    expect(fetchSpy).not.toHaveBeenCalledWith('https://other-domain.slack.com/ssb/redirect', expect.anything())
+  })
+
+  it('returns failure when no known domain validates the cookie', async () => {
+    // given — none of the domains in the map produce a valid token+cookie pair
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({
+      T_A: 'a',
+      T_B: 'b',
+    })
+
+    fetchSpy.mockResolvedValue(new Response('<html>"api_token":"xoxc-fresh"</html>', { status: 200 }))
+    testAuthSpy.mockRejectedValue(new Error('invalid_auth'))
+
+    // when
+    await ensureSlackAuth()
+
+    // then — every candidate is tried, none save
+    expect(fetchSpy).toHaveBeenCalledWith('https://a.slack.com/ssb/redirect', expect.anything())
+    expect(fetchSpy).toHaveBeenCalledWith('https://b.slack.com/ssb/redirect', expect.anything())
+    expect(setWorkspaceSpy).not.toHaveBeenCalled()
+  })
+
+  it('skips domains with non-subdomain characters', async () => {
+    // given — a tampered root-state.json with a domain that contains a dot/slash/colon
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({
+      T_EVIL: 'attacker.com#',
+      T_GOOD: 'good',
+    })
+
+    fetchSpy.mockResolvedValue(new Response('<html>"api_token":"xoxc-fresh"</html>', { status: 200 }))
+    authResponseByToken({ 'xoxc-fresh': { team_id: 'T_GOOD', team: 'Good' } })
+
+    // when
+    await ensureSlackAuth()
+
+    // then — the bad domain is never fetched; the good domain succeeds
+    expect(fetchSpy).not.toHaveBeenCalledWith(expect.stringContaining('attacker.com'), expect.anything())
+    expect(fetchSpy).toHaveBeenCalledWith('https://good.slack.com/ssb/redirect', expect.anything())
+    expect(setWorkspaceSpy).toHaveBeenCalledWith(expect.objectContaining({ workspace_id: 'T_GOOD' }))
+  })
+
+  it('rejects refresh result when testAuth returns empty team_id', async () => {
+    // given — the fresh token verifies but Slack returns no team_id
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({ T_A: 'a' })
+    fetchSpy.mockResolvedValue(new Response('<html>"api_token":"xoxc-fresh"</html>', { status: 200 }))
+    testAuthSpy.mockResolvedValue({ user_id: 'U1', team_id: '', user: 'user', team: undefined })
+
+    // when
+    await ensureSlackAuth()
+
+    // then — nothing is saved despite successful refresh+login
+    expect(setWorkspaceSpy).not.toHaveBeenCalled()
+  })
+
+  it('does not resolve multiple unknown workspaces to the same team', async () => {
+    // given — two unknown tokens share a cookie that validates against the first candidate domain.
+    // Naive iteration would resolve both to T_A; the resolved-team-id tracker must prevent the
+    // second unknown from claiming an already-saved team.
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale-1', cookie: 'xoxd-valid' },
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale-2', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({ T_A: 'a', T_B: 'b' })
+
+    fetchSpy.mockImplementation((url: string) => {
+      if (url.startsWith('https://a.slack.com/')) {
+        return Promise.resolve(new Response('<html>"api_token":"xoxc-fresh-a"</html>', { status: 200 }))
+      }
+      if (url.startsWith('https://b.slack.com/')) {
+        return Promise.resolve(new Response('<html>"api_token":"xoxc-fresh-b"</html>', { status: 200 }))
+      }
+      return Promise.resolve(new Response('', { status: 500 }))
+    })
+    authResponseByToken({
+      'xoxc-fresh-a': { team_id: 'T_A', team: 'A' },
+      'xoxc-fresh-b': { team_id: 'T_B', team: 'B' },
+    })
+
+    // when
+    await ensureSlackAuth()
+
+    // then — T_A and T_B each saved exactly once
+    const savedIds = setWorkspaceSpy.mock.calls.map((c) => (c[0] as { workspace_id: string }).workspace_id)
+    expect(savedIds.sort()).toEqual(['T_A', 'T_B'])
+  })
+
+  it('caches refresh attempts per (cookie, domain) within one extraction', async () => {
+    // given — two unknown tokens with the same cookie; both will iterate the same domains
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale-1', cookie: 'xoxd-valid' },
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale-2', cookie: 'xoxd-valid' },
+    ])
+    getWorkspaceDomainsSpy.mockReturnValue({ T_A: 'a', T_B: 'b' })
+
+    fetchSpy.mockResolvedValue(new Response('', { status: 500 }))
+    testAuthSpy.mockRejectedValue(new Error('invalid_auth'))
+
+    // when
+    await ensureSlackAuth()
+
+    // then — each domain fetched at most once across both workspaces (2 total, not 4)
+    const refreshCalls = fetchSpy.mock.calls.filter((c) => String(c[0]).includes('/ssb/redirect'))
+    expect(refreshCalls.length).toBe(2)
+  })
+
+  it('caps domain attempts at MAX_DOMAIN_ATTEMPTS', async () => {
+    // given — 20 candidate domains; only the first 16 should be attempted
+    extractSpy.mockResolvedValue([
+      { workspace_id: 'unknown', workspace_name: 'unknown', token: 'xoxc-stale', cookie: 'xoxd-valid' },
+    ])
+    const manyDomains: Record<string, string> = {}
+    for (let i = 0; i < 20; i++) manyDomains[`T_${i}`] = `dom${i}`
+    getWorkspaceDomainsSpy.mockReturnValue(manyDomains)
+
+    fetchSpy.mockResolvedValue(new Response('', { status: 500 }))
+    testAuthSpy.mockRejectedValue(new Error('invalid_auth'))
+
+    // when
+    await ensureSlackAuth()
+
+    // then — exactly 16 refresh attempts
+    const refreshCalls = fetchSpy.mock.calls.filter((c) => String(c[0]).includes('/ssb/redirect'))
+    expect(refreshCalls.length).toBe(16)
+  })
+
   it('skips web refresh when workspace has no cookie', async () => {
     // given — cookie is empty
     extractSpy.mockResolvedValue([