mocode-ai 1.4.2 → 1.4.3

package/dist/agent/index.js

@@ -8,10 +8,11 @@ import { summarizeToolCall, summarizeToolResult, truncateDisplay, fmtElapsed } f
 import { renderFileChange } from '../ui/diff.js';
 import * as layout from '../ui/layout.js';
 import * as batch from '../ui/batch.js';
-import { beginTurn } from '../rollback/index.js';
 import { config } from '../config/index.js';
-import { runAgentCore, isMutationTool } from './core.js';
+import { isMutationTool } from './core.js';
+import { createRuntime, defaultRuntime, Runtime } from '../runtime/index.js';
 import { createPetHooks } from '../pet/state.js';
+import { defaultAgentRuntimeContext } from './runtime-context.js';
 import { t } from '../i18n/index.js';
 import { isToolErrorOutput } from '../tools/result.js';
 import { appendCurrentSessionTraceEvent } from '../session/index.js';
@@ -81,7 +82,7 @@ function firstLineOf(ui) {
 /** 工具调用 ● 头:工具名 + 参数摘要(按 tool_calls 原顺序打印,让用户看到本轮跑哪些工具)。
  *  重构后改为累积到 BatchRenderer,onToolBatchEnd 时统一打摘要行;
  *  展开/折叠由 BatchRenderer + 鼠标 release 决定,本函数不再直接写屏。 */
-function writeToolHeader(tc) {
+function writeToolHeader(tc, toolRuntime) {
     if (tc.name === SUB_AGENT_TOOL) {
         // sub-agent：同一轮并行派发的多个 sub-agent 合并进同一个「组容器批」——
         // 顶层只有一个 ● 探索 N ... sub-agent N 摘要行,下面按 └─ sub-agent {...} 逐条
@@ -92,6 +93,8 @@ function writeToolHeader(tc) {
             // 避免普通批摘要行与 sub-agent 组摘要行粘在一起。
             if (currentBatchId)
                 flushToolBatch();
+            // 气泡/正文 → 组摘要行边界:尾部视觉空行幂等收成 1 条(见 mutation 分支同注释)。
+            layout.normalizeMutationBoundary();
             // 首个 sub-agent 调用：建组容器批(顶层)。label 缺省=「探索」,entries 累计各 sub-agent 调用。
             subAgentGroupId = batch.beginBatch(undefined, { groupParent: true });
             batch.recordCall(subAgentGroupId, tc.name, summarizeToolCall(tc.name, tc.arguments), tc.id);
@@ -115,10 +118,15 @@ function writeToolHeader(tc) {
     if (subAgentGroupId || subAgentGroupPendingSeparator) {
         flushToolBatch();
     }
-    if (isMutationTool(tc.name)) {
+    if (isMutationTool(tc.name, toolRuntime)) {
         // mutation 永远独占一批（diff 要紧跟调用行）。先收口当前普通批。
         if (currentBatchId)
             flushToolBatch();
+        // 气泡/正文 → 首摘要行边界:尾部视觉空行幂等收成恰好 1 条。
+        // 气泡 trailingBlank、轮次分隔 \n、flush 补行等各路写入都可能让尾部留 2+ 条空行,
+        // 首摘要落屏前统一归一,与正文 → mutation 的 onToolHeader normalize 同语义(此处覆盖
+        // 无前置正文的 turn 首工具;有前置正文时 toolBatchFollowsText 分支也会归一,幂等无副作用)。
+        layout.normalizeMutationBoundary();
         const id = batch.beginBatch();
         currentBatchId = id;
         batch.bindCall(tc.id, id);
@@ -127,7 +135,11 @@ function writeToolHeader(tc) {
     }
     else {
         // 普通工具合并到 currentBatchId；同轮并行或连续无正文的工具轮次共享一个摘要行。
+        const isNewBatch = currentBatchId == null;
         const id = (currentBatchId ??= batch.beginBatch());
+        // 新建批 = 新摘要行落屏:同 mutation 分支,边界空行归一(复用已有批时不碰,避免打断批内续行)。
+        if (isNewBatch)
+            layout.normalizeMutationBoundary();
         // 结果按 tool_call id 归位：并行执行时 currentBatchId 会漂移，只按“当前批”回填会漏填，
         // 摘要行就永远停在 ◇（用户实测：子 agent 跑完主侧菱形没变成实心圆）。
         batch.bindCall(tc.id, id);
@@ -138,7 +150,7 @@ function writeToolHeader(tc) {
 }
 /** 渲染工具结果:mutation 成功走 diff 块(行号 + 语法高亮);其余走一行 preview。
  *  同 writeToolHeader,改为累积到 BatchRenderer(只缓存字符串,不写屏)。 */
-function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
+function writeToolResult(tc, output, parsed, preWriteOld, editStartLine, toolRuntime) {
     // 优先按 tool_call id 反查所属批（并行 / sub-agent 组时 currentBatchId 已不是它）。
     const batchId = batch.batchIdForCall(tc.id) ?? currentBatchId;
     if (!batchId)
@@ -180,7 +192,7 @@ function writeToolResult(tc, output, parsed, preWriteOld, editStartLine) {
     batch.recordResult(batchId, tc.name, preview, diff, output, isToolErrorOutput(output));
     batch.showLiveBatch(batchId, layout);
     // mutation 结果（成功 diff 或错误输出）立即可见，并阻止后续普通工具并入这一批。
-    if (isMutationTool(tc.name))
+    if (isMutationTool(tc.name, toolRuntime))
         finishStandaloneBatch(batchId, true);
 }
 /** 收尾一个独占批（mutation / sub-agent）。按 id 收尾而不是按 currentBatchId：
@@ -250,9 +262,14 @@ onContextUpdate,
 /** 本用户 turn 的自动路由工具策略。 */
 toolPolicy, 
 /** 仅真实用户 turn 传入；合成 plan 执行轮继承 policy 但不重复记录初始路由。 */
-initialToolRoute) {
-    // 开新轮次(回滚用):首行截断 40,供 /rollback 轮次菜单展示。
-    beginTurn(truncateDisplay(firstLineOf(userInput), 40));
+initialToolRoute, 
+/** TUI composition root 绑定的 Runtime；旧调用传 AgentRuntimeContext 仍兼容。 */
+runtimeOrContext = defaultRuntime) {
+    const runtime = runtimeOrContext instanceof Runtime
+        ? runtimeOrContext
+        : runtimeOrContext === defaultAgentRuntimeContext
+            ? defaultRuntime
+            : createRuntime({ context: runtimeOrContext });
     layout.contentMode(); // 防御性:运行态光标归输入框光标位供 IME 锚定(enterRunningMode 已置,这里兜底)
     currentBatchId = null; // 新 turn 清旧 batch id(防上 turn 残留)
     subAgentGroupId = null;
@@ -295,6 +312,11 @@ initialToolRoute) {
         // 一旦模型开始解释阶段结果，立即收尾当前摘要；后续工具重新建立批次。
         if (visible)
             flushToolBatch();
+        // 工具块 → 正文边界幂等归一:无论 flush/expand 路径漏出几条空行(历史 bug 实测最多 6 条),
+        // 落正文前把尾部视觉空行收成恰好 1 条。与正文 → mutation 的 normalizeMutationBoundary 对称。
+        // 仅首 chunk(followsToolBatch)做:后续 chunk 属同一段流式正文,归一会截断 md 段。
+        if (followsToolBatch && visible)
+            layout.normalizeMutationBoundary();
         spinner.stop(); // 任何正文 token 都停 spinner(首 token 停「思考中」;onToolCall 重启后若又来文本则停「生成中」)。未旋转时 stop 为 no-op。
         layout.contentWriteMd(visible); // 正文走 markdown 渲染(代码块高亮 / 标题 / 列表 / 行内 …),见 ui/markdown.ts
         if (visible) {
@@ -373,15 +395,15 @@ initialToolRoute) {
         onToolHeader: (tc) => {
             // mutation 的自动展开会把 current/committed 空行状态互相转换；在首摘要真正
             // 落屏前按视觉行归一，避免同样的文本→edit 边界偶发 1 行或 2 行。
-            if (toolBatchFollowsText && isMutationTool(tc.name)) {
+            if (toolBatchFollowsText && isMutationTool(tc.name, runtime.context.toolRuntime)) {
                 layout.normalizeMutationBoundary();
             }
             toolBatchFollowsText = false;
-            writeToolHeader(tc);
+            writeToolHeader(tc, runtime.context.toolRuntime);
         },
         onToolStart: (name) => spinner.start(t('agent.executing', { tool: name })),
         onToolDone: () => spinner.stop(),
-        onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine),
+        onToolResult: (tc, output, parsed, preWriteOld, editStartLine) => writeToolResult(tc, output, parsed, preWriteOld, editStartLine, runtime.context.toolRuntime),
         onToolBatchEnd: () => {
             // 一次工具轮次结束不再切 UI batch；下一轮若仍无正文，继续复用 currentBatchId。
         },
@@ -419,7 +441,9 @@ initialToolRoute) {
     const combinedHooks = mergeHooks(hooks, petHooks);
     let result;
     try {
-        result = await runAgentCore({
+        result = await runtime.run({
+            turn: 'new',
+            turnLabel: truncateDisplay(firstLineOf(userInput), 40),
             history,
             userInput,
             signal,

package/dist/agent/model-turn.js

@@ -0,0 +1,218 @@
+import { estimatePromptTokens, estimateTokens, isContextLengthError, } from '../llm/index.js';
+/** Executes context preparation plus exactly one model step, including the single overflow retry path. */
+export async function runModelTurn(input) {
+    const { opts, ctx, history, historyManager, runtimeContextState, scheduler, contextTrimmer, modelRunner, activeTools, runPolicy, step, cacheState, turnLifecycle, cancellationLifecycle, rebuildHistoryIndexes, } = input;
+    const { signal, onContextUpdate, hooks } = opts;
+    const { usageMeter, emitTrace } = turnLifecycle;
+    const requestBaseURL = ctx.config.baseURL;
+    const requestModel = ctx.getActiveModel();
+    const storedCalibration = ctx.getTokenCalibration(requestBaseURL, requestModel, activeTools);
+    runtimeContextState.correction = storedCalibration.correction;
+    runtimeContextState.calibrationSamples = storedCalibration.samples;
+    let sessionStateText = opts.suppressSessionState ? '' : ctx.buildSessionStateReminder();
+    runtimeContextState.ephemeralText = sessionStateText || undefined;
+    onContextUpdate?.();
+    let historyRebuilt = false;
+    let overflowRetried = false;
+    const compactStartedAt = Date.now();
+    const trimResult = await contextTrimmer.trim({
+        mode: scheduler ? 'scheduled' : 'fallback',
+        history: historyManager.snapshot(),
+        step,
+        tools: activeTools,
+        ephemeralTokens: sessionStateText ? estimateTokens(sessionStateText) : 0,
+        signal,
+    });
+    historyRebuilt = trimResult.kind === 'rebuild';
+    const trimStats = trimResult.kind === 'aborted' ? {} : trimResult.stats;
+    if (scheduler && trimStats.compactHistoryCalled) {
+        emitTrace('compact', {
+            source: 'automatic',
+            reason: 'scheduled',
+            historyRebuilt,
+            durationMs: Date.now() - compactStartedAt,
+        });
+    }
+    else if (!scheduler && trimResult.kind !== 'aborted' && trimStats.reason) {
+        emitTrace('compact', {
+            source: 'automatic_fallback',
+            reason: trimStats.reason,
+            compacted: trimStats.compacted,
+            historyRebuilt,
+            estimateBefore: trimStats.estimateBefore,
+            estimateAfter: trimStats.estimateAfter,
+            durationMs: Date.now() - compactStartedAt,
+        });
+    }
+    if (historyRebuilt) {
+        rebuildHistoryIndexes();
+        if (!opts.suppressSessionState)
+            sessionStateText = ctx.buildSessionStateReminder();
+    }
+    hooks.onStepStart?.();
+    const stream = { mode: 'idle', gotText: false, lastChar: '' };
+    const onText = (text) => {
+        hooks.onText?.(text);
+        stream.mode = 'text';
+        stream.gotText = true;
+        if (text)
+            stream.lastChar = text[text.length - 1];
+    };
+    const onToolCall = (name) => {
+        if (stream.lastChar && stream.lastChar !== '\n') {
+            hooks.onTextEnd?.();
+            stream.lastChar = '\n';
+        }
+        hooks.onToolCall?.(name);
+    };
+    let result;
+    const modelStartedAt = Date.now();
+    const provider = ctx.safeProviderId(requestBaseURL);
+    emitTrace('model_start', { model: requestModel, provider });
+    const buildRequestHistory = () => {
+        const ephemeralReminder = [
+            runPolicy.reminder,
+            !opts.suppressOpeningAnalysis && step === 0
+                ? '## Opening analysis\nBegin your FIRST response of this turn with a brief analysis of the request and your planned approach (1-3 sentences, no filler), THEN start tool calls. This opening is the only place where pre-tool prose is expected; after it, work quietly with no narration between tool calls.'
+                : '',
+            historyRebuilt
+                ? '## Post-compaction recovery\n' +
+                    'Context was compacted before this request. Recover before doing anything else, in this order:\n' +
+                    '1. Read the session summary at the top of the history: `## Completed` is already done — do not redo or re-verify it. `## In Progress` / `## Next Steps` tell you exactly where work stopped and what is next.\n' +
+                    '2. Read `## Session state` below (from notes.md, refreshed every step): the active plan is authoritative — `[x]` steps are finished, resume from the first `[ ]`. A `## Compaction Snapshot` section there is the progress checkpoint written at this compaction.\n' +
+                    (sessionStateText
+                        ? ''
+                        : '(No active plan or snapshot was found in notes.md — reconstruct what is done purely from the summary and treat its `## Completed` as ground truth.)\n') +
+                    '3. Before any file edit, read_file the target fresh to get the current content hash — never edit from memory of pre-compaction content.\n' +
+                    '4. Before re-running a search/read you think you already did, check the summary and notes first: only repeat it if the result is genuinely missing or the target has changed.'
+                : '',
+            sessionStateText,
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+        return ephemeralReminder ? [...history, { role: 'system', content: ephemeralReminder }] : history;
+    };
+    let requestHistory = buildRequestHistory();
+    onContextUpdate?.();
+    let stepPromptEst = estimatePromptTokens(requestHistory, activeTools, runtimeContextState.correction);
+    const reportLive = (progress) => {
+        const completedUsage = usageMeter.snapshot();
+        const curPrompt = progress.promptTokens ?? stepPromptEst;
+        const curCached = progress.cachedTokens ??
+            (cacheState.providerCacheSeen ? Math.min(cacheState.lastStepPromptTokens, curPrompt) : 0);
+        hooks.onLiveUsage?.({
+            promptTokens: (completedUsage?.promptTokens ?? 0) + curPrompt,
+            completionTokens: (completedUsage?.completionTokens ?? 0) + progress.completionTokens,
+            totalTokens: (completedUsage?.totalTokens ?? 0) + curPrompt + progress.completionTokens,
+            cachedTokens: (completedUsage?.cachedTokens ?? 0) + curCached,
+        });
+    };
+    reportLive({ completionTokens: 0 });
+    const chatHandlers = {
+        onText,
+        onToolCall,
+        onProgress: reportLive,
+        onRetry: (retry) => emitTrace('model_retry', {
+            model: requestModel,
+            provider,
+            attempt: retry.attempt,
+            nextAttempt: retry.nextAttempt,
+            waitMs: retry.waitMs,
+            code: retry.code,
+        }),
+    };
+    const runChatOnce = async () => {
+        try {
+            return await modelRunner.run({ history: requestHistory, handlers: chatHandlers, tools: activeTools }, signal);
+        }
+        catch (error) {
+            const errorValue = error && typeof error === 'object' ? error : undefined;
+            emitTrace('model_end', {
+                model: requestModel,
+                provider,
+                status: signal?.aborted ? 'aborted' : 'error',
+                code: typeof errorValue?.status === 'number'
+                    ? `HTTP_${errorValue.status}`
+                    : (errorValue?.code ?? errorValue?.name ?? 'MODEL_ERROR'),
+                durationMs: Date.now() - modelStartedAt,
+            });
+            throw error;
+        }
+    };
+    try {
+        result = await runChatOnce();
+    }
+    catch (error) {
+        if (signal?.aborted ||
+            (error instanceof Error && (error.name === 'AbortError' || error.name === 'APIUserAbortError'))) {
+            cancellationLifecycle.restore();
+            turnLifecycle.markAborted();
+            return { kind: 'aborted', result: turnLifecycle.buildAbortedResult() };
+        }
+        if (!overflowRetried && isContextLengthError(error)) {
+            overflowRetried = true;
+            const rawEstimate = estimatePromptTokens(requestHistory, activeTools);
+            if (rawEstimate > 1_000) {
+                const calibration = ctx.updateTokenCalibration(requestBaseURL, requestModel, activeTools, rawEstimate, ctx.config.contextWindowTokens);
+                runtimeContextState.correction = calibration.correction;
+                runtimeContextState.calibrationSamples = calibration.samples;
+            }
+            const overflowResult = await contextTrimmer.trim({
+                mode: 'overflow',
+                history: historyManager.snapshot(),
+                step,
+                tools: activeTools,
+                ephemeralTokens: sessionStateText ? estimateTokens(sessionStateText) : 0,
+                signal,
+            });
+            const overflowStats = overflowResult.kind === 'aborted' ? {} : overflowResult.stats;
+            emitTrace('compact', {
+                source: 'overflow_retry',
+                reason: overflowStats.reason ?? 'noop',
+                compacted: overflowStats.compacted === true,
+                estimateBefore: overflowStats.estimateBefore,
+                estimateAfter: overflowStats.estimateAfter,
+                durationMs: Date.now() - modelStartedAt,
+            });
+            if (overflowResult.kind === 'none' || overflowResult.kind === 'aborted')
+                throw error;
+            if (overflowResult.kind === 'rebuild') {
+                historyRebuilt = true;
+                rebuildHistoryIndexes();
+            }
+            requestHistory = buildRequestHistory();
+            stepPromptEst = estimatePromptTokens(requestHistory, activeTools, runtimeContextState.correction);
+            result = await runChatOnce();
+        }
+        else {
+            throw error;
+        }
+    }
+    emitTrace('model_end', {
+        model: requestModel,
+        provider,
+        status: 'success',
+        durationMs: Date.now() - modelStartedAt,
+        promptTokens: result.usage?.promptTokens,
+        completionTokens: result.usage?.completionTokens,
+        totalTokens: result.usage?.totalTokens,
+        cachedTokens: result.usage?.cachedTokens,
+        reasoningTokens: result.usage?.reasoningTokens,
+    });
+    runtimeContextState.lastUsage = result.usage;
+    usageMeter.add(result.usage);
+    if (result.usage) {
+        cacheState.lastStepPromptTokens = result.usage.promptTokens;
+        if (result.usage.cachedTokens > 0)
+            cacheState.providerCacheSeen = true;
+    }
+    if (result.usage?.promptTokens && result.usage.promptTokens > 100) {
+        const estimated = estimatePromptTokens(requestHistory, activeTools);
+        const updated = ctx.updateTokenCalibration(requestBaseURL, requestModel, activeTools, estimated, result.usage.promptTokens);
+        runtimeContextState.correction = updated.correction;
+        runtimeContextState.calibrationSamples = updated.samples;
+    }
+    hooks.onChatDone?.();
+    onContextUpdate?.();
+    return { kind: 'result', result, stream };
+}

package/dist/agent/pipeline.js

@@ -0,0 +1,18 @@
+import { AGENT_STAGE_NAMES, } from './stages/contracts.js';
+import { createLegacyHistoryManager, createStagedHistoryManager } from './stages/history-manager.js';
+import { createLegacyCoordinatorAdapter, createLegacyStageAdapters, } from './stages/legacy-adapters.js';
+/** Build a fresh, independently overridable stage assembly for one agent run. */
+export function createAgentPipelineAssembly(init) {
+    const pipeline = init.pipeline ?? 'legacy';
+    const coordinator = createLegacyCoordinatorAdapter(init.runLegacy);
+    const defaults = Object.fromEntries(AGENT_STAGE_NAMES.map((name) => [name, pipeline === 'staged' ? 'staged' : 'legacy']));
+    const stages = createLegacyStageAdapters({ ...defaults, ...init.stageOverrides });
+    const createHistoryManager = stages.history.implementation === 'staged' ? createStagedHistoryManager : createLegacyHistoryManager;
+    return Object.freeze({
+        pipeline,
+        coordinator,
+        stages,
+        createHistoryManager,
+        run: (options) => coordinator.run(options, createHistoryManager({ messages: options.history }), stages),
+    });
+}

package/dist/agent/run-contracts.js

@@ -0,0 +1 @@
+export {};