kimaki 1.3.0 → 1.5.0

package/src/tunnel.ts

@@ -5,16 +5,22 @@
 
 import crypto from 'node:crypto'
 import { execFile, spawn, type ChildProcess } from 'node:child_process'
+import http from 'node:http'
 import net from 'node:net'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { promisify, stripVTControlCharacters } from 'node:util'
-import { create as createOpenTunnel, type OpenTunnelConnection } from '@opentunnel/client'
+import {
+  create as createOpenTunnel,
+  isValidRouteName,
+  OpenTunnelClientError,
+  publicUrl,
+  type OpenTunnelClientEvent,
+  type OpenTunnelConnection,
+} from '@opentunnel/client'
 
 const execFileAsync = promisify(execFile)
 
-const ROUTE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/
 const PORT_WAIT_MS = 30_000
-const ATTACH_TIMEOUT_MS = 60_000
 const CHILD_KILL_GRACE_MS = 5_000
 
 // Only lines with host:port, so "Port 5173 is in use" does not match.
@@ -31,12 +37,28 @@ export function detectPortFromText(text: string): number | null {
   return null
 }
 
+// Traforo accepted any tunnel ID, so map it to a DNS label instead of failing: `My_App` becomes `my-app`.
+function toRouteLabel(raw: string): string {
+  const label = raw.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 63).replace(/-+$/, '')
+  return isValidRouteName(label) ? label : ''
+}
+
 // Explicit name, then the tuistory session ID (stable URL across restarts of one session), then random.
 export function routeName({ name, tuistorySessionId }: { name?: string; tuistorySessionId?: string }): string | Error {
-  if (name) return ROUTE_NAME.test(name) ? name : new Error(`Invalid tunnel ID ${JSON.stringify(name)}: use lowercase letters, digits and dashes`)
-  const fromSession = tuistorySessionId?.toLowerCase()
-  if (fromSession && ROUTE_NAME.test(fromSession)) return fromSession
-  return crypto.randomBytes(8).toString('hex')
+  if (name) return toRouteLabel(name) || new Error(`Invalid tunnel ID ${JSON.stringify(name)}: use letters, digits and dashes`)
+  return toRouteLabel(tuistorySessionId ?? '') || crypto.randomBytes(8).toString('hex')
+}
+
+// Parses `netstat -ano` output on Windows: `TCP  0.0.0.0:5173  0.0.0.0:0  LISTENING  1234`.
+export function parseNetstatListeningPids({ stdout, port }: { stdout: string; port: number }): number[] {
+  const pids = new Set<number>()
+  for (const line of stdout.split('\n')) {
+    const [protocol, local, , state, pid] = line.trim().split(/\s+/)
+    if (protocol !== 'TCP' || state !== 'LISTENING' || !local?.endsWith(`:${port}`)) continue
+    const parsed = Number(pid)
+    if (Number.isInteger(parsed) && parsed > 0) pids.add(parsed)
+  }
+  return [...pids]
 }
 
 function isPortInUse({ port, host }: { port: number; host: string }): Promise<boolean> {
@@ -55,6 +77,10 @@ async function waitForPort({ port, host, signal }: { port: number; host: string;
 }
 
 async function listeningPids(port: number): Promise<number[]> {
+  if (process.platform === 'win32') {
+    const { stdout } = await execFileAsync('netstat', ['-ano'], { timeout: 5_000 }).catch(() => ({ stdout: '' }))
+    return parseNetstatListeningPids({ stdout, port })
+  }
   const { stdout } = await execFileAsync('lsof', ['-ti', `tcp:${port}`, '-sTCP:LISTEN'], { timeout: 5_000 }).catch(() => ({ stdout: '' }))
   return stdout.split('\n').map(Number).filter((pid) => Number.isInteger(pid) && pid > 0)
 }
@@ -107,6 +133,69 @@ function killChild(child: ChildProcess | undefined, signal: NodeJS.Signals = 'SI
 
 const log = (line: string) => process.stderr.write(`${line}\n`)
 
+function logTunnelEvent(event: OpenTunnelClientEvent) {
+  if (event.type === 'disconnected') log(`Tunnel disconnected: ${event.reason}`)
+  if (event.type === 'connected') log('Tunnel connected')
+}
+
+function forwardedHeaders({ headers, target }: { headers: http.IncomingHttpHeaders; target: string }): http.OutgoingHttpHeaders {
+  return {
+    ...headers,
+    host: target,
+    'x-forwarded-host': headers['x-forwarded-host'] ?? headers.host,
+    'x-forwarded-proto': headers['x-forwarded-proto'] ?? 'https',
+  }
+}
+
+function rawResponseHead(response: http.IncomingMessage): string {
+  let head = `HTTP/1.1 ${response.statusCode} ${response.statusMessage}\r\n`
+  for (let i = 0; i < response.rawHeaders.length; i += 2) head += `${response.rawHeaders[i]}: ${response.rawHeaders[i + 1]}\r\n`
+  return `${head}\r\n`
+}
+
+// opentunnel forwards the raw bytes, so the app would see the public Host header. Vite and other dev
+// servers reject unknown hosts (DNS rebinding protection) with 403. This loopback proxy sends
+// Host: localhost:<port> and keeps the public host in X-Forwarded-Host, like traforo did.
+export function startHostProxy({ host, port }: { host: string; port: number }): Promise<http.Server | Error> {
+  const target = `${host}:${port}`
+  const server = http.createServer((req, res) => {
+    const upstream = http.request({ host, port, method: req.method, path: req.url, headers: forwardedHeaders({ headers: req.headers, target }) }, (response) => {
+      res.writeHead(response.statusCode ?? 502, response.statusMessage, response.rawHeaders)
+      response.pipe(res)
+    })
+    upstream.on('error', () => {
+      if (!res.headersSent) res.writeHead(502)
+      res.end()
+    })
+    req.pipe(upstream)
+  })
+
+  // WebSocket upgrades (Vite HMR): replay the handshake upstream, then pipe both sockets.
+  server.on('upgrade', (req, socket, head) => {
+    const upstream = http.request({ host, port, method: req.method, path: req.url, headers: forwardedHeaders({ headers: req.headers, target }) })
+    upstream.on('upgrade', (response, upstreamSocket, upstreamHead) => {
+      socket.write(rawResponseHead(response))
+      if (upstreamHead.length > 0) socket.write(upstreamHead)
+      if (head.length > 0) upstreamSocket.write(head)
+      upstreamSocket.on('error', () => socket.destroy())
+      socket.on('error', () => upstreamSocket.destroy())
+      upstreamSocket.pipe(socket).pipe(upstreamSocket)
+    })
+    upstream.on('response', (response) => {
+      socket.write(rawResponseHead(response))
+      response.pipe(socket)
+    })
+    upstream.on('error', () => socket.destroy())
+    socket.on('error', () => upstream.destroy())
+    upstream.end()
+  })
+
+  return new Promise((resolve) => {
+    server.once('error', (cause) => resolve(new Error('Could not start the tunnel proxy', { cause })))
+    server.listen(0, '127.0.0.1', () => resolve(server))
+  })
+}
+
 export async function runTunnel(options: {
   port?: number
   command?: string[]
@@ -127,11 +216,18 @@ export async function runTunnel(options: {
   }
 
   const client = createOpenTunnel()
-  const existing = await client.tunnel.get().catch(() => undefined)
-  if (!existing) log('Creating the opentunnel.xyz tunnel of this machine (waits for a certificate, up to a minute)...')
-  const identity = await client.tunnel.ensure().catch((cause: unknown) => new Error('Could not create the opentunnel tunnel', { cause }))
+  let waitLogged = false
+  const identity = await client.tunnel
+    .ensure({
+      onProgress: (stage) => {
+        if (waitLogged || stage === 'checking-certificate' || stage === 'ready') return
+        waitLogged = true
+        log('Getting a certificate for the opentunnel.xyz tunnel of this machine (up to a minute)...')
+      },
+    })
+    .catch((cause) => new Error('Could not create the opentunnel tunnel', { cause }))
   if (identity instanceof Error) return identity
-  const url = `https://${route}.${identity.hostname}`
+  const url = publicUrl(route, identity.hostname)
 
   let child: ChildProcess | undefined
   let connection: OpenTunnelConnection | undefined
@@ -186,24 +282,27 @@ export async function runTunnel(options: {
   if (!port) return fail(new Error('Could not find the local port. Pass --port'))
   const ready = await waitForPort({ port, host, signal: portSignal })
   if (ready instanceof Error) return fail(ready)
+  const proxy = await startHostProxy({ host, port })
+  if (proxy instanceof Error) return fail(proxy)
+  const proxyAddress = proxy.address()
+  if (!proxyAddress || typeof proxyAddress === 'string') return fail(new Error('Tunnel proxy has no TCP address'))
 
-  // connect retries route_conflict forever, so a route held by another process would hang here.
-  const connecting = client.tunnel.connect({ routes: { [route]: `${host}:${port}` } })
-  const timeout = sleep(ATTACH_TIMEOUT_MS, null, { ref: false })
-  const attached = await Promise.race([connecting, timeout]).catch((cause: unknown) => new Error('Could not connect the tunnel', { cause }))
+  const attached = await client.tunnel
+    .connect({ routes: { [route]: `127.0.0.1:${proxyAddress.port}` }, onRouteConflict: 'fail', onEvent: logTunnelEvent })
+    .catch((cause) => {
+      if (cause instanceof OpenTunnelClientError && cause.code === 'route_conflict') {
+        return new Error(`Tunnel ID ${route} is already used by another process. Pass a different -t`, { cause })
+      }
+      return new Error('Could not connect the tunnel', { cause })
+    })
   if (attached instanceof Error) return fail(attached)
-  if (!attached) return fail(new Error(`Tunnel did not attach in ${ATTACH_TIMEOUT_MS / 1000}s. Another process may use the tunnel ID ${route}`))
   connection = attached
 
-  process.stdout.write(`\nLocal:  http://${host}:${port}\nTunnel: ${url}\n\n`)
-
-  void (async () => {
-    for await (const event of attached.events) {
-      if (event.type === 'disconnected') log(`Tunnel disconnected: ${event.reason}`)
-      if (event.type === 'connected') log('Tunnel connected')
-    }
-  })()
+  process.stdout.write(
+    `\nLocal:  http://${host}:${port}\nTunnel: ${url}\n` +
+      `Agents: validate with the Local URL (playwriter, curl), it is much faster. The Tunnel URL is for the user.\n\n`,
+  )
 
-  const closed = await attached.closed.then(() => undefined, (cause: unknown) => new Error('Tunnel stopped', { cause }))
+  const closed = await attached.closed.then(() => undefined, (cause) => new Error('Tunnel stopped', { cause }))
   return fail(closed ?? new Error('Tunnel stopped'))
 }

package/src/voice-attachments.e2e.test.ts

@@ -39,9 +39,9 @@ const matchers: DeterministicMatcher[] = [
   {
     id: 'image',
     priority: 500,
-    // The plugin adds the numbered <attachments> and <discord-user> to the model request only.
+    // The plugin adds the numbered <attachments>, the concise reminder and <discord-user> to the model request only.
     when: {
-      latestUserTextRegex: 'image-marker[\\s\\S]*<attachments>[\\s\\S]*1\\. dot\\.png \\(inline\\): [^\\n]*\\n2\\. notes\\.txt: [^\\n]*\\n3\\. archive\\.zip: [^\\n]*\\n</attachments>\\n<discord-user ',
+      latestUserTextRegex: 'image-marker[\\s\\S]*<attachments>[\\s\\S]*1\\. dot\\.png \\(inline\\): [^\\n]*\\n2\\. notes\\.txt: [^\\n]*\\n3\\. archive\\.zip: [^\\n]*\\n</attachments>\\n<system-reminder>[^\\n]*</system-reminder>\\n<discord-user ',
       rawPromptIncludes: 'image/png',
     },
     then: { parts: textParts('I see an image') },
@@ -51,6 +51,10 @@ const matchers: DeterministicMatcher[] = [
   reply('voice-btw', 'voice btw ok'),
   reply('voice-new', 'voice new session ok'),
   reply('voice-plan', 'voice plan ok'),
+  reply('order-start', 'order start ok'),
+  // Above order-start: the thread name in <discord-user> repeats that marker.
+  { ...reply('order-voice', 'order voice ok'), priority: 600 },
+  { ...reply('order-text', 'order text ok'), priority: 600 },
 ]
 
 let server: OpencodeTestServer
@@ -130,7 +134,7 @@ test('image and text attachments reach the model as files', async () => {
     --- from: assistant (TestBot)
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     I see an image
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   const sessionId = bot.store.getState().roots[thread.id]!
   const messages = await (await server.client()).message.list({ sessionID: sessionId })
@@ -156,13 +160,78 @@ test('voice in a channel starts a session with the transcription and the spoken
     "--- from: user (tommy)
     [attachment: voice-message.ogg]
     --- from: assistant (TestBot)
-    » **tommy:** Plan the refactor voice-plan
+    -# » **tommy:** Plan the refactor voice-plan
     -# *using deterministic-provider/deterministic-v2 ⋅ plan*
     voice plan ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ plan*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2 ⋅ plan*"
   `)
 })
 
+test('a text sent while a voice message is transcribed waits for it', async () => {
+  const thread = await newThread(() => twin.discord.channel(twin.channelId).user(TEST_USER_ID).sendMessage({ content: 'Start order-start' }))
+  await waitForFooter({ discord: twin.discord, threadId: thread.id })
+  const user = twin.discord.thread(thread.id).user(TEST_USER_ID)
+  await user.sendVoiceMessage({ url: voiceUrl({ transcription: 'Spoken first order-voice', route: 'queue', delayMs: 500 }) })
+  await user.sendMessage({ content: 'Typed second order-text' })
+  await waitForBotMessageContaining({ discord: twin.discord, threadId: thread.id, text: 'order text ok' })
+  await waitForFooter({ discord: twin.discord, threadId: thread.id, count: 2 })
+  expect(await twin.discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    Start order-start
+    --- from: assistant (TestBot)
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    order start ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    --- from: user (tommy)
+    [attachment: voice-message.ogg]
+    Typed second order-text
+    --- from: assistant (TestBot)
+    -# » **tommy:** Spoken first order-voice
+    order text ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+  const sessionId = bot.store.getState().roots[thread.id]!
+  const messages = await (await server.client()).message.list({ sessionID: sessionId, order: 'asc' })
+  expect(messages.data.flatMap((message) => (message.type === 'user' ? [message.text] : []))).toMatchInlineSnapshot(`
+    [
+      "Start order-start",
+      "Spoken first order-voice",
+      "Typed second order-text",
+    ]
+  `)
+})
+
+// https://github.com/remorses/kimaki/issues/246
+test('a long voice transcript is echoed in full over several messages, in a channel and in a thread', async () => {
+  const words = Array.from({ length: 450 }, (_, index) => `w${index}`)
+  const transcription = `Long voice-steer ${words.join(' ')}`
+  const voice = { url: voiceUrl({ transcription, route: 'steer' }) }
+  const thread = await newThread(() => twin.discord.channel(twin.channelId).user(TEST_USER_ID).sendVoiceMessage(voice))
+  await waitForFooter({ discord: twin.discord, threadId: thread.id })
+  await twin.discord.thread(thread.id).user(TEST_USER_ID).sendVoiceMessage(voice)
+  await waitForFooter({ discord: twin.discord, threadId: thread.id, count: 2 })
+  const text = await twin.discord.thread(thread.id).text()
+  expect(text.replace(/w\d+( w\d+)*/g, (run) => `<${run.split(' ')[0]}..${run.split(' ').at(-1)}>`)).toMatchInlineSnapshot(`
+    "--- from: user (tommy)
+    [attachment: voice-message.ogg]
+    --- from: assistant (TestBot)
+    -# » **tommy:** Long voice-steer <w0..w414>
+    -# <w415..w449>
+    -# *using deterministic-provider/deterministic-v2 ⋅ build*
+    voice steer ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    --- from: user (tommy)
+    [attachment: voice-message.ogg]
+    --- from: assistant (TestBot)
+    -# » **tommy:** Long voice-steer <w0..w414>
+    -# <w415..w449>
+    voice steer ok
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+  `)
+  const echoed = (await twin.discord.thread(thread.id).getMessages()).map((message) => message.content).filter((content) => /\bw\d/.test(content))
+  expect(echoed.join(' ').replaceAll('-# ', '')).toBe(`» **tommy:** ${transcription} » **tommy:** ${transcription}`)
+})
+
 // https://github.com/remorses/kimaki/issues/235
 test('uploaded audio files with odd Discord media types are transcribed', async () => {
   const user = twin.discord.channel(twin.channelId).user(TEST_USER_ID)
@@ -179,10 +248,10 @@ test('uploaded audio files with odd Discord media types are transcribed', async
     "--- from: user (tommy)
     [attachment: memo.m4a]
     --- from: assistant (TestBot)
-    » **tommy:** From m4a voice-steer
+    -# » **tommy:** From m4a voice-steer
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     voice steer ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect([m4a.name, mp3.name]).toMatchInlineSnapshot(`
     [
@@ -217,7 +286,7 @@ test('voice in a busy thread: queue waits, btw forks, new-session starts a threa
   await waitForFooter({ discord: twin.discord, threadId: thread.id, count: 2 })
 
   const hide = (text: string) => text.replace(/<#\d+>/g, '<#THREAD>')
-  expect(hide(await twin.discord.thread(thread.id).text())).toMatchInlineSnapshot(`
+  expect(hide(await twin.discord.thread(thread.id).text({ showReplies: true }))).toMatchInlineSnapshot(`
     "--- from: user (tommy)
     Long work slow-marker
     --- from: assistant (TestBot)
@@ -225,23 +294,30 @@ test('voice in a busy thread: queue waits, btw forks, new-session starts a threa
     --- from: user (tommy)
     [attachment: voice-message.ogg]
     --- from: assistant (TestBot)
-    » **tommy:** Afterwards voice-queue
-    -# Queued message sent
+    [reply to tommy: ]
+    -# » **tommy:** Afterwards voice-queue
+    [reply to tommy: ]
+    -# Queued
     --- from: user (tommy)
     [attachment: voice-message.ogg]
     --- from: assistant (TestBot)
-    » **tommy:** Side voice-btw
+    [reply to tommy: ]
+    -# » **tommy:** Side voice-btw
+    [reply to tommy: ]
     Session forked! Continue in <#THREAD>
     --- from: user (tommy)
     [attachment: voice-message.ogg]
     --- from: assistant (TestBot)
-    » **tommy:** Fresh start voice-new
+    [reply to tommy: ]
+    -# » **tommy:** Fresh start voice-new
+    [reply to tommy: ]
     Started a new session in <#THREAD>
     slow-done
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-    » **tommy:** Afterwards voice-queue
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+    [reply to tommy: ]
+    -# Queued message sent
     voice queue ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect([btw.name, fresh.name]).toMatchInlineSnapshot(`
     [
@@ -254,14 +330,14 @@ test('voice in a busy thread: queue waits, btw forks, new-session starts a threa
     Reusing context from <#THREAD> to answer prompt...
     Side voice-btw
     voice btw ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   expect(hide(await twin.discord.thread(fresh.id).text())).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    » **tommy:** Fresh start voice-new
+    -# » **tommy:** Fresh start voice-new
     -# *using deterministic-provider/deterministic-v2 ⋅ build*
     voice new session ok
-    -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+    -# *main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
   `)
   // The transcription request offers btw and queue only inside a session thread.
   expect(gemini.requests.map((request) => request.routes)).toMatchInlineSnapshot(`
@@ -270,6 +346,22 @@ test('voice in a busy thread: queue waits, btw forks, new-session starts a threa
         "steer",
         "new-session",
       ],
+      [
+        "steer",
+        "queue",
+        "btw",
+        "new-session",
+      ],
+      [
+        "steer",
+        "new-session",
+      ],
+      [
+        "steer",
+        "queue",
+        "btw",
+        "new-session",
+      ],
       [
         "steer",
         "new-session",

package/src/voice-call.e2e.test.ts

@@ -136,12 +136,12 @@ test('a user joins and speaks, the backend runs kimaki commands and the model sa
   // Thread IDs are snowflakes: replace them for a stable snapshot.
   expect((await twin.discord.channel(voiceChannelId).text()).replace(/<#\d+>/g, '<#thread>')).toMatchInlineSnapshot(`
     "--- from: assistant (TestBot)
-    -# ⬦ voice call started ⋅ gpt-live ⋅ cove
+    -# voice call started ⋅ gpt-live ⋅ cove
     Hello tommy.
-    » **tommy:** Which projects do I have?
+    -# » **tommy:** Which projects do I have?
     -# ┣ shell _seq 1 2000; kimaki project list_
     -# ┣ shell _kimaki send --channel 200000000000000100 --prompt 'Voice call note' --notify-on…_
-    -# ⬦ session started in <#thread>
+    -# session started in <#thread>
     -#  ⨯  post\\_message _text must not be empty_
     You have one project."
   `)
@@ -205,12 +205,12 @@ test('chat messages reach the backend, and end_call leaves after the goodbye whi
   expect(botPackets() - packetsBefore).toBeGreaterThanOrEqual(30)
   expect(live.backendInputs.at(-1)).toBe(`<chat-message from="tommy" user-id="${TEST_USER_ID}">\nplease hang up\n</chat-message>`)
   expect(await chatSince(before)).toMatchInlineSnapshot(`
-    "TestBot: -# ⬦ voice call started ⋅ gpt-live ⋅ cove
+    "TestBot: -# voice call started ⋅ gpt-live ⋅ cove
     TestBot: Hi again.
     tommy: please hang up
     TestBot: -# ┣ end\\_call
     TestBot: Bye.
-    TestBot: -# ⬦ voice call ended: the assistant hung up"
+    TestBot: -# voice call ended: the assistant hung up"
   `)
   await twin.discord.channel(voiceChannelId).user(TEST_USER_ID).leaveVoice()
 })
@@ -244,15 +244,15 @@ test('finished threads of any project are announced in the call; the model answe
   live.replies.length = 0
 
   expect(await chatSince(before)).toMatchInlineSnapshot(`
-    "TestBot: -# ⬦ voice call started ⋅ gpt-live ⋅ cove
+    "TestBot: -# voice call started ⋅ gpt-live ⋅ cove
     TestBot: Hi.
     tommy: start a thread
     TestBot: -# ┣ shell _kimaki send --channel <id> --prompt 'call-thread-marker' --user '…_
-    TestBot: -# ⬦ session started in <#<id>>
+    TestBot: -# session started in <#<id>>
     TestBot: Started.
-    TestBot: -# ⬦ thread finished: call-thread-marker ⋅ https://discord.com/channels/<id>/<id> ⋅ <ses>
+    TestBot: -# thread finished: call-thread-marker ⋅ https://discord.com/channels/<id>/<id> ⋅ <ses>
     TestBot: Your thread finished.
-    TestBot: -# ⬦ thread finished: other-thread-marker ⋅ https://discord.com/channels/<id>/<id> ⋅ <ses>"
+    TestBot: -# thread finished: other-thread-marker ⋅ https://discord.com/channels/<id>/<id> ⋅ <ses>"
   `)
   const notices = live.appends.filter((append) => append.text.startsWith('<system>Thread finished'))
   expect(notices.map((notice) => ({ ...notice, text: notice.text.replace(/\d{17,20}/g, '<id>').replace(/ses_\w+/g, '<ses>') }))).toMatchInlineSnapshot(`

package/src/voice-call.ts

@@ -330,7 +330,7 @@ export function createVoiceCalls({ opencodeConfigDir }: { opencodeConfigDir: str
 
   // Bot lines in the text chat of the voice channel, through the same FIFO as session output.
   function post(bot: Bot, { channelId, text, markdown = false }: { channelId: string; text: string; markdown?: boolean }) {
-    bot.effects.run(channelId, [markdown ? { type: 'markdown', text, blankLineBefore: false } : { type: 'send', text }])
+    bot.effects.run(channelId, [markdown ? { type: 'markdown', text, blankLineBefore: false, replyTo: null } : { type: 'send', text }])
   }
 
   // Errors during a call go to the log and to the text chat of the voice channel.
@@ -505,7 +505,7 @@ export function createVoiceCalls({ opencodeConfigDir }: { opencodeConfigDir: str
                 sent.push(threadId)
                 current.started.add(threadId)
                 if (waits) current.waiting.add(threadId)
-                post(bot, { channelId: current.channelId, text: asSubtext(`⬦ ${started} <#${threadId}>`) })
+                post(bot, { channelId: current.channelId, text: asSubtext(`${started} <#${threadId}>`) })
               }
             : undefined
           const run = runShell(bot, { call: current, command: input.command, timeoutMs, onLine }).then((result) => {
@@ -668,8 +668,8 @@ export function createVoiceCalls({ opencodeConfigDir }: { opencodeConfigDir: str
     }
     listen(bot, call)
     logger.info(`voice call started in ${channelId}, voice ${settings.voice}`)
-    post(bot, { channelId, text: `-# ⬦ voice call started ⋅ gpt-live ⋅ ${settings.voice}` })
-    if (settings.voiceNotice) post(bot, { channelId, text: asSubtext(`⬦ ${settings.voiceNotice}`) })
+    post(bot, { channelId, text: `-# voice call started ⋅ gpt-live ⋅ ${settings.voice}` })
+    if (settings.voiceNotice) post(bot, { channelId, text: asSubtext(settings.voiceNotice) })
     live.append({ text: 'The call started. Greet the users by name in one short sentence.', channel: 'speakable' })
   }
 
@@ -684,7 +684,7 @@ export function createVoiceCalls({ opencodeConfigDir }: { opencodeConfigDir: str
     call.speaker.stop()
     if (call.connection.state.status !== VoiceConnectionStatus.Destroyed) call.connection.destroy()
     logger.info(`voice call ended in ${call.channelId}${reason ? `: ${reason}` : ''}`)
-    post(bot, { channelId: call.channelId, text: `-# ⬦ voice call ended${reason ? `: ${reason}` : ''}` })
+    post(bot, { channelId: call.channelId, text: `-# voice call ended${reason ? `: ${reason}` : ''}` })
   }
 
   async function onVoiceState(bot: Bot, { before, after }: { before: VoiceState; after: VoiceState }) {
@@ -727,7 +727,7 @@ export function createVoiceCalls({ opencodeConfigDir }: { opencodeConfigDir: str
     if (!call || call.ending) return
     const url = `https://discord.com/channels/${thread.guildId}/${threadId}`
     const state = error === null ? 'finished' : 'failed'
-    post(bot, { channelId: call.channelId, text: asSubtext(`⬦ thread ${state}: ${thread.name} ⋅ ${url} ⋅ ${sessionId}`) })
+    post(bot, { channelId: call.channelId, text: asSubtext(`thread ${state}: ${thread.name} ⋅ ${url} ⋅ ${sessionId}`) })
     const failure = error === null ? '' : ` Error: ${error}`
     const notice = `<system>Thread ${state}: "${thread.name}". Thread ID ${threadId}, session ID ${sessionId}, URL ${url}.${failure}</system>`
     // Answer only for threads started in this call. A pending kimaki send --wait brings the transcript next.