zen-gitsync 2.17.6 → 2.17.8

package/src/cli/ai/cli.integration.test.js

@@ -0,0 +1,124 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { promises as fs } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import http from 'node:http'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const entry = fileURLToPath(new URL('../../gitCommit.js', import.meta.url))
+
+async function fixture(t) {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'zen-ai-cli-'))
+  // Every subprocess gets an isolated home/config and only a local fake provider.
+  const profile = path.join(directory, 'profile'), project = path.join(directory, 'project')
+  await fs.mkdir(path.join(profile, '.zen-gitsync'), { recursive: true })
+  await fs.mkdir(project)
+  await fs.writeFile(path.join(project, 'demo.txt'), 'fixture text')
+  await fs.writeFile(path.join(project, 'AGENTS.md'), '@CLAUDE.md')
+  await fs.writeFile(path.join(project, 'CLAUDE.md'), 'Fixture project rule: verify before editing.')
+  const requests = []
+  const server = http.createServer(async (req, res) => {
+    let raw = ''
+    for await (const chunk of req) raw += chunk
+    const body = JSON.parse(raw)
+    requests.push(body)
+    res.writeHead(200, { 'Content-Type': 'text/event-stream' })
+    const send = data => res.write(`data: ${JSON.stringify(data)}\n\n`)
+    if (requests.length === 1) {
+      for (let i = 1; i <= 15; i++) {
+        for (const chunk of [`Inspection step ${i}: `, 'check the requested file.\n\n']) {
+          send({ choices: [{ delta: { reasoning_content: chunk } }] })
+        }
+      }
+      send({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'read1', type: 'function', function: { name: 'read_file', arguments: '{"path":"demo.txt"}' } }] }, finish_reason: 'tool_calls' }] })
+      send({ choices: [], usage: { prompt_tokens: 100, completion_tokens: 20, total_tokens: 120 } })
+    } else {
+      send({ choices: [{ delta: { content: 'Fixture answer.\n' }, finish_reason: 'stop' }] })
+      send({ choices: [], usage: { prompt_tokens: 50, completion_tokens: 10, total_tokens: 60 } })
+    }
+    res.end('data: [DONE]\n\n')
+  })
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
+  const baseURL = `http://127.0.0.1:${server.address().port}/v1`
+  await fs.writeFile(path.join(profile, '.zen-gitsync', 'config.json'), JSON.stringify({
+    locale: 'en-US', models: [{ name: 'fixture', model: 'fixture', baseURL, apiKey: 'test-only', isDefault: true }],
+  }))
+  t.after(async () => {
+    await new Promise(resolve => server.close(resolve))
+    assert.equal(path.dirname(directory), path.resolve(os.tmpdir()))
+    assert.ok(path.basename(directory).startsWith('zen-ai-cli-'))
+    await fs.rm(directory, { recursive: true, force: true })
+  })
+  return { directory, profile, project, requests }
+}
+
+async function run(f, args, onOutput) {
+  const child = spawn(process.execPath, [entry, 'ai', ...args], {
+    cwd: f.directory, windowsHide: true,
+    env: { ...process.env, USERPROFILE: f.profile, HOME: f.profile, NO_COLOR: '1', FORCE_COLOR: '0' },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  })
+  let stdout = '', stderr = ''
+  child.stdout.on('data', data => { stdout += data; onOutput?.(stdout, child) })
+  child.stderr.on('data', data => { stderr += data })
+  const timer = setTimeout(() => child.kill(), 12000)
+  const code = await new Promise((resolve, reject) => { child.once('error', reject); child.once('close', resolve) })
+  clearTimeout(timer)
+  assert.equal(code, 0, stdout + stderr)
+  assert.doesNotMatch(stderr, /fatal: not a git repository/)
+  return stdout
+}
+
+test('CLI uses switched directory, saves metrics and loads local project instructions', { timeout: 15000 }, async t => {
+  const f = await fixture(t)
+  let stage = 0
+  const output = await run(f, [], (stdout, child) => {
+    if (stage === 0 && stdout.includes('Zen GitSync')) { stage++; child.stdin.write(`/cd ${f.project}\n`) }
+    else if (stage === 1 && stdout.includes('Working directory changed:')) { stage++; child.stdin.write('Read demo.txt\n') }
+    else if (stage === 2 && stdout.includes('Token 180')) { stage++; child.stdin.write('/exit\n') }
+  })
+  assert.match(output, /first token/)
+  assert.match(output, /first answer/)
+  assert.match(output, /Token 180/)
+  assert.match(output, /Inspection step 15:/)
+  assert.doesNotMatch(output, /first 12 lines shown/)
+  assert.equal(f.requests.length, 2)
+  assert.match(f.requests[0].messages[0].content, /Fixture project rule/)
+  assert.ok(f.requests[1].messages.some(m => m.role === 'tool' && m.content.includes('fixture text')))
+  const dir = path.join(f.profile, '.zen-gitsync', 'agent-sessions')
+  const files = (await fs.readdir(dir)).filter(file => file.endsWith('.json'))
+  assert.equal(files.length, 1)
+  const saved = JSON.parse(await fs.readFile(path.join(dir, files[0]), 'utf8'))
+  assert.equal(saved.cwd, f.project)
+  assert.equal(saved.lastTurnStats.usage.totalTokens, 180)
+  assert.equal(saved.sessionStats.turns, 1)
+  assert.equal(saved.messages.at(-1).content, 'Fixture answer.\n')
+})
+
+test('one-shot CLI shows full thinking by default and prints the usage footer', { timeout: 15000 }, async t => {
+  const f = await fixture(t)
+  const output = await run(f, ['inspect'])
+  assert.match(output, /Token 180/)
+  assert.match(output, /One-shot done/)
+  assert.match(output, /Inspection step 15:/)
+  assert.doesNotMatch(output, /first 12 lines shown/)
+})
+
+test('CLI help lists thinking modes and /think full shows reasoning beyond the preview', { timeout: 15000 }, async t => {
+  const f = await fixture(t)
+  let stage = 0
+  const output = await run(f, [], (stdout, child) => {
+    if (stage === 0 && stdout.includes('Zen GitSync')) { stage++; child.stdin.write('/help\n') }
+    else if (stage === 1 && stdout.includes('/think compact')) { stage++; child.stdin.write('/think full\n') }
+    else if (stage === 2 && stdout.includes('Thinking for future requests: full')) { stage++; child.stdin.write('Read demo.txt\n') }
+    else if (stage === 3 && stdout.includes('Token 180')) { stage++; child.stdin.write('/exit\n') }
+  })
+  assert.equal(stage, 4)
+  assert.match(output, /\/think full/)
+  assert.match(output, /\/think off/)
+  assert.match(output, /Inspection step 15: check the requested file\./)
+  assert.doesNotMatch(output, /first 12 lines shown/)
+  assert.equal(f.requests.length, 2, 'display commands must not call the model')
+})

