mocode-ai 1.4.2 → 1.4.3

package/dist/agent/trace-state.js

@@ -1,118 +1,114 @@
-/**
- * agent 单轮的 trace / token-usage 状态聚合(从 core.ts 提取,2.0 步骤2 深拆第一刀)。
- *
- * runAgentCore 原本把 emitTrace / addUsage / reportLive 写成函数内闭包,捕获
- * traceSessionId / traceTurnId / currentTraceStep / abortTraced / turnUsage 等一坨可变局部量。
- * 这里把这坨状态收敛进一个对象,runAgentCore 持有实例并调用方法,行为与字节级事件 payload 不变。
- *
- * 设计约束:
- *  - emit() 的 currentTraceStep 三元逻辑逐字保留——trace 事件落盘格式是观测契约,不能漂移。
- *  - addUsage() 的逐字段累加(含 cacheCreationTokens 的 ?? 0 兜底)逐字保留。
- *  - reportLive() 的 onLiveUsage 上报警文结构与 turnUsage 闭包累加口径一致(实时 chip 显示)。
- *  - turnId 类型为 number | undefined:traceTurnId 兜底链可能产出 undefined(--no-session)。
- */
-import { createTraceEvent } from '../session/index.js';
-export class TurnTraceState {
-    sessionId;
-    turnId;
-    /** 当前步序号;循环每步开头赋值,finally 归 undefined。stepId 由此拼。 */
-    currentTraceStep;
-    /** abort 事件只记一次的幂等旗标。 */
-    abortTraced = false;
-    /** 本轮工具调用总数(turn_end 摘要用)。 */
-    toolCallCount = 0;
-    /** 本轮 token 累计;未开启 include_usage 或全失败时为 undefined。 */
-    turnUsage;
+class CallbackTraceSink {
+    implementation;
     onTraceEvent;
-    constructor(init) {
-        this.sessionId = init.sessionId;
-        this.turnId = init.turnId;
-        this.onTraceEvent = init.onTraceEvent;
+    constructor(implementation, onTraceEvent) {
+        this.implementation = implementation;
+        this.onTraceEvent = onTraceEvent;
     }
-    /** 记一条 trace 事件。best-effort:回调抛错被吞,绝不改变执行路径。 */
-    emit(type, data = {}, ids = {}) {
-        const turnId = this.turnId;
-        if (turnId === undefined)
-            return; // 无会话上下文(--no-session)不产生事件,与原闭包行为一致
+    emit(event) {
         try {
-            this.onTraceEvent?.(createTraceEvent({
-                sessionId: this.sessionId,
-                turnId,
-                type,
-                ...(this.currentTraceStep === undefined
-                    ? {}
-                    : {
-                        step: this.currentTraceStep,
-                        stepId: `${turnId}:step:${this.currentTraceStep}`,
-                    }),
-                ...ids,
-                data,
-            }));
+            this.onTraceEvent?.(event);
         }
         catch {
             // Trace is best-effort and must never alter execution.
         }
     }
-    /** 累加一次 chat 返回的真实 usage 到本轮 turnUsage。 */
-    addUsage(u) {
-        if (!u)
+}
+class TurnUsageMeter {
+    implementation;
+    usage;
+    constructor(implementation) {
+        this.implementation = implementation;
+    }
+    add(next) {
+        if (!next)
             return;
-        this.turnUsage = this.turnUsage
+        this.usage = this.usage
             ? {
-                promptTokens: this.turnUsage.promptTokens + u.promptTokens,
-                completionTokens: this.turnUsage.completionTokens + u.completionTokens,
-                totalTokens: this.turnUsage.totalTokens + u.totalTokens,
-                cachedTokens: this.turnUsage.cachedTokens + u.cachedTokens,
-                cacheCreationTokens: (this.turnUsage.cacheCreationTokens ?? 0) + (u.cacheCreationTokens ?? 0),
-                reasoningTokens: this.turnUsage.reasoningTokens + u.reasoningTokens,
+                promptTokens: this.usage.promptTokens + next.promptTokens,
+                completionTokens: this.usage.completionTokens + next.completionTokens,
+                totalTokens: this.usage.totalTokens + next.totalTokens,
+                cachedTokens: this.usage.cachedTokens + next.cachedTokens,
+                cacheCreationTokens: (this.usage.cacheCreationTokens ?? 0) + (next.cacheCreationTokens ?? 0),
+                reasoningTokens: this.usage.reasoningTokens + next.reasoningTokens,
             }
-            : u;
+            : next;
     }
-    /**
-     * 实时用量上报:onLiveUsage 推送「已完成步实测(turnUsage) + 当前步(prompt 估算/实测 + 流式 completion)」。
-     * turnUsage 在本对象内被 addUsage 原地累加,这里每次读最新值,口径与轮末摘要一致。
-     */
-    reportLive(hooks, stepPromptEst, lastStepPromptTokens, providerCacheSeen, p) {
-        // 当前步 prompt:末尾 usage chunk 到达后用实测,流式期间用估算(含校准)。
-        // 当前步 cache 命中同理:上报即用实测;流式期间按前缀缓存估算 ≈ 上一步实测 prompt
-        // (当前 prompt 总含其为前缀),不超过当前步 prompt;后端从不报 cache 时不估算。
-        // 口径与轮末摘要一致:chip ↑ 显计费 prompt(裸 - cached),↓/↻ 同。
-        const curPrompt = p.promptTokens ?? stepPromptEst;
-        const curCached = p.cachedTokens ?? (providerCacheSeen ? Math.min(lastStepPromptTokens, curPrompt) : 0);
-        hooks.onLiveUsage?.({
-            promptTokens: (this.turnUsage?.promptTokens ?? 0) + curPrompt,
-            completionTokens: (this.turnUsage?.completionTokens ?? 0) + p.completionTokens,
-            totalTokens: (this.turnUsage?.totalTokens ?? 0) + curPrompt + p.completionTokens,
-            cachedTokens: (this.turnUsage?.cachedTokens ?? 0) + curCached,
-        });
+    snapshot() {
+        return this.usage;
     }
-    /**
-     * 中断还原:记一次 abort 事件(幂等)→ onAbort 钩子 → history 回滚到快照 → 模式还原。
-     * 与 core.ts 原 abortRestore 闭包逐字一致(含调用顺序);traceStatus 赋值留在 core
-     * (它是 core 局部 let,turn_end 埋点还要读)。
-     */
-    abortRestore(deps) {
-        if (!this.abortTraced) {
-            this.emit('abort', { phase: 'observed', reason: 'signal' });
-            this.abortTraced = true;
+}
+export class RunCancellationLifecycle {
+    implementation;
+    init;
+    savedHistory;
+    observed = false;
+    constructor(implementation, init) {
+        this.implementation = implementation;
+        this.init = init;
+    }
+    checkpoint() {
+        this.savedHistory = this.init.historyManager.createCheckpoint();
+    }
+    restore() {
+        if (!this.observed) {
+            this.init.onObserved();
+            this.observed = true;
         }
-        deps.hooks.onAbort?.();
-        deps.history.length = 0;
-        deps.history.push(...deps.savedHistory);
-        deps.ctx.setAgentMode(deps.savedMode);
+        this.init.onAbort();
+        if (!this.savedHistory)
+            throw new Error('Cancellation restore requires an initialized history checkpoint.');
+        this.init.historyManager.restore(this.savedHistory);
+        this.init.onHistoryRestored();
+        this.init.restoreMode();
+    }
+}
+class LegacyTraceSink extends CallbackTraceSink {
+    constructor(init) {
+        super('legacy', init.onTraceEvent);
     }
-    /**
-     * 构造中断返回值(completed=false / terminationReason='aborted' / finalText=null)。
-     * core.ts 两处 aborted-return 块逐字节相同,收敛到此处;mutation 由调用方现取
-     * (ctx.getCurrentTurnMutationState()),保证读取时点与原内联代码一致。
-     */
-    buildAbortedResult(mutation) {
-        return {
-            completed: false,
-            terminationReason: 'aborted',
-            finalText: null,
-            usage: this.turnUsage,
-            changedFiles: mutation.changedFiles.map((item) => item.path),
-        };
+}
+class StagedTraceSink extends CallbackTraceSink {
+    constructor(init) {
+        super('staged', init.onTraceEvent);
     }
 }
+class LegacyUsageMeter extends TurnUsageMeter {
+    constructor() {
+        super('legacy');
+    }
+}
+class StagedUsageMeter extends TurnUsageMeter {
+    constructor() {
+        super('staged');
+    }
+}
+class LegacyCancellationLifecycle extends RunCancellationLifecycle {
+    constructor(init) {
+        super('legacy', init);
+    }
+}
+class StagedCancellationLifecycle extends RunCancellationLifecycle {
+    constructor(init) {
+        super('staged', init);
+    }
+}
+/** Separate factories preserve a per-stage rollback seam while sharing the frozen protocol implementation. */
+export function createLegacyTraceSink(init) {
+    return new LegacyTraceSink(init);
+}
+export function createStagedTraceSink(init) {
+    return new StagedTraceSink(init);
+}
+export function createLegacyUsageMeter() {
+    return new LegacyUsageMeter();
+}
+export function createStagedUsageMeter() {
+    return new StagedUsageMeter();
+}
+export function createLegacyCancellationLifecycle(init) {
+    return new LegacyCancellationLifecycle(init);
+}
+export function createStagedCancellationLifecycle(init) {
+    return new StagedCancellationLifecycle(init);
+}

package/dist/agent/turn-lifecycle.js

@@ -0,0 +1,110 @@
+import { createTraceEvent } from '../session/index.js';
+import { createLegacyCancellationLifecycle, createLegacyTraceSink, createLegacyUsageMeter, createStagedCancellationLifecycle, createStagedTraceSink, createStagedUsageMeter, } from './trace-state.js';
+/** Owns turn-scoped trace, usage, cancellation and outer-finally state without changing their observable order. */
+export function createTurnLifecycle(opts, ctx, stages, savedMode) {
+    const startedAt = Date.now();
+    const traceSessionId = opts.traceContext?.sessionId ?? ctx.getCurrentSessionId() ?? `ephemeral-${process.pid}`;
+    const traceTurnId = opts.traceContext?.turnId ?? ctx.getCurrentTurnId();
+    const traceSink = stages.trace.implementation === 'staged'
+        ? createStagedTraceSink({ onTraceEvent: opts.onTraceEvent })
+        : createLegacyTraceSink({ onTraceEvent: opts.onTraceEvent });
+    const usageMeter = stages.usage.implementation === 'staged' ? createStagedUsageMeter() : createLegacyUsageMeter();
+    let currentTraceStep;
+    let toolCallCount = 0;
+    let done = false;
+    let traceStatus = 'error';
+    const emitTrace = (type, data = {}, ids = {}) => {
+        if (traceTurnId === undefined)
+            return;
+        traceSink.emit(createTraceEvent({
+            sessionId: traceSessionId,
+            turnId: traceTurnId,
+            type,
+            ...(currentTraceStep === undefined
+                ? {}
+                : {
+                    step: currentTraceStep,
+                    stepId: `${traceTurnId}:step:${currentTraceStep}`,
+                }),
+            ...ids,
+            data,
+        }));
+    };
+    emitTrace('turn_start', { mode: ctx.getAgentMode() });
+    if (opts.initialToolRoute)
+        emitTrace('tool_route', opts.initialToolRoute);
+    return {
+        usageMeter,
+        traceSessionId,
+        traceTurnId,
+        startedAt,
+        emitTrace,
+        setCurrentStep: (step) => {
+            currentTraceStep = step;
+        },
+        addToolCalls: (count) => {
+            toolCallCount += count;
+        },
+        markCompleted: () => {
+            done = true;
+            traceStatus = 'completed';
+        },
+        markAborted: () => {
+            traceStatus = 'aborted';
+        },
+        markMaxSteps: () => {
+            done = true;
+            traceStatus = 'max_steps';
+        },
+        createCancellation: (historyManager, rebuildHistoryIndexes) => {
+            const init = {
+                historyManager,
+                onObserved: () => emitTrace('abort', { phase: 'observed', reason: 'signal' }),
+                onAbort: () => opts.hooks.onAbort?.(),
+                onHistoryRestored: rebuildHistoryIndexes,
+                restoreMode: () => ctx.setAgentMode(savedMode),
+            };
+            return stages.cancellation.implementation === 'staged'
+                ? createStagedCancellationLifecycle(init)
+                : createLegacyCancellationLifecycle(init);
+        },
+        buildAbortedResult: () => {
+            const mutation = ctx.getCurrentTurnMutationState();
+            return {
+                completed: false,
+                terminationReason: 'aborted',
+                finalText: null,
+                usage: usageMeter.snapshot(),
+                changedFiles: mutation.changedFiles.map((item) => item.path),
+            };
+        },
+        finalize: () => {
+            const finalMutation = ctx.getCurrentTurnMutationState();
+            currentTraceStep = undefined;
+            emitTrace('turn_end', {
+                status: traceStatus,
+                durationMs: Date.now() - startedAt,
+                toolCalls: toolCallCount,
+                changedFiles: finalMutation.changedFiles.map((item) => item.path),
+                totalTokens: usageMeter.snapshot()?.totalTokens,
+            });
+            try {
+                opts.onTrace?.({
+                    ts: new Date().toISOString(),
+                    sessionId: traceSessionId,
+                    turnId: traceTurnId,
+                    status: traceStatus,
+                    durationMs: Date.now() - startedAt,
+                    toolCalls: toolCallCount,
+                    changedFiles: finalMutation.changedFiles.map((item) => item.path),
+                    usage: usageMeter.snapshot(),
+                });
+            }
+            catch {
+                // Trace is best-effort and must not change the turn result.
+            }
+            if (done)
+                opts.hooks.onDone?.(Date.now() - startedAt, usageMeter.snapshot());
+        },
+    };
+}

package/dist/config/index.js

@@ -530,6 +530,20 @@ export const config = {
     permissionEnabled: process.env.MOCODE_PERMISSION !== 'false',
     permissionNonInteractiveAllow: process.env.MOCODE_PERMISSION_NON_INTERACTIVE_ALLOW === 'true',
 };
+/**
+ * 创建一份独立 Config 快照，不重新读取环境变量、配置文件或 preset。
+ *
+ * `source.systemPrompt` 若是 getter（全局 config 即如此）会在创建时求值并物化为字符串，
+ * 使快照不会继续隐式依赖全局 config；调用方也可通过 overrides 显式替换它。
+ * 当前 Config 的可变容器字段 llmKeysFromShell 始终复制，避免 runtime 间共享数组引用。
+ */
+export function createConfigSnapshot(overrides = {}, source = config) {
+    const snapshot = { ...source, ...overrides };
+    return {
+        ...snapshot,
+        llmKeysFromShell: [...snapshot.llmKeysFromShell],
+    };
+}
 /**
  * 会话钉死模型：窗口/会话启动时由 pinSessionModel() 捕获一次。
  * 运行中 agent 一律经 getActiveModel() 取模型，而非热切的 config.model——

package/dist/host/stdio.js

@@ -1,30 +1,34 @@
 import { randomUUID } from 'node:crypto';
 import readline from 'node:readline';
-import { runAgentCore } from '../agent/core.js';
-import { setAgentMode } from '../agent/mode.js';
-import { buildBasePrompt, config } from '../config/index.js';
-import { refreshChatTools, estimateMessagesTokens } from '../llm/index.js';
+import { createRuntime } from '../runtime/index.js';
+import { buildBasePrompt } from '../config/index.js';
+import { estimateMessagesTokens } from '../llm/index.js';
 import { initializeAllMcp, getMcpTools, getMcpWarnings, closeAllMcp } from '../mcp/index.js';
-import { setSandboxRoot } from '../sandbox/index.js';
-import { appendCurrentSessionTraceEvent, createContextState, loadSession, newSessionId, saveSession, } from '../session/index.js';
-import { setCurrentSessionId } from '../session/state.js';
-import { manualCompact } from '../session/scheduler.js';
+import { appendCurrentSessionTraceEvent, createContextState } from '../session/index.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
 import { clearSkillActivation } from '../skills/activation.js';
-import { registerToolsExtension } from '../tools/registry.js';
 import { ToolPolicyController } from '../tools/policy.js';
 import { routeToolGroups } from '../tools/router.js';
 // 装配官方默认工具包:registry 不再顶层 import builtins(破模块循环),host 入口须显式装配。
 import '../tools/builtins/index.js';
 import { parseCommand } from './protocol.js';
 let initialized = null;
+let runtimeFacade = null;
 let activeRun = null;
+let closing = false;
+const hostClosedReason = new DOMException('Host input closed.', 'AbortError');
+const shutdownController = new AbortController();
 let sessionId = '';
 let history = [];
 let queryHistory = [];
 let lastToolGroups = [];
 let contextState = createContextState();
 const approvals = new Map();
+function runtime() {
+    if (!runtimeFacade)
+        throw new Error('Runtime is not initialized.');
+    return runtimeFacade;
+}
 function write(envelope) {
     process.stdout.write(`${JSON.stringify(envelope)}\n`);
 }
@@ -38,15 +42,22 @@ async function initializeRuntime() {
     if (initialized)
         return initialized;
     initialized = (async () => {
-        setSandboxRoot(process.cwd());
-        setAgentMode('auto');
+        if (closing)
+            return;
         await initializeAllMcp();
-        registerToolsExtension('mcp', getMcpTools());
-        refreshChatTools();
+        if (closing)
+            return;
+        const createdRuntime = createRuntime({ sandboxRoot: process.cwd(), initialMode: 'auto' });
+        runtimeFacade = createdRuntime;
+        createdRuntime.context.toolRuntime.registerToolsExtension('mcp', getMcpTools());
+        await createdRuntime.start();
+        if (closing)
+            return;
+        const runtimeConfig = createdRuntime.context.config;
         emit('runtime_ready', {
-            projectRoot: process.cwd(),
-            provider: config.provider,
-            promptCache: config.provider === 'anthropic' && config.anthropicPromptCache,
+            projectRoot: createdRuntime.context.sandboxRoot,
+            provider: runtimeConfig.provider,
+            promptCache: runtimeConfig.provider === 'anthropic' && runtimeConfig.anthropicPromptCache,
             warnings: getMcpWarnings(),
         });
     })();
@@ -56,21 +67,21 @@ function systemMessage() {
     return effectiveSystemPrompt(buildBasePrompt(sessionId));
 }
 function createSession() {
-    sessionId = newSessionId();
-    setCurrentSessionId(sessionId, process.cwd());
-    setAgentMode('auto');
+    const activeRuntime = runtime();
+    sessionId = activeRuntime.session.create();
+    activeRuntime.context.setAgentMode('auto');
     history = [{ role: 'system', content: systemMessage() }];
     queryHistory = [];
     lastToolGroups = [];
     contextState = createContextState();
 }
 function restoreSession(id) {
-    const loaded = loadSession(id);
+    const activeRuntime = runtime();
+    const loaded = activeRuntime.session.resume(id);
     if (!loaded?.history.length)
         return false;
     sessionId = loaded.id;
-    setCurrentSessionId(sessionId, process.cwd());
-    setAgentMode('auto');
+    activeRuntime.context.setAgentMode('auto');
     history = [...loaded.history];
     if (history[0]?.role === 'system')
         history[0] = { role: 'system', content: systemMessage() };
@@ -81,6 +92,11 @@ function restoreSession(id) {
     contextState = createContextState();
     return true;
 }
+function persistSession() {
+    if (!sessionId)
+        return;
+    runtime().session.save(history, sessionId, queryHistory, lastToolGroups);
+}
 function prepareSession(requestedSessionId) {
     if (!requestedSessionId) {
         if (!sessionId)
@@ -92,6 +108,8 @@ function prepareSession(requestedSessionId) {
     return restoreSession(requestedSessionId) ? true : null;
 }
 function waitForApproval(runId, request) {
+    if (closing)
+        return Promise.resolve({ action: 'cancelled' });
     const approvalId = randomUUID();
     emit('approval_requested', {
         approvalId,
@@ -114,6 +132,8 @@ function hooksFor(runId) {
     };
 }
 async function run(command) {
+    if (closing)
+        return;
     if (activeRun)
         return error('An agent run is already active for this project.', command.id);
     if (!command.prompt.trim())
@@ -121,6 +141,8 @@ async function run(command) {
     let toolPolicy;
     try {
         await initializeRuntime();
+        if (closing)
+            return;
         const resumed = prepareSession(command.sessionId);
         if (resumed === null)
             return error(`Session ${command.sessionId} could not be restored.`, command.id);
@@ -142,8 +164,8 @@ async function run(command) {
             sessionId,
             projectRoot: process.cwd(),
             resumed,
-            provider: config.provider,
-            promptCache: config.provider === 'anthropic' && config.anthropicPromptCache,
+            provider: runtime().context.config.provider,
+            promptCache: runtime().context.config.provider === 'anthropic' && runtime().context.config.anthropicPromptCache,
             attachments: command.attachments?.map((attachment) => attachment.name) ?? [],
         }, command.id);
         const previousGroups = [...lastToolGroups];
@@ -153,11 +175,16 @@ async function run(command) {
             planMode: false,
             attachmentNames: command.attachments?.map((attachment) => attachment.name),
             signal: controller.signal,
+            transport: runtime().context.modelTransport,
+            tools: runtime().context.toolRuntime.tools,
         });
+        if (closing)
+            throw hostClosedReason;
         toolPolicy = new ToolPolicyController({
             groups: decision.groups,
             reason: decision.reason,
             confidence: decision.confidence,
+            tools: runtime().context.toolRuntime.tools,
         });
         lastToolGroups = toolPolicy.groupNames;
         const initialToolRoute = {
@@ -172,8 +199,9 @@ async function run(command) {
             planMode: false,
         };
         emit('tool_route', initialToolRoute, command.id);
-        const turnId = queryHistory.length;
-        const result = await runAgentCore({
+        const result = await runtime().run({
+            turn: 'new',
+            turnLabel: command.prompt.split('\n')[0]?.slice(0, 40) ?? command.prompt.slice(0, 40),
             history,
             userInput,
             signal: controller.signal,
@@ -181,22 +209,22 @@ async function run(command) {
             contextState,
             toolPolicy,
             initialToolRoute,
-            traceContext: { sessionId, turnId },
+            traceContext: { sessionId },
             onTraceEvent: appendCurrentSessionTraceEvent,
             permissionPrompt: (request) => waitForApproval(command.id, request),
         });
         lastToolGroups = toolPolicy.groupNames;
-        saveSession(history, sessionId, queryHistory, lastToolGroups);
+        persistSession();
         emit('run_completed', {
             sessionId,
             completed: result.completed,
             terminationReason: result.terminationReason,
             changedFiles: result.changedFiles ?? [],
             usage: result.usage,
-            provider: config.provider,
-            promptCache: config.provider === 'anthropic' && config.anthropicPromptCache,
+            provider: runtime().context.config.provider,
+            promptCache: runtime().context.config.provider === 'anthropic' && runtime().context.config.anthropicPromptCache,
             usagePercent: Math.round(contextUsagePercent() * 100),
-            contextWindow: config.contextWindowTokens,
+            contextWindow: runtime().context.config.contextWindowTokens,
         }, command.id);
     }
     catch (cause) {
@@ -205,7 +233,7 @@ async function run(command) {
             lastToolGroups = toolPolicy.groupNames;
         try {
             if (sessionId)
-                saveSession(history, sessionId, queryHistory, lastToolGroups);
+                persistSession();
         }
         catch {
             /* Preserve the runtime error. */
@@ -231,6 +259,7 @@ function cancel(command) {
     if (!activeRun)
         return emit('run_idle', {}, command.id);
     activeRun.controller.abort();
+    runtimeFacade?.cancel();
     for (const [approvalId, waiter] of approvals) {
         if (waiter.runId === activeRun.id) {
             waiter.resolve({ action: 'cancelled' });
@@ -243,25 +272,35 @@ function cancel(command) {
 function contextUsagePercent() {
     const dialog = history.filter((m) => m.role !== 'system');
     const est = estimateMessagesTokens(dialog);
-    return Math.min(1, est / config.contextWindowTokens);
+    return Math.min(1, est / runtime().context.config.contextWindowTokens);
 }
 async function compact(command) {
+    if (closing)
+        return;
     if (activeRun)
         return error('有正在运行的任务，请先取消后再压缩。', command.id);
     try {
         await initializeRuntime();
+        if (closing)
+            return;
         if (!sessionId)
             createSession();
         emit('status', { value: 'compacting' }, command.id);
-        const log = await manualCompact(history, command.focus, { force: true });
-        saveSession(history, sessionId, queryHistory, lastToolGroups);
+        const activeRuntime = runtime();
+        const log = await activeRuntime.compact(history, {
+            focus: command.focus,
+            force: true,
+            contextState,
+            signal: shutdownController.signal,
+        });
+        persistSession();
         const pct = contextUsagePercent();
         emit('compact_done', {
             compacted: log.compactHistoryCalled,
             beforeTokens: log.compactDetail?.estimateBefore,
             afterTokens: log.compactDetail?.estimateAfter,
             usagePercent: Math.round(pct * 100),
-            contextWindow: config.contextWindowTokens,
+            contextWindow: runtime().context.config.contextWindowTokens,
         }, command.id);
     }
     catch (cause) {
@@ -285,20 +324,42 @@ async function handle(command) {
         return compact(command);
     resolveApproval(command);
 }
+function requestShutdownCancellation() {
+    activeRun?.controller.abort(hostClosedReason);
+    runtimeFacade?.cancel(hostClosedReason);
+    for (const [approvalId, waiter] of approvals) {
+        waiter.resolve({ action: 'cancelled' });
+        approvals.delete(approvalId);
+    }
+}
 const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
-void initializeRuntime().catch((cause) => error(cause instanceof Error ? cause.message : String(cause)));
+const pendingCommands = new Set();
+const startupPromise = initializeRuntime();
+void startupPromise.catch((cause) => error(cause instanceof Error ? cause.message : String(cause)));
 for await (const line of input) {
     if (!line.trim())
         continue;
     try {
         const command = parseCommand(JSON.parse(line));
-        if (!command)
+        if (!command) {
             error('Invalid Mocode Work host command.');
-        else
-            void handle(command);
+        }
+        else {
+            const pending = Promise.resolve(handle(command));
+            pendingCommands.add(pending);
+            void pending.then(() => pendingCommands.delete(pending), () => pendingCommands.delete(pending));
+        }
     }
     catch {
         error('Invalid JSON command.');
     }
 }
+closing = true;
+shutdownController.abort(hostClosedReason);
+requestShutdownCancellation();
+await startupPromise.catch(() => undefined);
+requestShutdownCancellation();
+await Promise.allSettled([...pendingCommands]);
+const runtimeAtShutdown = runtimeFacade;
+await runtimeAtShutdown?.close().catch(() => undefined);
 await closeAllMcp().catch(() => undefined);