typeclaw 0.1.0 → 0.1.2

package/src/channels/adapters/kakaotalk.ts

@@ -8,6 +8,7 @@ import {
   type KakaoProfile,
   type KakaoSendResult,
   type KakaoTalkListenerEventMap,
+  type KakaoTalkPushEmoticonEvent,
   type KakaoTalkPushMessageEvent,
 } from 'agent-messenger/kakaotalk'
 
@@ -24,9 +25,11 @@ import type {
   SendResult,
 } from '@/channels/types'
 
+import { emoticonEventToMessageEvent, formatHistoryText, formatInboundText } from './kakaotalk-attachment'
 import { createKakaoAuthorResolver, type KakaoAuthorResolver } from './kakaotalk-author-resolver'
 import { createKakaoChannelResolver, type KakaoChannelResolver } from './kakaotalk-channel-resolver'
 import { classifyInbound, type InboundDropReason } from './kakaotalk-classify'
+import { createFetchAttachmentCallback } from './kakaotalk-fetch-attachment'
 
 // Inlined locally because agent-messenger/kakaotalk's index does not
 // re-export KakaoMarkReadResult even though client.markRead returns it
@@ -237,7 +240,7 @@ export function createKakaoHistoryCallback(deps: {
             externalMessageId: m.log_id,
             authorId,
             authorName,
-            text: m.message,
+            text: formatHistoryText(m),
             ts: m.sent_at,
             isBot: selfId !== null && authorId === selfId,
             replyToBotMessageId: null,
@@ -312,11 +315,46 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
     formatChannelTag,
   })
 
