goatchain 0.0.1

package/cli/turn.mjs

@@ -0,0 +1,751 @@
+/**
+ * Run one interactive turn, supporting tool-approval pause/resume via `requires_action`.
+ *
+ * This is intentionally UI-agnostic: the caller provides `askApproval(prompt)`.
+ */
+import path from 'node:path'
+import { ansi, formatOneLine } from './ui.mjs'
+
+export async function runTurnWithApprovals({
+  agent,
+  sessionId,
+  history,
+  input,
+  signal,
+  askApproval,
+  askApprovalForTool,
+  approvalStrategy = 'high_risk',
+  autoApprove = false,
+  emoji = process.env.GOATCHAIN_EMOJI !== '0',
+  showTools = process.env.GOATCHAIN_SHOW_TOOLS !== '0',
+  toolStyle = process.env.GOATCHAIN_TOOL_STYLE ?? 'inline',
+  showStatus = process.env.GOATCHAIN_SHOW_STATUS !== '0',
+  showActivity = process.env.GOATCHAIN_SHOW_ACTIVITY !== '0',
+  showStatusLine = process.env.GOATCHAIN_SHOW_STATUSLINE !== '0',
+  promptContinue = process.env.GOATCHAIN_PROMPT_CONTINUE !== '0',
+  autoContinue = process.env.GOATCHAIN_AUTO_CONTINUE === '1',
+  write = (s) => process.stdout.write(s),
+}) {
+  const useEmoji = Boolean(emoji) && process.stdout.isTTY && process.env.TERM !== 'dumb'
+  const icon = (s) => (useEmoji ? `${s} ` : '')
+
+  let atLineStart = true
+  /** @type {null | { start: () => void, stop: () => void, set: (p: string, d?: string) => void, onOutput: () => void, onPauseForInput: () => void }} */
+  let activity = null
+
+  const out = (s) => {
+    activity?.onOutput()
+    const str = String(s ?? '')
+    write(str)
+    const lastNl = str.lastIndexOf('\n')
+    if (lastNl === -1) {
+      atLineStart = false
+      return
+    }
+    atLineStart = lastNl === str.length - 1
+  }
+
+  const ensureNewline = () => {
+    if (!atLineStart)
+      out('\n')
+  }
+
+  /** @type {any[]} */
+  const messagesToAppend = []
+
+  /** @type {{ text: string, toolCalls: any[], flushedToolCallAssistant: boolean }} */
+  let iteration = { text: '', toolCalls: [], flushedToolCallAssistant: false }
+  /** @type {Map<string, string>} */
+  let toolNameById = new Map()
+  /** @type {Map<string, string>} */
+  let toolArgsSummaryById = new Map()
+  /** @type {Set<string>} */
+  let printedToolCallIds = new Set()
+  /** @type {Set<string>} */
+  const executedToolNames = new Set()
+  /** @type {{ stopReason?: string, modelStopReason?: string, tools: Array<{ toolName: string, argsSummary?: string, resultSummary?: string }> }} */
+  const meta = { tools: [] }
+
+  let approveAllToolsThisTurn = false
+
+  const byteLen = (s) => {
+    try {
+      return Buffer.byteLength(String(s ?? ''), 'utf8')
+    }
+    catch {
+      return String(s ?? '').length
+    }
+  }
+
+  const humanBytes = (n) => {
+    const num = Number(n)
+    if (!Number.isFinite(num) || num < 0)
+      return ''
+    if (num < 1024)
+      return `${num} B`
+    if (num < 1024 * 1024)
+      return `${(num / 1024).toFixed(2)} KB`
+    return `${(num / (1024 * 1024)).toFixed(2)} MB`
+  }
+
+  const summarizeArgsForDisplay = (toolName, args) => {
+    const name = String(toolName ?? '')
+    const a = args && typeof args === 'object' ? args : {}
+
+    if (name === 'Write') {
+      const filePath = typeof a.file_path === 'string' ? a.file_path : ''
+      const size = typeof a.content === 'string' ? humanBytes(byteLen(a.content)) : ''
+      return {
+        summary: `${filePath}${size ? ` (content ${size})` : ''}`,
+        lines: [
+          filePath ? `file: ${filePath}` : undefined,
+          size ? `content: ${size}` : undefined,
+        ].filter(Boolean),
+      }
+    }
+
+    if (name === 'Edit') {
+      const filePath = typeof a.file_path === 'string' ? a.file_path : ''
+      const edits = Array.isArray(a.edits) ? a.edits : []
+      const first = edits[0] && typeof edits[0] === 'object' ? edits[0] : undefined
+      const oldText = first && typeof first.oldText === 'string' ? first.oldText : ''
+      const newText = first && typeof first.newText === 'string' ? first.newText : ''
+      const firstPreview = oldText || newText
+        ? `first edit: ${formatOneLine(oldText, 60)} → ${formatOneLine(newText, 60)}`
+        : undefined
+      return {
+        summary: `${filePath}${edits.length ? ` (${edits.length} edits)` : ''}`,
+        lines: [
+          filePath ? `file: ${filePath}` : undefined,
+          edits.length ? `edits: ${edits.length}` : undefined,
+          firstPreview,
+        ].filter(Boolean),
+      }
+    }
+
+    if (name === 'Read') {
+      const filePath = typeof a.file_path === 'string' ? a.file_path : ''
+      const offset = typeof a.offset === 'number' ? a.offset : undefined
+      const limit = typeof a.limit === 'number' ? a.limit : undefined
+      const range = offset || limit
+        ? ` (${offset ? `from ${offset}` : ''}${offset && limit ? ', ' : ''}${limit ? `limit ${limit}` : ''})`
+        : ''
+      return {
+        summary: `${filePath}${range}`,
+        lines: [
+          filePath ? `file: ${filePath}` : undefined,
+          offset ? `offset: ${offset}` : undefined,
+          limit ? `limit: ${limit}` : undefined,
+        ].filter(Boolean),
+      }
+    }
+
+    if (name === 'Glob') {
+      const pattern = typeof a.pattern === 'string' ? a.pattern : ''
+      return {
+        summary: pattern,
+        lines: [pattern ? `pattern: ${pattern}` : undefined].filter(Boolean),
+      }
+    }
+
+    if (name === 'Grep') {
+      const pattern = typeof a.pattern === 'string' ? a.pattern : ''
+      const outputMode = typeof a.output_mode === 'string' ? a.output_mode : ''
+      const path = typeof a.path === 'string' ? a.path : ''
+      return {
+        summary: `${pattern}${path ? ` in ${path}` : ''}`,
+        lines: [
+          pattern ? `pattern: ${formatOneLine(pattern, 120)}` : undefined,
+          path ? `path: ${path}` : undefined,
+          outputMode ? `mode: ${outputMode}` : undefined,
+        ].filter(Boolean),
+      }
+    }
+
+    if (name === 'WebSearch') {
+      const q = typeof a.query === 'string' ? a.query : ''
+      return {
+        summary: formatOneLine(q, 120),
+        lines: [q ? `query: ${formatOneLine(q, 200)}` : undefined].filter(Boolean),
+      }
+    }
+
+    // Generic fallback: show keys but avoid huge payloads.
+    const keys = Object.keys(a)
+    const short = keys.slice(0, 6).join(', ')
+    return {
+      summary: short ? `{${short}${keys.length > 6 ? ', …' : ''}}` : '{}',
+      lines: short ? [`args: { ${short}${keys.length > 6 ? ', …' : ''} }`] : [],
+    }
+  }
+
+  const createActivity = () => {
+    if ((!showActivity && !showStatusLine) || !process.stdout.isTTY)
+      return null
+
+    const baseTitle = process.env.GOATCHAIN_TITLE ?? 'GoatChain'
+    let phase = 'working'
+    let detail = ''
+    let tick = 0
+    let timer = null
+    let spinnerVisible = false
+    let lastOutputAt = Date.now()
+
+    const dots = () => {
+      tick = (tick + 1) % 4
+      return '.'.repeat(tick)
+    }
+
+    const phaseIcon = (p) => {
+      if (!useEmoji)
+        return ''
+      if (p === 'thinking')
+        return '🤔'
+      if (p === 'tool_call')
+        return '🛠️'
+      if (p === 'responding')
+        return '✍️'
+      if (p === 'working')
+        return '…'
+      return ''
+    }
+
+    const label = () => {
+      const pi = phaseIcon(phase)
+      const p = pi ? `${pi} ${phase}` : phase
+      return detail ? `${p}: ${detail}` : p
+    }
+
+    const setTitle = (text) => {
+      if (!showActivity)
+        return
+      process.stdout.write(`\u001B]0;${text}\u0007`)
+    }
+
+    const showSpinner = () => {
+      if (!showStatusLine)
+        return
+      if (Date.now() - lastOutputAt < 450)
+        return
+      // Put spinner on its own line at the bottom of current output, update in-place.
+      if (!spinnerVisible) {
+        if (!atLineStart) {
+          process.stdout.write('\n')
+          atLineStart = true
+        }
+        spinnerVisible = true
+      }
+      const d = dots()
+      const txt = `${label()}${d}`
+      process.stdout.write(`\r\u001B[2K${ansi.dim(formatOneLine(txt, 120))}`)
+      atLineStart = false
+    }
+
+    const hideSpinner = () => {
+      if (!spinnerVisible)
+        return
+      process.stdout.write('\r\u001B[2K')
+      spinnerVisible = false
+      atLineStart = true
+    }
+
+    const render = () => {
+      const d = dots()
+      const t = `${baseTitle} — ${label()}${d}`
+      setTitle(t)
+      showSpinner()
+    }
+
+    const start = () => {
+      if (timer)
+        return
+      render()
+      timer = setInterval(render, 250)
+      if (typeof timer?.unref === 'function')
+        timer.unref()
+    }
+
+    const stop = () => {
+      if (timer) {
+        clearInterval(timer)
+        timer = null
+      }
+      hideSpinner()
+      setTitle(baseTitle)
+    }
+
+    return {
+      start,
+      stop,
+      set(nextPhase, nextDetail) {
+        phase = String(nextPhase ?? 'working')
+        detail = String(nextDetail ?? '')
+      },
+      onOutput() {
+        lastOutputAt = Date.now()
+        hideSpinner()
+      },
+      onPauseForInput() {
+        hideSpinner()
+      },
+    }
+  }
+
+  const resetIteration = () => {
+    iteration = { text: '', toolCalls: [], flushedToolCallAssistant: false }
+    toolNameById = new Map()
+    toolArgsSummaryById = new Map()
+    printedToolCallIds = new Set()
+  }
+
+  const flushAssistantToolCallsMessageIfNeeded = () => {
+    if (iteration.flushedToolCallAssistant)
+      return
+    if (!Array.isArray(iteration.toolCalls) || iteration.toolCalls.length === 0)
+      return
+    messagesToAppend.push({
+      role: 'assistant',
+      content: iteration.text || '',
+      tool_calls: iteration.toolCalls,
+    })
+    iteration.flushedToolCallAssistant = true
+  }
+
+  const pushToolMessage = (toolCallId, result) => {
+    const content = typeof result === 'string' ? result : JSON.stringify(result)
+    messagesToAppend.push({
+      role: 'tool',
+      tool_call_id: toolCallId,
+      content,
+    })
+  }
+
+  const previewToolArgs = (toolCall) => {
+    try {
+      const name = toolCall?.function?.name ?? 'unknown'
+      const raw = toolCall?.function?.arguments
+      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw
+      return summarizeArgsForDisplay(name, parsed).summary
+    }
+    catch {
+      return ''
+    }
+  }
+
+  const previewToolResult = (result) => {
+    try {
+      if (result && typeof result === 'object') {
+        const sc = result.structuredContent && typeof result.structuredContent === 'object'
+          ? result.structuredContent
+          : null
+
+        // Glob: { files, totalMatches, truncated }
+        if (sc && 'totalMatches' in sc && 'files' in sc && Array.isArray(sc.files)) {
+          const totalMatches = Number(sc.totalMatches ?? sc.files.length)
+          const shown = sc.files.length
+          const truncated = sc.truncated === true
+          const parts = [
+            `Found ${Number.isFinite(totalMatches) ? totalMatches : shown} file(s)`,
+            truncated ? `(showing ${shown})` : shown !== totalMatches ? `(showing ${shown})` : '',
+          ].filter(Boolean)
+          return parts.join(' ')
+        }
+
+        // Read: { fileSize, totalLines, linesReturned, truncated, isBinary, mimeType }
+        if (sc && 'fileSize' in sc && ('totalLines' in sc || 'linesReturned' in sc)) {
+          const totalLines = Number(sc.totalLines ?? 0)
+          const linesReturned = Number(sc.linesReturned ?? 0)
+          const truncated = sc.truncated === true
+          const fileSize = Number(sc.fileSize ?? 0)
+          const parts = [
+            'Read file',
+            Number.isFinite(linesReturned) && Number.isFinite(totalLines) && totalLines > 0
+              ? `(${linesReturned}/${totalLines} lines)`
+              : linesReturned > 0
+                ? `(${linesReturned} lines)`
+                : '',
+            Number.isFinite(fileSize) && fileSize > 0 ? `(${humanBytes(fileSize)})` : '',
+            truncated ? '(truncated)' : '',
+          ].filter(Boolean)
+          return parts.join(' ')
+        }
+
+        // Write: { success, filePath, bytesWritten, overwritten }
+        if (sc && 'bytesWritten' in sc && 'filePath' in sc) {
+          const filePath = String(sc.filePath ?? '')
+          const bytes = Number(sc.bytesWritten ?? 0)
+          const overwritten = sc.overwritten === true
+          const parts = [
+            overwritten ? 'Overwrote' : 'Wrote',
+            filePath || 'file',
+            bytes > 0 ? `(${humanBytes(bytes)})` : '',
+          ].filter(Boolean)
+          return parts.join(' ')
+        }
+
+        // Fallback: first text block
+        if (Array.isArray(result.content)) {
+          const first = result.content.find(b => b && typeof b === 'object' && b.type === 'text' && typeof b.text === 'string')
+          if (first && typeof first.text === 'string')
+            return formatOneLine(first.text, 200)
+        }
+      }
+      return formatOneLine(typeof result === 'string' ? result : JSON.stringify(result), 200)
+    }
+    catch {
+      return ''
+    }
+  }
+
+  const maybeApprove = async (event) => {
+    if (approveAllToolsThisTurn)
+      return { approved: true }
+
+    if (typeof askApprovalForTool === 'function') {
+      const toolName = event.toolName
+      const info = summarizeArgsForDisplay(toolName, event.args)
+      const actionRaw = await askApprovalForTool({
+        toolName,
+        riskLevel: event.riskLevel,
+        args: event.args,
+        display: info,
+      })
+      if (typeof actionRaw === 'boolean')
+        return { approved: actionRaw }
+      const action = String(actionRaw ?? '').trim().toLowerCase()
+      if (action === 'approve_all' || action === 'all') {
+        approveAllToolsThisTurn = true
+        return { approved: true }
+      }
+      if (action === 'approve' || action === 'yes' || action === 'y')
+        return { approved: true }
+      if (action === 'abort')
+        throw new Error('Aborted by user')
+      return { approved: false }
+    }
+
+    if (!askApproval)
+      return { approved: false, reason: 'No approval handler available' }
+    const toolName = event.toolName
+    const risk = event.riskLevel ? ` (${event.riskLevel})` : ''
+    const info = summarizeArgsForDisplay(toolName, event.args)
+    const header = ansi.highlight(` approval required `)
+    const title = `${header}${useEmoji ? ` ${icon('🛑').trimEnd()}` : ''} ${ansi.bold(String(toolName ?? 'tool'))}${risk}\n`
+    const body = (info.lines.length > 0 ? info.lines : ['(no args)'])
+      .map(l => `- ${l}`)
+      .join('\n')
+    const q = `\n${title}${ansi.dim(body)}\n${ansi.bold(`${icon('✅').trimEnd()}Allow?`)} [y/N] `
+    const answer = await askApproval(q)
+    const ok = String(answer ?? '').trim().toLowerCase()
+    return { approved: ok === 'y' || ok === 'yes' }
+  }
+
+  const printToolBlock = (title, lines, padAfter = false) => {
+    if (!showTools)
+      return
+    ensureNewline()
+    out(`${ansi.dim(`┌─ ${useEmoji ? '🛠️ ' : ''}${title}`)}\n`)
+    for (const line of lines) {
+      if (line)
+        out(`${ansi.dim(`│ ${line}`)}\n`)
+    }
+    out(`${ansi.dim('└─')}\n`)
+    if (padAfter)
+      out('\n')
+  }
+
+  const shortPath = (p) => {
+    const s = String(p ?? '')
+    if (!s)
+      return ''
+    try {
+      const rel = s.startsWith('/')
+        ? path.relative(process.cwd(), s)
+        : s
+      return formatOneLine(rel, 80)
+    }
+    catch {
+      return formatOneLine(s, 80)
+    }
+  }
+
+  const printToolInlineCall = (toolName, argsSummary) => {
+    if (!showTools)
+      return
+    ensureNewline()
+    const name = ansi.bold(String(toolName ?? 'tool'))
+    const a = String(argsSummary ?? '').trim()
+    const tag = useEmoji ? `${icon('🛠️').trimEnd()} [tool]` : '[tool]'
+    const lhs = [ansi.dim(tag), name, a ? ansi.dim(a) : ''].filter(Boolean).join(' ')
+    out(`${ansi.dim('•')} ${lhs}\n`)
+  }
+
+  const printToolInlineResult = (resultSummary) => {
+    if (!showTools)
+      return
+    const r = String(resultSummary ?? '').trim() || '[no output]'
+    out(`${ansi.dim('  └')} ${ansi.dim(`${useEmoji ? '📄 ' : ''}${r}`)}\n`)
+  }
+
+  const toolResultIcon = (result) => {
+    if (!useEmoji)
+      return ''
+    if (result && typeof result === 'object') {
+      if (result.isError === true)
+        return '❌'
+      const sc = result.structuredContent && typeof result.structuredContent === 'object'
+        ? result.structuredContent
+        : null
+      if (sc && sc.truncated === true)
+        return '⚠️'
+    }
+    return '✅'
+  }
+
+  const looksUnfinished = (text) => {
+    const t = String(text ?? '').trim()
+    if (!t)
+      return false
+    if (/[。.!?？！]$/.test(t))
+      return false
+    if (/(我将|我會|我会|接下来|下一步|然后|让我|开始创建|我将创建|我会创建)/.test(t))
+      return true
+    if ((/(\.html|\.ts|tank-battle)/i.test(t)) && (/(创建|写入|生成|create|write|implement)/i.test(t)))
+      return true
+    return false
+  }
+
+  const runSegment = async (segmentIter) => {
+    let doneReason = ''
+    let modelStopReason = ''
+    activity = createActivity()
+    activity?.start()
+    for await (const event of segmentIter) {
+      if (event.type === 'thinking_start') {
+        activity?.set('thinking', '')
+      }
+      else if (event.type === 'thinking_end') {
+        activity?.set('working', '')
+      }
+      else if (event.type === 'iteration_start') {
+        resetIteration()
+        activity?.set('thinking', '')
+      }
+      else if (event.type === 'text_delta') {
+        iteration.text += event.delta
+        out(event.delta)
+        activity?.set('responding', '')
+      }
+      else if (event.type === 'tool_call_start') {
+        activity?.set('tool_call', event.toolName ?? '')
+      }
+      else if (event.type === 'tool_call_end') {
+        iteration.toolCalls.push(event.toolCall)
+        const name = event.toolCall?.function?.name ?? 'unknown'
+        if (event.toolCall?.id)
+          toolNameById.set(event.toolCall.id, name)
+        let parsedArgs = {}
+        try {
+          const raw = event.toolCall?.function?.arguments
+          parsedArgs = typeof raw === 'string' ? JSON.parse(raw) : (raw ?? {})
+        }
+        catch {
+          parsedArgs = { _raw: event.toolCall?.function?.arguments }
+        }
+        const info = summarizeArgsForDisplay(name, parsedArgs)
+        if (event.toolCall?.id) {
+          // Prefer a readable path summary for common file tools.
+          if (name === 'Read' || name === 'Write' || name === 'Edit') {
+            const filePath = typeof parsedArgs.file_path === 'string' ? parsedArgs.file_path : ''
+            if (name === 'Write') {
+              const size = typeof parsedArgs.content === 'string' ? humanBytes(byteLen(parsedArgs.content)) : ''
+              toolArgsSummaryById.set(event.toolCall.id, `${shortPath(filePath)}${size ? ` (${size})` : ''}`.trim())
+            }
+            else if (name === 'Edit') {
+              const edits = Array.isArray(parsedArgs.edits) ? parsedArgs.edits.length : 0
+              toolArgsSummaryById.set(event.toolCall.id, `${shortPath(filePath)}${edits ? ` (${edits} edits)` : ''}`.trim())
+            }
+            else {
+              // Read
+              toolArgsSummaryById.set(event.toolCall.id, shortPath(filePath) || '')
+            }
+          }
+          else {
+            toolArgsSummaryById.set(event.toolCall.id, info.summary || '')
+          }
+        }
+        if (toolStyle === 'box') {
+          printToolBlock(`${ansi.bold(name)}${info.summary ? ` ${ansi.dim(info.summary)}` : ''}`, info.lines.length ? info.lines : [info.summary || '(no args)'])
+        }
+        else if (event.toolCall?.id && !printedToolCallIds.has(event.toolCall.id)) {
+          printedToolCallIds.add(event.toolCall.id)
+          const argsSummary = toolArgsSummaryById.get(event.toolCall.id) ?? ''
+          printToolInlineCall(name, argsSummary || info.summary || '')
+          meta.tools.push({ toolName: name, argsSummary: argsSummary || info.summary || '' })
+        }
+        activity?.set('tool_call', event.toolCall?.function?.name ?? '')
+      }
+      else if (event.type === 'tool_result') {
+        flushAssistantToolCallsMessageIfNeeded()
+        pushToolMessage(event.tool_call_id, event.result)
+        const prev = previewToolResult(event.result)
+        const toolName = toolNameById.get(event.tool_call_id)
+        if (toolName)
+          executedToolNames.add(toolName)
+        if (toolStyle !== 'box') {
+          // If we didn't print the call line (e.g. legacy tool events), do it now.
+          if (toolName && !printedToolCallIds.has(event.tool_call_id)) {
+            printedToolCallIds.add(event.tool_call_id)
+            const argsSummary = toolArgsSummaryById.get(event.tool_call_id) ?? ''
+            printToolInlineCall(toolName, argsSummary)
+            meta.tools.push({ toolName, argsSummary })
+          }
+          const argsSummary = toolArgsSummaryById.get(event.tool_call_id) ?? ''
+          void argsSummary
+          const status = toolResultIcon(event.result)
+          printToolInlineResult(`${status ? `${status} ` : ''}${prev || '[no output]'}`)
+          if (toolName) {
+            const last = meta.tools.slice().reverse().find(t => t.toolName === toolName && !t.resultSummary)
+            if (last)
+              last.resultSummary = prev || '[no output]'
+            else
+              meta.tools.push({ toolName, argsSummary, resultSummary: prev || '[no output]' })
+          }
+        }
+        else {
+          const status = toolResultIcon(event.result)
+          const title = toolName ? `tool result ${ansi.bold(toolName)}${status ? ` ${status}` : ''}` : `tool result${status ? ` ${status}` : ''}`
+          printToolBlock(title, [prev || '[no output]'])
+        }
+        activity?.set('thinking', '')
+      }
+      else if (event.type === 'requires_action' && event.kind === 'tool_approval') {
+        flushAssistantToolCallsMessageIfNeeded()
+        // Stop any spinner/title updates while waiting for user input.
+        // Otherwise the status line can overwrite the readline prompt and make input impossible.
+        activity?.stop()
+        activity = null
+        ensureNewline()
+
+        const decision = await maybeApprove(event)
+        const checkpoint = event.checkpoint
+        if (!checkpoint) {
+          throw new Error('Approval requested but no checkpoint provided; configure a checkpoint store or enable inline checkpoint')
+        }
+
+        return runSegment(
+          agent.streamFromCheckpoint({
+            checkpoint,
+            signal,
+            toolContext: {
+              approval: {
+                decisions: {
+                  [event.tool_call_id]: decision,
+                },
+              },
+            },
+          }),
+        )
+      }
+      else if (event.type === 'iteration_end') {
+        if (event.willContinue === false) {
+          messagesToAppend.push({ role: 'assistant', content: iteration.text || '' })
+        }
+      }
+      else if (event.type === 'done') {
+        doneReason = event.stopReason ? String(event.stopReason) : ''
+        modelStopReason = event.modelStopReason ? String(event.modelStopReason) : ''
+        break
+      }
+      else if (event.type === 'error') {
+        const msg = event.error instanceof Error ? event.error.message : String(event.error)
+        ensureNewline()
+        out(`${ansi.red(`${icon('❌').trimEnd()}[error] ${msg}`)}\n`)
+        doneReason = 'error'
+      }
+    }
+
+    activity?.stop()
+    return { doneReason, modelStopReason }
+  }
+
+  let lastDoneReason = ''
+  let lastModelStopReason = ''
+
+  const first = await runSegment(agent.stream({
+    sessionId,
+    input,
+    messages: history,
+    signal,
+    toolContext: {
+      approval: { strategy: approvalStrategy, autoApprove },
+    },
+  }))
+  lastDoneReason = first.doneReason
+  lastModelStopReason = first.modelStopReason
+
+  // If the model ended in a "plan-y" way without writing files, optionally prompt to continue.
+  const finalAssistant = [...messagesToAppend].reverse().find(m => m && typeof m === 'object' && m.role === 'assistant')
+  const finalText = typeof finalAssistant?.content === 'string' ? finalAssistant.content : ''
+  const autoContinueUnfinished = autoContinue
+  if (
+    (autoContinueUnfinished || (promptContinue && typeof askApproval === 'function'))
+    && !executedToolNames.has('Write')
+    && !executedToolNames.has('Edit')
+    && looksUnfinished(finalText)
+  ) {
+    let shouldContinue = autoContinueUnfinished
+    if (!shouldContinue) {
+      const ans = await askApproval(`${ansi.dim('\nThe model seems to have stopped before implementing.')} Continue? [Y/n] `)
+      const ok = String(ans ?? '').trim().toLowerCase()
+      shouldContinue = ok === '' || ok === 'y' || ok === 'yes'
+    }
+    if (shouldContinue) {
+      const continuePrompt = '继续。不要只说计划：请立刻开始实现，使用 Write/Edit 创建或修改文件。'
+      // Persist the continuation user message in the caller history.
+      messagesToAppend.push({ role: 'user', content: continuePrompt })
+      // Build the full message history including the initial user input.
+      const base = [...history, { role: 'user', content: input }, ...messagesToAppend.slice(0, -1)]
+      const second = await runSegment(agent.stream({
+        sessionId,
+        input: continuePrompt,
+        messages: base,
+        signal,
+        toolContext: {
+          approval: { strategy: approvalStrategy, autoApprove },
+        },
+      }))
+      lastDoneReason = second.doneReason
+      lastModelStopReason = second.modelStopReason
+    }
+  }
+
+  meta.stopReason = lastDoneReason
+  meta.modelStopReason = lastModelStopReason
+
+  if (showStatus) {
+    ensureNewline()
+    const parts = []
+    if (lastDoneReason && lastDoneReason !== 'final_response')
+      parts.push(`stopReason=${lastDoneReason}`)
+    if (lastModelStopReason && lastModelStopReason !== 'final')
+      parts.push(`modelStopReason=${lastModelStopReason}`)
+    const label = `${icon('✅').trimEnd()}done${parts.length ? ` (${parts.join(' ')})` : ''}`
+    out(`${ansi.dim(`─ ${label} ─`)}\n`)
+
+    if (lastModelStopReason === 'length') {
+      out(`${ansi.dim(`${icon('💡').trimEnd()}hint: increase maxTokens via /set maxTokens 2048 if output is truncated`)}\n`)
+    }
+    else {
+      const finalAssistant2 = [...messagesToAppend].reverse().find(m => m && typeof m === 'object' && m.role === 'assistant')
+      const finalText2 = typeof finalAssistant2?.content === 'string' ? finalAssistant2.content : ''
+      if (!executedToolNames.has('Write') && !executedToolNames.has('Edit') && looksUnfinished(finalText2 || iteration.text || '')) {
+        out(`${ansi.dim(`${icon('💡').trimEnd()}hint: response ended before any Write/Edit; ask “继续并开始写文件” or increase maxTokens`)}\n`)
+      }
+    }
+  }
+
+  ensureNewline()
+  out('\n')
+  return { messagesToAppend, meta }
+}