switchroom 0.5.0

package/telegram-plugin/tests/outbound-ordering.test.ts

@@ -0,0 +1,293 @@
+/**
+ * Per-chat FIFO ordering tests for outbound Telegram API calls.
+ *
+ * The MCP tool handlers (reply, stream_reply, react, edit, delete, pin,
+ * forward) used to call `bot.api.*` concurrently with no coordination —
+ * so a later `reply` could overtake an earlier in-flight edit, or a
+ * `react` could resolve before the `reply` it reacts to.
+ *
+ * These tests pin the contract: per-chat dispatches to bot.api run
+ * strictly sequentially (in tool-invocation order) even when later calls
+ * have much shorter mocked latency than earlier ones, and calls to
+ * DIFFERENT chats still run concurrently.
+ */
+import { describe, it, expect } from 'vitest'
+import { createChatLock } from '../chat-lock.js'
+import { handleStreamReply, type StreamReplyDeps, type StreamReplyState } from '../stream-reply-handler.js'
+import type { DraftStreamHandle } from '../draft-stream.js'
+import { createMockBot } from './bot-api.harness.js'
+
+function deferred<T = unknown>(): {
+  promise: Promise<T>
+  resolve: (v: T) => void
+  reject: (e: unknown) => void
+} {
+  let resolve!: (v: T) => void
+  let reject!: (e: unknown) => void
+  const promise = new Promise<T>((r, j) => {
+    resolve = r
+    reject = j
+  })
+  return { promise, resolve, reject }
+}
+
+describe('createChatLock', () => {
+  it('serializes same-chat calls in invocation order even when later work is faster', async () => {
+    const lock = createChatLock()
+    const order: string[] = []
+    const slow = deferred<void>()
+
+    const first = lock.run('c1', async () => {
+      order.push('first:start')
+      await slow.promise
+      order.push('first:end')
+      return 'A'
+    })
+    const second = lock.run('c1', async () => {
+      order.push('second:start')
+      order.push('second:end')
+      return 'B'
+    })
+
+    // Give the scheduler a chance; second must NOT have started yet.
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(order).toEqual(['first:start'])
+
+    slow.resolve()
+    const [a, b] = await Promise.all([first, second])
+    expect(a).toBe('A')
+    expect(b).toBe('B')
+    expect(order).toEqual([
+      'first:start',
+      'first:end',
+      'second:start',
+      'second:end',
+    ])
+  })
+
+  it('runs different chats concurrently', async () => {
+    const lock = createChatLock()
+    const order: string[] = []
+    const d1 = deferred<void>()
+    const d2 = deferred<void>()
+
+    const p1 = lock.run('c1', async () => {
+      order.push('c1:start')
+      await d1.promise
+      order.push('c1:end')
+    })
+    const p2 = lock.run('c2', async () => {
+      order.push('c2:start')
+      await d2.promise
+      order.push('c2:end')
+    })
+
+    // Both should have started before either resolves.
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(order).toEqual(['c1:start', 'c2:start'])
+
+    d2.resolve()
+    d1.resolve()
+    await Promise.all([p1, p2])
+    // c2 finishes first because it was resolved first — no over-serialization.
+    expect(order).toEqual(['c1:start', 'c2:start', 'c2:end', 'c1:end'])
+  })
+
+  it('does not poison the chain on rejection', async () => {
+    const lock = createChatLock()
+    const first = lock.run('c1', async () => {
+      throw new Error('boom')
+    })
+    const second = lock.run('c1', async () => 'ok')
+
+    await expect(first).rejects.toThrow('boom')
+    await expect(second).resolves.toBe('ok')
+  })
+})
+
+describe('wrapBot — bot.api.* calls auto-lock by first-arg chat id', () => {
+  it('same-chat sendMessage calls dispatch in invocation order despite timing inversion', async () => {
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dSlow = deferred<{ message_id: number }>()
+    const startOrder: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      startOrder.push(`A:start:${t}`)
+      const r = await dSlow.promise
+      startOrder.push(`A:end:${t}`)
+      return r
+    })
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      startOrder.push(`B:start:${t}`)
+      return { message_id: 2 }
+    })
+
+    const p1 = wrapped.api.sendMessage('chatX', 'first', {})
+    const p2 = wrapped.api.sendMessage('chatX', 'second', {})
+
+    // Drain microtasks. Only A should have started.
+    await Promise.resolve(); await Promise.resolve()
+    expect(startOrder).toEqual(['A:start:first'])
+
+    dSlow.resolve({ message_id: 1 })
+    await Promise.all([p1, p2])
+
+    expect(startOrder).toEqual(['A:start:first', 'A:end:first', 'B:start:second'])
+    // Confirm the underlying bot saw calls in the right order
+    expect(bot.api.sendMessage.mock.calls.map((c) => c[1])).toEqual(['first', 'second'])
+  })
+
+  it('different chats run concurrently through the same wrapped bot', async () => {
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dA = deferred<{ message_id: number }>()
+    const dB = deferred<{ message_id: number }>()
+    const started: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async (c: string) => {
+      started.push(c)
+      return dA.promise
+    })
+    bot.api.sendMessage.mockImplementationOnce(async (c: string) => {
+      started.push(c)
+      return dB.promise
+    })
+
+    const pA = wrapped.api.sendMessage('A', 'a', {})
+    const pB = wrapped.api.sendMessage('B', 'b', {})
+    await Promise.resolve(); await Promise.resolve()
+    expect(started).toEqual(['A', 'B'])
+
+    dB.resolve({ message_id: 20 })
+    dA.resolve({ message_id: 10 })
+    const [ra, rb] = await Promise.all([pA, pB])
+    expect(ra.message_id).toBe(10)
+    expect(rb.message_id).toBe(20)
+  })
+
+  it('react (setMessageReaction) queues behind an in-flight reply (sendMessage) to the same chat', async () => {
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dSend = deferred<{ message_id: number }>()
+    const wire: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      wire.push('send:start')
+      const r = await dSend.promise
+      wire.push('send:end')
+      return r
+    })
+    bot.api.setMessageReaction.mockImplementationOnce(async () => {
+      wire.push('react:start')
+      return true as const
+    })
+
+    const pReply = wrapped.api.sendMessage('chatZ', 'hello', {})
+    const pReact = wrapped.api.setMessageReaction('chatZ', 42, [{ type: 'emoji', emoji: '👍' }])
+    await Promise.resolve(); await Promise.resolve()
+    expect(wire).toEqual(['send:start']) // react must not have dispatched
+
+    dSend.resolve({ message_id: 99 })
+    await Promise.all([pReply, pReact])
+    expect(wire).toEqual(['send:start', 'send:end', 'react:start'])
+  })
+})
+
+describe('wrapBot + handleStreamReply + reply ordering', () => {
+  function makeDeps(
+    bot: ReturnType<typeof createMockBot>,
+    overrides?: Partial<StreamReplyDeps>,
+  ): StreamReplyDeps {
+    return {
+      bot,
+      markdownToHtml: (t) => t,
+      escapeMarkdownV2: (t) => t,
+      repairEscapedWhitespace: (t) => t,
+      takeHandoffPrefix: () => '',
+      assertAllowedChat: () => {},
+      resolveThreadId: () => undefined,
+      disableLinkPreview: true,
+      defaultFormat: 'text',
+      logStreamingEvent: () => {},
+      endStatusReaction: () => {},
+      historyEnabled: false,
+      recordOutbound: () => {},
+      writeError: () => {},
+      throttleMs: 0,
+      ...overrides,
+    }
+  }
+
+  it('a follow-on reply sendMessage waits for a slow in-flight stream send to resolve', async () => {
+    // Simulates: stream_reply(chat, "draft") in flight, then reply(chat,
+    // "final") to the same chat. Without the lock, the reply's sendMessage
+    // can overtake the stream's sendMessage on the wire. With the lock,
+    // reply starts only after the stream's initial send resolves.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+    const state: StreamReplyState = { activeDraftStreams: new Map<string, DraftStreamHandle>() }
+    const deps = makeDeps(bot, { bot: wrapped })
+
+    const wire: string[] = []
+    const dStreamSend = deferred<{ message_id: number }>()
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      wire.push('stream:send:start')
+      const r = await dStreamSend.promise
+      wire.push('stream:send:end')
+      return r
+    })
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      wire.push('reply:send')
+      return { message_id: 501 }
+    })
+
+    // Fire stream_reply (no done — just an update that triggers the send).
+    const pStream = handleStreamReply({ chat_id: 'cZ', text: 'draft' }, state, deps)
+    // Immediately issue a direct sendMessage via the wrapped bot (stand-in
+    // for a second reply call to the same chat racing the stream).
+    const pReply = wrapped.api.sendMessage('cZ', 'final answer', {})
+
+    for (let i = 0; i < 10; i++) await Promise.resolve()
+    // Stream's send is in flight; reply must be queued behind it.
+    expect(wire).toEqual(['stream:send:start'])
+
+    dStreamSend.resolve({ message_id: 500 })
+    await Promise.all([pStream, pReply])
+
+    expect(wire).toEqual([
+      'stream:send:start',
+      'stream:send:end',
+      'reply:send',
+    ])
+  })
+
+  it('recordOutbound-style history order matches wire order for same-chat races', async () => {
+    // Assert: when two same-chat sendMessage calls race with inverted
+    // latency, the resolution order (what recordOutbound would observe)
+    // matches invocation order.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dA = deferred<{ message_id: number }>()
+    bot.api.sendMessage.mockImplementationOnce(async () => dA.promise)
+    bot.api.sendMessage.mockImplementationOnce(async () => ({ message_id: 2 }))
+
+    const resolved: number[] = []
+    const p1 = wrapped.api.sendMessage('c', 'first', {}).then((r) => resolved.push(r.message_id))
+    const p2 = wrapped.api.sendMessage('c', 'second', {}).then((r) => resolved.push(r.message_id))
+
+    // Resolve A later even though invocation order was A then B.
+    dA.resolve({ message_id: 1 })
+    await Promise.all([p1, p2])
+
+    expect(resolved).toEqual([1, 2])
+  })
+})