+  const fetchAttachmentCallback = createFetchAttachmentCallback({ logger })
+
   const handleMessageEvent = async (event: KakaoTalkPushMessageEvent): Promise<void> => {
+    // Synthesize the displayed text BEFORE classify so attachments
+    // (photo, file, video, ...) survive classifyInbound's empty_text
+    // drop and reach the agent with a `[KakaoTalk message with ...]`
+    // placeholder. For text-only messages this is a no-op —
+    // formatInboundText returns event.message unchanged. See
+    // kakaotalk-attachment.ts for the per-message-type rules.
+    await processInbound({ ...event, message: formatInboundText(event) })
+  }
+
+  const handleEmoticonEvent = async (event: KakaoTalkPushEmoticonEvent): Promise<void> => {
+    // Stickers arrive on a separate listener event in agent-messenger
+    // 2.15.0 and have no `message` field. We wrap them into the same
+    // MSG-shaped payload classifyInbound expects so the engagement /
+    // allow-list / self-author rules apply identically across plain
+    // messages and stickers — there is no second classifier to keep in
+    // sync.
+    await processInbound(emoticonEventToMessageEvent(event))
+  }
+
+  const processInbound = async (event: KakaoTalkPushMessageEvent): Promise<void> => {
     inflightInbounds++
     try {
       if (channelResolver.lookupChat(event.chat_id) === null) {
         await channelResolver.refresh()
+        if (channelResolver.lookupChat(event.chat_id) === null) {
+          // The push event itself proves the chat exists, even when
+          // getChats({all:true}) does not surface it (e.g. memo chats,
+          // certain open chats, recently-joined groups that haven't
+          // propagated). Register a provisional @kakao-group entry so the
+          // strictest allow rules still apply, but the message is no longer
+          // silently dropped as unknown_chat. The next real refresh
+          // upgrades the entry if the chat is actually a DM or open chat.
+          channelResolver.ingestProvisional(event.chat_id)
+          logger.warn(
+            `[kakaotalk] provisional chat=${event.chat_id} log_id=${event.log_id} bucket=@kakao-group reason=not_in_getchats`,
+          )
+        }
       }
 
       const inboundTag = await formatChannelTag(
@@ -324,7 +362,7 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
         event.chat_id,
       )
       logger.info(
-        `[kakaotalk] inbound log_id=${event.log_id} author=${event.author_id} ${inboundTag} text_len=${event.message.length}`,
+        `[kakaotalk] inbound log_id=${event.log_id} author=${event.author_id} ${inboundTag} type=${event.message_type} text_len=${event.message.length}`,
       )
 
       // Ack the message BEFORE classify/route so the sender's unread "1"
@@ -500,6 +538,9 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
       listener.on('message', (event) => {
         void handleMessageEvent(event)
       })
+      listener.on('emoticon', (event) => {
+        void handleEmoticonEvent(event)
+      })
       listener.on('member_joined', () => {
         void channelResolver.refresh()
       })
@@ -510,6 +551,18 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
       try {
         await listener.start()
       } catch (err) {
+        // Tear down defensively. Handlers (including the new 'emoticon'
+        // one) were already wired before start(), and a partial start can
+        // leave LOCO sockets half-open in the SDK. Without an explicit
+        // stop here, a later adapter.stop() short-circuits on
+        // !started and the listener leaks; with it, the SDK closes its
+        // resources and our handler closures become unreachable.
+        try {
+          listener.stop()
+        } catch {
+          // ignore — best-effort cleanup, the start failure is what we surface
+        }
+        listener = null
         started = false
         logger.error(`[kakaotalk] listener start failed: ${describe(err)}`)
         throw err
@@ -523,6 +576,7 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
       options.router.registerOutbound('kakaotalk', outboundCallback)
       options.router.registerChannelNameResolver('kakaotalk', channelResolver.resolve)
       options.router.registerHistory('kakaotalk', historyCallback)
+      options.router.registerFetchAttachment('kakaotalk', fetchAttachmentCallback)
     },
 
     async stop(): Promise<void> {
@@ -531,6 +585,7 @@ export function createKakaotalkAdapter(options: KakaotalkAdapterOptions): Kakaot
       options.router.unregisterOutbound('kakaotalk', outboundCallback)
       options.router.unregisterChannelNameResolver('kakaotalk', channelResolver.resolve)
       options.router.unregisterHistory('kakaotalk', historyCallback)
+      options.router.unregisterFetchAttachment('kakaotalk', fetchAttachmentCallback)
       if (inflightInbounds > 0) {
         await new Promise<void>((resolve) => {
           stopWaiters.push(resolve)
@@ -601,7 +656,7 @@ function dropHint(
     case 'not_in_allow_list':
       return ` (add ${suggestedAllowPattern(bucket, chatId)} to channels.kakaotalk.allow to admit this chat)`
     case 'unknown_chat':
-      return ' (chat not in cache; resolver refresh may be lagging)'
+      return ' (chat not in cache after refresh and provisional registration; check earlier resolver-refresh-failed warnings)'
     case 'empty_text':
     case 'pre_connect':
     case 'self_author':

package/src/channels/router.ts

@@ -776,6 +776,32 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
     }
   }
 
+  const fireSessionTurnStart = async (live: LiveSession): Promise<void> => {
+    if (!live.hooks) return
+    try {
+      await live.hooks.runSessionTurnStart({
+        sessionId: live.sessionId,
+        agentDir: options.agentDir,
+        origin: buildLiveOrigin(live),
+      })
+    } catch (err) {
+      logger.warn(`[channels] session.turn.start hook threw for ${live.keyId}: ${describe(err)}`)
+    }
+  }
+
+  const fireSessionTurnEnd = async (live: LiveSession): Promise<void> => {
+    if (!live.hooks) return
+    try {
+      await live.hooks.runSessionTurnEnd({
+        sessionId: live.sessionId,
+        agentDir: options.agentDir,
+        origin: buildLiveOrigin(live),
+      })
+    } catch (err) {
+      logger.warn(`[channels] session.turn.end hook threw for ${live.keyId}: ${describe(err)}`)
+    }
+  }
+
   const buildLiveOrigin = (live: LiveSession): SessionOrigin => {
     const membership = readMembership(live.key)
     return {
@@ -848,6 +874,7 @@ 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
+        await fireSessionTurnStart(live)
         try {
           await live.session.prompt(text)
           await validateChannelTurn(live, successfulSendsBeforePrompt)
@@ -856,6 +883,8 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
         } catch (err) {
           logger.warn(`[channels] ${live.keyId}: prompt threw: ${describe(err)}`)
           live.consecutiveSends.clear()
+        } finally {
+          await fireSessionTurnEnd(live)
         }
         await fireSessionIdle(live)
         live.lastTurnAuthorIds = new Set(live.currentTurnAuthorIds)
@@ -1155,10 +1184,19 @@ export function createChannelRouter(options: CreateChannelRouterOptions): Channe
   ): Promise<FetchAttachmentResult> => {
     const callbacks = fetchAttachmentCallbacks.get(adapter)
     if (!callbacks || callbacks.size === 0) {
-      return { ok: false, error: 'fetch-attachment-not-supported' }
+      return { ok: false, error: `no fetchAttachment callback registered for "${adapter}"` }
     }
     const snapshot = Array.from(callbacks)
-    let lastError: FetchAttachmentResult & { ok: false } = { ok: false, error: 'fetch-attachment-not-supported' }
+    // Initialized only so TypeScript can prove the variable is assigned
+    // before return. The loop body always overwrites it on the failure
+    // path (we just returned on the success path), so this string is
+    // unreachable at runtime — kept as a clearly-tagged sentinel rather
+    // than a non-null assertion so a future loop refactor that breaks
+    // this invariant surfaces a recognizable error string.
+    let lastError: FetchAttachmentResult & { ok: false } = {
+      ok: false,
+      error: `fetchAttachment for "${adapter}" returned no result (router bug)`,
+    }
     for (const cb of snapshot) {
       const result = await cb(args)
       if (result.ok) return result

package/src/cli/compose.ts

@@ -1,7 +1,17 @@
 import { defineCommand } from 'citty'
 
-import { composeLogs, composeRestart, composeStart, composeStatus, composeStop, type AgentResult } from '@/compose'
+import {
+  composeDoctor,
+  composeLogs,
+  composeRestart,
+  composeStart,
+  composeStatus,
+  composeStop,
+  type AgentResult,
+  type ComposeDoctorReport,
+} from '@/compose'
 import { config } from '@/config'
+import { formatJson, formatReport } from '@/doctor'
 
 import { formatComposeStatus } from './compose-status'
 import { c, spinner } from './ui'
@@ -156,6 +166,41 @@ const logsSub = defineCommand({
   },
 })
 
+const doctorSub = defineCommand({
+  meta: { name: 'doctor', description: 'diagnose every agent in immediate subdirectories of cwd' },
+  args: {
+    verbose: { type: 'boolean', alias: 'v', default: false, description: 'show check details' },
+    json: { type: 'boolean', default: false, description: 'emit the report as JSON' },
+    fix: {
+      type: 'boolean',
+      default: false,
+      description: 'attempt auto-fixes per agent and commit changes in each agent folder',
+    },
+    only: { type: 'string', description: 'comma-separated category filter' },
+    shallow: {
+      type: 'boolean',
+      default: false,
+      description: 'run cross-agent checks only; skip per-agent doctor runs',
+    },
+  },
+  async run({ args }) {
+    const only = args.only
+      ? args.only
+          .split(',')
+          .map((s) => s.trim())
+          .filter((s) => s.length > 0)
+      : undefined
+    const report = await composeDoctor({
+      rootCwd: process.cwd(),
+      fix: args.fix,
+      shallow: args.shallow,
+      ...(only !== undefined ? { only } : {}),
+    })
+    emitComposeDoctor(report, { verbose: args.verbose, json: args.json })
+    if (!report.ok) process.exit(1)
+  },
+})
+
 export const composeCommand = defineCommand({
   meta: {
     name: 'compose',
@@ -167,6 +212,7 @@ export const composeCommand = defineCommand({
     restart: restartSub,
     status: statusSub,
     logs: logsSub,
+    doctor: doctorSub,
   },
 })
 
@@ -238,3 +284,48 @@ function formatRestartDone<T extends { start: { hostPort: number } }>(result: Ag
   if (!result.ok) return `${c.red('✖')} ${c.red('failed:')} ${result.reason}`
   return `${c.green('✔')} restarted on host port ${c.cyan(String(result.data.start.hostPort))}`
 }
+
+function emitComposeDoctor(report: ComposeDoctorReport, opts: { verbose: boolean; json: boolean }): void {
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`)
+    return
+  }
+  const useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined
+  const sectionHead = useColor ? c.bold : (s: string) => s
+
+  process.stdout.write(`${sectionHead('compose doctor')}  ${c.dim(report.rootCwd)}\n\n`)
+
+  process.stdout.write(`${sectionHead('Cross-agent checks')}\n`)
+  for (const check of report.crossChecks) {
+    const marker = checkMarker(check.status)
+    process.stdout.write(`  ${marker} ${check.message} ${c.dim(`(${check.name})`)}\n`)
+    if (opts.verbose && check.details !== undefined) {
+      for (const d of check.details) process.stdout.write(`      ${c.dim(`• ${d}`)}\n`)
+    }
+  }
+  process.stdout.write('\n')
+
+  for (const agent of report.agents) {
+    process.stdout.write(`${sectionHead(`Agent: ${agent.entry.name}`)}  ${c.dim(agent.entry.cwd)}\n`)
+    process.stdout.write(
+      `${opts.json ? formatJson(agent.result.final ?? agent.result.initial) : formatReport(agent.result.initial, { useColor, verbose: opts.verbose })}\n\n`,
+    )
+  }
+
+  process.stdout.write(
+    `${report.ok ? c.green('●') : c.red('●')} compose doctor ${report.ok ? 'passed' : 'found issues'}\n`,
+  )
+}
+
+function checkMarker(status: 'ok' | 'warning' | 'error' | 'info'): string {
+  switch (status) {
+    case 'ok':
+      return c.green('✓')
+    case 'warning':
+      return c.yellow('!')
+    case 'error':
+      return c.red('✗')
+    case 'info':
+      return c.cyan('i')
+  }
+}

package/src/cli/doctor.ts

@@ -0,0 +1,100 @@
+import { defineCommand } from 'citty'
+
+import { formatJson, formatReport, runDoctor, type DoctorRunResult } from '@/doctor'
+import { findAgentDir } from '@/init'
+
+export const doctorCommand = defineCommand({
+  meta: {
+    name: 'doctor',
+    description: 'diagnose the host, agent folder, and plugins; surface remediation steps',
+  },
+  args: {
+    verbose: {
+      type: 'boolean',
+      alias: 'v',
+      description: 'show check details and per-entry hints',
+      default: false,
+    },
+    json: {
+      type: 'boolean',
+      description: 'emit the doctor report as JSON',
+      default: false,
+    },
+    fix: {
+      type: 'boolean',
+      description: 'attempt to auto-fix issues and commit changes in the agent folder',
+      default: false,
+    },
+    only: {
+      type: 'string',
+      description: 'comma-separated list of categories to include (e.g. docker,config)',
+    },
+  },
+  async run({ args }) {
+    const cwd = findAgentDir(process.cwd()) ?? process.cwd()
+    const only = parseOnly(args.only)
+    const result = await runDoctor({
+      cwd,
+      fix: args.fix,
+      ...(only !== undefined ? { only } : {}),
+    })
+    emit(result, { verbose: args.verbose, json: args.json })
+    process.exit(exitCodeFor(result))
+  },
+})
+
+export function exitCodeFor(result: DoctorRunResult): number {
+  const last = result.final ?? result.initial
+  if (last.ok) return 0
+  return 1
+}
+
+function parseOnly(value: string | undefined): string[] | undefined {
+  if (value === undefined) return undefined
+  const parts = value
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0)
+  return parts.length > 0 ? parts : undefined
+}
+
+function emit(result: DoctorRunResult, opts: { verbose: boolean; json: boolean }): void {
+  if (opts.json) {
+    process.stdout.write(`${formatJson(result.final ?? result.initial)}\n`)
+    return
+  }
+  const useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined
+  process.stdout.write(`${formatReport(result.initial, { useColor, verbose: opts.verbose })}\n`)
+
+  if (result.fixAttempts) {
+    process.stdout.write('\n')
+    process.stdout.write(`${formatFixAttempts(result, useColor)}\n`)
+  }
+  if (result.final) {
+    process.stdout.write('\n')
+    process.stdout.write(`${formatReport(result.final, { useColor, verbose: opts.verbose })}\n`)
+  }
+}
+
+function formatFixAttempts(result: DoctorRunResult, useColor: boolean): string {
+  const lines: string[] = []
+  lines.push(useColor ? '\u001b[1m--fix\u001b[0m' : '--fix')
+  for (const attempt of result.fixAttempts ?? []) {
+    const tag = attempt.source === 'static' ? '[static]' : `[plugin]`
+    if (attempt.ok) {
+      lines.push(`  ${tag} ${attempt.name}: ${attempt.summary}`)
+    } else {
+      lines.push(`  ${tag} ${attempt.name}: failed: ${attempt.reason}`)
+    }
+  }
+  if (result.commit) {
+    if (result.commit.kind === 'committed') {
+      lines.push(`  commit: ${result.commit.commitSha.slice(0, 12)} (${result.commit.pathsStaged.length} path(s))`)
+    } else if (result.commit.kind === 'skipped') {
+      lines.push(`  commit: skipped — ${result.commit.reason}`)
+    } else {
+      lines.push(`  commit: failed — ${result.commit.reason}`)
+    }
+  }
+  return lines.join('\n')
+}

package/src/cli/index.ts

@@ -20,6 +20,7 @@ const main = defineCommand({
     shell: () => import('./shell').then((m) => m.shellCommand),
     compose: () => import('./compose').then((m) => m.composeCommand),
     channel: () => import('./channel').then((m) => m.channelCommand),
+    doctor: () => import('./doctor').then((m) => m.doctorCommand),
     _hostd: () => import('./hostd').then((m) => m.hostdCommand),
   },
 })

package/src/compose/doctor.ts

@@ -0,0 +1,141 @@
+import { loadConfigSync } from '@/config'
+import { runDoctor, type DoctorRunResult, type RunDoctorOptions } from '@/doctor'
+
+import { discoverAgents, type AgentEntry } from './discover'
+
+export type ComposeDoctorAgent = {
+  entry: AgentEntry
+  result: DoctorRunResult
+}
+
+export type ComposeDoctorCrossCheck = {
+  name: string
+  status: 'ok' | 'warning' | 'error' | 'info'
+  message: string
+  details?: string[]
+}
+
+export type ComposeDoctorReport = {
+  rootCwd: string
+  agents: ComposeDoctorAgent[]
+  crossChecks: ComposeDoctorCrossCheck[]
+  ok: boolean
+}
+
+export type ComposeDoctorOptions = {
+  rootCwd: string
+  fix?: boolean
+  only?: string[]
+  shallow?: boolean
+  runDoctorFn?: (opts: RunDoctorOptions) => Promise<DoctorRunResult>
+}
+
+export async function composeDoctor(opts: ComposeDoctorOptions): Promise<ComposeDoctorReport> {
+  const runDoctorFn = opts.runDoctorFn ?? runDoctor
+  const agents = discoverAgents(opts.rootCwd)
+
+  const crossChecks: ComposeDoctorCrossCheck[] = []
+  if (agents.length === 0) {
+    crossChecks.push({
+      name: 'compose.root-has-agents',
+      status: 'info',
+      message: 'no typeclaw agents found in immediate subdirectories',
+    })
+  } else {
+    crossChecks.push(...runCrossChecks(agents))
+  }
+
+  let agentResults: ComposeDoctorAgent[] = []
+  if (!opts.shallow) {
+    agentResults = await Promise.all(
+      agents.map(async (entry) => ({
+        entry,
+        result: await runDoctorFn({
+          cwd: entry.cwd,
+          ...(opts.fix === true ? { fix: true } : {}),
+          ...(opts.only !== undefined ? { only: opts.only } : {}),
+        }),
+      })),
+    )
+  }
+
+  const ok =
+    crossChecks.every((c) => c.status === 'ok' || c.status === 'info') &&
+    agentResults.every((a) => (a.result.final ?? a.result.initial).ok)
+
+  return { rootCwd: opts.rootCwd, agents: agentResults, crossChecks, ok }
+}
+
+export function runCrossChecks(agents: AgentEntry[]): ComposeDoctorCrossCheck[] {
+  const checks: ComposeDoctorCrossCheck[] = []
+
+  const portConfigs = collectPreferredPorts(agents)
+  const portDuplicates = findDuplicates(portConfigs.map(({ port }) => port))
+  if (portDuplicates.size === 0) {
+    checks.push({
+      name: 'compose.no-port-collisions',
+      status: 'ok',
+      message: `${portConfigs.length} agent(s) declare unique preferred ports`,
+    })
+  } else {
+    const details = [...portDuplicates].map((port) => {
+      const names = portConfigs.filter((p) => p.port === port).map((p) => p.name)
+      return `port ${port}: ${names.join(', ')}`
+    })
+    checks.push({
+      name: 'compose.no-port-collisions',
+      status: 'warning',
+      message: `${portDuplicates.size} preferred port(s) shared across agents`,
+      details,
+    })
+  }
+
+  const nameDuplicates = findDuplicates(agents.map((a) => a.containerName))
+  if (nameDuplicates.size === 0) {
+    checks.push({
+      name: 'compose.no-container-name-collisions',
+      status: 'ok',
+      message: 'all agent folders map to unique Docker names',
+    })
+  } else {
+    const details = [...nameDuplicates].map((name) => {
+      const collisions = agents.filter((a) => a.containerName === name).map((a) => a.name)
+      return `${name}: ${collisions.join(', ')}`
+    })
+    checks.push({
+      name: 'compose.no-container-name-collisions',
+      status: 'error',
+      message: `${nameDuplicates.size} container name(s) shared across agents`,
+      details,
+    })
+  }
+
+  return checks
+}
+
+function collectPreferredPorts(agents: AgentEntry[]): Array<{ name: string; port: number }> {
+  const out: Array<{ name: string; port: number }> = []
+  for (const agent of agents) {
+    const port = readPreferredPort(agent.cwd)
+    if (port !== null) out.push({ name: agent.name, port })
+  }
+  return out
+}
+
+function readPreferredPort(cwd: string): number | null {
+  try {
+    return loadConfigSync(cwd).port
+  } catch {
+    return null
+  }
+}
+
+function findDuplicates<T>(items: T[]): Set<T> {
+  const seen = new Set<T>()
+  const dupes = new Set<T>()
+  for (const item of items) {
+    if (seen.has(item)) dupes.add(item)
+    else seen.add(item)
+  }
+  return dupes
+}

package/src/compose/index.ts

@@ -1,4 +1,12 @@
 export { discoverAgents, type AgentEntry } from './discover'
+export {
+  composeDoctor,
+  runCrossChecks,
+  type ComposeDoctorAgent,
+  type ComposeDoctorCrossCheck,
+  type ComposeDoctorOptions,
+  type ComposeDoctorReport,
+} from './doctor'
 export { colorFor, composeLogs, makeLinePrefixer, type ComposeLogsOptions, type ComposeLogsResult } from './logs'
 export { composeStatus, type AgentRuntimeState, type AgentStatusEntry, type ComposeStatusResult } from './status'
 export {

package/src/compose/logs.ts

@@ -1,4 +1,6 @@
 import { containerExists } from '@/container'
+import { supportsColor } from '@/container/log-colors'
+import { makeLogTimestampReformatter, type TimestampReformatter } from '@/container/log-timestamps'
 import { getBun } from '@/container/shared'
 
 import { discoverAgents, type AgentEntry } from './discover'
@@ -91,7 +93,9 @@ export async function composeLogs({
   const useColor = supportsColor(out)
 
   const procs = attached.map((agent) => {
-    const cmd = follow ? ['docker', 'logs', '-f', agent.containerName] : ['docker', 'logs', agent.containerName]
+    const cmd = follow
+      ? ['docker', 'logs', '--timestamps', '-f', agent.containerName]
+      : ['docker', 'logs', '--timestamps', agent.containerName]
     const proc = bun.spawn({ cmd, stdout: 'pipe', stderr: 'pipe' })
     return { agent, proc }
   })
@@ -110,8 +114,18 @@ export async function composeLogs({
   const pumps = procs.flatMap(({ agent, proc }) => {
     const color = colorFor(agent.name)
     return [
-      pumpStream(proc.stdout, makeLinePrefixer(agent.name, width, color, useColor), out),
-      pumpStream(proc.stderr, makeLinePrefixer(agent.name, width, color, useColor), err),
+      pumpStream(
+        proc.stdout,
+        makeLogTimestampReformatter(undefined, { color: useColor }),
+        makeLinePrefixer(agent.name, width, color, useColor),
+        out,
+      ),
+      pumpStream(
+        proc.stderr,
+        makeLogTimestampReformatter(undefined, { color: useColor }),
+        makeLinePrefixer(agent.name, width, color, useColor),
+        err,
+      ),
     ]
   })
 
@@ -128,35 +142,34 @@ export async function composeLogs({
 
 async function pumpStream(
   stream: ReadableStream<Uint8Array>,
+  reformatter: TimestampReformatter,
   prefixer: { write: (s: string) => string; flush: () => string },
   sink: NodeJS.WritableStream,
 ): Promise<void> {
   const decoder = new TextDecoder()
   const reader = stream.getReader()
+  const writeChunk = (chunk: string): void => {
+    const reformatted = reformatter.write(chunk)
+    if (reformatted.length === 0) return
+    const prefixed = prefixer.write(reformatted)
+    if (prefixed.length > 0) sink.write(prefixed)
+  }
   try {
     while (true) {
       const { done, value } = await reader.read()
       if (done) break
-      if (value && value.byteLength > 0) {
-        const out = prefixer.write(decoder.decode(value, { stream: true }))
-        if (out.length > 0) sink.write(out)
-      }
+      if (value && value.byteLength > 0) writeChunk(decoder.decode(value, { stream: true }))
     }
     const tail = decoder.decode()
-    if (tail.length > 0) {
-      const out = prefixer.write(tail)
-      if (out.length > 0) sink.write(out)
+    if (tail.length > 0) writeChunk(tail)
+    const flushedTs = reformatter.flush()
+    if (flushedTs.length > 0) {
+      const prefixed = prefixer.write(flushedTs)
+      if (prefixed.length > 0) sink.write(prefixed)
     }
-    const flushed = prefixer.flush()
-    if (flushed.length > 0) sink.write(flushed)
+    const flushedPrefix = prefixer.flush()
+    if (flushedPrefix.length > 0) sink.write(flushedPrefix)
   } finally {
     reader.releaseLock()
   }
 }
-
-function supportsColor(stream: NodeJS.WritableStream): boolean {
-  const tty = (stream as unknown as { isTTY?: boolean }).isTTY === true
-  if (!tty) return false
-  if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') return false
-  return true
-}