mocode-ai 0.7.0 → 0.7.2

package/dist/repl/index.js

@@ -1,7 +1,7 @@
 import readline from 'node:readline/promises';
 import { emitKeypressEvents } from 'node:readline';
 import { stdin, stdout } from 'node:process';
-import { config, updateModelConfig, isModelConfigured, updateMemoryConfig, isMemoryEnabled, isProjectSkillEnabled, isProjectSnapshotEnabled, updateProjectSkillConfig, updateSnapshotConfig, updateLanguageConfig, languageFromShell, buildBasePrompt, getPlanModeSuffix, } from '../config/index.js';
+import { config, updateModelConfig, isModelConfigured, updateMemoryConfig, isMemoryEnabled, isSubAgentEnabled, updateSubAgentConfig, isProjectSkillEnabled, isProjectSnapshotEnabled, updateProjectSkillConfig, updateSnapshotConfig, updateLanguageConfig, languageFromShell, buildBasePrompt, getPlanModeSuffix, } from '../config/index.js';
 import { getLanguage, normalizeLanguage, t, } from '../i18n/index.js';
 import { updateConfigKey, writeConfigKeys, CONFIG_PATH } from '../config/file.js';
 import { deletePreset, getPreset, isValidPresetName, listPresets, migrateCurrentToPreset, savePreset, } from '../config/presets.js';
@@ -16,14 +16,14 @@ import * as mouse from '../ui/mouse.js';
 import * as batch from '../ui/batch.js';
 import { promptWithSlashMenu, promptTurnPicker, promptSessionPicker, promptThemePicker, promptRevertChoice, } from '../ui/prompt.js';
 import { promptIntervention } from '../ui/intervention.js';
-import { tools, registerToolsExtension } from '../tools/registry.js';
+import { registerToolsExtension } from '../tools/registry.js';
 import { initializeAllMcp, getMcpTools, closeAllMcp } from '../mcp/index.js';
-import { estimateMessagesTokens, reconfigureClient, refreshChatTools, } from '../llm/index.js';
+import { estimateMessagesTokens, reconfigureClient, refreshChatTools, chatTools, } from '../llm/index.js';
 import { loadImageAttachment, renderChip, MAX_INLINE_BYTES_DEFAULT, } from '../attachments/image.js';
 import { modelSupportsVision } from '../llm/capabilities.js';
 import { computePruneStats } from '../context/relevance.js';
-import { manualCompact, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
-import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, } from '../rollback/index.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';
 import { buildMemorySection, buildMemoryIndexSection, kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, loadAll, } from '../memory/index.js';
 import { buildSnapshot, clearSnapshotCache } from '../project-snapshot/index.js';
@@ -63,6 +63,13 @@ function buildSlashCommands() {
                 { name: 'init', value: '/init', desc: d('commands.memoryInit') },
             ],
         },