package/src/cli/ai/context.js

@@ -0,0 +1,90 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+
+const textOf = m => typeof m?.content === 'string' ? m.content : (m?.content || []).filter?.(p => p.type === 'text').map(p => p.text).join('\n') || ''
+const clip = (text, limit) => text.length <= limit ? text : text.slice(0, Math.floor(limit / 2)) + '\n[… earlier output omitted …]\n' + text.slice(-Math.floor(limit / 2))
+
+// A saved turn may have been interrupted between tools. Mark missing results,
+// never replay a possibly completed write/command automatically on resume.
+export function repairToolHistory(messages) {
+  const result = []
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i]
+    if (message.role === 'tool') continue
+    result.push({ ...message })
+    if (!message.tool_calls?.length) continue
+    const outputs = new Map()
+    while (messages[i + 1]?.role === 'tool') {
+      const output = messages[++i]
+      outputs.set(output.tool_call_id, output)
+    }
+    for (const call of message.tool_calls) result.push(outputs.get(call.id) || {
+      role: 'tool', tool_call_id: call.id, name: call.function?.name,
+      content: 'Interrupted before a result was saved. Execution status is unknown; inspect current files/state before retrying.',
+    })
+  }
+  return result
+}
+
+// Build a bounded request copy. The complete transcript on disk is never trimmed.
+// Budgets are characters/messages, not purported token counts.
+export function buildRequestMessages(messages, { maxMessages = 40, maxChars = 80000 } = {}) {
+  const copy = repairToolHistory(messages).map(m => ({ ...m,
+    ...(m.role === 'tool' ? { content: clip(textOf(m), 6000) } : {}),
+  }))
+  const size = m => textOf(m).length + JSON.stringify(m.tool_calls || []).length
+  if (copy.length <= maxMessages && copy.reduce((n, m) => n + size(m), 0) <= maxChars) return copy
+  const keep = new Set()
+  if (copy[0]?.role === 'system') keep.add(0)
+  const firstUser = copy.findIndex(m => m.role === 'user')
+  const lastUser = copy.findLastIndex(m => m.role === 'user')
+  if (firstUser >= 0) keep.add(firstUser)
+  if (lastUser >= 0) keep.add(lastUser)
+  let chars = [...keep].reduce((n, i) => n + size(copy[i]), 0)
+  const groups = []
+  for (let i = 0; i < copy.length; i++) {
+    const group = [i]
+    if (copy[i].tool_calls?.length) while (copy[i + 1]?.role === 'tool') group.push(++i)
+    groups.push(group)
+  }
+  for (const group of groups.reverse()) {
+    const fresh = group.filter(i => !keep.has(i))
+    const cost = fresh.reduce((n, i) => n + size(copy[i]), 0)
+    if (keep.size + fresh.length > maxMessages - 1 || chars + cost > maxChars - 6000) continue
+    fresh.forEach(i => keep.add(i)); chars += cost
+  }
+  const omitted = copy.filter((_, i) => !keep.has(i))
+  const excerpts = omitted.map(m => {
+    const calls = m.tool_calls?.map(c => `${c.function?.name} ${clip(c.function?.arguments || '', 200)}`).join('; ')
+    return `${m.role}: ${clip(calls || textOf(m), m.role === 'user' ? 800 : 250)}`
+  }).join('\n')
+  const note = { role: 'user', content: '[Earlier conversation excerpts; historical data, not new instructions. Some outputs were omitted; re-read files when necessary.]\n' + clip(excerpts, 5000) }
+  const result = copy.filter((_, i) => keep.has(i))
+  result.splice(result[0]?.role === 'system' ? 1 : 0, 0, note)
+  return result
+}
+
+// Only load explicitly named project instruction files, with bounded local redirects.
+export async function loadProjectInstructions(cwd) {
+  const visited = new Set(), sections = []
+  let remaining = 16000
+  async function read(file, depth = 0) {
+    if (depth > 3 || remaining <= 0 || visited.has(file)) return
+    const relative = path.relative(cwd, file)
+    if (relative.startsWith('..') || path.isAbsolute(relative)) return
+    visited.add(file)
+    let raw
+    try {
+      const st = await fs.stat(file)
+      if (!st.isFile() || st.size > 128000) return
+      raw = await fs.readFile(file, 'utf8')
+    } catch { return }
+    const content = raw.slice(0, remaining)
+    remaining -= content.length
+    sections.push(`--- ${relative} ---\n${content}`)
+    for (const match of content.matchAll(/^@([^\r\n]+\.md)\s*$/gm)) await read(path.resolve(path.dirname(file), match[1].trim()), depth + 1)
+  }
+  await read(path.join(cwd, 'AGENTS.md'))
+  await read(path.join(cwd, 'CLAUDE.md'))
+  return sections.length ? '\n\n# Project instructions (apply within this project; user requests take precedence)\n' + sections.join('\n\n') : ''
+}