package/telegram-plugin/tests/parse-mode-rotation.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Integration tests for stream-reply parseMode rotation.
+ *
+ * Covers the specific bug-1 scenario in stream-reply-handler.ts: when
+ * two stream_reply calls land on the same chat+thread+lane but with
+ * different parseMode (e.g. PTY-tail auto-stream creates a text-mode
+ * stream, then an explicit stream_reply with format:'html' reuses it),
+ * the stale controller must be finalized + discarded and a fresh one
+ * created with the new mode.
+ *
+ * Without that, the second call inherits the wrong parseMode and sends
+ * literal markdown, or edits the wrong baked-in format into Telegram.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { handleStreamReply, type StreamReplyDeps, type StreamReplyState } from '../stream-reply-handler.js'
+import type { DraftStreamHandle } from '../draft-stream.js'
+import { markdownToHtml as realMarkdownToHtml } from '../format.js'
+import { createFakeBotApi, type FakeBot } from './fake-bot-api.js'
+
+function makeState(): StreamReplyState {
+  return {
+    activeDraftStreams: new Map<string, DraftStreamHandle>(),
+    activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+  }
+}
+
+function makeDeps(bot: FakeBot, overrides?: Partial<StreamReplyDeps>): StreamReplyDeps {
+  return {
+    bot: bot as unknown as StreamReplyDeps['bot'],
+    markdownToHtml: (t) => realMarkdownToHtml(t),
+    escapeMarkdownV2: (t) => `ESC(${t})`,
+    repairEscapedWhitespace: (t) => t,
+    takeHandoffPrefix: () => '',
+    assertAllowedChat: () => {},
+    resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
+    disableLinkPreview: true,
+    defaultFormat: 'html',
+    logStreamingEvent: () => {},
+    endStatusReaction: () => {},
+    historyEnabled: false,
+    recordOutbound: () => {},
+    writeError: () => {},
+    throttleMs: 0,
+    ...overrides,
+  }
+}
+
+describe('stream-reply parseMode rotation', () => {
+  let bot: FakeBot
+
+  beforeEach(() => {
+    bot = createFakeBotApi({ startMessageId: 500 })
+  })
+
+  it('same format → stream is reused (no rotation)', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'v1', format: 'html' }, state, deps)
+    const streamBefore = state.activeDraftStreams.get('c:_')
+    await handleStreamReply({ chat_id: 'c', text: 'v2', format: 'html' }, state, deps)
+    const streamAfter = state.activeDraftStreams.get('c:_')
+
+    expect(streamBefore).toBe(streamAfter) // identity preserved
+    expect(bot.state.sent).toHaveLength(1)
+    expect(bot.api.editMessageText).toHaveBeenCalled()
+  })
+
+  it('html → markdownv2 rotation: old stream finalized, new one created', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'hello', format: 'html' }, state, deps)
+    expect(state.activeDraftParseModes.get('c:_')).toBe('HTML')
+    const firstStreamHandle = state.activeDraftStreams.get('c:_')
+
+    // Now call with a different parse mode.
+    await handleStreamReply({ chat_id: 'c', text: 'hello2', format: 'markdownv2' }, state, deps)
+    expect(state.activeDraftParseModes.get('c:_')).toBe('MarkdownV2')
+    const secondStreamHandle = state.activeDraftStreams.get('c:_')
+
+    // Stream instance should have been replaced.
+    expect(secondStreamHandle).not.toBe(firstStreamHandle)
+    // Two messages sent — one in html, one in markdownv2.
+    expect(bot.state.sent).toHaveLength(2)
+    expect(bot.state.sent[0].parse_mode).toBe('HTML')
+    expect(bot.state.sent[1].parse_mode).toBe('MarkdownV2')
+    // The second message's text ran through the MarkdownV2 escaper.
+    expect(bot.state.sent[1].text).toBe('ESC(hello2)')
+  })
+
+  it('undefined (text) → html rotation: old stream finalized, new one created', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot, { defaultFormat: 'text' })
+
+    // First call in text mode (no parse_mode).
+    await handleStreamReply({ chat_id: 'c', text: 'plain', format: 'text' }, state, deps)
+    expect(state.activeDraftParseModes.get('c:_')).toBeUndefined()
+    expect(bot.state.sent[0].parse_mode).toBeUndefined()
+
+    // Second call in html.
+    await handleStreamReply({ chat_id: 'c', text: 'rich', format: 'html' }, state, deps)
+    expect(state.activeDraftParseModes.get('c:_')).toBe('HTML')
+    expect(bot.state.sent).toHaveLength(2)
+    expect(bot.state.sent[1].parse_mode).toBe('HTML')
+  })
+
+  it('markdownv2 → undefined rotation', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'a', format: 'markdownv2' }, state, deps)
+    expect(state.activeDraftParseModes.get('c:_')).toBe('MarkdownV2')
+
+    await handleStreamReply({ chat_id: 'c', text: 'b', format: 'text' }, state, deps)
+    expect(state.activeDraftParseModes.get('c:_')).toBeUndefined()
+    expect(bot.state.sent).toHaveLength(2)
+    expect(bot.state.sent[0].parse_mode).toBe('MarkdownV2')
+    expect(bot.state.sent[1].parse_mode).toBeUndefined()
+  })
+
+  it('rotation across two distinct lanes is independent', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply(
+      { chat_id: 'c', text: 'main', format: 'html', lane: 'main' },
+      state,
+      deps,
+    )
+    await handleStreamReply(
+      { chat_id: 'c', text: 'activity', format: 'text', lane: 'activity' },
+      state,
+      deps,
+    )
+
+    expect(state.activeDraftParseModes.get('c:_:main')).toBe('HTML')
+    expect(state.activeDraftParseModes.get('c:_:activity')).toBeUndefined()
+    // Two messages: different lanes, different modes, different streams.
+    expect(bot.state.sent).toHaveLength(2)
+  })
+
+  it('rotation across threads is independent', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply(
+      { chat_id: 'c', text: 'thread-a', format: 'html', message_thread_id: '1' },
+      state,
+      deps,
+    )
+    await handleStreamReply(
+      { chat_id: 'c', text: 'thread-b', format: 'markdownv2', message_thread_id: '2' },
+      state,
+      deps,
+    )
+
+    expect(state.activeDraftStreams.size).toBe(2)
+    expect(state.activeDraftParseModes.get('c:1')).toBe('HTML')
+    expect(state.activeDraftParseModes.get('c:2')).toBe('MarkdownV2')
+    expect(bot.state.sent).toHaveLength(2)
+  })
+})

