mocode-ai 1.4.2 → 1.4.3

package/dist/agent/runtime-context.js

@@ -1,40 +1,134 @@
 /**
  * AgentRuntimeContext:runAgentCore 的运行时依赖注入接缝。
  *
- * 2.0 框架化第一步(Context 参数化):把 core.ts 直读的模块级单例(config / agentMode /
- * sessionId / sandboxRoot / token 校准 / notes mtime)收敛成一个显式接口。默认实现
- * defaultAgentRuntimeContext 原样绑定全局单例,行为与改造前完全一致;宿主(TUI / stdio host /
- * 子 agent / 未来多 runtime)可注入自定义实现,在同一进程内获得互不干扰的运行时视图。
- *
- * 本模块是叶子:只依赖各单例所在模块,不反向 import core.ts,依赖方向无环。
- *
- * 取舍说明:
- *  - 用方法(getter)而非裸值字段:config.model 等会被 /model 热切,方法保证每次读取取最新值,
- *    与改造前「每次直读全局」的语义一致。
- *  - jailResolve / getCurrentTurnMutationState 等涉及真实 I/O 或可变返回,保持函数形态原样透传。
- *  - 暂未覆盖 executeToolOutcome / findTool(tools registry 单例)与 checkPermission:它们属
- *    工具系统(步骤 4 抽包时处理),本轮只收敛 agent 运行时自身的单例。
+ * 独立 runtime 通过 createAgentRuntimeContext 装配自己的 config、工具表、模型 transport、
+ * mode 与 sandbox scope；默认上下文则继续显式绑定进程级单例，保持现有 TUI/host 行为。
+ * 本模块不 import builtins：默认工具包只从 defaultToolRuntime.builtinTools 复制，避免
+ * registry → builtins → core → runtime-context 的模块循环。
  */
-import { config, getActiveModel, extractActivePlanSection, buildSessionStateReminder } from '../config/index.js';
-import { getAgentMode, setAgentMode } from './mode.js';
-import { getCurrentSessionId } from '../session/state.js';
-import { getCurrentTurnId, getCurrentTurnMutationState } from '../rollback/index.js';
-import { getNotesMtime } from '../session/notes.js';
-import { jailResolve } from '../sandbox/index.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { resolve } from 'node:path';
+import { buildSessionStateReminder, config, createConfigSnapshot, extractActivePlanSection, getActiveModel, } from '../config/index.js';
 import { getTokenCalibration, updateTokenCalibration } from '../context/token-calibration.js';
+import { chat, createChatClientState, createChatTransport, } from '../llm/index.js';
+import { checkPermission, createPermissionChecker } from '../permissions/index.js';
+import { defaultRollbackStore, RollbackStore, withRollbackStore, } from '../rollback/index.js';
+import { getSandboxRoot, jailResolve, withSandboxRoot } from '../sandbox/index.js';
+import { getNotesMtime } from '../session/notes.js';
+import { defaultSessionStore, SessionStore, withSessionStore } from '../session/store.js';
 import { safeProviderId } from '../session/trace-sanitize.js';