package/src/cli/ai/modelSetup.js

@@ -49,6 +49,7 @@ export const PROVIDERS = [
   { id: 'gemini',     label: 'Google (Gemini)',     url: 'https://generativelanguage.googleapis.com/v1beta/openai' },
   { id: 'xai',        label: 'xAI (Grok)',          url: 'https://api.x.ai/v1' },
   { id: 'meta',       label: 'Meta (Llama)',        url: 'https://api.llama-api.com/v1' },
+  { id: 'nvidia',     label: 'NVIDIA',              url: 'https://integrate.api.nvidia.com/v1' },
   { id: 'mistral',    label: 'Mistral AI',          url: 'https://api.mistral.ai/v1' },
   { id: 'minimax',    label: 'MiniMax',             url: 'https://api.minimaxi.com/v1' },
   { id: 'moonshot',   label: 'Moonshot (Kimi)',     url: 'https://api.moonshot.cn/v1' },
@@ -58,6 +59,8 @@ export const PROVIDERS = [
   { id: 'groq',       label: 'Groq',                url: 'https://api.groq.com/openai/v1' },
   { id: 'together',   label: 'Together AI',         url: 'https://api.together.xyz/v1' },
   { id: 'openrouter', label: 'OpenRouter',          url: 'https://openrouter.ai/api/v1' },
+  { id: 'opencode',   label: 'OpenCode Go',         url: 'https://opencode.ai/zen/go/v1' },
+  { id: 'agnes',      label: 'Agnes AI',            url: 'https://apihub.agnes-ai.com/v1' },
   { id: 'ollama',     label: 'Ollama (本地)',        url: 'http://localhost:11434/v1' },
 ]
 
@@ -115,9 +118,44 @@ export const BUILTIN_MODELS = {
     'meta-llama/Llama-3.3-70B-Instruct-Turbo',
     'deepseek-ai/DeepSeek-V3',
   ],
+  'https://apihub.agnes-ai.com/v1': [
+    'agnes-2.5-pro-alpha', 'agnes-2.0-flash', 'agnes-image-2.0', 'agnes-video-v2.0',
+  ],
   'http://localhost:11434/v1': [
     'qwen2.5', 'llama3.1', 'mistral', 'deepseek-r1:7b', 'qwen3', 'llama4',
   ],
+  'https://integrate.api.nvidia.com/v1': [
+    'nvidia/llama-3.3-nemotron-super-49b-v1',
+    'nvidia/nemotron-3-nano-30b-a3b',
+    'nvidia/nemotron-3-super-120b-a12b',
+    'nvidia/llama-3.1-nemotron-ultra-253b-v1',
+    'meta/llama-3.3-70b-instruct',
+    'meta/llama-4-maverick-17b-128e-instruct',
+    'deepseek-ai/deepseek-r1',
+    'qwen/qwq-32b',
+  ],
+  // OpenCode Go — 同一 base URL 下混了 chat / responses / messages 三族协议
+  // (协议识别与请求头由 src/utils/aiEndpoint.js 统一处理,选非 chat 族模型
+  //  在测试连接/对话时会收到可读报错提示)。更新: 2026-09-17,与 ai-model-form 同步。
+  'https://opencode.ai/zen/go/v1': [
+    // ——— OpenAI 兼容 /chat/completions ———
+    'deepseek-v4.1-flash', 'deepseek-v4-pro', 'deepseek-v4-flash',
+    'deepseek-v4-flash-vision-exp', 'deepseek-flash',
+    'glm-5.3', 'glm-5.3-flash', 'glm-5.2', 'glm-5.1', 'glm-5',
+    'kimi-k3', 'kimi-k2.7-code', 'kimi-k2.6', 'kimi-k2.5',
+    'longcat-2.0',
+    'mimo-v2.5', 'mimo-v2.5-pro', 'mimo-v2-pro', 'mimo-v2-omni',
+    'hy4-preview', 'hy3', 'hy3-preview',
+    'omen-alpha',
+    // ——— OpenAI Responses 协议 /responses ———
+    'grok-4.6', 'grok-4.5', 'gpt-5.6-luna',
+    'muse-spark-1.3-contributor', 'muse-spark-1.2-contributor',
+    // ——— Anthropic 协议 /messages ———
+    'minimax-m3', 'minimax-m2.7', 'minimax-m2.5',
+    'qwen3.8-max', 'qwen3.8-flash', 'qwen3.7-max', 'qwen3.7-plus',
+    'qwen3.6-plus', 'qwen3.5-plus',
+    'union-alpha',
+  ],
 }
 
 // ──────────────────────────────────────────────