package/telegram-plugin/tests/permission-rule.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for the always-allow rule resolver — pinned by the Telegram
+ * `🔁 Always allow` button (popup callback handler in gateway.ts).
+ *
+ * The shape we promise to the gateway:
+ *   - `null` ⇒ "don't show the Always button" (unknown tool, missing
+ *     skill name, characters that could break Claude Code's
+ *     permission-rule grammar).
+ *   - `{rule, label}` ⇒ a string we can hand to
+ *     `switchroom agent grant <agent> <rule>` and a human-readable
+ *     label for the chat confirmation.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { resolveAlwaysAllowRule } from '../permission-rule.js'
+
+describe('resolveAlwaysAllowRule — Skill', () => {
+  it('returns Skill(name) for a typical skill input', () => {
+    const result = resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'mail' }))
+    expect(result).toEqual({ rule: 'Skill(mail)', label: 'Skill(mail)' })
+  })
+
+  it('falls back to skill_name field', () => {
+    const result = resolveAlwaysAllowRule('Skill', JSON.stringify({ skill_name: 'calendar' }))
+    expect(result).toEqual({ rule: 'Skill(calendar)', label: 'Skill(calendar)' })
+  })
+
+  it('falls back to skillName field', () => {
+    const result = resolveAlwaysAllowRule('Skill', JSON.stringify({ skillName: 'garmin' }))
+    expect(result).toEqual({ rule: 'Skill(garmin)', label: 'Skill(garmin)' })
+  })
+
+  it('falls back to name field', () => {
+    const result = resolveAlwaysAllowRule('Skill', JSON.stringify({ name: 'home-assistant' }))
+    expect(result).toEqual({ rule: 'Skill(home-assistant)', label: 'Skill(home-assistant)' })
+  })
+
+  it('extracts skill name from path with SKILL.md', () => {
+    const result = resolveAlwaysAllowRule(
+      'Skill',
+      JSON.stringify({ path: 'skills/coolify/SKILL.md' }),
+    )
+    expect(result).toEqual({ rule: 'Skill(coolify)', label: 'Skill(coolify)' })
+  })
+
+  it('extracts skill name from a directory path', () => {
+    const result = resolveAlwaysAllowRule(
+      'Skill',
+      JSON.stringify({ skill_path: '/home/x/.switchroom/skills/mail' }),
+    )
+    expect(result).toEqual({ rule: 'Skill(mail)', label: 'Skill(mail)' })
+  })
+
+  it('returns null when no skill identifier is present', () => {
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ unrelated: 'x' }))).toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', undefined)).toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', '')).toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', 'not-json')).toBeNull()
+  })
+
+  it('refuses skill names with characters that could break the rule grammar', () => {
+    // Parens, slashes, quotes, whitespace would break Claude Code's
+    // permission-rule parser or expand to unintended matches.
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'mail(secret)' }))).toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'mail/calendar' }))).toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'mail calendar' }))).toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'mail"calendar' }))).toBeNull()
+  })
+
+  it('accepts the safe alphanumeric + ._-+ alphabet', () => {
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'home-assistant' }))).not.toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'home_assistant' }))).not.toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'docs.v2' }))).not.toBeNull()
+    expect(resolveAlwaysAllowRule('Skill', JSON.stringify({ skill: 'work+personal' }))).not.toBeNull()
+  })
+})
+
+describe('resolveAlwaysAllowRule — built-in tools', () => {
+  it.each([
+    'Bash', 'Read', 'Write', 'Edit', 'MultiEdit', 'NotebookEdit',
+    'Glob', 'Grep', 'WebFetch', 'WebSearch',
+    'Task', 'Agent', 'TodoWrite', 'ExitPlanMode',
+  ])('returns the bare tool name for %s', (tool) => {
+    expect(resolveAlwaysAllowRule(tool, undefined)).toEqual({ rule: tool, label: tool })
+  })
+
+  it('returns the bare name even when input_preview is present', () => {
+    // The button is for "trust this tool category" — fine-grained
+    // pattern rules (Bash(npm:*) etc.) are the operator's job to
+    // craft via the CLI.
+    const result = resolveAlwaysAllowRule(
+      'Bash',
+      JSON.stringify({ command: 'rm -rf /tmp/x' }),
+    )
+    expect(result).toEqual({ rule: 'Bash', label: 'Bash' })
+  })
+})
+
+describe('resolveAlwaysAllowRule — MCP tools', () => {
+  it('preserves the namespaced MCP tool name', () => {
+    expect(resolveAlwaysAllowRule('mcp__switchroom-telegram__reply', undefined))
+      .toEqual({ rule: 'mcp__switchroom-telegram__reply', label: 'mcp__switchroom-telegram__reply' })
+  })
+
+  it('accepts MCP server-only namespaces', () => {
+    expect(resolveAlwaysAllowRule('mcp__hindsight', undefined))
+      .toEqual({ rule: 'mcp__hindsight', label: 'mcp__hindsight' })
+  })
+
+  it('refuses malformed mcp_ shapes (missing prefix structure)', () => {
+    expect(resolveAlwaysAllowRule('mcp_foo', undefined)).toBeNull()
+    expect(resolveAlwaysAllowRule('mcp__', undefined)).toBeNull()
+  })
+})
+
+describe('resolveAlwaysAllowRule — fallback', () => {
+  it('returns null for unknown tools', () => {
+    expect(resolveAlwaysAllowRule('UnknownTool', undefined)).toBeNull()
+    expect(resolveAlwaysAllowRule('', undefined)).toBeNull()
+  })
+})

