zhiqu 0.1.0 → 0.2.0

package/src/agent.js

@@ -26,6 +26,8 @@ import { parseTodos, TODO_TOOL, todoBlock, todoLines, todoNudge, todoReply, todo
 import { spillLongInput } from './longinput.js';
 import { applyGoalUpdate, DEFAULT_MAX_GOAL_TURNS, GOAL_TOOL, goalBlock, goalSchema, MAX_VERIFY_FAILURES, parseVerdict, verificationMaterial, VERIFY_INSTRUCTIONS } from './goal.js';
 import { monotonic } from './clock.js';
+import { AGENT_TOOLS, agentSchemas, describeAgentCall } from './subagents.js';
+import { judgmentText, listDetail, patchDetail, runDetail, writeDetail } from './steps.js';
 
 export const REMOTE_READ_TOOLS = new Set(['search_wiki', 'read_wiki_page', 'read_memory', 'list_tasks']);
 /** 远程工具里**直接生效**的（不是草稿）：plan 档不给，ask 档先问（第二十九轮，用户定的「改状态直接做」）。 */
@@ -146,6 +148,9 @@ function shellPolicy(ctx) {
 }
 
 /** 这一轮给模型哪些工具。 */
+/** 这一次下发的 shell 有没有 background（toolset 里同一个条件） */
+const offeredBackground = (ctx) => Boolean(ctx.local && ctx.local.sandbox && !ctx.local.hosted);
+
 export function toolset(ctx) {
   const plan = ctx.mode === 'plan';
   const out = [];
@@ -159,7 +164,8 @@ export function toolset(ctx) {
     if (!plan || READ_TOOLS.has(t.function.name)) out.push({ schema: t, kind: 'local' });
   }
   // 服务器上没有后台命令（第一百一十七轮）：要管它们活多久、占多少，先不给
-  if (sandboxed) for (const t of shellSchemas({ background: !ctx.local.hosted })) out.push({ schema: t, kind: 'local' });
+  // 子 agent 也给（第一百二十六轮，用户定的：子 agent 能跑命令；但它停下之前，它自己起的后台命令要先停下 —— 见 subagents.js 的 settle）
+  if (sandboxed) for (const t of shellSchemas({ background: offeredBackground(ctx) })) out.push({ schema: t, kind: 'local' });
   for (const t of ctx.remoteTools || []) {
     if (!plan || REMOTE_READ_TOOLS.has(t.function.name)) out.push({ schema: t, kind: 'remote' });
   }
@@ -182,6 +188,8 @@ export function toolset(ctx) {
   // exec 的只读没有人批准计划：把结论写出来就是了（第一百一十三轮）
   if (plan && !ctx.execReadOnly) out.push({ schema: exitPlanSchema(), kind: 'plan' });
   if (ctx.goal && ctx.goal.status === 'active') out.push({ schema: goalSchema(), kind: 'goal' });
+  // 子 agent（第一百二十三轮）：只有主 agent 有，子 agent 不能再派（深度 1）；命令行建了 ctx.agents 才有（网页的代码模式这一轮不给）
+  if (ctx.agents && !ctx.subagent) for (const t of agentSchemas()) out.push({ schema: t, kind: 'agent' });
   // 同名只留第一个：本地工具优先于远程 / MCP（MCP 名字有前缀，本不会撞）
   const seen = new Set();
   return out.filter((t) => (seen.has(t.schema.function.name) ? false : seen.add(t.schema.function.name)));
@@ -273,6 +281,8 @@ function truncatedArgs(raw) {
 // ── 模型调用 ─────────────────────────────────────────────────────────────
 
 export const MODEL_RETRY_WAITS = [1000, 3000];
+/** 一段思考在步骤里最多留多少字（点开看的，不是给模型的） */
+export const THINKING_KEEP = 6000;
 
 /**
  * 调模型，失败了在安全的时候重来：只有「还没收到任何实质输出」且错误是临时性的（连接断开、服务器 5xx / 429、
@@ -314,6 +324,17 @@ async function callModelOnce(ctx, tools, signal, { render = true, maxTokens = DE
   };
   if (ctx.effort) body.reasoning = ctx.effort;   // 不说就听服务端的默认
   let thought = 0;
+  let thinkingFrom = null;
+  let thinkingMs = 0;
+  // 第一个正文 / 工具调用到了：思考到此为止（第一百二十八轮）。原来只在 delta / tool_call 里算，
+  // 模型想完直接调工具、一个字正文都没写时 thinkingMs 一直是 0 —— 网页上那一步成了「思考 1 秒」，
+  // 看着像没思考（用户：「思考过程反而不见了」）。现在收尾时也按「第一个思考字到此刻」算
+  const stopThinking = () => {
+    if (thinkingFrom != null && !thinkingMs) thinkingMs = monotonic() - thinkingFrom;
+  };
+  // 思考的原文（第一百二十八轮：网页上「思考 100 秒」点开看得到想了什么）—— 只在有人要（stepLog）时才攒，攒到上限为止
+  const keepThinking = Boolean(ctx.stepLog);
+  let thinkingText = '';
   // 安静模式不边收边打：这时断了，已经收到的那一段就这么没了（第二十二轮实测：回答到一半服务器重启，只剩一句「断开了」）。
   // 把它打出来 —— 用户至少看得到说到哪了。断的两种样子都要：连接出错（下面的 catch）、流好好结束了却没有 done
   const showPartial = () => {
@@ -323,8 +344,8 @@ async function callModelOnce(ctx, tools, signal, { render = true, maxTokens = DE
     partial.feed(text);
     partial.finish();
   };
-  try {
-  await ctx.api.stream('/api/harness/model/stream', body, (name, data) => {
+  // 直连供应商（第一百二十九轮）：配了 direct 就不经服务器，事件形状两边一样（见 direct.js）
+  const onEvent = (name, data) => {
     if (name !== 'start') stopWaiting();
     if (name === 'start') {
       if (data.droppedMessages > 0 || data.elidedToolOutputs > 0) {
@@ -334,12 +355,16 @@ async function callModelOnce(ctx, tools, signal, { render = true, maxTokens = DE
     } else if (name === 'reasoning') {
       // 思考不打进终端（要回传的内容在 done 的 message 里，见 HarnessModelGateway），只说它在想：不然模型想一分钟，看着像卡死了
       thought += String(data.text || '').length;
+      if (keepThinking && thinkingText.length < THINKING_KEEP) thinkingText += String(data.text || '').slice(0, THINKING_KEEP - thinkingText.length);
+      if (thinkingFrom == null) thinkingFrom = monotonic();
       if (hush) ui.setActivity(`思考中 ${formatBytes(thought)}`);
       else if (render) ui.status.set(ui.paint.dim(`… 思考中 ${formatBytes(thought)}`));
     } else if (name === 'delta') {
+      stopThinking();
       text += data.text;
       if (md) md.feed(data.text);
     } else if (name === 'tool_call') {
+      stopThinking();
       toolNames.set(data.index, data.name);
       if (md && md.wroteAnything) md.finish();     // 正文说完了才轮到工具：先把这段收尾换行
       if (hush) ui.setActivity(`准备 ${data.name}`);
@@ -351,7 +376,10 @@ async function callModelOnce(ctx, tools, signal, { render = true, maxTokens = DE
     } else if (name === 'done') {
       done = data;
     }
-  }, { signal });
+  };
+  try {
+    if (ctx.modelClient) await ctx.modelClient.stream(body, onEvent, { signal });
+    else await ctx.api.stream('/api/harness/model/stream', body, onEvent, { signal });
   } catch (e) {
     if (!(e && e.name === 'AbortError')) showPartial();
     throw e;
@@ -371,7 +399,10 @@ async function callModelOnce(ctx, tools, signal, { render = true, maxTokens = DE
     // 输入里命中供应商前缀缓存的部分（第九十三轮）：网关在供应商报了时才给；命中的按命中价算钱
     ctx.usage.cached = (ctx.usage.cached || 0) + (done.usage ? done.usage.cachedTokens || 0 : 0);
   }
-  return { ...done, text, maxTokens: done.maxTokens || maxTokens };
+  if (ctx.onUsage && done.usage) ctx.onUsage(done.usage);
+  // 这一次想了多久（第一百二十七轮：网页回答里「思考 N 秒」那一步）—— 从第一个思考字到第一个正文 / 工具调用
+  stopThinking();
+  return { ...done, text, maxTokens: done.maxTokens || maxTokens, thought: { chars: thought, ms: thinkingMs, text: thinkingText } };
 }
 
 /** /usage 里输入后面那一句「（缓存命中 N，P%）」；没命中、供应商没报就不说。 */
@@ -519,6 +550,7 @@ export function describeCall(name, args) {
     case 'load_skill': return `读取 skill ${args.name}${args.file ? ` / ${args.file}` : ''}`;
     case 'find_mcp_tool': return `找 MCP 工具「${args.query}」`;
     case 'exit_plan_mode': return '提交计划';
+    case 'spawn_agent': case 'wait_agent': case 'send_input': case 'close_agent': return describeAgentCall(name, args);
     case TODO_TOOL: return '更新任务清单';
     case GOAL_TOOL: return `目标状态：${args.status}`;
     case 'search_wiki': return wikiSearchLabel(args);
@@ -581,11 +613,17 @@ function hushedUi(ui) {
 function refuseUnoffered(ctx, name, offered) {
   const ui = ctx.ui;
   const available = [...offered.keys()].join('、');
+  if (ctx.subagent && AGENT_TOOLS.has(name)) {
+    ui.step(`${name}（子 agent 不能再派子 agent）`);
+    ui.result('已拒绝', false);
+    return `你是子 agent，不能再派子 agent：自己做完，把结论交回去。能用的工具：${available}。`;
+  }
   if (existingToolNames(ctx).has(name)) {
     ui.step(`${name}（${ctx.mode} 档不给这个工具）`);
     ui.result('已拒绝', false);
     return `${name} 在当前的 ${ctx.mode} 档没有下发，没有执行。`
-      + (ctx.execReadOnly ? '现在是只读的（zhiqu exec 默认）：改不了文件。把结论写出来；用户要改的话得用 --mode auto 重跑。'
+      + (ctx.subagent && ctx.subagent.role === 'explorer' ? '你是只读探索的子 agent：不能改文件、不能跑会改东西的命令。把要改什么写进结论交回去，由主 agent 决定。'
+        : ctx.execReadOnly ? '现在是只读的（zhiqu exec 默认）：改不了文件。把结论写出来；用户要改的话得用 --mode auto 重跑。'
         : ctx.mode === 'plan' ? '现在是只读的 plan 档：想好之后用 exit_plan_mode 提交计划，用户批准后才能写、才能跑。' : '')
       + `这一档能用的：${available}。`;
   }
@@ -631,8 +669,20 @@ const windowReminder = (p, offset) => `你在接着上一次往下读 ${p}（第
  * 不调工具的那条回复之后还要不要推一句（清单没做完）。在问用户问题、最后一轮不推。
  * 要推的话那条先不当结论打出来 —— 原来安静模式下先打一遍结论、推完再打一遍（第八十九轮真模型试出来的）。
  */
+/** 子 agent 自己起的、还在跑的后台命令 */
+function runningOwnJobs(ctx) {
+  if (!ctx.ownJobs || !ctx.ownJobs.size || !ctx.local || !ctx.local.jobs) return [];
+  return ctx.local.jobs.running().map((j) => j.id).filter((id) => ctx.ownJobs.has(id));
+}
+const ownJobsNudge = (ids) => `（你起的后台命令 ${ids.join('、')} 还在跑。交结论之前先处理掉：要结果就用 shell_output 看完，不用了就 shell_stop 停掉。`
+  + '你交了结论就算停下，到时还在跑的会被停掉。）';
+
 function pendingNudge(ctx, text, { nudged, claimChecked, lastRound }) {
   if (lastRound || /[？?]\s*$/.test((text || '').trim())) return null;
+  // 派出去的子 agent 还在跑就收尾：推一次去 wait_agent（第一百二十三轮）
+  if (ctx.agents && !ctx.subagent && !ctx.agents.nudged && ctx.agents.running().length) return 'agents';
+  // 子 agent 要交结论时它起的后台命令还在跑：推一次「看完输出、停掉」（第一百二十六轮）；还不停，交结论时由 settle 停掉
+  if (ctx.subagent && !ctx.jobsNudged && runningOwnJobs(ctx).length) return 'jobs';
   if (!nudged && ctx.mode !== 'plan' && unfinished(ctx.todos).length) return 'todo';
   // 交活时说的和这一轮做的对不上：宿主给的核对（第九十五轮：网页代码模式里一个工具没调就说「已生成三个文件的草稿」），只推一次。命令行里没有这个钩子
   if (!claimChecked && ctx.claimCheck && ctx.claimCheck(text)) return 'claim';
@@ -693,17 +743,63 @@ const sameEditReminder = (file) => (n) => `你已经连续 ${n} 次没能改成
 const runReminder = (line) => (n) => `同一条命令 ${line} 已经连续 ${n} 次失败。先把上面的错误信息完整读一遍，找出根因（不是症状）、`
   + '想清楚要改哪里再改，一次改对；如果是环境问题或者需要用户决定，就停下来说明，不要换着花样重跑。';
 
+/**
+ * 一次工具调用记成一步（第一百二十七轮）：开始一条、结束一条。各分支用 ctx.stepNote({...}) 补结果 / detail，
+ * 没补的就按给模型的那句话当小结。没有 ctx.stepLog（命令行的终端）就什么都不做 —— 终端的显示不变。
+ */
 async function executeTool(ctx, call, offered, signal) {
+  const log = ctx.stepLog;
+  if (!log) return runTool(ctx, call, offered, signal);
+  const name = call.function && call.function.name;
+  const parsed = parseArgs(call.function.arguments);
+  const step = log.start(name || '', parsed.ok ? parsed.value : {});
+  let note = null;
+  ctx.stepNote = (n) => { note = { ...(note || {}), ...n }; };
+  try {
+    const content = await runTool(ctx, call, offered, signal);
+    const n = note || {};
+    log.finish(step, { summary: n.summary ?? firstLineOf(content), ok: n.ok ?? true, detail: n.detail, kind: n.kind, title: n.title });
+    return content;
+  } catch (e) {
+    log.finish(step, { summary: e && e.message ? e.message : String(e), ok: false });
+    throw e;
+  } finally {
+    ctx.stepNote = null;
+  }
+}
+const firstLineOf = (s) => String(s || '').split('\n').find((l) => l.trim()) || '';
+/** 远程工具的结果多半是一整段 JSON（read_wiki_page 是 {title, content: 正文}）：不拿 JSON 当小结（review），只说读到了什么 */
+function remoteSummary(content) {
+  const text = String(content || '').trim();
+  if (!text.startsWith('{') && !text.startsWith('[')) return firstLineOf(text);
+  try {
+    const v = JSON.parse(text);
+    if (Array.isArray(v)) return `${v.length} 条`;
+    if (Array.isArray(v.results)) return `${v.results.length} 条`;
+    if (Array.isArray(v.pages)) return `${v.pages.length} 页`;
+    if (typeof v.title === 'string') return `「${v.title.slice(0, 60)}」`;
+    return '完成';
+  } catch {
+    return '完成';
+  }
+}
+/** 改动只是草稿（网页选了文件夹）；生成到产物（ArtifactTools 继承了 drafts 这个 Map）写的是真的 */
+const isDraft = (local) => Boolean(local && local.drafts && !local.artifact);
+/** 有就记（runTool 里的各分支用）。n 可以是函数：要算 diff 的那几种只在真的要记时才算（终端里没有 stepLog，不白算） */
+const stepNote = (ctx, n) => { if (ctx.stepNote) ctx.stepNote(typeof n === 'function' ? n() : n); };
+
+async function runTool(ctx, call, offered, signal) {
   const name = call.function && call.function.name;
   // 读 / 搜 / 列目录、没下发的名字、参数坏了 —— 都是过程，安静模式下只在状态行里一闪，不留成行
   const hush = quiet(ctx) && (QUIET_TOOLS.has(name) || !offered.get(name));
   const ui = hush ? hushedUi(ctx.ui) : ctx.ui;
   const kind = offered.get(name);
-  if (!kind) return refuseUnoffered({ ...ctx, ui }, name, offered);
+  if (!kind) { stepNote(ctx, { ok: false, summary: '没有这个工具 / 这一档不给' }); return refuseUnoffered({ ...ctx, ui }, name, offered); }
   const parsed = parseArgs(call.function.arguments);
   if (!parsed.ok) {
     ui.step(`${name}（参数不对）`);
     ui.result(parsed.error, false);
+    stepNote(ctx, { ok: false, summary: `参数不对：${parsed.error}` });
     return `参数不是合法的 JSON（${parsed.error}），没有执行。请重新调用。`;
   }
   const args = parsed.value;
@@ -720,23 +816,30 @@ async function executeTool(ctx, call, offered, signal) {
       // 读文件按这个模型一次能看的量给（留一点给头部）：否则它以为看全了，其实后半截被截断了
       const cap = toolOutputCap(ctx.model ? ctx.model.effectiveContextWindow : null) - 300;
       const r = name === 'list_files' ? local.listFiles(args) : name === 'read_file' ? local.readFile(args, { maxChars: cap }) : local.search(args);
-      if (r.error) { ui.result(r.error, false); return r.error; }
+      if (r.error) { ui.result(r.error, false); stepNote(ctx, { ok: false, summary: r.error }); return r.error; }
       ui.result(r.summary);
+      // list_files 的头一行是「src：」这样的说明，search 没有（review：原来一律去掉头一行，搜索的第一条命中没了）
+      stepNote(ctx, () => ({ summary: r.summary, detail: name === 'read_file' ? { path: String(args.path || '') }
+        : listDetail(name === 'list_files' ? r.content.split('\n').slice(1).join('\n') : r.content) }));
       return r.content;
     }
     if (name === 'write_file' || name === 'edit_file') {
       const spinKey = `write:${String(args.path || '')}`;
       const prep = name === 'edit_file' ? local.prepareEdit(args) : local.prepareWrite(args);
-      if (prep.error) { ui.result(prep.error, false); return failed(ctx, spinKey, prep.error, (prep.unchanged ? sameEditReminder : writeReminder)(args.path)); }
+      if (prep.error) { ui.result(prep.error, false); stepNote(ctx, { ok: false, summary: prep.error }); return failed(ctx, spinKey, prep.error, (prep.unchanged ? sameEditReminder : writeReminder)(args.path)); }
       if (prep.newDirectories.length) ui.note(`    （会连同新建目录 ${prep.newDirectories.join('、')}）`);
       if (!(await confirmWrite(ctx, prep))) {
         ui.result('用户没有同意，没写', false);
+        stepNote(ctx, { ok: false, summary: '用户没有同意，没写' });
         return `用户没有同意写入 ${prep.rel}，文件没有改动。不要原样重试；问问用户想怎么改，或者换个做法。`;
       }
       const r = local.commitWrite(prep);
-      if (r.error) { ui.result(r.error, false); return r.error; }
+      if (r.error) { ui.result(r.error, false); stepNote(ctx, { ok: false, summary: r.error }); return r.error; }
       succeeded(ctx, spinKey);
       ctx.changedFiles.add(prep.rel);
+      // 新建的算 create，改已有的（edit_file、覆盖、追加）算 edit；草稿模式另说一句「草稿，没落盘」
+      stepNote(ctx, () => ({ kind: prep.creating ? 'create' : 'edit', title: prep.creating ? '新建' : prep.kind === 'append' ? '追加' : '修改',
+        summary: `+${r.added} -${r.removed}${isDraft(local) ? '（草稿）' : ''}${r.syntax ? '，语法错误' : ''}`, ok: !r.syntax, detail: writeDetail(prep, r) }));
       ui.result(ui.paint.green(`✓ ${r.content.split('（')[0]}  +${r.added} -${r.removed}`));
       if (r.syntax) ui.result(`语法错误：${r.syntax.split('\n')[0]}`, false);
       return r.content;
@@ -745,78 +848,119 @@ async function executeTool(ctx, call, offered, signal) {
       const spinKey = `patch:${String(args.patch || '').slice(0, 300)}`;
       const shown = patchFiles(args.patch).join('、') || '补丁';
       const prep = local.preparePatch(args);
-      if (prep.error) { ui.result(prep.error, false); return failed(ctx, spinKey, prep.error, (prep.unchanged ? sameEditReminder : writeReminder)(shown)); }
+      if (prep.error) { ui.result(prep.error, false); stepNote(ctx, { ok: false, summary: prep.error }); return failed(ctx, spinKey, prep.error, (prep.unchanged ? sameEditReminder : writeReminder)(shown)); }
       if (!(await confirmPatch(ctx, prep))) {
         ui.result('用户没有同意，没改', false);
+        stepNote(ctx, { ok: false, summary: '用户没有同意，没改' });
         return `用户没有同意这个补丁，${shown} 都没有改动。不要原样重试；问问用户想怎么改，或者换个做法。`;
       }
       const r = local.commitPatch(prep);
-      if (r.error) { ui.result(r.error, false); return r.error; }
+      if (r.error) { ui.result(r.error, false); stepNote(ctx, { ok: false, summary: r.error }); return r.error; }
       succeeded(ctx, spinKey);
       for (const rel of r.changed) ctx.changedFiles.add(rel);
+      stepNote(ctx, () => ({ summary: `${r.summary}${isDraft(local) ? '（草稿）' : ''}${r.syntax ? '，语法错误' : ''}`, ok: !r.syntax, detail: patchDetail(prep) }));
       ui.result(ui.paint.green(`✓ ${r.summary}`));
       if (r.syntax) ui.result(`语法错误：${r.syntax.split('\n')[0]}`, false);
       return r.content;
     }
     if (name === 'delete_file') {
       const prep = local.prepareDelete(args);
-      if (prep.error) { ui.result(prep.error, false); return prep.error; }
+      if (prep.error) { ui.result(prep.error, false); stepNote(ctx, { ok: false, summary: prep.error }); return prep.error; }
       if (!(await confirmDelete(ctx, prep))) {
         ui.result('用户没有同意，没删', false);
+        stepNote(ctx, { ok: false, summary: '用户没有同意，没删' });
         return `用户没有同意删除 ${prep.rel}，文件还在。不要原样重试；问问用户想怎么处理。`;
       }
       const r = local.commitDelete(prep);
-      if (r.error) { ui.result(r.error, false); return r.error; }
+      if (r.error) { ui.result(r.error, false); stepNote(ctx, { ok: false, summary: r.error }); return r.error; }
       ctx.changedFiles.add(`${prep.rel}（已删除）`);
+      stepNote(ctx, { summary: `${prep.lines} 行，挪进 .zhiqu/trash/` });
       ui.result(ui.paint.green(`✓ 已删除 ${prep.rel}`) + ui.paint.dim(`  → ${r.trashed}`));
       return r.content;
     }
     if (name === 'shell') {
       const spinKey = `shell:${args.command}${args.cwd ? `@${args.cwd}` : ''}`;
       const prep = local.prepareShell(args);
-      if (prep.error) { ui.result(prep.error, false); return failed(ctx, spinKey, prep.error, runReminder(String(args.command))); }
+      if (prep.error) { ui.result(prep.error, false); stepNote(ctx, { ok: false, summary: prep.error }); return failed(ctx, spinKey, prep.error, runReminder(String(args.command))); }
       if (ctx.mode === 'ask' && !(await confirmShell(ctx, prep))) {
         ui.result('用户没有同意，没运行', false);
+        stepNote(ctx, { ok: false, summary: '用户没有同意，没运行' });
         return `用户没有同意运行 ${prep.command}。不要原样重试；问问用户，或者换个做法。`;
       }
-      if (args.background) {
+      // 没下发 background（服务器上）就不当后台命令起：模型照着别处的说法传了 background: true，原来照样起了（第一百二十六轮 review）
+      if (args.background && offeredBackground(ctx)) {
         const job = await local.startJob(prep, { policy: shellPolicy(ctx), signal });
-        if (job.error) { ui.result(job.error, false); return failed(ctx, spinKey, job.error, runReminder(prep.command)); }
+        if (job.error) { ui.result(job.error, false); stepNote(ctx, { ok: false, summary: job.error }); return failed(ctx, spinKey, job.error, runReminder(prep.command)); }
         succeeded(ctx, spinKey);
+        stepNote(ctx, { summary: `${job.id} ${job.snap.running ? '在后台跑着' : `结束了（退出码 ${job.snap.exitCode}）`}`, ok: job.snap.running || job.snap.exitCode === 0,
+          detail: runDetail(prep, { output: job.snap.output, exitCode: job.snap.running ? null : job.snap.exitCode }) });
+        // 子 agent 起的记在它自己名下：它停下之前要先停掉（subagents.js 的 settle）
+        if (ctx.ownJobs) ctx.ownJobs.add(job.id);
         ui.result(`${job.id} 在后台${job.snap.running ? '跑着' : `结束了（退出码 ${job.snap.exitCode}）`}`, job.snap.running || job.snap.exitCode === 0);
         return job.content;
       }
       let tail = '';
       const onOutput = (s) => { tail = (tail + s).slice(-4000); };
-      let r = await local.commitShell(prep, { policy: shellPolicy(ctx), signal, onOutput });
+      // 跑命令期间状态行说「运行中 N 秒 · 命令」（第一百二十九轮）：原来一直是「思考中」，分不清在等模型还是在等命令
+      ui.startRun(prep.command);
+      let r;
+      try {
+        r = await local.commitShell(prep, { policy: shellPolicy(ctx), signal, onOutput });
+      } finally {
+        ui.endRun();
+      }
       // 被沙箱挡住：只有 ask 档、用户当场点了才不带沙箱再跑一次（默认不）。plan、auto 只把边界告诉模型
       if (r.blocked && ctx.mode === 'ask' && await confirmUnsandboxed(ctx, prep)) {
-        r = await local.commitShell(prep, { unsandboxed: true, signal, onOutput });
+        ui.startRun(prep.command);
+        try {
+          r = await local.commitShell(prep, { unsandboxed: true, signal, onOutput });
+        } finally {
+          ui.endRun();
+        }
       }
       for (const l of shownOutput(r.output.split('\n').filter((x) => x.trim()))) ui.line(`    ${ui.paint.dim(termSafe(l.length > 200 ? `${l.slice(0, 200)}…` : l, { singleLine: true }))}`);
       ui.result(r.summary, r.exitCode === 0);
+      stepNote(ctx, { summary: r.summary, ok: r.exitCode === 0, detail: runDetail(prep, r) });
       if (r.exitCode === 0) { succeeded(ctx, spinKey); return r.content; }
       return failed(ctx, spinKey, r.content, runReminder(prep.command));
     }
     if (name === 'shell_output' || name === 'shell_stop') {
+      // 子 agent 只管自己起的（别人的 dev server 它停不得）
+      if (ctx.ownJobs && !ctx.ownJobs.has(String(args.id || ''))) {
+        const mine = [...ctx.ownJobs];
+        const msg = `${args.id} 不是你起的后台命令${mine.length ? `：你起的是 ${mine.join('、')}` : '：你还没起过后台命令'}。`;
+        ui.result(msg, false);
+        stepNote(ctx, { ok: false, summary: msg });
+        return msg;
+      }
       const r = name === 'shell_output' ? await local.readJob(args, { signal }) : await local.stopJob(args, { signal });
-      if (r.error) { ui.result(r.error, false); return r.error; }
+      if (r.error) { ui.result(r.error, false); stepNote(ctx, { ok: false, summary: r.error }); return r.error; }
       ui.result(r.snap.running ? `${r.snap.id} 还在跑` : `${r.snap.id} 已结束（退出码 ${r.snap.exitCode}）`);
+      stepNote(ctx, { summary: r.snap.running ? `${r.snap.id} 还在跑` : `${r.snap.id} 已结束（退出码 ${r.snap.exitCode}）`, ok: r.snap.running || r.snap.exitCode === 0,
+        detail: runDetail({ command: r.snap.command || '' }, { output: r.snap.output, exitCode: r.snap.running ? null : r.snap.exitCode }) });
       return r.content;
     }
     if (name === 'run_command') {
       const line = [args.command, ...(Array.isArray(args.args) ? args.args : [])].join(' ');
       const spinKey = `run:${line}${args.cwd ? `@${args.cwd}` : ''}`;
       const prep = local.prepareRun(args);
-      if (prep.error) { ui.result(prep.error, false); return failed(ctx, spinKey, prep.error, runReminder(line)); }
+      if (prep.error) { ui.result(prep.error, false); stepNote(ctx, { ok: false, summary: prep.error }); return failed(ctx, spinKey, prep.error, runReminder(line)); }
       if (!(await confirmRun(ctx, prep))) {
         ui.result('用户没有同意，没运行', false);
+        stepNote(ctx, { ok: false, summary: '用户没有同意，没运行' });
         return `用户没有同意运行 ${[prep.command, ...prep.args].join(' ')}。不要原样重试；问问用户，或者换个做法。`;
       }
       let tail = '';
-      const r = await local.commitRun(prep, { signal, onOutput: (s) => { tail = (tail + s).slice(-4000); } });
+      ui.startRun(line);
+      let r;
+      try {
+        r = await local.commitRun(prep, { signal, onOutput: (s) => { tail = (tail + s).slice(-4000); } });
+      } finally {
+        ui.endRun();
+      }
       for (const l of shownOutput(r.output.split('\n').filter((x) => x.trim()))) ui.line(`    ${ui.paint.dim(termSafe(l.length > 200 ? `${l.slice(0, 200)}…` : l, { singleLine: true }))}`);
       ui.result(r.summary, r.exitCode === 0);
+      stepNote(ctx, { summary: r.summary, ok: r.exitCode === 0, detail: runDetail(prep, r) });
       if (r.exitCode === 0) { succeeded(ctx, spinKey); return r.content; }
       return failed(ctx, spinKey, r.content, runReminder(line));
     }
@@ -832,9 +976,11 @@ async function executeTool(ctx, call, offered, signal) {
         : await ctx.api.post('/api/harness/tools/call', { sessionId: ctx.session.id, name, arguments: args }, { signal, timeoutMs: 60_000 });
       const drafts = r.drafts || [];
       ui.result(drafts.length ? `草稿：${drafts.map((d) => d.title).join('、')} → 到网页里确认` : '完成');
+      stepNote(ctx, { summary: drafts.length ? `草稿：${drafts.map((d) => d.title).join('、')}` : remoteSummary(r.content) });
       return r.content;
     } catch (e) {
       ui.result(e.message, false);
+      stepNote(ctx, { ok: false, summary: e.message });
       // 没拿到回应（服务器可能已经做了）：别说成「失败」—— 模型会换个说法再调一次；照原样再调，同一个键，不会重复
       return e.uncertain ? `远程工具没拿到回应：${e.message}` : `远程工具调用失败：${e.message}`;
     }
@@ -864,6 +1010,12 @@ async function executeTool(ctx, call, offered, signal) {
   if (kind === 'plan') {
     return approvePlan(ctx, String(args.plan || ''));
   }
+  if (kind === 'agent') {
+    const r = await ctx.agents.call(ctx, name, args, { signal });
+    if (r.error) { ui.result(r.error, false); return r.error; }
+    ui.result(r.summary, r.ok !== false);
+    return r.content;
+  }
   if (kind === 'todo') {
     const r = parseTodos(args);
     if (r.error) { ui.result(r.error, false); return r.error; }
@@ -871,6 +1023,8 @@ async function executeTool(ctx, call, offered, signal) {
     ctx.roundsSinceTodo = 0;
     const [head, ...items] = todoLines(r.todos, ui.paint);
     ui.result(head);
+    // 网页里每项带状态（画成什么由前端定，不把终端的 ☑ ◐ ☐ 带过去）
+    stepNote(ctx, { summary: head, detail: { todos: r.todos.slice(0, 30).map((t) => ({ content: String(t.content).slice(0, 300), status: t.status })) } });
     for (const l of items) ui.line(`  ${l}`);
     if (ctx.store && ctx.session) ctx.store.append(ctx.session.id, { type: 'todos', todos: ctx.todos });
     return todoReply(r.todos);
@@ -938,6 +1092,12 @@ export async function compactNow(ctx, signal, { manual = false } = {}) {
 
 export async function runTurn(ctx, userText, { signal, origin = null } = {}) {
   ctx.steps = [];
+  // 网页存档的步骤每一轮（主 agent）重开一份：上一轮被 Ctrl+C 打断 / 模型出错时 archiveTurn 没跑，
+  // 步骤会留在数组里，被下一轮的成功存档一起发上去 —— 网页上下一轮的回答上方会多出上一轮的步骤。
+  // 子 agent 的 ctx 是从父 ctx 浅拷贝来的，共用这个数组，不能清（它的步骤要由父 agent 的「派 / 等」两步代表）。
+  // 只在人说的那一句开头清：exec --output-schema 不合格式时推回去重写也走 runTurn（origin 'system'），
+  // 那一次清掉的话，存档里只剩重写那几步、真正干活的那一段没了（第一百二十八轮 review）
+  if (!origin && !ctx.subagent) resetArchive(ctx);
   ctx.spin = new Map();
   ctx.repeat = null;
   ctx.changedFiles = ctx.changedFiles || new Set();
@@ -954,12 +1114,15 @@ export async function runTurn(ctx, userText, { signal, origin = null } = {}) {
   }
   let finalText = '';
   let stalled = false;
+  let exhausted = false;   // 轮数用完了、模型还在调工具：没有结论（宿主据此照实说「用完了 N 轮」，不拿半路被推回去的那句顶上）
   let continuations = 0;
   let nudged = false;
   let claimChecked = false;
   ctx.turnStats = { read: 0, search: 0, list: 0 };
   ctx.readStreak = 0;
   ctx.readWindows = new Map(); ctx.readHinted = new Set();
+  const lead = ctx.agents && !ctx.subagent;   // 主 agent 的一句话：管着这一句派出去的子 agent
+  if (lead) ctx.agents.beginTurn(ctx, signal);
   if (quiet(ctx)) ctx.ui.startThinking();
   try {
   const maxRounds = ctx.maxRounds || 60;
@@ -978,11 +1141,17 @@ export async function runTurn(ctx, userText, { signal, origin = null } = {}) {
     const res = await callModel(ctx, tools, signal);
     const message = res.message || { role: 'assistant', content: res.text };
     const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    // 思考那一步在工具调用之后才收尾（第一百二十八轮）：原来紧跟着模型调用就记，那时还不知道这一轮要调工具，
+    // 网页上「思考」排在「读取 / 运行」后面 —— 和实际顺序反了。现在它排在这一次调用的工具前面，用时也照实
+    if (ctx.stepLog && res.thought) ctx.stepLog.thinking(res.thought.chars, res.thought.ms, res.thought.text);
+    // 调工具前的那一句（第一百三十轮）：有字就马上打一行，排在工具前面。结论还是只认最后那句（下面不调工具的那条）。
+    // --verbose 边收边打过了，这里不重复打；步骤照样记（网页 / 存档要这一条）
+    if (calls.length) showJudgment(ctx, message.content);
     // 原地重复：历史和回答里只留开头一段
     const looping = res.finishReason === 'length' && !calls.length && repeating(message.content);
     if (looping) message.content = loopTrimmed(message.content);
 
-    // 安静模式下文字是收完才打的：不调工具的那条就是结论（被截断的结论也是结论的一段），调工具的那条是过程，不打
+    // 安静模式：不调工具的那条才是结论，收完才打（被截断的结论也是结论的一段）。调工具前的那一句已经在上面打过一行
     const nudge = calls.length || res.finishReason === 'length' ? null
       : pendingNudge(ctx, message.content, { nudged, claimChecked, lastRound: round === maxRounds - 1 });
     if (quiet(ctx) && !calls.length && !nudge && !looping && (message.content || '').trim()) showAnswer(ctx, message.content);
@@ -1022,6 +1191,15 @@ export async function runTurn(ctx, userText, { signal, origin = null } = {}) {
         record(ctx, { role: 'user', content: todoNudge(ctx.todos) }, 'system');
         continue;
       }
+      if (nudge === 'jobs') {
+        ctx.jobsNudged = true;
+        record(ctx, { role: 'user', content: ownJobsNudge(runningOwnJobs(ctx)) }, 'system');
+        continue;
+      }
+      if (nudge === 'agents') {
+        record(ctx, { role: 'user', content: ctx.agents.nudgeText() || '（派出去的子 agent 刚做完：用 wait_agent 拿到它们的结论再收尾。）' }, 'system');
+        continue;
+      }
       if (nudge === 'claim') {
         claimChecked = true;
         record(ctx, { role: 'user', content: ctx.claimCheck(message.content) }, 'system');
@@ -1076,15 +1254,18 @@ export async function runTurn(ctx, userText, { signal, origin = null } = {}) {
       break;
     }
     if (round === maxRounds - 1) {
+      exhausted = true;
       ctx.ui.warn(`已经连续调用了 ${maxRounds} 轮工具，先停在这里。说「继续」可以接着做。`);
     }
   }
   } finally {
+    // 这一句结束时还在跑的子 agent 停掉，不留到下一句（Codex 有完成了的子 agent 一直占名额的 issue）
+    if (lead) await ctx.agents.endTurn(ctx);
     ctx.ui.stopThinking();
   }
   if (signal && signal.aborted) ctx.messages = dropDanglingToolCalls(ctx.messages);
   if (ctx.store && ctx.session) ctx.store.touch(ctx.session.id, { messages: ctx.messages.length, model: ctx.model ? ctx.model.label : null });
-  return { finalText, stalled, steps: ctx.steps.slice(), changedFiles: [...ctx.changedFiles], stats: { ...ctx.turnStats } };
+  return { finalText, stalled, exhausted, steps: ctx.steps.slice(), changedFiles: [...ctx.changedFiles], stats: { ...ctx.turnStats } };
 }
 
 /** 在会话历史后面追加一问一答，不走模型（/review 的结论放回会话，才能接着说「修第 1 条」）。历史只追加。 */
@@ -1097,6 +1278,14 @@ export function recordExchange(ctx, userText, answer) {
   ctx.store.touch(ctx.session.id, { title: ctx.session.title, messages: ctx.messages.length });
 }
 
+/** 调工具前的那一句判断：安静模式打一行灰字；步骤里一条 note（点不开）。空白不打、不记。 */
+function showJudgment(ctx, text) {
+  const said = judgmentText(text);
+  if (!said) return;
+  if (quiet(ctx) && ctx.ui) ctx.ui.note(`· ${said}`);
+  if (ctx.stepLog) ctx.stepLog.note(said);
+}
+
 /** 结论：一次整段打（按 Markdown 渲染）。 */
 function showAnswer(ctx, text) {
   if (ctx.exec) return;   // zhiqu exec：结论由它写到 stdout，stderr 里不再打一遍
@@ -1122,14 +1311,38 @@ export function statsNote(stats) {
  * 失败了那一轮就永远缺在网页上。现在 archiveTurn 只入队，真正的发送串在 ctx.archiveChain 上；发不出去的留在队列里，
  * 下一轮连同新的一起补；退出前 flushArchive 再等一会儿。
  */
+/** 存到网站上的一轮最多这么多步（和后端 TraceSteps.MAX_STEPS 一样）；多出来的只记个数，网页上说「后面还有 N 步没存」 */
+export const ARCHIVE_STEPS = 200;
+
+/** 记一步（StepLog 每次变化都叫）：同一步先 running 后收尾，按 id 留最后那条；满了的只记 id、不留内容 */
+export function archiveStep(ctx, step) {
+  if (!Array.isArray(ctx.archiveSteps)) ctx.archiveSteps = [];
+  const at = ctx.archiveSteps.findIndex((x) => x.id === step.id);
+  if (at >= 0) ctx.archiveSteps[at] = step;
+  else if (ctx.archiveSteps.length < ARCHIVE_STEPS) ctx.archiveSteps.push(step);
+  else (ctx.archiveOverflow || (ctx.archiveOverflow = new Set())).add(step.id);
+}
+
+/** 这一轮的存档步骤从头记（主 agent 每一句开头、archiveTurn 发完之后） */
+export function resetArchive(ctx) {
+  if (Array.isArray(ctx.archiveSteps)) ctx.archiveSteps = [];
+  ctx.archiveOverflow = null;
+}
+
 export function archiveTurn(ctx, userText, result) {
   if (!ctx.api || !ctx.session || ctx.archiveDisabled) return Promise.resolve();
-  const steps = result.steps.length ? `\n\n> 过程：${result.steps.slice(0, 30).join(' · ')}${result.steps.length > 30 ? ` …共 ${result.steps.length} 步` : ''}` : '';
+  // 每一步单独给（第一百二十八轮）：原来拼成一行「> 过程：列出 . · 运行 … 共 32 步」接在回答正文后面，
+  // 网页上 heredoc 被当成 Markdown / 公式渲染成一堆乱码，也和网页代码模式那种一步一行的样子对不上（用户：「不是说所有显示都要像 codex 那样吗」）
+  const steps = Array.isArray(ctx.archiveSteps) ? ctx.archiveSteps.slice(0, ARCHIVE_STEPS) : [];
+  // 截断要说出来：满了以后没存的步数一起交上去（原来一声不响地只存前 200 步）
+  const dropped = (ctx.archiveOverflow ? ctx.archiveOverflow.size : 0) + (Array.isArray(ctx.archiveSteps) ? ctx.archiveSteps.length - steps.length : 0);
   ctx.archivePending = ctx.archivePending || [];
   ctx.archivePending.push({
     sessionId: ctx.session.id, title: ctx.session.title || userText.slice(0, 40),
-    messages: [{ role: 'user', content: userText }, { role: 'assistant', content: (result.finalText || '（没有文字回答）') + steps }],
+    messages: [{ role: 'user', content: userText }, { role: 'assistant', content: result.finalText || '（没有文字回答）',
+      ...(steps.length ? { steps } : {}), ...(dropped > 0 ? { stepsDropped: dropped } : {}) }],
   });
+  resetArchive(ctx);
   ctx.archiveChain = (ctx.archiveChain || Promise.resolve()).then(() => sendPending(ctx));
   return ctx.archiveChain;
 }
@@ -1184,6 +1397,9 @@ export async function verifyGoal(ctx, signal) {
  */
 export async function runGoal(ctx, { signal, maxTurns = DEFAULT_MAX_GOAL_TURNS, onTurn } = {}) {
   const ui = ctx.ui;
+  // 存到网站的步骤从这里开始记（目标的每一轮 origin 是 goal，runTurn 不替它清；每一轮存完 archiveTurn 自己清）：
+  // 上一句被打断时没存档，它的步骤不能挂到目标第一轮的回答上面
+  resetArchive(ctx);
   const goal = ctx.goal;
   ctx.goalChangedFiles = ctx.goalChangedFiles || new Set();
   let text = goal.turns === 0 ? `目标：${goal.text}\n开始做。` : `继续朝目标推进：${goal.text}`;