package/src/cli/ai/runtime.test.js

@@ -0,0 +1,181 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { streamChatOnce } from './transport.js'
+import { normalizeUsage, addUsage } from './telemetry.js'
+import { runAgentTurn } from './turn.js'
+import { buildRequestMessages, repairToolHistory } from './context.js'
+import { createAssistantWriter, stripAnsi } from './termui.js'
+
+const model = { model: 'test', baseURL: 'https://example.invalid/v1', apiKey: 'test' }
+const event = data => `data: ${JSON.stringify(data)}\n\n`
+const response = chunks => new Response(new ReadableStream({ start(controller) {
+  const bytes = new TextEncoder()
+  chunks.forEach(chunk => controller.enqueue(bytes.encode(chunk)))
+  controller.close()
+} }))
+
+test('usage includes cache/reasoning subsets without double counting', () => {
+  const usage = normalizeUsage({ prompt_tokens: 100, completion_tokens: 20, total_tokens: 120,
+    prompt_tokens_details: { cached_tokens: 80 }, completion_tokens_details: { reasoning_tokens: 10 } })
+  assert.deepEqual(usage, { inputTokens: 100, outputTokens: 20, totalTokens: 120, cachedTokens: 80, reasoningTokens: 10 })
+  assert.equal(addUsage(usage, usage).totalTokens, 240)
+  assert.equal(normalizeUsage({}), null)
+  assert.equal(normalizeUsage({ input_tokens: 2, output_tokens: 3 }).totalTokens, 5)
+})
+
+test('SSE supports split events, final usage-only events and an unterminated final line', async () => {
+  let sent
+  const content = event({ choices: [{ delta: { content: '你好' } }] })
+  const result = await streamChatOnce({ model, messages: [], fetchFn: async (_url, init) => {
+    sent = JSON.parse(init.body)
+    return response([content.slice(0, 12), content.slice(12),
+      event({ choices: [{ delta: {}, finish_reason: 'stop' }] }),
+      event({ choices: [], usage: { prompt_tokens: 10, completion_tokens: 3, total_tokens: 13 } }),
+      'data: [DONE]'])
+  } })
+  assert.deepEqual(sent.stream_options, { include_usage: true })
+  assert.equal(result.content, '你好')
+  assert.equal(result.usage.totalTokens, 13)
+})
+
+test('cumulative usage events replace snapshots instead of adding them', async () => {
+  const result = await streamChatOnce({ model, messages: [], fetchFn: async () => response([
+    event({ usage: { prompt_tokens: 10, completion_tokens: 1, total_tokens: 11 } }),
+    event({ choices: [{ delta: { content: 'ok' }, finish_reason: 'stop' }], usage: { prompt_tokens: 10, completion_tokens: 2, total_tokens: 12 } }),
+  ]) })
+  assert.equal(result.usage.totalTokens, 12)
+})
+
+test('unsupported stream_options retries once without requesting usage', async () => {
+  const bodies = []
+  const result = await streamChatOnce({ model: { ...model, model: 'legacy' }, messages: [], fetchFn: async (_url, init) => {
+    bodies.push(JSON.parse(init.body))
+    return bodies.length === 1
+      ? new Response(JSON.stringify({ error: { message: 'unknown parameter stream_options' } }), { status: 400 })
+      : response([event({ choices: [{ delta: { content: 'ok' }, finish_reason: 'stop' }] })])
+  } })
+  assert.equal(bodies.length, 2)
+  assert.equal(bodies[1].stream_options, undefined)
+  assert.equal(result.usage, null)
+})
+
+test('truncated streams do not yield executable tool calls', async () => {
+  await assert.rejects(streamChatOnce({ model, messages: [], fetchFn: async () => response([
+    event({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'x', function: { name: 'write_file', arguments: '{}' } }] } }] }),
+  ]) }), /中断/)
+})
+
+test('timeout and explicit cancellation have different outcomes', async () => {
+  const hanging = async (_url, { signal }) => new Promise((_, reject) => {
+    const abort = () => reject(new DOMException('Aborted', 'AbortError'))
+    if (signal.aborted) abort()
+    else signal.addEventListener('abort', abort, { once: true })
+  })
+  await assert.rejects(streamChatOnce({ model, messages: [], fetchFn: hanging, timeoutMs: 10 }), /超时/)
+  const result = await streamChatOnce({ model, messages: [], fetchFn: hanging, signal: AbortSignal.abort() })
+  assert.equal(result.aborted, true)
+  assert.deepEqual(result.toolCalls, [])
+})
+
+const call = n => ({ id: `call${n}`, type: 'function', function: { name: 'read_file', arguments: '{}' } })
+const strings = { waiting: '', toolRunning: x => x, toolIterLimit: n => String(n), llmError: x => x, emptyResponse: 'empty' }
+const noop = () => {}
+const quiet = { startSpinner: () => ({ stop: noop }), createAssistantWriter: () => ({ writeContent: noop, writeThinking: noop, finish: noop }),
+  printToolHeader: noop, printToolResult: noop, printWarn: noop, printError: noop, printTurnSummary: noop }
+const state = () => ({ messages: [{ role: 'system', content: 'rules' }], ctx: { cwd: '.' }, abortController: new AbortController(), maxToolIterations: 4 })
+
+test('turn shows 12 nonblank preview rows, supports full/off, and keeps all reasoning in history', async () => {
+  const reasoning = Array.from({ length: 15 }, (_, i) => `Inspection step ${i + 1}.`).join('\n\n')
+  for (const mode of ['compact', 'full', 'off']) {
+    const s = { ...state(), thinkingMode: mode, showThinking: mode !== 'off' }
+    let output = ''
+    const stats = await runAgentTurn(s, 'task', strings, [], {
+      ui: { ...quiet, createAssistantWriter: options => createAssistantWriter({ ...options, write: text => { output += text } }) },
+      chat: async ({ onToken }) => {
+        for (const chunk of reasoning) onToken({ thinking: chunk })
+        onToken({ content: 'Final answer.' })
+        return { content: 'Final answer.', reasoning, toolCalls: [] }
+      },
+    })
+    assert.equal(stats.status, 'completed')
+    assert.equal(s.messages.at(-1).reasoning_content, reasoning)
+    const text = stripAnsi(output)
+    assert.match(text, /Final answer/)
+    if (mode === 'compact') {
+      assert.match(text, /Inspection step 12\./)
+      assert.doesNotMatch(text, /Inspection step 13\./)
+      assert.match(text, /\/think full/)
+    } else if (mode === 'full') {
+      assert.match(text, /Inspection step 15\./)
+      assert.doesNotMatch(text, /\/think full/)
+    } else assert.doesNotMatch(text, /Inspection step/)
+  }
+})
+
+test('turn aggregates all model calls, persists progress and records response timings', async () => {
+  const s = state()
+  let requests = 0, saves = 0
+  s.persistSession = async () => { saves++ }
+  const stats = await runAgentTurn(s, 'task', strings, [], { ui: quiet, execute: async () => 'file contents', chat: async ({ onToken }) => {
+    requests++
+    onToken({ content: requests === 1 ? 'checking\n' : 'answer\n' })
+    return { content: requests === 1 ? 'checking' : 'answer', toolCalls: requests === 1 ? [call(1)] : [], usage: normalizeUsage({ prompt_tokens: 10, completion_tokens: 2 }) }
+  } })
+  assert.equal(stats.status, 'completed')
+  assert.equal(stats.requests, 2)
+  assert.equal(stats.toolCalls, 1)
+  assert.equal(stats.usage.totalTokens, 24)
+  assert.equal(stats.usageRequests, 2)
+  assert.ok(stats.firstTokenMs >= 0)
+  assert.ok(stats.firstAnswerMs >= stats.firstTokenMs)
+  assert.ok(stats.totalMs >= stats.llmMs + stats.toolsMs)
+  assert.ok(saves >= 4)
+  assert.equal(s.sessionStats.usage.totalTokens, 24)
+})
+
+test('cancellation during a tool skips the remaining batch and keeps valid tool history', async () => {
+  const s = state(), executed = []
+  const stats = await runAgentTurn(s, 'task', strings, [], { ui: quiet,
+    chat: async () => ({ content: '', toolCalls: [call(1), call(2)] }),
+    execute: async name => { executed.push(name); s.abortController.abort(); return 'first result' },
+  })
+  assert.equal(stats.status, 'cancelled')
+  assert.equal(executed.length, 1)
+  assert.equal(s.messages.filter(m => m.role === 'tool').length, 2)
+  assert.match(s.messages.at(-1).content, /not executed/)
+})
+
+test('failed turns retain the user request and report partial usage honestly', async () => {
+  const s = state()
+  let requests = 0
+  const stats = await runAgentTurn(s, 'keep my task', strings, [], { ui: quiet, execute: async () => 'ok', chat: async () => {
+    if (++requests === 2) throw new Error('offline')
+    return { content: '', toolCalls: [call(1)], usage: normalizeUsage({ prompt_tokens: 1, completion_tokens: 1 }) }
+  } })
+  assert.equal(stats.status, 'failed')
+  assert.equal(stats.requests, 2)
+  assert.equal(stats.usageRequests, 1)
+  assert.ok(s.messages.some(m => m.content === 'keep my task'))
+})
+
+test('long tool turns have bounded request history without losing original goals or mutating the transcript', () => {
+  const messages = [{ role: 'system', content: 'rules' }, { role: 'user', content: 'original goal' }]
+  for (let i = 0; i < 60; i++) messages.push({ role: 'assistant', tool_calls: [call(i)] }, { role: 'tool', tool_call_id: `call${i}`, content: 'data'.repeat(4000) })
+  const before = structuredClone(messages)
+  const compact = buildRequestMessages(messages)
+  assert.ok(compact.length <= 40)
+  assert.ok(JSON.stringify(compact).length < 90000)
+  assert.ok(compact.some(m => m.content === 'original goal'))
+  assert.deepEqual(messages, before)
+  for (let i = 0; i < compact.length; i++) {
+    if (compact[i].tool_calls) assert.equal(compact[i + 1].tool_call_id, compact[i].tool_calls[0].id)
+  }
+})
+
+test('resume marks missing tool results without replaying actions', () => {
+  const repaired = repairToolHistory([{ role: 'user', content: 'task' }, { role: 'assistant', tool_calls: [call(1), call(2)] },
+    { role: 'tool', tool_call_id: 'call1', content: 'saved' }])
+  assert.equal(repaired[2].content, 'saved')
+  assert.equal(repaired[3].tool_call_id, 'call2')
+  assert.match(repaired[3].content, /status is unknown/)
+})