+        {
+            name: '/subagent', desc: d('commands.subagent'), children: [
+                { name: 'on', value: '/subagent on', desc: d('commands.subagentOn') },
+                { name: 'off', value: '/subagent off', desc: d('commands.subagentOff') },
+                { name: 'status', value: '/subagent status', desc: d('commands.subagentStatus') },
+            ],
+        },
         {
             name: '/project_skill', desc: d('commands.skill'), children: [
                 { name: 'toggle', value: '/project_skill', desc: d('commands.toggle') },
@@ -322,6 +329,8 @@ function runningStateFor(cmd) {
             return { status: t('running.memory'), placeholder: t('running.switching') };
         case '/memory_status':
             return { status: t('running.memoryStatus'), placeholder: '…' };
+        case '/subagent':
+            return { status: t('running.subagent'), placeholder: t('running.switching') };
         case '/project_skill':
             return { status: t('running.skill'), placeholder: t('running.processing') };
         case '/snapshot':
@@ -387,8 +396,9 @@ function onRunningKey(_str, key) {
             runningInput = '';
             layout.paintRunningInputEcho(runningInput, runningPlaceholder);
         }
-        else {
-            currentAbort?.abort();
+        else if (currentAbort && !currentAbort.signal.aborted) {
+            appendCurrentSessionRuntimeEvent('abort', { phase: 'requested', source: 'keyboard' });
+            currentAbort.abort();
         }
         return;
     }
@@ -734,12 +744,11 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
     // 本轮 token 累计:runAgent 返回后写入,供底栏模式 chip 右边显示。undefined=无实测
     // (后端不开 include_usage / 后端失败时)。
     let lastTurnUsage;
-    const toolsLine = tools.map((t) => t.name).join(' · ');
     const banner = () => ({
         model: config.model,
         baseURL: config.baseURL,
         cwd: process.cwd(),
-        tools: toolsLine,
+        tools: chatTools.map((tool) => tool.function.name).join(' · '),
         memoryEnabled: isMemoryEnabled(),
     });
     // 开场:按 config.theme 切主题(横幅 / 状态行 / 后续渲染皆用新色),再进 alt screen + 状态基线 + 清内容区。
@@ -868,10 +877,22 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             for (const c of revertable)
                 revertPaths.add(c.path);
         }
-        applyRollback(plan, history, revertPaths);
+        const rolledBackFromTurnId = getCurrentTurnId();
+        const turnCountBeforeRollback = listTurns().length;
+        const rollbackResult = applyRollback(plan, history, revertPaths);
         if (!currentSessionId)
             currentSessionId = newSessionId();
         setCurrentSessionId(currentSessionId, process.cwd()); // 同步到 session/state,确保 notes.md 存在
+        appendCurrentSessionRuntimeEvent('rollback', {
+            status: 'applied',
+            rolledBackFromTurnId,
+            cutoffTurnId: plan.cutoffTurnId,
+            retainedTurns: plan.n,
+            rolledBackTurns: Math.max(0, turnCountBeforeRollback - plan.n),
+            deletedMessages: rollbackResult.deletedMsgs,
+            revertedFiles: rollbackResult.revertedFiles,
+            requestedFileCount: revertPaths.size,
+        }, plan.cutoffTurnId);
         try {
             saveSession(history, currentSessionId, queryHistory);
         }
@@ -1313,6 +1334,15 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             // 返回 SchedulerRunLog 给 UI 显示决策;退化路径(开关关时)在 manualCompact 内部走 compactHistory。
             const log = await manualCompact(history, focus, { force });
             const d = log.compactDetail;
+            appendCurrentSessionRuntimeEvent('compact', {
+                source: 'manual',
+                force,
+                called: log.compactHistoryCalled,
+                reason: d?.reason ?? 'unknown',
+                estimateBefore: d?.estimateBefore,
+                estimateAfter: d?.estimateAfter,
+                focusHash: focus ? hashTraceValue(focus) : undefined,
+            });
             if (!d) {
                 // 兜底(旧调用):只显示 old 文案
                 if (!log.compactHistoryCalled) {
@@ -1858,6 +1888,32 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             await rollbackFlow();
             continue;
         }
+        if (line === '/subagent' || line.startsWith('/subagent ')) {
+            const arg = line.startsWith('/subagent ')
+                ? line.slice('/subagent '.length).trim().toLowerCase()
+                : 'status';
+            if (arg === '' || arg === 'status') {
+                const enabled = isSubAgentEnabled();
+                const state = t(enabled ? 'subagent.stateOn' : 'subagent.stateOff');
+                layout.contentWrite(`${ui.accent}${t('subagent.status', { state })}${ui.reset}\n` +
+                    `${ui.dim}MOCODE_SUBAGENT_ENABLED=${enabled ? 'true' : 'false'} · ${CONFIG_PATH}${ui.reset}\n`);
+                continue;
+            }
+            if (arg !== 'on' && arg !== 'off') {
+                layout.contentWrite(`${ui.yellow}${t('subagent.usage')}${ui.reset}\n`);
+                continue;
+            }
+            const enabled = arg === 'on';
+            if (enabled !== isSubAgentEnabled()) {
+                updateSubAgentConfig(enabled);
+                updateConfigKey('MOCODE_SUBAGENT_ENABLED', enabled ? 'true' : 'false');
+                refreshChatTools();
+                history[0] = { role: 'system', content: buildSystemMessage(getAgentMode() === 'plan') };
+                layout.rewriteBanner(bannerLines(banner()));
+            }
+            layout.contentWrite(`${enabled ? ui.green : ui.yellow}${t(enabled ? 'subagent.changedOn' : 'subagent.changedOff')}${ui.reset}\n`);
+            continue;
+        }
         if (line === '/memory_switch' ||
             line.startsWith('/memory_switch ') ||
             line === '/memory_status' ||

package/dist/rollback/index.js

@@ -6,6 +6,8 @@ import { toText } from '../context/utils.js';
 let turnIdCounter = 0;
 let currentTurnId = 0;
 let sequenceCounter = 0;
+/** Monotonic process-local generation; repeated writes to one path still invalidate validation. */
+let mutationVersion = 0;
 let turns = [];
 let snapshots = [];
 const rootDir = () => path.resolve(process.cwd());
@@ -112,6 +114,11 @@ export function beginTurn(firstLine) {
     turnIdCounter += 1;
     currentTurnId = turnIdCounter;
     turns.push({ turnId: currentTurnId, firstLine });
+    return currentTurnId;
+}
+/** Stable identity shared by tracing, validation, and rollback for the active main turn. */
+export function getCurrentTurnId() {
+    return currentTurnId;
 }
 /** 单路径工具执行前捕获，不立即记账；失败/no-op 不应出现在 rollback 中。 */
 export function beginPathMutation(p) {
@@ -128,17 +135,22 @@ export function endPathMutation(capture, op) {
     const full = safeFullPath(capture.path);
     if (!full)
         return;
+    let changed = false;
     const after = readState(full);
     if (!sameState(capture.before, after)) {
+        changed = true;
         addSnapshot(snapshotFromState(capture.path, capture.before, capture.sequence, op, capture.createdParents));
     }
     // 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));
         }
     }
+    if (changed)
+        mutationVersion += 1;
 }
 function isWorkspaceExcluded(full) {
     const base = path.basename(full).toLowerCase();
@@ -183,13 +195,37 @@ export function beginWorkspaceMutation() {
 export function endWorkspaceMutation(capture, op) {
     const after = scanWorkspace();
     const paths = new Set([...capture.entries.keys(), ...after.keys()]);
+    let changed = false;
     for (const rel of paths) {
         const beforeState = capture.entries.get(rel) ?? { kind: 'missing' };
         const afterState = after.get(rel) ?? { kind: 'missing' };
         if (sameState(beforeState, afterState))
             continue;
+        changed = true;
         addSnapshot(snapshotFromState(rel, beforeState, capture.sequence, op));
     }
+    if (changed)
+        mutationVersion += 1;
+}
+/** Current main turn changes, deduplicated by path, plus a generation for validation invalidation. */
+export function getCurrentTurnMutationState() {
+    const order = [];
+    const byPath = new Map();
+    for (const snapshot of snapshots) {
+        if (snapshot.turnId !== currentTurnId)
+            continue;
+        let change = byPath.get(snapshot.path);
+        if (!change) {
+            change = { path: snapshot.path, ops: [], snapshotAvailable: true };
+            byPath.set(snapshot.path, change);
+            order.push(snapshot.path);
+        }
+        for (const op of snapshot.ops ?? ['file_change']) {
+            if (!change.ops.includes(op))
+                change.ops.push(op);
+        }
+    }
+    return { version: mutationVersion, changedFiles: order.map((item) => byPath.get(item)) };
 }
 export function listTurns() {
     return turns.slice();

package/dist/session/index.js

@@ -12,3 +12,6 @@ export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, con
 export { runScheduler, manualCompact, createBudgetScheduler, } from './scheduler.js';
 export { dropContextFromHistory, formatDropResult, } from './drop.js';
 export { newSessionId, saveSession, loadSession, listSessions, sessionDir, } from './persist.js';
+export { appendCurrentSessionTrace, appendCurrentSessionTraceEvent, appendCurrentSessionRuntimeEvent, createTraceEvent, } from './trace.js';
+export { reduceTraceMetrics, readTraceEvents, readTraceMetrics } from './trace-metrics.js';
+export { summarizeToolArguments, hashTraceValue, safeProviderId } from './trace-sanitize.js';

package/dist/session/trace-metrics.js

@@ -0,0 +1,70 @@
+import { readFileSync } from 'node:fs';
+export function reduceTraceMetrics(events) {
+    const ends = events.filter((event) => event.type === 'tool_call_end');
+    let recovered = false;
+    let hadFailure = false;
+    let successes = 0;
+    let toolRetries = 0;
+    let tokens = 0;
+    let hasTokens = false;
+    for (const event of ends) {
+        const status = String(event.data.status ?? 'error');
+        const retry = Number(event.data.retry ?? 0);
+        toolRetries += Number.isFinite(retry) ? retry : 0;
+        if (status === 'success') {
+            successes++;
+            if (hadFailure)
+                recovered = true;
+        }
+        else {
+            hadFailure = true;
+        }
+    }
+    for (const event of events) {
+        if (event.type !== 'model_end')
+            continue;
+        const value = event.data.totalTokens;
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            tokens += value;
+            hasTokens = true;
+        }
+    }
+    const modelRetries = events.filter((event) => event.type === 'model_retry').length;
+    const firstValidation = events.find((event) => event.type === 'validation_end');
+    const turnEnd = [...events].reverse().find((event) => event.type === 'turn_end');
+    return {
+        toolCalls: events.filter((event) => event.type === 'tool_call_start').length,
+        toolFailures: ends.length - successes,
+        toolRecovery: recovered,
+        firstSuccessRate: ends.length ? successes / ends.length : 1,
+        modelRetries,
+        toolRetries,
+        retries: modelRetries + toolRetries,
+        tokens: hasTokens ? tokens : null,
+        durationMs: Number(turnEnd?.data.durationMs ?? 0),
+        firstValidationPassed: firstValidation?.data.status === 'passed',
+    };
+}
+/** Reads event JSONL; malformed/legacy summary lines are ignored. */
+export function readTraceEvents(file) {
+    const events = [];
+    for (const line of readFileSync(file, 'utf8').split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (value.schemaVersion === 1 && typeof value.type === 'string' &&
+                typeof value.sessionId === 'string' && typeof value.turnId === 'number' &&
+                value.data && typeof value.data === 'object') {
+                events.push(value);
+            }
+        }
+        catch {
+            // One corrupt best-effort trace line must not hide the remaining run.
+        }
+    }
+    return events;
+}
+export function readTraceMetrics(file) {
+    return reduceTraceMetrics(readTraceEvents(file));
+}

package/dist/session/trace-sanitize.js

@@ -0,0 +1,34 @@
+import { createHash } from 'node:crypto';
+export function hashTraceValue(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+/** Never persists argument values: only shape, size, and a one-way fingerprint. */
+export function summarizeToolArguments(raw) {
+    let keys = [];
+    let parseable = false;
+    try {
+        const parsed = raw.trim() ? JSON.parse(raw) : {};
+        parseable = true;
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            keys = Object.keys(parsed).sort();
+        }
+    }
+    catch {
+        // Invalid arguments are still fingerprinted without retaining their contents.
+    }
+    return {
+        sha256: hashTraceValue(raw),
+        byteLength: Buffer.byteLength(raw, 'utf8'),
+        keys,
+        parseable,
+    };
+}
+/** Provider identity is deliberately reduced to a hostname; credentials/path/query are discarded. */
+export function safeProviderId(baseURL) {
+    try {
+        return new URL(baseURL).hostname.toLowerCase() || 'custom';
+    }
+    catch {
+        return 'custom';
+    }
+}

package/dist/session/trace.js

@@ -0,0 +1,54 @@
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { config } from '../config/index.js';
+import { getCurrentTurnId } from '../rollback/index.js';
+import { getCurrentSessionId } from './state.js';
+export function createTraceEvent(input) {
+    return {
+        schemaVersion: 1,
+        eventId: randomUUID(),
+        ts: new Date().toISOString(),
+        ...input,
+    };
+}
+function appendTraceLine(sessionId, value) {
+    try {
+        const dir = path.join(config.sessionDir, sessionId);
+        mkdirSync(dir, { recursive: true });
+        appendFileSync(path.join(dir, 'trace.jsonl'), `${JSON.stringify(value)}\n`, 'utf8');
+    }
+    catch {
+        // Observability is best-effort and cannot block coding work.
+    }
+}
+/** Persists a typed event in the current session's append-only black-box log. */
+export function appendCurrentSessionTraceEvent(event) {
+    const sessionId = getCurrentSessionId();
+    if (!sessionId)
+        return;
+    appendTraceLine(sessionId, { ...event, sessionId });
+}
+/** Records events initiated outside runAgentCore, such as Ctrl+C, /compact, and /rollback. */
+export function appendCurrentSessionRuntimeEvent(type, data, turnId = getCurrentTurnId()) {
+    const sessionId = getCurrentSessionId();
+    if (!sessionId)
+        return;
+    appendTraceLine(sessionId, createTraceEvent({ sessionId, turnId, type, data }));
+}
+/** Legacy turn-summary sink retained for API compatibility. New production code writes events. */
+export function appendCurrentSessionTrace(trace) {
+    const sessionId = getCurrentSessionId();
+    if (!sessionId)
+        return;
+    const validation = trace.validation
+        ? {
+            status: trace.validation.status,
+            level: trace.validation.level,
+            durationMs: trace.validation.durationMs,
+            verificationComplete: trace.validation.verificationComplete,
+            fingerprint: trace.validation.fingerprint,
+        }
+        : undefined;
+    appendTraceLine(sessionId, { ...trace, sessionId, validation });
+}

package/dist/tools/builtins/edit-file.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { verifyWrittenFile } from '../../verification/postconditions.js';
 // ---------- edit_file ----------
 export const editFileTool = {
     name: 'edit_file',
@@ -39,6 +40,17 @@ export const editFileTool = {
         // 检测原始行尾风格,写回时还原(存在 \r\n 即视为 CRLF 文件;纯 LF 文件保持 LF)
         const out = data.includes('\r\n') ? updated.replace(/\n/g, '\r\n') : updated;
         await writeFile(full, out, 'utf8');
-        return `已在 ${path} 中完成 1 处替换。`;
+        const postcondition = await verifyWrittenFile(full, out);
+        if (postcondition.status === 'failed') {
+            return {
+                status: 'error',
+                code: 'POSTCONDITION_FAILED',
+                retryable: true,
+                output: postcondition.diagnostics
+                    .map((item) => `[${item.code ?? 'V0_FAILED'}] ${item.file ?? path}: ${item.message}`)
+                    .join('\n'),
+            };
+        }
+        return `已在 ${path} 中完成 1 处替换 (sha256=${postcondition.actualHash})。`;
     },
 };

package/dist/tools/builtins/index.js

@@ -46,7 +46,40 @@ const _projectSkillEnabledAtBoot = process.env.MOCODE_PROJECT_SKILL === 'true';
 const _projectSkillTools = _projectSkillEnabledAtBoot
     ? [projectSkillUpdateTool]
     : [];
-export const builtinTools = [
+const pathResource = (args) => typeof args.path === 'string' && args.path ? [`file:${args.path}`] : ['workspace'];
+const workspaceResource = () => ['workspace'];
+const memoryResource = () => ['memory-store'];
+const CAPABILITIES = {
+    read_file: { effect: 'read', concurrency: 'parallel', retry: 'safe', resources: pathResource },
+    write_file: { effect: 'write', concurrency: 'resource-locked', retry: 'never', resources: pathResource },
+    edit_file: { effect: 'write', concurrency: 'resource-locked', retry: 'never', resources: pathResource },
+    run_command: { effect: 'process', concurrency: 'serial', retry: 'never', resources: workspaceResource, supportsAbort: true },
+    glob: { effect: 'read', concurrency: 'parallel', retry: 'safe', resources: workspaceResource },
+    grep: { effect: 'read', concurrency: 'parallel', retry: 'safe', resources: workspaceResource },
+    codegraph: { effect: 'read', concurrency: 'parallel', retry: 'safe', resources: workspaceResource, supportsAbort: true },
+    web_search: { effect: 'network', concurrency: 'parallel', retry: 'safe', supportsAbort: true },
+    web_fetch: { effect: 'network', concurrency: 'parallel', retry: 'safe', supportsAbort: true },
+    use_skill: { effect: 'read', concurrency: 'serial', retry: 'safe' },
+    ask_human: { effect: 'read', concurrency: 'serial', retry: 'never' },
+    switch_mode: { effect: 'write', concurrency: 'serial', retry: 'never', resources: () => ['agent-mode'] },
+    drop_context: { effect: 'write', concurrency: 'serial', retry: 'never', resources: () => ['conversation-context'] },
+    memory_save: { effect: 'write', concurrency: 'serial', retry: 'never', resources: memoryResource },
+    memory_search: { effect: 'write', concurrency: 'serial', retry: 'never', resources: memoryResource },
+    memory_list: { effect: 'read', concurrency: 'serial', retry: 'safe', resources: memoryResource },
+    memory_update: { effect: 'write', concurrency: 'serial', retry: 'never', resources: memoryResource },
+    memory_forget: { effect: 'write', concurrency: 'serial', retry: 'never', resources: memoryResource },
+    project_skill_update: { effect: 'write', concurrency: 'serial', retry: 'never', resources: workspaceResource },
+    // task 只编排子 Agent；真实读写由子调用自行持锁，父调用不得包 workspace 锁。
+    task: {
+        effect: 'write',
+        concurrency: 'serial',
+        retry: 'never',
+        resources: workspaceResource,
+        delegatesResourceLocks: true,
+        supportsAbort: true,
+    },
+};
+const rawBuiltinTools = [
     readFileTool,
     writeFileTool,
     editFileTool,
@@ -58,9 +91,14 @@ export const builtinTools = [
     webFetchTool,
     useSkillTool,
     askHumanTool,
-    switchModeTool, // plan↔auto 自切(两模式都可见,不进 PLAN_DISABLED_TOOLS;副作用控制工具→串行分支)
-    dropContextTool, // 运行中剔除无关 tool 结果(上下文管理,无副作用;两模式都可见,串行分支)
+    switchModeTool,
+    dropContextTool,
     ..._memoryTools,
     ..._projectSkillTools,
-    taskTool, // 派生子 agent(独立 history + 可受限工具集);plan 模式禁用(见 PLAN_DISABLED_TOOLS)
+    taskTool,
 ];
+/** 所有内置工具均携带显式能力；新增工具遗漏声明时 registry 会保守串行。 */
+export const builtinTools = rawBuiltinTools.map((tool) => ({
+    ...tool,
+    capabilities: CAPABILITIES[tool.name],
+}));