package/telegram-plugin/tests/permission-title.test.ts

@@ -0,0 +1,106 @@
+import { describe, test, expect } from 'vitest'
+import { summarizeToolForTitle } from '../permission-title.js'
+
+describe('summarizeToolForTitle (#186)', () => {
+  test('Skill: surfaces the skill name in brackets', () => {
+    const input = JSON.stringify({ skill: 'mail' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (mail)')
+  })
+
+  test('Bash: truncates long commands', () => {
+    const input = JSON.stringify({
+      command: 'find /var/log -name "*.log" -mtime -1 -exec gzip {} \\;',
+    })
+    const out = summarizeToolForTitle('Bash', input)
+    expect(out.startsWith('Bash: ')).toBe(true)
+    expect(out.length).toBeLessThanOrEqual(60)
+    expect(out.endsWith('…')).toBe(true)
+  })
+
+  test('Read/Edit/Write: shows basename only', () => {
+    const input = JSON.stringify({ file_path: '/long/absolute/path/to/server.ts' })
+    expect(summarizeToolForTitle('Read', input)).toBe('Read: server.ts')
+    expect(summarizeToolForTitle('Edit', input)).toBe('Edit: server.ts')
+    expect(summarizeToolForTitle('Write', input)).toBe('Write: server.ts')
+  })
+
+  test('Glob/Grep: surfaces the pattern', () => {
+    const input = JSON.stringify({ pattern: '**/*.ts' })
+    expect(summarizeToolForTitle('Glob', input)).toBe('Glob: **/*.ts')
+    expect(summarizeToolForTitle('Grep', input)).toBe('Grep: **/*.ts')
+  })
+
+  test('WebFetch: surfaces the URL', () => {
+    const input = JSON.stringify({ url: 'https://example.com/some/page' })
+    expect(summarizeToolForTitle('WebFetch', input)).toBe(
+      'WebFetch: https://example.com/some/page',
+    )
+  })
+
+  test('falls back to bare toolName for unrecognised tools', () => {
+    expect(summarizeToolForTitle('SomeCustomTool', JSON.stringify({ x: 1 }))).toBe(
+      'SomeCustomTool',
+    )
+  })
+
+  test('falls back to bare toolName when input_preview is malformed', () => {
+    expect(summarizeToolForTitle('Skill', 'not-json')).toBe('Skill')
+    expect(summarizeToolForTitle('Skill', '')).toBe('Skill')
+    expect(summarizeToolForTitle('Skill', undefined)).toBe('Skill')
+  })
+
+  test('falls back to bare toolName when expected key is missing', () => {
+    const input = JSON.stringify({ unrelated: 'x' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill')
+    expect(summarizeToolForTitle('Bash', input)).toBe('Bash')
+  })
+
+  test('Bash: collapses internal whitespace before truncating', () => {
+    const input = JSON.stringify({
+      command: 'echo  \t  hello\nworld',
+    })
+    expect(summarizeToolForTitle('Bash', input)).toBe('Bash: echo hello world')
+  })
+
+  test('NotebookEdit: prefers notebook_path when file_path absent', () => {
+    const input = JSON.stringify({ notebook_path: '/work/analysis.ipynb' })
+    expect(summarizeToolForTitle('NotebookEdit', input)).toBe(
+      'NotebookEdit: analysis.ipynb',
+    )
+  })
+
+  // Skill-name fallbacks — the user reported a `🔐 Permission: Skill`
+  // popup with no brackets. Pre-fix only `input.skill` was checked;
+  // these tests pin the wider field set so the skill name lands in
+  // brackets even when Claude Code passes the input in a different
+  // shape.
+  test('Skill: falls back to skill_name field', () => {
+    const input = JSON.stringify({ skill_name: 'calendar' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (calendar)')
+  })
+
+  test('Skill: falls back to skillName field', () => {
+    const input = JSON.stringify({ skillName: 'garmin' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (garmin)')
+  })
+
+  test('Skill: falls back to bare name field', () => {
+    const input = JSON.stringify({ name: 'home-assistant' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (home-assistant)')
+  })
+
+  test('Skill: lifts basename out of a path field', () => {
+    const input = JSON.stringify({ path: 'skills/coolify/SKILL.md' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (coolify)')
+  })
+
+  test('Skill: lifts basename out of a skill_path directory', () => {
+    const input = JSON.stringify({ skill_path: '/x/.switchroom/skills/mail' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (mail)')
+  })
+
+  test('Skill: original `skill` field still wins when multiple are present', () => {
+    const input = JSON.stringify({ skill: 'mail', name: 'wrong' })
+    expect(summarizeToolForTitle('Skill', input)).toBe('Skill (mail)')
+  })
+})