mocode-ai 0.7.3 → 1.0.2

package/dist/context/artifacts.js

@@ -0,0 +1,254 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { estimateTokens } from '../llm/index.js';
+import { canonicalizePath, extractPath, toText } from './utils.js';
+const states = new WeakMap();
+const STALE_PREFIX = '⌦[stale artifact:';
+const ARTIFACT_HEADER = /^\[artifact\s+([^\]]+)\]\n?/;
+function stateFor(state) {
+    let current = states.get(state);
+    if (!current) {
+        current = { artifacts: new Map() };
+        states.set(state, current);
+    }
+    return current;
+}
+function parseArgs(raw) {
+    try {
+        const value = JSON.parse(raw || '{}');
+        return value && typeof value === 'object' ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function callArgs(history, idx) {
+    const id = history[idx].tool_call_id;
+    if (!id)
+        return null;
+    for (let cursor = idx - 1; cursor >= 0; cursor--) {
+        const message = history[cursor];
+        if (message.role !== 'assistant')
+            continue;
+        const calls = message.tool_calls;
+        const hit = calls?.find((call) => call.id === id);
+        if (hit?.function?.name)
+            return { tool: hit.function.name, argsRaw: hit.function.arguments ?? '{}' };
+    }
+    return null;
+}
+function sourceType(tool) {
+    if (tool === 'read_file')
+        return 'read';
+    if (tool === 'grep' || tool === 'glob' || tool === 'codegraph')
+        return 'search';
+    if (tool === 'run_command')
+        return 'diagnostic';
+    return null;
+}
+function pathsFromOutput(tool, output) {
+    const paths = new Set();
+    const add = (value) => {
+        const normalized = canonicalizePath(value);
+        if (normalized)
+            paths.add(normalized);
+    };
+    if (tool === 'grep' || tool === 'codegraph' || tool === 'run_command') {
+        const expression = /^(.+?\.[A-Za-z0-9]+):(?:\d+|\s*\d+\s*(?:处匹配|matches?))/gmi;
+        let match;
+        while ((match = expression.exec(output)))
+            add(match[1]);
+    }
+    else if (tool === 'glob') {
+        for (const line of output.split(/\r?\n/)) {
+            const value = line.trim();
+            if (value && !value.includes(' ') && (value.includes('/') || value.includes('\\')))
+                add(value);
+        }
+    }
+    return [...paths];
+}
+function parseReadHash(output) {
+    return /\bhash=(sha256:[a-f0-9]{64})\b/i.exec(output)?.[1]?.toLowerCase();
+}
+function currentFileHash(file) {
+    if (file === '*')
+        return undefined;
+    try {
+        return `sha256:${createHash('sha256').update(readFileSync(file)).digest('hex')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function updateStats(state, artifactState) {
+    const stats = { fresh: 0, stale: 0, stubbed: 0, tokensBySource: {} };
+    for (const artifact of artifactState.artifacts.values()) {
+        stats[artifact.freshness] += 1;
+        stats.tokensBySource[artifact.source.type] =
+            (stats.tokensBySource[artifact.source.type] ?? 0) + artifact.tokenCount;
+    }
+    state.artifactStats = stats;
+}
+export function recordArtifact(state, history, idx, output, succeeded) {
+    if (!succeeded)
+        return;
+    const call = callArgs(history, idx);
+    if (!call)
+        return;
+    const type = sourceType(call.tool);
+    if (!type)
+        return;
+    const args = parseArgs(call.argsRaw);
+    const id = history[idx].tool_call_id ?? `${idx}`;
+    const directPath = canonicalizePath(extractPath(call.argsRaw));
+    let dependencies = directPath
+        ? [{ path: directPath }]
+        : pathsFromOutput(call.tool, output).map((path) => ({ path }));
+    // Diagnostics and searches with no parseable result conservatively depend on the workspace.
+    if (dependencies.length === 0 && type !== 'read')
+        dependencies = [{ path: '*' }];
+    // Capture dependency versions now; future scheduler steps can detect external changes.
+    dependencies = dependencies.map((dependency) => {
+        const hashAtCreation = currentFileHash(dependency.path);
+        return { ...dependency, ...(hashAtCreation ? { hash: hashAtCreation } : {}) };
+    });
+    const hash = type === 'read' ? parseReadHash(output) : undefined;
+    if (hash && dependencies[0])
+        dependencies[0].hash = hash;
+    const content = toText(history[idx].content);
+    const artifact = {
+        id,
+        source: { type, tool: call.tool, toolCallId: id },
+        ...(hash ? { hash } : {}),
+        version: Date.now(),
+        dependencies,
+        freshness: content.startsWith('⌦[') ? 'stubbed' : 'fresh',
+        rebuildable: true,
+        tokenCount: estimateTokens(content),
+        messageIndex: idx,
+    };
+    stateFor(state).artifacts.set(id, artifact);
+    updateStats(state, stateFor(state));
+}
+function affected(artifact, changed) {
+    return artifact.dependencies.some((dependency) => dependency.path === '*' || changed.has(dependency.path));
+}
+/** Mark and immediately stub stale facts; this is stronger than waiting for budget pressure. */
+export function invalidateArtifacts(state, history, changedFiles) {
+    const changed = new Set(changedFiles.map(canonicalizePath).filter((item) => !!item));
+    if (changed.size === 0)
+        return 0;
+    const artifactState = stateFor(state);
+    let count = 0;
+    for (const artifact of artifactState.artifacts.values()) {
+        if (artifact.freshness !== 'fresh' || !affected(artifact, changed))
+            continue;
+        artifact.freshness = 'stale';
+        const message = history[artifact.messageIndex];
+        if (message?.role === 'tool') {
+            const original = toText(message.content);
+            const paths = artifact.dependencies.map((item) => item.path).join(', ');
+            const stub = `${STALE_PREFIX}${artifact.source.tool}] source=${artifact.id} dependencies=${paths} ` +
+                `invalidated-by=${[...changed].join(', ')}; re-run ${artifact.source.tool} before using this fact.`;
+            message.content = stub;
+            artifact.tokenCount = estimateTokens(stub);
+        }
+        count++;
+    }
+    updateStats(state, artifactState);
+    return count;
+}
+/** Rebuild indices after resume/compaction while retaining versions for surviving tool_call IDs. */
+export function rehydrateArtifacts(state, history) {
+    const artifactState = stateFor(state);
+    const previous = new Map(artifactState.artifacts);
+    artifactState.artifacts.clear();
+    for (let idx = 0; idx < history.length; idx++) {
+        const message = history[idx];
+        if (message.role !== 'tool')
+            continue;
+        const call = callArgs(history, idx);
+        if (!call || !sourceType(call.tool))
+            continue;
+        const content = toText(message.content);
+        const id = message.tool_call_id ?? `${idx}`;
+        const retained = previous.get(id);
+        if (retained) {
+            retained.messageIndex = idx;
+            retained.tokenCount = estimateTokens(content);
+            retained.freshness = content.startsWith(STALE_PREFIX)
+                ? 'stale'
+                : content.startsWith('⌦[') ? 'stubbed' : retained.freshness;
+            artifactState.artifacts.set(id, retained);
+        }
+        else {
+            recordArtifact(state, history, idx, content, true);
+            const artifact = artifactState.artifacts.get(id);
+            if (artifact && content.startsWith(STALE_PREFIX))
+                artifact.freshness = 'stale';
+            else if (artifact && content.startsWith('⌦['))
+                artifact.freshness = 'stubbed';
+        }
+    }
+    updateStats(state, artifactState);
+}
+/** Compare captured dependency versions before each model step to detect external edits. */
+export function refreshArtifactFreshness(state, history) {
+    const changed = new Set();
+    for (const artifact of stateFor(state).artifacts.values()) {
+        if (artifact.freshness !== 'fresh')
+            continue;
+        for (const dependency of artifact.dependencies) {
+            if (!dependency.hash || dependency.path === '*')
+                continue;
+            if (currentFileHash(dependency.path) !== dependency.hash)
+                changed.add(dependency.path);
+        }
+    }
+    return changed.size > 0 ? invalidateArtifacts(state, history, [...changed]) : 0;
+}
+/** Scheduler entry point: stale artifacts are already stubs; normalize any resumed stale message first. */
+export function pruneStaleArtifacts(state, history) {
+    const artifactState = stateFor(state);
+    let pruned = 0;
+    for (const artifact of artifactState.artifacts.values()) {
+        if (artifact.freshness !== 'stale')
+            continue;
+        const message = history[artifact.messageIndex];
+        if (message?.role !== 'tool')
+            continue;
+        const content = toText(message.content);
+        if (!content.startsWith(STALE_PREFIX)) {
+            message.content = `${STALE_PREFIX}${artifact.source.tool}] source=${artifact.id}; re-run before use.`;
+            artifact.tokenCount = estimateTokens(String(message.content));
+            pruned++;
+        }
+    }
+    updateStats(state, artifactState);
+    return pruned;
+}
+export function collectArtifactRefs(messages) {
+    const refs = new Set();
+    for (const message of messages) {
+        if (message.role !== 'tool')
+            continue;
+        const id = message.tool_call_id;
+        if (id)
+            refs.add(id);
+        const content = toText(message.content);
+        const hash = parseReadHash(content);
+        if (hash)
+            refs.add(hash);
+    }
+    return [...refs].slice(0, 24);
+}
+export function formatArtifactTokenSources(stats) {
+    if (!stats)
+        return 'none';
+    const entries = Object.entries(stats.tokensBySource)
+        .filter((entry) => typeof entry[1] === 'number' && entry[1] > 0)
+        .sort((left, right) => right[1] - left[1]);
+    return entries.length > 0 ? entries.map(([source, tokens]) => `${source} ${tokens}`).join(' · ') : 'none';
+}
+export { STALE_PREFIX, ARTIFACT_HEADER };

package/dist/context/classifier.js

@@ -37,7 +37,7 @@ const BY_NAME = {
     memory_update: 'status',
     memory_forget: 'status',
     // summary:子 agent 摘要(轻量)
-    task: 'summary',
+    'sub-agent': 'summary',
 };
 /**
  * 形状启发:对未在 BY_NAME 登记的工具输出做模式识别(为 MCP / 未来工具兜底)。

package/dist/context/index.js

@@ -6,6 +6,7 @@
 // (叶子级:仅 stdlib + tools/constants + session/compact 的 capToolResultForHistory 兜底 + config 开关)。
 export { optimizeToolResult } from './pipeline.js';
 export { classify, knownToolKinds } from './classifier.js';
+export { recordArtifact, invalidateArtifacts, rehydrateArtifacts, refreshArtifactFreshness, pruneStaleArtifacts, collectArtifactRefs, formatArtifactTokenSources, } from './artifacts.js';
 export { registerEncoder, registerAll, getEncoder, registeredKinds, } from './registry.js';
 // ── Context Budget Scheduler ───────────────────────────────────────────────
 export { evaluateBudget, scheduleActions, formatReport, quickEstimate, userTurnBoundary, BUDGET_LAYERS, DEFAULT_BUDGET_POLICY, BUDGET_RATIO, HOT_TURN_WINDOW, TOOL_OLD_AGE, } from './budget.js';

package/dist/i18n/index.js

@@ -169,6 +169,12 @@ const zhCN = {
     'agent.validationNoCommand': '未发现验证命令',
     'agent.validationResult': '自动验证 {command} → {status}',
     'agent.workedFor': '耗时 {elapsed}',
+    'agent.toolsRunning': '正在探索',
+    'agent.toolsComplete': '探索',
+    'agent.toolsFailed': '探索失败',
+    'agent.changes': '文件变更',
+    'agent.files': '{count} 个文件',
+    'agent.complete': '完成',
     'toolSummary.lines': '{count} 行',
     'toolSummary.files': '{count} 个文件',
     'toolSummary.matches': '{count} 处匹配',
@@ -212,8 +218,8 @@ const zhCN = {
     'subagent.status': '子 Agent：{state}',
     'subagent.stateOn': '开启',
     'subagent.stateOff': '关闭',
-    'subagent.changedOn': '已开启子 Agent；task 将从下一次模型请求起可用。',
-    'subagent.changedOff': '已关闭子 Agent；task 已从模型工具表移除。',
+    'subagent.changedOn': '已开启子 Agent；sub-agent 将从下一次模型请求起可用。',
+    'subagent.changedOff': '已关闭子 Agent；sub-agent 已从模型工具表移除。',
     'subagent.usage': '用法：/subagent on|off|status',
     'plan.ready': '计划已就绪',
     'plan.approvalDetail': '切换到 auto 模式按上述计划执行？（plan 模式只读探查，执行需切 auto）',
@@ -395,6 +401,12 @@ const en = {
     'agent.validationNoCommand': 'no validation command',
     'agent.validationResult': 'Automatic validation {command} → {status}',
     'agent.workedFor': 'Worked for {elapsed}',
+    'agent.toolsRunning': 'Exploring',
+    'agent.toolsComplete': 'Exploration',
+    'agent.toolsFailed': 'Exploration failed',
+    'agent.changes': 'Changes',
+    'agent.files': '{count} file(s)',
+    'agent.complete': 'Complete',
     'toolSummary.lines': '{count} lines',
     'toolSummary.files': '{count} files',
     'toolSummary.matches': '{count} matches',
@@ -438,8 +450,8 @@ const en = {
     'subagent.status': 'Sub-agent: {state}',
     'subagent.stateOn': 'enabled',
     'subagent.stateOff': 'disabled',
-    'subagent.changedOn': 'Sub-agents enabled; task will be available from the next model request.',
-    'subagent.changedOff': 'Sub-agents disabled; task has been removed from the model tool list.',
+    'subagent.changedOn': 'Sub-agents enabled; sub-agent will be available from the next model request.',
+    'subagent.changedOff': 'Sub-agents disabled; sub-agent has been removed from the model tool list.',
     'subagent.usage': 'Usage: /subagent on|off|status',
     'plan.ready': 'Plan ready',
     'plan.approvalDetail': 'Switch to auto mode and execute the plan above? (Plan mode is read-only; execution requires auto mode.)',

package/dist/llm/index.js

@@ -149,10 +149,10 @@ export function __setChatCreateImpl(impl) {
 export const chatTools = [];
 export const planChatTools = [];
 export function refreshChatTools() {
-    // task 常驻内部 registry，运行时开关只控制模型可见 schema，因而 on/off 可即时生效。
+    // sub-agent 常驻内部 registry，运行时开关只控制模型可见 schema，因而 on/off 可即时生效。
     const visibleTools = isSubAgentEnabled()
         ? tools
-        : tools.filter((tool) => tool.name !== 'task');
+        : tools.filter((tool) => tool.name !== 'sub-agent');
     const next = visibleTools.map((t) => ({
         type: 'function',
         function: {

package/dist/repl/index.js

@@ -22,6 +22,7 @@ import { estimateMessagesTokens, reconfigureClient, refreshChatTools, chatTools,
 import { loadImageAttachment, renderChip, MAX_INLINE_BYTES_DEFAULT, } from '../attachments/image.js';
 import { modelSupportsVision } from '../llm/capabilities.js';
 import { computePruneStats } from '../context/relevance.js';
+import { formatArtifactTokenSources } from '../context/artifacts.js';
 import { manualCompact, contextState, newSessionId, saveSession, loadSession, listSessions, appendCurrentSessionRuntimeEvent, hashTraceValue, } from '../session/index.js';
 import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, getCurrentTurnId, } from '../rollback/index.js';
 import { listSkills, effectiveSystemPrompt, } from '../skills/index.js';
@@ -223,11 +224,15 @@ function renderContextBar(history) {
     const pctCol = pct >= config.compactThreshold ? ui.yellow : ui.accent;
     const lifecycle = contextState.lifecycleStats;
     const archived = computePruneStats(history);
+    const artifactStats = contextState.artifactStats;
+    const artifactLine = artifactStats
+        ? `\n  artifacts · fresh ${artifactStats.fresh} · stale ${artifactStats.stale} · stubbed ${archived.stubbed} · tokens ${formatArtifactTokenSources(artifactStats)}`
+        : '\n  artifacts · no file-backed facts recorded';
     const lifecycleLine = lifecycle
         ? `\n  lifecycle · live ${lifecycle.live} · referenced ${lifecycle.referenced} · digested ${lifecycle.digested} · stubbed ${lifecycle.stubbed}`
         : '\n  lifecycle · no active snapshot (run a tool-enabled turn first)';
     const archiveLine = `\n  archived tool results · ${archived.stubbed}`;
-    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${ui.reset}${lifecycleLine}${archiveLine}`;
+    return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${ui.reset}${artifactLine}${lifecycleLine}${archiveLine}`;
 }
 /** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
  * 只计算对话内容(不含 system prompt),让用户感知"我发了多少、agent 回复了多少"占用 context。 */
@@ -485,6 +490,10 @@ function echoInput(lines, trailingBlank = true) {
     for (const a of pendingAttachments) {
         layout.contentWrite(`  ${ui.dim}${renderChip(a)}${ui.reset}\n`);
     }
+    // 用户气泡会填满终端整列宽；Windows Terminal 在末列进入 pending-wrap 后，紧随的 LF
+    // 偶尔只更新内部滚屏状态，导致上一轮耗时行与新气泡暂时黏连。缓冲中的物理行始终正确，
+    // 提交后立即按缓冲重绘，避免必须等滚动或 Agent 结束时的 repaint 才显示正确边界。
+    layout.repaintViewport();
 }
 /**
  * 等待 pending 撤回窗口(用户 Enter 后、agent 真发请求前的 500ms 兜底)。
@@ -637,6 +646,12 @@ export function renderHistory(history) {
             }
             const tcs = m.tool_calls;
             if (Array.isArray(tcs) && tcs.length > 0) {
+                if (text) {
+                    // contentWriteMdOnce 会裁掉 markdown 尾部空行，而 history 中的原始 text 是否以 \n
+                    // 结尾并不能代表当前物理布局。按缓冲中的视觉行归一化，和实时“正文 → 工具”
+                    // 边界一致地保留一条空行，避免 /resume 回放时工具摘要紧贴正文。
+                    layout.normalizeMutationBoundary();
+                }
                 // 累积到 pendingBatch,顺序 = tool_calls 序
                 for (const tc of tcs) {
                     const name = tc?.function?.name ?? '';
@@ -717,7 +732,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
     // 与开关联动:① base 用 buildBasePrompt() 取代 config.systemPrompt(后者是启动时一次性
     // 求值的常量,运行时 /memory_switch 不会刷新);② plan suffix 走 getPlanModeSuffix() 现拼;
     // ③ buildMemorySection 内已自决 ;④ buildMemoryIndexSection 显式传 isMemoryEnabled() 关闭段。
-    const buildSystemMessage = (planMode) => effectiveSystemPrompt(buildBasePrompt() +
+    const buildSystemMessage = (planMode) => effectiveSystemPrompt(buildBasePrompt(currentSessionId) +
         (planMode ? getPlanModeSuffix() : '') +
         buildMemorySection() +
         buildMemoryIndexSection(isMemoryEnabled()));
@@ -891,6 +906,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             rolledBackTurns: Math.max(0, turnCountBeforeRollback - plan.n),
             deletedMessages: rollbackResult.deletedMsgs,
             revertedFiles: rollbackResult.revertedFiles,
+            conflictedFiles: rollbackResult.conflictedFiles,
             requestedFileCount: revertPaths.size,
         }, plan.cutoffTurnId);
         try {
@@ -903,6 +919,9 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         // 复显剩余对话(无提示行),输入框预填该轮 user 输入 → 下轮 Enter 重新跑
         layout.clearContent();
         renderHistory(history);
+        if (rollbackResult.conflictedFiles.length > 0) {
+            layout.contentWrite(`${ui.yellow}  ⚠ rollback conflict: ${rollbackResult.conflictedFiles.join(', ')} 已在 Agent 提交后变化，未覆盖。${ui.reset}\n`);
+        }
         // 末尾补空行:与后续用户消息(❯ bubble)之间分隔。runTurn 在每个 agent 轮结束后
         // contentWrite('\n') 做轮次分隔,/resume 后接 \n\n,/theme·/model 后接 \n;
         // rollbackFlow 原本漏了这一行,renderHistory 末尾的 batch 摘要行 / assistant 文本
@@ -1021,6 +1040,9 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             layout.contentWrite(`${ui.yellow}${t('repl.loadFailed')}${ui.reset}\n`);
             return;
         }
+        // Bind before rebuilding the prompt, or it can retain the previous session's notes path.
+        currentSessionId = loaded.id;
+        setCurrentSessionId(loaded.id, process.cwd());
         if (loaded.history[0]?.role === 'system') {
             loaded.history[0] = { role: 'system', content: buildSystemMessage(false) };
         }
@@ -1030,8 +1052,6 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             ? [...loaded.queryHistory]
             : queryHistoryFromMessages(loaded.history);
         setAgentMode('auto'); // 续接重置为 auto(mode 不落盘;listener 重写 history[0] 回 auto,与 loaded 幂等)
-        currentSessionId = loaded.id;
-        setCurrentSessionId(loaded.id, process.cwd()); // 切换会话:确保该会话的 notes.md 存在
         // 读回该会话的轮次/快照;无文件则从 history 重建 turns(无快照→旧轮次文件改动不可撤销)
         if (!loadSnapshots(loaded.id))
             rebuildFromHistory(history);
@@ -1043,6 +1063,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         // 末尾 \n\n:与后续用户消息(❯ bubble)之间空一行。
         layout.contentWrite(`${ui.dim}${t('repl.resumed', { id: loaded.id })}${ui.reset}\n\n`);
     }
+    let hasSubmittedInput = false;
     while (true) {
         // INPUT 态:画底栏输入框 + 状态行,光标入输入框
         refreshStatusBase(history);
@@ -1053,6 +1074,10 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             layout.contentWrite(`  ${ui.gray}↳ ${formatReflectResult(reflectRes)}${ui.reset}\n`);
             clearLastReflectResult();
         }
+        // 所有斜杠命令和 Agent 轮次共用同一个输出→输入边界，避免某条命令漏写第二个 \n
+        // 后下一条 ❯ 气泡紧贴确认文案；已有多余空行也会收敛为恰好一行。
+        if (hasSubmittedInput)
+            layout.normalizeInputBoundary();
         layout.enterInputMode(t('repl.idle'));
         let input = null;
         try {
@@ -1080,6 +1105,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
         const line = joined.trim();
         if (!line)
             continue;
+        hasSubmittedInput = true;
         if (line === '/exit' || line === '/quit')
             break;
         // RUNNING 态:回显输入 → 底栏改 dim 占位、光标回内容续写位
@@ -2029,7 +2055,7 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
                     const initPrompt = `请直接初始化或优化当前项目的 Project Skill，并完成写入。
 
 要求：
-1. 直接由你完成，禁止调用 task 工具或派生任何子 agent。
+1. 直接由你完成，禁止调用 sub-agent 工具或派生任何子 agent。
 2. 优先利用系统提示中已有的 Project Snapshot 和 Project Skill；不要重复扫描其中已有的目录、依赖、命令和模块清单。
 3. 最多进行 1 次 codegraph 探索；只有缺少关键依据时，才额外进行少量定点 read_file/grep。禁止全仓 glob 和逐文件扫描。
 4. Skill 只记录 Snapshot 无法提供的 WHY/HOW/GOTCHAS/CONVENTIONS：设计取舍、关键调用链、非直觉边界、项目约定和可操作坑点。使用具体路径和例子，删除重复或过时内容。

package/dist/rollback/index.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, rmdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { config } from '../config/index.js';
@@ -52,6 +53,11 @@ function readState(full) {
 function sameState(a, b) {
     return a.kind === b.kind && a.data === b.data && a.mode === b.mode;
 }
+function stateFingerprint(state) {
+    return createHash('sha256')
+        .update(JSON.stringify([state.kind, state.data ?? null, state.mode ?? null]))
+        .digest('hex');
+}
 function stateFromSnapshot(snapshot) {
     if (snapshot.kind) {
         return { kind: snapshot.kind, data: snapshot.before ?? undefined, mode: snapshot.mode };
@@ -64,7 +70,7 @@ function stateFromSnapshot(snapshot) {
         data: Buffer.from(snapshot.before, 'utf8').toString('base64'),
     };
 }
-function snapshotFromState(rel, state, sequence, op, createdParents = []) {
+function snapshotFromState(rel, state, sequence, op, createdParents = [], after) {
     return {
         turnId: currentTurnId,
         path: rel,
@@ -75,6 +81,7 @@ function snapshotFromState(rel, state, sequence, op, createdParents = []) {
         sequence,
         ops: [op],
         createdParents: createdParents.length > 0 ? createdParents : undefined,
+        afterFingerprint: after ? stateFingerprint(after) : undefined,
     };
 }
 /** 同轮同路径只保留最早的 before；后续实际改动仅合并工具名。 */
@@ -90,11 +97,15 @@ function addSnapshot(next) {
     const existingSequence = existing.sequence ?? Number.MAX_SAFE_INTEGER;
     const nextSequence = next.sequence ?? Number.MAX_SAFE_INTEGER;
     const ops = new Set([...(existing.ops ?? []), ...(next.ops ?? [])]);
+    const latestAfterFingerprint = nextSequence >= existingSequence
+        ? next.afterFingerprint
+        : existing.afterFingerprint;
     if (nextSequence < existingSequence) {
-        snapshots[existingIndex] = { ...next, ops: [...ops] };
+        snapshots[existingIndex] = { ...next, ops: [...ops], afterFingerprint: latestAfterFingerprint };
     }
     else {
         existing.ops = [...ops];
+        existing.afterFingerprint = latestAfterFingerprint;
     }
 }
 function missingParents(full) {
@@ -139,14 +150,14 @@ export function endPathMutation(capture, op) {
     const after = readState(full);
     if (!sameState(capture.before, after)) {
         changed = true;
-        addSnapshot(snapshotFromState(capture.path, capture.before, capture.sequence, op, capture.createdParents));
+        addSnapshot(snapshotFromState(capture.path, capture.before, capture.sequence, op, capture.createdParents, after));
     }
     // write_file 会递归创建父目录；即使最终写文件失败，这些目录也是本轮真实副作用。
     for (const parentRel of capture.createdParents) {
         const parent = safeFullPath(parentRel);
         if (parent && readState(parent).kind !== 'missing') {
             changed = true;
-            addSnapshot(snapshotFromState(parentRel, { kind: 'missing' }, capture.sequence, op));
+            addSnapshot(snapshotFromState(parentRel, { kind: 'missing' }, capture.sequence, op, [], readState(parent)));
         }
     }
     if (changed)
@@ -202,7 +213,7 @@ export function endWorkspaceMutation(capture, op) {
         if (sameState(beforeState, afterState))
             continue;
         changed = true;
-        addSnapshot(snapshotFromState(rel, beforeState, capture.sequence, op));
+        addSnapshot(snapshotFromState(rel, beforeState, capture.sequence, op, [], afterState));
     }
     if (changed)
         mutationVersion += 1;
@@ -285,7 +296,11 @@ function restoreSnapshot(snapshot) {
     const state = stateFromSnapshot(snapshot);
     try {
         if (state.kind === 'missing') {
-            rmSync(full, { recursive: true, force: true });
+            const current = readState(full);
+            if (current.kind === 'directory')
+                rmdirSync(full);
+            else
+                rmSync(full, { recursive: false, force: true });
             for (const parentRel of snapshot.createdParents ?? []) {
                 const parent = safeFullPath(parentRel);
                 if (!parent)
@@ -329,9 +344,16 @@ export function applyRollback(plan, history, revertPaths) {
     const deletedMsgs = history.length - plan.cutoffIndex;
     history.length = plan.cutoffIndex;
     const picks = new Map();
+    const latest = new Map();
     for (const snapshot of snapshots) {
         if (snapshot.turnId <= plan.cutoffTurnId || !revertPaths.has(snapshot.path))
             continue;
+        const latestSnapshot = latest.get(snapshot.path);
+        if (!latestSnapshot || snapshot.turnId > latestSnapshot.turnId ||
+            (snapshot.turnId === latestSnapshot.turnId &&
+                (snapshot.sequence ?? -1) > (latestSnapshot.sequence ?? -1))) {
+            latest.set(snapshot.path, snapshot);
+        }
         const existing = picks.get(snapshot.path);
         if (!existing ||
             snapshot.turnId < existing.turnId ||
@@ -341,7 +363,18 @@ export function applyRollback(plan, history, revertPaths) {
             picks.set(snapshot.path, snapshot);
         }
     }
-    const selected = [...picks.values()];
+    const selected = [];
+    const conflictedFiles = [];
+    for (const snapshot of picks.values()) {
+        const expected = latest.get(snapshot.path)?.afterFingerprint;
+        const full = safeFullPath(snapshot.path);
+        if (expected && (!full || stateFingerprint(readState(full)) !== expected)) {
+            conflictedFiles.push(snapshot.path);
+        }
+        else {
+            selected.push(snapshot);
+        }
+    }
     // 先深到浅删除本轮新建项，再浅到深恢复原目录/文件。
     const removals = selected
         .filter((item) => stateFromSnapshot(item).kind === 'missing')
@@ -353,11 +386,13 @@ export function applyRollback(plan, history, revertPaths) {
     for (const snapshot of [...removals, ...restores]) {
         if (restoreSnapshot(snapshot))
             revertedFiles.push(snapshot.path);
+        else if (!conflictedFiles.includes(snapshot.path))
+            conflictedFiles.push(snapshot.path);
     }
     turns = turns.filter((turn) => turn.turnId <= plan.cutoffTurnId);
     snapshots = snapshots.filter((snapshot) => snapshot.turnId <= plan.cutoffTurnId);
     currentTurnId = turns.at(-1)?.turnId ?? 0;
-    return { deletedMsgs, revertedFiles };
+    return { deletedMsgs, revertedFiles, conflictedFiles };
 }
 export function pruneAfterCompaction(history) {
     const count = history.filter((message) => message.role === 'user').length;

package/dist/sandbox/index.js

@@ -1,5 +1,5 @@
 // 沙箱子系统 barrel。叶子:仅 node:path / node:fs,不反向依赖业务。
-export { getSandboxRoot, setSandboxRoot } from './root.js';
+export { getSandboxRoot, setSandboxRoot, withSandboxRoot } from './root.js';
 export { jailResolve, jailGlobPattern, isInsideRoot } from './jail.js';
 export { filterEnv, isCommandDenied } from './command.js';
 export { SANDBOX_EXEMPT_TOOLS, SANDBOX_PATH_TOOLS, enforceSandbox, } from './policy.js';

package/dist/sandbox/policy.js

@@ -8,7 +8,7 @@ import { jailResolve, jailGlobPattern } from './jail.js';
  *  - web_*:跨网络,非文件路径
  *  - ask_human / switch_mode:无文件路径
  *  - codegraph:只读 cwd 下 .codegraph/ 索引(只读、不写盘)
- *  - task:派生子 agent,继承全局 root(子 agent 同进程天然共享 getSandboxRoot)
+ *  - sub-agent:派生子 agent，通过 scoped sandbox root 使用隔离 overlay
  */
 export const SANDBOX_EXEMPT_TOOLS = new Set([
     'memory_save', 'memory_update', 'memory_forget', 'memory_search', 'memory_list',
@@ -16,7 +16,7 @@ export const SANDBOX_EXEMPT_TOOLS = new Set([
     'web_search', 'web_fetch',
     'ask_human', 'switch_mode',
     'codegraph',
-    'task',
+    'sub-agent',
 ]);
 /**
  * 路径类工具:enforceSandbox 集中把 args.path 重写为牢内绝对路径(默认安全;工具内

package/dist/sandbox/root.js

@@ -3,12 +3,18 @@
 // —— 全是「业务 → 叶子」,同 src/agent/mode.ts。
 //
 // 设计:sandboxRoot 是纯边界记录(默认 = process.cwd(),不 chdir),避免与 config.sessionDir 等
-// 模块加载期计算的值产生错位(若 chdir 会令那些值变陈旧)。子 agent 同进程天然继承全局 root
-// (未来 agents/ 做 worktree 隔离时再改为沿 opts 透传,照 signal 同形链路,7 处改动)。
+// 模块加载期计算的值产生错位(若 chdir 会令那些值变陈旧)。主 Agent 使用全局 root，
+// 并发子 Agent 通过 AsyncLocalStorage 获得互不干扰的 overlay root。
+import { AsyncLocalStorage } from 'node:async_hooks';
 let currentRoot = null;
+const scopedRoots = new AsyncLocalStorage();
 /** 当前沙箱根(绝对路径)。未初始化返 null,调用方 ?? process.cwd() 兜底(防御)。 */
 export function getSandboxRoot() {
-    return currentRoot;
+    return scopedRoots.getStore() ?? currentRoot;
+}
+/** Run one asynchronous agent against an isolated sandbox without changing sibling roots. */
+export function withSandboxRoot(root, run) {
+    return scopedRoots.run(root, run);
 }
 /** 设置沙箱根。repl startRepl 启动时调一次(默认 process.cwd();--sandbox-root / SANDBOX_ROOT 可覆盖)。
  *  返回之前的值,供未来 save/restore(子 agent worktree 隔离)用。 */