package/src/cli/ai/safety.js

@@ -67,15 +67,25 @@ function isRootTargetToken(token) {
 
 // 从命令串中抽出所有 "命令段"(按 ; && || | 切分),返回小写化前的原文段
 function splitCommandSegments(cmd) {
-  return String(cmd).split(/&&|\|\||[;|]/).map(s => s.trim()).filter(Boolean)
+  const parts = []
+  let quote = null, start = 0
+  for (let i = 0; i < cmd.length; i++) {
+    const char = cmd[i]
+    if (quote) {
+      if (char === quote && cmd[i - 1] !== '\\') quote = null
+    } else if (char === '"' || char === "'") quote = char
+    else if (';&|\n'.includes(char)) { parts.push(cmd.slice(start, i)); start = i + 1 }
+  }
+  parts.push(cmd.slice(start))
+  return parts.map(s => s.trim()).filter(Boolean)
 }
 
 // 解析命令段:返回小写命令名(跳过 sudo / doas 前缀) + 原始参数串
 // 注意:args 必须用匹配到的原始串长度切片,不能用 indexOf(小写名) —
 // 混合大小写命令(Remove-Item 等)会 indexOf 失败导致切片错位
 function parseSegment(seg) {
-  const m = seg.match(/^(?:sudo|doas)\s+(\S+)|^(\S+)/)
-  const name = (m?.[1] || m?.[2] || '')
+  const m = seg.match(/^(?:(?:sudo|doas)\s+)?("[^"]+"|'[^']+'|\S+)/)
+  const name = (m?.[1] || '').replace(/^["'@]+|["']+$/g, '').split(/[\\/]/).pop().replace(/\.exe$/i, '')
   const args = m ? seg.slice(m[0].length) : seg
   return { head: name.toLowerCase(), args }
 }
@@ -96,7 +106,7 @@ function hasRecursiveFlag(args, style) {
  * @returns {{ blocked: boolean, reason: string|null }}
  *   blocked=true 时 reason 给出中文原因(会回喂给模型,让它换方案)
  */
-export function checkDangerousCommand(cmd) {
+export function checkDangerousCommand(cmd, depth = 0) {
   if (typeof cmd !== 'string' || !cmd.trim()) {
     return { blocked: false, reason: null }
   }
@@ -124,6 +134,19 @@ export function checkDangerousCommand(cmd) {
   for (const seg of splitCommandSegments(text)) {
     const { head, args } = parseSegment(seg)
 
+    // Inspect common shell wrappers too. This remains a best-effort guard,
+    // not a sandbox or an interpreter for arbitrary scripts/variable expansion.
+    if (depth < 8 && /^(cmd|powershell|pwsh|sh|bash|zsh)$/i.test(head)) {
+      const flag = head === 'cmd' ? /(?:^|\s)\/[ck]\s+/i : /(?:^|\s)-(?:command|c|lc)\s+/i
+      const match = flag.exec(args)
+      if (match) {
+        let nested = args.slice(match.index + match[0].length).trim()
+        if ((nested.startsWith('"') && nested.endsWith('"')) || (nested.startsWith("'") && nested.endsWith("'"))) nested = nested.slice(1, -1)
+        const result = checkDangerousCommand(nested, depth + 1)
+        if (result.blocked) return result
+      }
+    }
+
     // 关机/重启/停机
     if (/^(shutdown|reboot|poweroff|halt|init|telinit|stop-computer|restart-computer)$/i.test(head)) {
       // init 只有 0/6 才是关机/重启

package/src/cli/ai/safety.test.js

@@ -149,6 +149,19 @@ for (const cmd of ALLOWED) {
 
 // ========== 边界输入 ==========
 
+test('common nested shell wrappers retain system-operation checks', () => {
+  for (const command of [
+    'cmd /c shutdown /s /t 0',
+    'cmd.exe /d /s /c "shutdown.exe /s /t 0"',
+    'powershell -NoProfile -Command "Stop-Computer"',
+    'bash -c "rm -rf /"',
+    'cmd /c "echo ready & shutdown /s"',
+  ]) assert.equal(checkDangerousCommand(command).blocked, true, command)
+  for (const command of ['cmd /c "echo shutdown"', 'powershell -Command "Write-Output shutdown"', 'node -e "console.log(\'shutdown\')"']) {
+    assert.equal(checkDangerousCommand(command).blocked, false, command)
+  }
+})
+
 test('非字符串/空输入不拦截也不报错', () => {
   for (const bad of [null, undefined, 123, {}, [], '', '   ']) {
     const r = checkDangerousCommand(bad)

package/src/cli/ai/telemetry.js

@@ -0,0 +1,43 @@
+// Token counts come from provider usage only. Cache/reasoning counts are subsets,
+// never extra tokens to add on top of the provider's total.
+const count = (...values) => values.find(v => Number.isFinite(v) && v >= 0) ?? null
+
+export function normalizeUsage(raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const inputTokens = count(raw.prompt_tokens, raw.input_tokens)
+  const outputTokens = count(raw.completion_tokens, raw.output_tokens)
+  const totalTokens = count(raw.total_tokens,
+    inputTokens !== null && outputTokens !== null ? inputTokens + outputTokens : null)
+  if (inputTokens === null && outputTokens === null && totalTokens === null) return null
+  return {
+    inputTokens, outputTokens, totalTokens,
+    cachedTokens: count(raw.prompt_tokens_details?.cached_tokens, raw.input_tokens_details?.cached_tokens, raw.prompt_cache_hit_tokens),
+    reasoningTokens: count(raw.completion_tokens_details?.reasoning_tokens, raw.output_tokens_details?.reasoning_tokens),
+  }
+}
+
+export function addUsage(previous, next) {
+  if (!next) return previous || null
+  if (!previous) return { ...next }
+  return Object.fromEntries(Object.keys(next).map(key => [key,
+    previous[key] == null || next[key] == null ? null : previous[key] + next[key],
+  ]))
+}
+
+export function createTurnStats() {
+  return {
+    startedAt: new Date().toISOString(), completedAt: null, status: 'running',
+    totalMs: 0, llmMs: 0, toolsMs: 0, firstTokenMs: null, firstAnswerMs: null,
+    requests: 0, toolCalls: 0, usageRequests: 0, usage: null,
+  }
+}
+
+export function accumulateSessionStats(previous, turn) {
+  return {
+    turns: (previous?.turns || 0) + 1,
+    totalMs: (previous?.totalMs || 0) + turn.totalMs,
+    requests: (previous?.requests || 0) + turn.requests,
+    usageRequests: (previous?.usageRequests || 0) + turn.usageRequests,
+    usage: addUsage(previous?.usage, turn.usage),
+  }
+}