+import { defaultToolRuntime, ToolRuntime } from '../tools/registry.js';
+import { getAgentMode, setAgentMode } from './mode.js';
+const activeRuntimeContexts = new AsyncLocalStorage();
+/** 当前异步 agent 树绑定的 RuntimeContext；编排工具据此让子 agent 继承父 runtime。 */
+export function getActiveAgentRuntimeContext() {
+    return activeRuntimeContexts.getStore();
+}
+/** 仅由 agent composition root 调用；嵌套异步任务自动继承且并发树互不污染。 */
+export function withAgentRuntimeContext(runtimeContext, run) {
+    return activeRuntimeContexts.run(runtimeContext, run);
+}
+/**
+ * 创建一个基础独立 runtime。构造过程不读取 env/config 文件，不加载 builtins 模块，
+ * 也不修改全局 mode、sandbox root、工具表或模型客户端。
+ */
+export function createAgentRuntimeContext(init = {}) {
+    if (init.toolRuntime && init.tools) {
+        throw new TypeError('toolRuntime and tools are mutually exclusive');
+    }
+    const runtimeConfig = createConfigSnapshot(init.configOverrides, init.config ?? config);
+    const runtimeSandboxRoot = resolve(init.sandboxRoot ?? runtimeConfig.sandboxRoot ?? getSandboxRoot() ?? process.cwd());
+    const hasExplicitSessionsRoot = init.config !== undefined || init.configOverrides?.sessionDir !== undefined;
+    const runtimeSessionsRoot = hasExplicitSessionsRoot
+        ? runtimeConfig.sessionDir
+        : resolve(runtimeSandboxRoot, '.mocode', 'sessions');
+    if (!hasExplicitSessionsRoot)
+        runtimeConfig.sessionDir = runtimeSessionsRoot;
+    const services = init.services ?? {};
+    const runtimeGetActiveModel = services.getActiveModel ?? (() => runtimeConfig.model);
+    const runtimeSessionStore = init.sessionStore ??
+        new SessionStore({
+            sessionsRoot: runtimeSessionsRoot,
+            workspaceRoot: runtimeSandboxRoot,
+            getModel: runtimeGetActiveModel,
+        });
+    const runtimeRollbackStore = init.rollbackStore ?? new RollbackStore(runtimeSandboxRoot, runtimeSessionStore.sessionsRoot);
+    const runtimeToolRuntime = init.toolRuntime ??
+        new ToolRuntime({
+            beginPathMutation: runtimeRollbackStore.beginPathMutation.bind(runtimeRollbackStore),
+            endPathMutation: runtimeRollbackStore.endPathMutation.bind(runtimeRollbackStore),
+            beginWorkspaceMutation: runtimeRollbackStore.beginWorkspaceMutation.bind(runtimeRollbackStore),
+            endWorkspaceMutation: runtimeRollbackStore.endWorkspaceMutation.bind(runtimeRollbackStore),
+            getCurrentTurnMutationState: runtimeRollbackStore.getCurrentTurnMutationState.bind(runtimeRollbackStore),
+        });
+    if (!init.toolRuntime) {
+        runtimeToolRuntime.installBuiltinTools([...(init.tools ?? defaultToolRuntime.builtinTools)]);
+    }
+    let runtimeMode = init.initialMode ?? 'auto';
+    const localGetAgentMode = () => runtimeMode;
+    const localSetAgentMode = (mode) => {
+        const previous = runtimeMode;
+        runtimeMode = mode;
+        return previous;
+    };
+    const runtimeModelTransport = init.modelTransport ??
+        createChatTransport({
+            config: runtimeConfig,
+            getModel: runtimeGetActiveModel,
+            clientState: createChatClientState(runtimeConfig, init.modelClientOverrides),
+        });
+    return {
+        config: runtimeConfig,
+        toolRuntime: runtimeToolRuntime,
+        modelTransport: runtimeModelTransport,
+        sessionStore: runtimeSessionStore,
+        rollbackStore: runtimeRollbackStore,
+        sandboxRoot: runtimeSandboxRoot,
+        runInScope: (fn) => withSessionStore(runtimeSessionStore, () => withRollbackStore(runtimeRollbackStore, () => withSandboxRoot(runtimeSandboxRoot, fn))),
+        checkPermission: services.checkPermission ?? createPermissionChecker(runtimeConfig, runtimeSandboxRoot),
+        getActiveModel: runtimeGetActiveModel,
+        getAgentMode: services.getAgentMode ?? localGetAgentMode,
+        setAgentMode: services.setAgentMode ?? localSetAgentMode,
+        beginTurn: services.beginTurn ?? runtimeRollbackStore.beginTurn.bind(runtimeRollbackStore),
+        getCurrentSessionId: services.getCurrentSessionId ?? runtimeSessionStore.getCurrentSessionId.bind(runtimeSessionStore),
+        getCurrentTurnId: services.getCurrentTurnId ?? runtimeRollbackStore.getCurrentTurnId.bind(runtimeRollbackStore),
+        getCurrentTurnMutationState: services.getCurrentTurnMutationState ??
+            runtimeRollbackStore.getCurrentTurnMutationState.bind(runtimeRollbackStore),
+        buildSessionStateReminder: services.buildSessionStateReminder ??
+            (() => buildSessionStateReminder(runtimeSessionStore.getCurrentSessionId())),
+        extractActivePlanSection: services.extractActivePlanSection ?? (() => extractActivePlanSection(runtimeSessionStore.getCurrentSessionId())),
+        getNotesMtime: services.getNotesMtime ?? (() => getNotesMtime(runtimeSessionStore.getCurrentSessionId())),
+        jailResolve: services.jailResolve ?? jailResolve,
+        getTokenCalibration: services.getTokenCalibration ?? getTokenCalibration,
+        updateTokenCalibration: services.updateTokenCalibration ?? updateTokenCalibration,
+        safeProviderId: services.safeProviderId ?? safeProviderId,
+    };
+}
+function currentGlobalSandboxRoot() {
+    return resolve(getSandboxRoot() ?? config.sandboxRoot ?? process.cwd());
+}
 /**
- * 默认运行时上下文:原样绑定全局单例,与改造前 runAgentCore 的直读行为完全一致。
- * 每个方法都是对应单例函数的透传;config 是同一对象引用(字段读取热生效)。
+ * 默认运行时上下文：显式绑定全部旧全局单例。sandboxRoot 使用 getter，确保 REPL 在模块加载后
+ * 调用 setSandboxRoot 仍能即时生效；runInScope 在每次调用时捕获当前全局根。
  */
 export const defaultAgentRuntimeContext = {
     config,
+    toolRuntime: defaultToolRuntime,
+    modelTransport: chat,
+    sessionStore: defaultSessionStore,
+    rollbackStore: defaultRollbackStore,
+    get sandboxRoot() {
+        return currentGlobalSandboxRoot();
+    },
+    runInScope: (fn) => withSessionStore(defaultSessionStore, () => withRollbackStore(defaultRollbackStore, () => withSandboxRoot(currentGlobalSandboxRoot(), fn))),
+    checkPermission,
     getActiveModel,
     getAgentMode,
     setAgentMode,
-    getCurrentSessionId,
-    getCurrentTurnId,
-    getCurrentTurnMutationState,
+    beginTurn: defaultRollbackStore.beginTurn.bind(defaultRollbackStore),
+    getCurrentSessionId: defaultSessionStore.getCurrentSessionId.bind(defaultSessionStore),
+    getCurrentTurnId: defaultRollbackStore.getCurrentTurnId.bind(defaultRollbackStore),
+    getCurrentTurnMutationState: defaultRollbackStore.getCurrentTurnMutationState.bind(defaultRollbackStore),
     buildSessionStateReminder,
     extractActivePlanSection,
     getNotesMtime,

package/dist/agent/spawn.js

@@ -10,8 +10,7 @@
 //  - 主屏渲染可选:TUI 激活时把子 agent 内部工具调用实时写入主内容区并复用 batch 折叠;
 //    TUI 未激活(host 嵌入 / 非 TTY)时纯静默,中间过程只缓冲进 transcript。
 //  - 独立 history 分支:子任务的工具噪声不回灌主对话,只有最终摘要回灌。
-import { chatTools } from '../llm/index.js';
-import { buildMocodeCorePrompt, config, isSubAgentHardDisabled } from '../config/index.js';
+import { buildMocodeCorePrompt, isSubAgentHardDisabled } from '../config/index.js';
 import { getToolChatSchema } from '../tools/policy.js';
 import { effectiveSystemPrompt } from '../skills/index.js';
 import { ui } from '../ui/theme.js';
@@ -19,10 +18,11 @@ import * as layout from '../ui/layout.js';
 import { isTuiActive } from '../ui/layout.js';
 import * as batch from '../ui/batch.js';
 import { isToolErrorOutput } from '../tools/result.js';
-import { runAgentCore } from './core.js';
+import { createRuntime, getActiveRuntime } from '../runtime/index.js';
 import { summarizeToolCall, summarizeToolResult, truncateDisplay } from '../ui/render.js';
 import { t } from '../i18n/index.js';
 import { createContextState } from '../session/compact.js';
+import { defaultAgentRuntimeContext, getActiveAgentRuntimeContext, } from './runtime-context.js';
 /** 子 agent 系统提示后缀(仅 legacy 直接调用路径用;共享前缀路径的系统提示直接复用父 agent)。 */
 const SUBAGENT_SUFFIX = `
 
@@ -48,6 +48,9 @@ You are executing one delegated sub-task with the same engineering standards and
  * 子 agent 跑在主 signal 下,主 abort 即子 abort;子 agent 的 abortRestore 还原子 history + 模式。
  */
 export async function spawnAgent(opts) {
+    const activeRuntime = opts.runtime ?? getActiveRuntime();
+    const runtimeContext = opts.runtimeContext ?? activeRuntime?.context ?? getActiveAgentRuntimeContext() ?? defaultAgentRuntimeContext;
+    const runtime = activeRuntime?.context === runtimeContext ? activeRuntime : createRuntime({ context: runtimeContext });
     if (isSubAgentHardDisabled()) {
         return {
             summary: null,
@@ -57,7 +60,7 @@ export async function spawnAgent(opts) {
             usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0, reasoningTokens: 0 },
         };
     }
-    const maxSteps = opts.maxSteps ?? config.subAgentMaxSteps;
+    const maxSteps = opts.maxSteps ?? runtimeContext.config.subAgentMaxSteps;
     const requested = opts.tools === undefined ? null : new Set(opts.tools);
     const shared = opts.delegation && opts.delegation.history.length > 0 && opts.delegation.history[0]?.role === 'system'
         ? opts.delegation
@@ -108,10 +111,10 @@ export async function spawnAgent(opts) {
         // chatTools 为 baseline；显式 tools:[] 必须保持零工具，不能误当成"未限制"。
         const parentNames = opts.parentAllowedToolNames
             ? [...new Set(opts.parentAllowedToolNames)]
-            : chatTools.map((tool) => tool.function.name);
+            : runtimeContext.toolRuntime.tools.map((tool) => tool.name);
         const effectiveNames = parentNames.filter((name) => !requested || requested.has(name));
         toolsOverride = effectiveNames.flatMap((name) => {
-            const schema = getToolChatSchema(name);
+            const schema = getToolChatSchema(name, runtimeContext.toolRuntime.tools);
             return schema ? [schema] : [];
         });
         runtimeAllowedToolNames = new Set(toolsOverride.map((tool) => tool.function.name));
@@ -282,7 +285,8 @@ export async function spawnAgent(opts) {
     // 与主 agent 完全同源:写操作直接落在工作区,进入主 agent 当前轮次的同一回滚事务
     // (spawn 不调 beginTurn)。没有 overlay 拷贝/ChangeSet 合并这一步——那是旧 read/write
     // 双模式的产物,子 agent 不再受限,也就不需要"先隔离再合并"。
-    const result = await runAgentCore({
+    const result = await runtime.run({
+        turn: 'inherit',
         history,
         userInput,
         signal: opts.signal,

package/dist/agent/stages/context-trimmer.js

@@ -0,0 +1,63 @@
+import { maybeCompact } from '../../session/index.js';
+import { defaultCompactionRuntime } from '../../session/compact.js';
+class LegacyCompatibleContextTrimmer {
+    implementation;
+    init;
+    constructor(implementation, init) {
+        this.implementation = implementation;
+        this.init = init;
+    }
+    async trim(request) {
+        if (request.mode === 'scheduled')
+            return this.trimScheduled(request);
+        const result = await this.init.historyManager.withLegacyMutableHistory((history) => maybeCompact(history, undefined, request.mode === 'overflow' ? { manual: true, force: true } : undefined, this.init.contextState, request.tools, request.signal, this.init.runtime ?? defaultCompactionRuntime));
+        if (!result)
+            return { kind: 'none', stats: {} };
+        const stats = {
+            reason: result.reason,
+            compacted: result.compacted,
+            estimateBefore: result.estimateBefore,
+            estimateAfter: result.estimateAfter,
+        };
+        if (result.historyRebuilt) {
+            return { kind: 'rebuild', history: this.compactedHistory(), stats };
+        }
+        return { kind: result.compacted ? 'content' : 'none', stats };
+    }
+    async trimScheduled(request) {
+        const scheduler = this.init.scheduler;
+        if (!scheduler)
+            throw new Error('Scheduled context trim requires a budget scheduler.');
+        await this.init.historyManager.withLegacyMutableHistory((history) => scheduler.runStep(history, request.step, request.tools, request.ephemeralTokens, request.signal));
+        const log = scheduler.lastRunLog;
+        const stats = {
+            reason: log?.compactHistoryCalled ? 'scheduled' : undefined,
+            compactHistoryCalled: log?.compactHistoryCalled,
+            estimateBefore: log?.report.total,
+            estimateAfter: log?.pressure.after,
+        };
+        if (log?.historyMutation === 'rebuild') {
+            return { kind: 'rebuild', history: this.compactedHistory(), stats };
+        }
+        return { kind: log?.historyMutation === 'content' ? 'content' : 'none', stats };
+    }
+    compactedHistory() {
+        return { messages: this.init.historyManager.snapshot().messages };
+    }
+}
+class LegacyContextTrimmer extends LegacyCompatibleContextTrimmer {
+    constructor(init) {
+        super('legacy', init);
+    }
+}
+class StagedContextTrimmer extends LegacyCompatibleContextTrimmer {
+    constructor(init) {
+        super('staged', init);
+    }
+}
+export function createLegacyContextTrimmer(init) {
+    return new LegacyContextTrimmer(init);
+}
+export function createStagedContextTrimmer(init) {
+    return new StagedContextTrimmer(init);
+}

package/dist/agent/stages/contracts.js

@@ -0,0 +1,12 @@
+/** Stable stage identities used by assembly and per-stage rollback. */
+export const AGENT_STAGE_NAMES = [
+    'history',
+    'model',
+    'tools',
+    'context',
+    'trace',
+    'usage',
+    'cancellation',
+    'termination',
+    'capabilities',
+];

package/dist/agent/stages/history-manager.js

@@ -0,0 +1,178 @@
+function replaceMessages(backing, messages) {
+    const replacement = messages.slice();
+    backing.length = 0;
+    backing.push(...replacement);
+}
+function assistantMessage(turn) {
+    const message = {
+        role: 'assistant',
+        content: turn.content,
+    };
+    if (turn.toolCalls.length > 0) {
+        message.tool_calls = turn.toolCalls.map((call) => ({
+            id: call.id,
+            type: 'function',
+            function: { name: call.name, arguments: call.arguments },
+        }));
+    }
+    return message;
+}
+function validateCalls(calls) {
+    const seen = new Set();
+    for (const call of calls) {
+        if (!call.id)
+            throw new Error('History tool batch contains an empty tool_call id.');
+        if (seen.has(call.id))
+            throw new Error(`History tool batch contains duplicate tool_call id: ${call.id}.`);
+        seen.add(call.id);
+    }
+}
+function validateAssistantBatch(backing, calls) {
+    const message = backing.at(-1);
+    if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls)) {
+        throw new Error('History tool batch must follow an assistant tool_calls message.');
+    }
+    if (message.tool_calls.length !== calls.length) {
+        throw new Error(`History assistant declared ${message.tool_calls.length} tool call(s), transaction received ${calls.length}.`);
+    }
+    for (let index = 0; index < calls.length; index++) {
+        const actual = message.tool_calls[index];
+        const expected = calls[index];
+        if (actual.id !== expected.id ||
+            actual.function?.name !== expected.name ||
+            actual.function?.arguments !== expected.arguments) {
+            throw new Error(`History tool batch call ${index} does not match the preceding assistant message.`);
+        }
+    }
+}
+function validateToolResults(calls, messages, resultStartIndex) {
+    const results = messages.slice(resultStartIndex);
+    if (results.length !== calls.length) {
+        throw new Error(`History tool batch expected ${calls.length} result(s), received ${results.length}.`);
+    }
+    const seen = new Set();
+    for (let index = 0; index < calls.length; index++) {
+        const message = results[index];
+        if (message.role !== 'tool') {
+            throw new Error(`History tool batch result ${index} must be a tool message.`);
+        }
+        const actualId = message.tool_call_id ?? '';
+        const expectedId = calls[index].id;
+        if (seen.has(actualId)) {
+            throw new Error(`History tool batch contains duplicate result id: ${actualId || '<empty>'}.`);
+        }
+        seen.add(actualId);
+        if (actualId !== expectedId) {
+            throw new Error(`History tool batch result ${index} expected id ${expectedId}, received ${actualId || '<empty>'}.`);
+        }
+    }
+}
+function validateAttachment(attachment) {
+    if (attachment && attachment.role !== 'user') {
+        throw new Error('History tool batch attachment must be a user message.');
+    }
+}
+class DefaultHistoryManager {
+    backing;
+    options;
+    revision = 0;
+    activeBatch = false;
+    activeBatchRollback;
+    constructor(backing, options) {
+        this.backing = backing;
+        this.options = options;
+    }
+    snapshot() {
+        return { revision: this.revision, messages: this.backing.slice() };
+    }
+    appendUserTurn(content) {
+        this.assertNoActiveBatch('append a user turn');
+        this.backing.push({ role: 'user', content });
+        this.revision++;
+    }
+    appendAssistantTurn(turn) {
+        this.assertNoActiveBatch('append an assistant turn');
+        if (turn.toolCalls.length > 0)
+            validateCalls(turn.toolCalls);
+        this.backing.push(assistantMessage(turn));
+        this.revision++;
+    }
+    beginToolBatch(calls) {
+        this.assertNoActiveBatch('begin another tool batch');
+        validateCalls(calls);
+        validateAssistantBatch(this.backing, calls);
+        this.activeBatch = true;
+        const resultStartIndex = this.backing.length;
+        const workingMessages = this.options.stagedToolBatches ? this.backing.slice() : this.backing;
+        let settled = false;
+        const settle = () => {
+            settled = true;
+            this.activeBatch = false;
+            this.activeBatchRollback = undefined;
+        };
+        const rollback = () => {
+            if (settled)
+                return;
+            // staged has only a shadow to discard; legacy deliberately leaves its direct working view unchanged.
+            settle();
+        };
+        this.activeBatchRollback = rollback;
+        return {
+            workingMessages,
+            commit: (attachment) => {
+                if (settled)
+                    throw new Error('History tool batch transaction is already settled.');
+                try {
+                    validateAttachment(attachment);
+                    validateToolResults(calls, workingMessages, resultStartIndex);
+                    if (this.options.stagedToolBatches) {
+                        this.backing.push(...workingMessages.slice(resultStartIndex));
+                    }
+                    if (attachment)
+                        this.backing.push(attachment);
+                    this.revision++;
+                    settle();
+                }
+                catch (error) {
+                    // Validation is pre-publication in staged mode. Legacy keeps its direct-view failure state for rollback parity.
+                    settle();
+                    throw error;
+                }
+            },
+            rollback,
+        };
+    }
+    replaceAfterCompaction(result) {
+        this.assertNoActiveBatch('replace history after compaction');
+        replaceMessages(this.backing, result.messages);
+        this.revision++;
+    }
+    createCheckpoint() {
+        return { revision: this.revision, messages: this.backing.slice() };
+    }
+    restore(checkpoint) {
+        this.activeBatchRollback?.();
+        replaceMessages(this.backing, checkpoint.messages);
+        this.revision++;
+    }
+    async withLegacyMutableHistory(operation) {
+        this.assertNoActiveBatch('run a legacy history mutation');
+        try {
+            return await operation(this.backing);
+        }
+        finally {
+            // The bridge deliberately assumes mutation: compact may rewrite message content without changing array shape.
+            this.revision++;
+        }
+    }
+    assertNoActiveBatch(action) {
+        if (this.activeBatch)
+            throw new Error(`Cannot ${action} while a history tool batch is active.`);
+    }
+}
+export function createLegacyHistoryManager(input) {
+    return new DefaultHistoryManager(input.messages, { stagedToolBatches: false });
+}
+export function createStagedHistoryManager(input) {
+    return new DefaultHistoryManager(input.messages, { stagedToolBatches: true });
+}

package/dist/agent/stages/legacy-adapters.js

@@ -0,0 +1,19 @@
+import { AGENT_STAGE_NAMES, } from './contracts.js';
+/**
+ * Untouched stages keep every business rule inside the existing coordinator. These adapters are explicit rollback
+ * boundaries, not fake partial implementations of HistoryManager/ToolDispatcher/etc. Each migration stage replaces
+ * one descriptor with a real port while the remaining stages continue through the same legacy coordinator.
+ */
+export function createLegacyStageAdapters(overrides = {}) {
+    return Object.freeze(Object.fromEntries(AGENT_STAGE_NAMES.map((name) => [
+        name,
+        Object.freeze({ name, implementation: overrides[name] ?? 'legacy' }),
+    ])));
+}
+/** One adapter per run: state and future staged replacements must never leak across agent runs. */
+export function createLegacyCoordinatorAdapter(coordinator) {
+    return Object.freeze({
+        implementation: 'legacy',
+        run: (options, historyManager, stages) => coordinator(options, historyManager, stages),
+    });
+}

package/dist/agent/stages/model-runner.js

@@ -0,0 +1,29 @@
+import { chat } from '../../llm/index.js';
+class ChatModelRunner {
+    implementation;
+    transport;
+    constructor(implementation, transport) {
+        this.implementation = implementation;
+        this.transport = transport;
+    }
+    run(request, signal) {
+        return this.transport(request.history.slice(), request.handlers, signal, request.tools.slice());
+    }
+}
+class LegacyChatModelRunner extends ChatModelRunner {
+    constructor(transport) {
+        super('legacy', transport);
+    }
+}
+class StagedChatModelRunner extends ChatModelRunner {
+    constructor(transport) {
+        super('staged', transport);
+    }
+}
+/** Legacy and staged bindings are separate rollback seams over the same frozen single-call transport contract. */
+export function createLegacyModelRunner(transport = chat) {
+    return new LegacyChatModelRunner(transport);
+}
+export function createStagedModelRunner(transport = chat) {
+    return new StagedChatModelRunner(transport);
+}

package/dist/agent/stages/run-policy.js

@@ -0,0 +1,73 @@
+class DefaultCapabilityResolver {
+    implementation;
+    constructor(implementation) {
+        this.implementation = implementation;
+    }
+    resolve(request) {
+        const configured = request.toolsOverride ?? request.toolPolicy?.tools ?? request.defaultTools;
+        const bounded = request.runtimeAllowedToolNames
+            ? configured.filter((tool) => request.runtimeAllowedToolNames?.has(tool.function.name))
+            : configured.slice();
+        const legacyDisabled = request.useLegacyDisabledFallback ? request.legacyDisabledToolNames : new Set();
+        const tools = bounded.filter((tool) => !request.skillDisabledToolNames.has(tool.function.name) && !legacyDisabled.has(tool.function.name));
+        return Object.freeze({
+            mode: request.mode,
+            tools: Object.freeze(tools),
+            allowedToolNames: new Set(tools.map((tool) => tool.function.name)),
+            ...(request.toolPolicy ? { toolPolicy: request.toolPolicy } : {}),
+            reminder: request.reminder,
+        });
+    }
+}
+class PhaseAwareTerminationPolicy {
+    implementation;
+    constructor(implementation) {
+        this.implementation = implementation;
+    }
+    decide(input) {
+        if (input.phase === 'step_start')
+            return input.aborted ? { kind: 'aborted' } : { kind: 'continue' };
+        if (input.phase === 'model_result') {
+            if (!input.modelResult)
+                throw new Error('model_result termination requires a model result.');
+            return input.modelResult.toolCalls.length === 0
+                ? { kind: 'completed', finalText: input.modelResult.content }
+                : { kind: 'continue' };
+        }
+        if (input.phase === 'tool_batch_committed')
+            return { kind: 'continue' };
+        return { kind: 'max_steps' };
+    }
+}
+class LegacyCapabilityResolver extends DefaultCapabilityResolver {
+    constructor() {
+        super('legacy');
+    }
+}
+class StagedCapabilityResolver extends DefaultCapabilityResolver {
+    constructor() {
+        super('staged');
+    }
+}
+class LegacyTerminationPolicy extends PhaseAwareTerminationPolicy {
+    constructor() {
+        super('legacy');
+    }
+}
+class StagedTerminationPolicy extends PhaseAwareTerminationPolicy {
+    constructor() {
+        super('staged');
+    }
+}
+export function createLegacyCapabilityResolver() {
+    return new LegacyCapabilityResolver();
+}
+export function createStagedCapabilityResolver() {
+    return new StagedCapabilityResolver();
+}
+export function createLegacyTerminationPolicy() {
+    return new LegacyTerminationPolicy();
+}
+export function createStagedTerminationPolicy() {
+    return new StagedTerminationPolicy();
+}