evolcore 0.0.1 → 0.0.2

package/dist/paths.js

@@ -0,0 +1,262 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { DAEMON_CONFIG_FILENAME, DEFAULT_RUNTIME_HOME_DIRNAME, INSTANCE_SOCKET_FILENAME, RUNTIME_HOME_ENV, WINDOWS_PIPE_PREFIX, } from './product.js';
+const isWindows = process.platform === 'win32';
+let _root = null;
+export function resolveRoot() {
+    if (_root)
+        return _root;
+    if (process.env[RUNTIME_HOME_ENV]) {
+        _root = process.env[RUNTIME_HOME_ENV];
+    }
+    else if (fs.existsSync(path.join(process.cwd(), 'agents', 'defaults.json'))) {
+        _root = process.cwd();
+    }
+    else {
+        _root = path.join(os.homedir(), DEFAULT_RUNTIME_HOME_DIRNAME);
+    }
+    return _root;
+}
+/** 重置缓存（仅供测试使用） */
+export function _resetRoot() {
+    _root = null;
+}
+export function resolvePaths() {
+    const root = resolveRoot();
+    return {
+        root,
+        sessionsDir: path.join(root, 'data', 'sessions'),
+        instanceDir: path.join(root, 'data', 'instance'),
+        outboxDir: path.join(root, 'data', 'outbox'),
+        dataDir: path.join(root, 'data'),
+        claudeModelCache: path.join(root, 'data', 'claude-model-cache.json'),
+        logs: path.join(root, 'logs'),
+        agentsDir: path.join(root, 'agents'),
+        lineStats: path.join(root, 'logs', 'line-stats.log'),
+        readySignal: path.join(root, 'data', 'instance', 'ready.signal'),
+        controlToken: path.join(root, 'data', 'instance', 'control.token'),
+        selfHealLog: path.join(root, 'logs', 'self-heal.md'),
+        socket: resolveInstanceSocketPath(root),
+        // ── daemon/process 配置与 ECK ─────────────────────────────
+        defaultsConfig: path.join(root, 'agents', 'defaults.json'),
+        daemonConfig: path.join(root, DAEMON_CONFIG_FILENAME),
+        eckDir: path.join(root, 'eck'),
+        instanceReadySignal: path.join(root, 'data', 'instance', 'ready.signal'),
+        instanceSocket: resolveInstanceSocketPath(root),
+        aidLogsDir: path.join(root, 'logs', 'aids'),
+        // ── 配置快照体系（config-system-design-v2.md §八/§九）──────
+        configBackupsDir: path.join(root, 'backups', 'config'),
+        configCurrentPointer: path.join(root, 'backups', 'config', 'current.json'),
+        configWVersion: path.join(root, 'backups', 'config', 'w-version.json'),
+        configBootLog: path.join(root, 'backups', 'config', 'boot-log.jsonl'),
+        configBootLogArchiveDir: path.join(root, 'backups', 'config', 'boot-log-archive'),
+    };
+}
+// per-agent relation 路径
+export function agentRelationConfig(aid, peerKey) {
+    return path.join(resolveRoot(), 'agents', aid, 'relations', peerKey, 'config.json');
+}
+// ── AID 路径（agent.md 存放在 $EVOLCORE_HOME/AIDs/<aid>/）──
+/**
+ * AUN SDK 数据根路径（密钥/证书/AgentMDs 等）。
+ * 与 evolcore 数据共用 $EVOLCORE_HOME 根，避免散落到 ~/.aun。
+ * 启动时 SDK 通过 aun_path 选项指向这里；agent.md 子目录通过 setAgentMdPath(aidsDir()) 单独设置。
+ */
+export function aunPath() {
+    return resolveRoot();
+}
+export function aidsDir() {
+    return path.join(resolveRoot(), 'AIDs');
+}
+export function aidLocalDir(aid) {
+    return path.join(resolveRoot(), 'AIDs', aid);
+}
+export function agentMdPath(aid) {
+    return path.join(resolveRoot(), 'AIDs', aid, 'agent.md');
+}
+// ── per-agent 路径（参数化，不进 resolvePaths() 的固定 map）──
+export function agentDir(aid) {
+    return path.join(resolveRoot(), 'agents', aid);
+}
+export function agentConfig(aid) {
+    return path.join(agentDir(aid), 'config.json');
+}
+export function agentContactConfig(aid) {
+    return path.join(agentDir(aid), 'contact.json');
+}
+export function agentPersonalDir(aid) {
+    return path.join(agentDir(aid), 'personal');
+}
+export function agentRolesDir(aid) {
+    return path.join(agentDir(aid), 'roles');
+}
+export function agentRolesIndex(aid) {
+    return path.join(agentRolesDir(aid), 'index.json');
+}
+export function agentRoleConfig(aid, roleId) {
+    return path.join(agentRolesDir(aid), `${roleId}.json`);
+}
+export function agentRelationsDir(aid) {
+    return path.join(agentDir(aid), 'relations');
+}
+/** @deprecated Use agentRelationsDir instead */
+export function agentIdentitiesDir(aid) {
+    return agentRelationsDir(aid);
+}
+export function agentIndexDir(aid) {
+    return path.join(agentDir(aid), 'index');
+}
+export function agentVenuesDir(aid) {
+    return path.join(agentDir(aid), 'venues');
+}
+export function agentSessionsDir(aid) {
+    return path.join(agentDir(aid), 'sessions');
+}
+export function agentLogsDir(aid) {
+    return path.join(agentDir(aid), 'logs');
+}
+export function agentDataDir(aid) {
+    return path.join(agentDir(aid), 'data');
+}
+export function agentDataCacheDir(aid) {
+    return path.join(agentDataDir(aid), 'cache');
+}
+export function agentTriggersDir(aid) {
+    return path.join(resolveRoot(), 'data', 'triggers', aid);
+}
+function resolveInstanceSocketPath(root) {
+    if (isWindows) {
+        const hash = crypto.createHash('sha1').update(root).digest('hex').slice(0, 12);
+        return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-${hash}`;
+    }
+    return path.join(root, 'data', 'instance', INSTANCE_SOCKET_FILENAME);
+}
+export function ensureDataDirs() {
+    const p = resolvePaths();
+    fs.mkdirSync(p.dataDir, { recursive: true });
+    fs.mkdirSync(p.logs, { recursive: true });
+    fs.mkdirSync(p.aidLogsDir, { recursive: true });
+    fs.mkdirSync(p.agentsDir, { recursive: true });
+    fs.mkdirSync(p.sessionsDir, { recursive: true });
+    fs.mkdirSync(p.instanceDir, { recursive: true });
+    fs.mkdirSync(p.outboxDir, { recursive: true });
+    fs.mkdirSync(p.eckDir, { recursive: true });
+    fs.mkdirSync(aidsDir(), { recursive: true });
+    seedConfigTemplates();
+    migrateFromAun();
+}
+const MIGRATION_MARKER = '.migrated-from-aun';
+/**
+ * 一次性迁移：把 ~/.aun 下的 SDK 数据搬到 $EVOLCORE_HOME 下。
+ * 通过标记文件判断是否已迁移，完成后写入标记，后续版本可删除此函数。
+ */
+function migrateFromAun() {
+    const newRoot = resolveRoot();
+    const markerPath = path.join(newRoot, MIGRATION_MARKER);
+    if (fs.existsSync(markerPath))
+        return;
+    const oldRoot = path.join(os.homedir(), '.aun');
+    if (!fs.existsSync(oldRoot) || oldRoot === newRoot) {
+        try {
+            fs.writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+        }
+        catch { }
+        return;
+    }
+    const copyFileIfMissing = (src, dst) => {
+        if (!fs.existsSync(src) || fs.existsSync(dst))
+            return;
+        fs.mkdirSync(path.dirname(dst), { recursive: true });
+        fs.copyFileSync(src, dst);
+    };
+    const copyDirIfMissing = (src, dst) => {
+        if (!fs.existsSync(src))
+            return;
+        if (!fs.statSync(src).isDirectory())
+            return;
+        for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+            const s = path.join(src, entry.name);
+            const d = path.join(dst, entry.name);
+            if (entry.isDirectory()) {
+                copyDirIfMissing(s, d);
+            }
+            else if (entry.isFile()) {
+                copyFileIfMissing(s, d);
+            }
+        }
+    };
+    try {
+        const oldAids = path.join(oldRoot, 'AIDs');
+        const newAids = aidsDir();
+        if (fs.existsSync(oldAids)) {
+            for (const entry of fs.readdirSync(oldAids, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                copyDirIfMissing(path.join(oldAids, entry.name), path.join(newAids, entry.name));
+            }
+        }
+        copyDirIfMissing(path.join(oldRoot, 'CA'), path.join(newRoot, 'CA'));
+        for (const f of ['.seed', '.device_id']) {
+            copyFileIfMissing(path.join(oldRoot, f), path.join(newRoot, f));
+        }
+    }
+    catch { /* best-effort */ }
+    try {
+        fs.writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+    }
+    catch { }
+}
+/**
+ * 首次运行时从 assets/ 模板拷贝 .env 到 $EVOLCORE_HOME。
+ * 已存在则跳过，不覆盖用户修改。
+ */
+function seedConfigTemplates() {
+    const root = resolveRoot();
+    const assetsDir = path.join(getPackageRoot(), 'assets');
+    const templates = [
+        { src: '.env.template', dst: '.env' },
+    ];
+    for (const { src, dst } of templates) {
+        const dstPath = path.join(root, dst);
+        if (fs.existsSync(dstPath))
+            continue;
+        const srcPath = path.join(assetsDir, src);
+        if (!fs.existsSync(srcPath))
+            continue;
+        try {
+            fs.copyFileSync(srcPath, dstPath);
+        }
+        catch { /* best-effort */ }
+    }
+}
+// ── kits 路径（始终从包内读取，不复制到 EVOLCORE_HOME）──
+export function kitsDir() {
+    return path.join(getPackageRoot(), 'kits');
+}
+export function kitsRulesDir() {
+    return path.join(getPackageRoot(), 'kits', 'rules');
+}
+export function kitsDocsDir() {
+    return path.join(getPackageRoot(), 'kits', 'docs');
+}
+export function kitsTemplatesDir() {
+    return path.join(getPackageRoot(), 'kits', 'templates');
+}
+export function kitsRoleTemplatesDir() {
+    return path.join(kitsTemplatesDir(), 'roles');
+}
+export function kitsSchemasDir() {
+    return path.join(getPackageRoot(), 'kits', 'schemas');
+}
+// ── Role System ──
+// ── 调试输出 ──
+export function eckDebugDir() {
+    return path.join(resolveRoot(), 'data', 'eck-debug');
+}
+export function getPackageRoot() {
+    // import.meta.dirname is available in Node.js 21.2+ and always returns
+    // the correct OS-native path, regardless of Git Bash or MSYS2 environment.
+    return path.resolve(import.meta.dirname, '..');
+}

package/dist/product.js

@@ -0,0 +1,18 @@
+/**
+ * Product/runtime naming boundary.
+ *
+ * Keep externally visible names here so the final EvolCore cutover is a
+ * deliberate constant flip instead of another repository-wide hunt.
+ */
+export const PRODUCT_DISPLAY_NAME = 'EvolCore';
+export const MAIN_PACKAGE_NAME = 'evolcore';
+export const MAIN_CLI_BIN = 'ec';
+export const WEB_PACKAGE_NAME = 'ec-web';
+export const WEB_CLI_BIN = 'ec-web';
+export const WEB_PACKAGE_LATEST = `${WEB_PACKAGE_NAME}@latest`;
+export const DAEMON_CONFIG_FILENAME = 'daemon.json';
+export const DAEMON_SCHEMA_NAME = 'daemon';
+export const RUNTIME_HOME_ENV = 'EVOLCORE_HOME';
+export const DEFAULT_RUNTIME_HOME_DIRNAME = '.evolcore';
+export const INSTANCE_SOCKET_FILENAME = 'daemon.sock';
+export const WINDOWS_PIPE_PREFIX = 'daemon';

package/dist/response-system/context-builder.js

@@ -0,0 +1,71 @@
+/**
+ * Response Mode Context Builder
+ *
+ * 构造 ResponseModeContext —— 响应模式的依赖注入容器。
+ *
+ * 设计：
+ *   - 核心依赖（session/config/channel/logger/sessionState/dataDir）进入 initialize 时即就绪
+ *   - 扩展能力（createAuxiliarySession 等）是懒创建工厂，简单模式从不触碰
+ *   - 缓存 per-(sessionId, modeId) 的 sessionState，使同会话同模式跨消息保持状态
+ *
+ * Phase 3 范围：核心字段就绪。辅助会话/线索/工作流工厂在对应内置模式
+ * （Phase 6）真正需要时接入 Runner，当前提供明确的"未实现"占位，避免空壳代码。
+ */
+import path from 'path';
+import fs from 'fs';
+export class ResponseModeContextBuilder {
+    /** (sessionId::modeId) → sessionState，跨消息保持 */
+    stateCache = new Map();
+    /**
+     * 构造响应模式上下文。
+     * @param modeId 模式 id（用于派生 dataDir 与 sessionState 缓存键）
+     */
+    build(modeId, deps) {
+        const sessionState = this.getOrCreateState(deps.session.id, modeId);
+        const dataDir = this.ensureDataDir(deps.agentDir, modeId);
+        return {
+            session: deps.session,
+            agentConfig: deps.agentConfig,
+            modeConfig: deps.modeConfig,
+            runner: deps.runner,
+            channel: deps.channel,
+            logger: deps.logger,
+            sessionState,
+            dataDir,
+            // ─── 扩展能力工厂（懒创建） ───
+            createAuxiliarySession: async (_options) => {
+                throw new Error('[ContextBuilder] createAuxiliarySession not yet implemented (Phase 6: dual-session)');
+            },
+            // createThreadManager / createWorkflowEngine 为可选方法，
+            // 未实现的模式不会调用；需要时在 Phase 6 接入。
+        };
+    }
+    /** 清理会话状态（会话结束或切换模式时调用） */
+    clearState(sessionId, modeId) {
+        if (modeId) {
+            this.stateCache.delete(`${sessionId}::${modeId}`);
+        }
+        else {
+            // 清理该会话的所有模式状态
+            for (const key of [...this.stateCache.keys()]) {
+                if (key.startsWith(`${sessionId}::`))
+                    this.stateCache.delete(key);
+            }
+        }
+    }
+    // ─── 内部辅助 ───
+    getOrCreateState(sessionId, modeId) {
+        const key = `${sessionId}::${modeId}`;
+        let state = this.stateCache.get(key);
+        if (!state) {
+            state = new Map();
+            this.stateCache.set(key, state);
+        }
+        return state;
+    }
+    ensureDataDir(agentDir, modeId) {
+        const dir = path.join(agentDir, 'response-system', modeId);
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+}

package/dist/response-system/coordinator.js

@@ -0,0 +1,117 @@
+/**
+ * Response Mode Coordinator
+ *
+ * 响应模式系统接入消息流的中枢。把 Registry/Resolver/ContextBuilder 串起来，
+ * 为 message-processor 提供两个能力：
+ *   - resolveInbound：解析会话该用哪个模式 + 运行 handleInbound 得到决策（含 runtimeState）
+ *   - resolveOutbound：对某个出站 payload 运行 handleOutbound 得到发送决策
+ *
+ * 设计原则：
+ *   - 选模式：标量 responseMode（关系级>agent级，合并后）> 注册表首选（single-session）
+ *   - chatMode 与选模式正交：由顶层 chatmode 字典按对端类型解析后注入 modeConfig
+ *   - 模式特有参数：从 responseModeParams[modeId] 桶读取
+ *   - 响应模式成为「响应决策的源头」，下游 message-processor 的执行流程原样保留
+ *   - 异常不降级（D6）：解析/决策失败时回落到安全默认，记 WARN
+ */
+import { ResponseModeResolver } from './resolver.js';
+import { ResponseModeContextBuilder } from './context-builder.js';
+/**
+ * 从模式的 configSchema 提取特有参数出厂默认值：`properties[key].default`。
+ *
+ * 模式 schema 是模式特有参数「候选值 + 默认值」的唯一事实源（architecture §五）。
+ * 宿主组装 modeConfig 时先铺这层默认，再叠用户显式配置——默认来源收敛到 schema，
+ * flow 不再硬编码 `?? true` 之类的默认。chatMode 无 default（宿主强制注入），跳过。
+ */
+function schemaDefaults(mode) {
+    const props = mode.configSchema?.properties;
+    if (!props)
+        return {};
+    const out = {};
+    for (const [key, spec] of Object.entries(props)) {
+        if (spec && typeof spec === 'object' && 'default' in spec)
+            out[key] = spec.default;
+    }
+    return out;
+}
+export class ResponseModeCoordinator {
+    registry;
+    resolver;
+    contextBuilder = new ResponseModeContextBuilder();
+    constructor(registry) {
+        this.registry = registry;
+        this.resolver = new ResponseModeResolver(registry);
+    }
+    /**
+     * 解析会话该用哪个响应模式 + 构建 context（不调 handleInbound）。
+     * 用于消息处理阶段（_processMessageInternal）：此时消息已出队，
+     * 需要的是处理钩子（beforeProcess/configureRun/onToolUse 等），而非入队决策。
+     *
+     * @param responseModeId 合并后的标量 responseMode（关系级>agent级，可空 → 注册表首选）
+     * @param resolvedChatMode 本会话生效的 chatmode（宿主按配置层级解析后传入），
+     *        注入进模式 config.chatmode；模式据此分流投递方式。与「选哪个模式」无关。
+     * @param responseModeParams 按模式分桶的参数字典 { [modeId]: {...} }，取当前模式的桶注入
+     * @param contextDeps 构建 context 所需依赖
+     */
+    resolveMode(responseModeId, resolvedChatMode, responseModeParams, contextDeps) {
+        try {
+            const resolved = this.resolver.resolve(responseModeId);
+            const mode = resolved.mode;
+            // 模式特有参数：先铺 schema 出厂默认，再叠用户显式桶（responseModeParams[modeId]，显式值优先）；
+            // chatmode 由宿主解析后强制注入（小写，与配置层 chatmode 字典一致）。
+            const modeSpecificParams = responseModeParams?.[mode.id] ?? {};
+            const modeConfig = { ...schemaDefaults(mode), chatmode: resolvedChatMode, ...modeSpecificParams };
+            contextDeps.logger.debug('[ResponseSystem] resolveMode mode=' + mode.id + ' source=' + resolved.source + ' chatmode=' + (modeConfig.chatmode ?? 'none'));
+            const context = this.contextBuilder.build(mode.id, { ...contextDeps, modeConfig });
+            return { mode, context, source: resolved.source };
+        }
+        catch (e) {
+            contextDeps.logger.warn(`[Coordinator] resolveMode failed: ${e instanceof Error ? e.message : String(e)}`);
+            return null;
+        }
+    }
+    /**
+     * 解析会话的入站响应模式 + 运行 handleInbound。
+     *
+     * @param message 入站消息
+     * @param resolvedChatMode 本会话生效的 chatMode（宿主解析后传入）
+     */
+    async resolveInbound(message, deps, resolvedChatMode) {
+        try {
+            // 解析模式：标量 responseMode（合并后）> 注册表首选。chatMode 不参与选模式。
+            const resolved = this.resolver.resolve(deps.agentConfig.responseMode);
+            const mode = resolved.mode;
+            // 先铺 schema 出厂默认，再叠用户显式桶（显式值优先），chatmode 强制注入。
+            const modeSpecificParams = deps.agentConfig.responseModeParams?.[mode.id] ?? {};
+            const modeConfig = { ...schemaDefaults(mode), chatmode: resolvedChatMode, ...modeSpecificParams };
+            deps.contextDeps.logger.debug('[ResponseSystem] resolveInbound mode=' + mode.id + ' source=' + resolved.source + ' chatmode=' + (modeConfig.chatmode ?? 'none'));
+            const context = this.contextBuilder.build(mode.id, {
+                ...deps.contextDeps,
+                modeConfig,
+            });
+            await mode.initialize(context);
+            const decision = await mode.handleInbound(message);
+            return { modeId: mode.id, decision, mode, context };
+        }
+        catch (e) {
+            deps.contextDeps.logger.warn(`[Coordinator] resolveInbound failed: ${e instanceof Error ? e.message : String(e)}`);
+            return null;
+        }
+    }
+    /**
+     * 对某个出站 payload 运行 handleOutbound。
+     * 失败时返回 direct（安全默认：照常发送，不静默吞消息）。
+     */
+    async resolveOutbound(resolved, payload) {
+        try {
+            return await resolved.mode.handleOutbound(payload);
+        }
+        catch (e) {
+            resolved.context.logger.warn(`[Coordinator] resolveOutbound failed for kind='${payload.kind}', defaulting to direct: ${e instanceof Error ? e.message : String(e)}`);
+            return { method: 'direct', type: 'message' };
+        }
+    }
+    /** 暴露 registry（供 CLI/Menu 查询） */
+    getRegistry() {
+        return this.registry;
+    }
+}

package/dist/response-system/decision-executor.js

@@ -0,0 +1,86 @@
+/**
+ * Decision Executor
+ *
+ * 执行响应模式返回的决策对象（InboundDecision / OutboundDecision）。
+ *
+ * 设计：决策与执行分离
+ *   - 响应模式只做决策（返回 Decision 对象，纯函数、易测试）
+ *   - DecisionExecutor 负责执行（操作队列、发送消息、切换模型）
+ *
+ * 副作用通过 ExecutorSinks 接口注入，便于单测 mock。
+ *
+ * 异常处理（D6）：不降级。执行中任何异常都记录日志、上报，由调用方决定后续。
+ */
+export class DecisionExecutor {
+    sinks;
+    logger;
+    constructor(sinks, logger) {
+        this.sinks = sinks;
+        this.logger = logger;
+    }
+    /**
+     * 执行入站决策。
+     * @returns 是否实际入队（drop/defer 返回 false）
+     */
+    async executeInbound(decision, message, context) {
+        // 逃生舱优先
+        if (decision.customHandler) {
+            await decision.customHandler(message, context);
+            return false; // customHandler 自行处理，不走标准入队
+        }
+        if (decision.action === 'drop') {
+            this.logger.debug(`[Executor] inbound dropped: ${decision.reason ?? 'no reason'}`);
+            return false;
+        }
+        if (decision.action === 'defer') {
+            this.logger.debug(`[Executor] inbound deferred: ${decision.reason ?? 'no reason'}`);
+            return false;
+        }
+        // action === 'process'：先执行附加指令，再入队
+        if (decision.instructions?.switchModel) {
+            await this.sinks.switchModel(decision.instructions.switchModel);
+        }
+        if (decision.instructions?.injectContext?.length) {
+            await this.sinks.injectContext(decision.instructions.injectContext);
+        }
+        if (decision.instructions?.interruptCurrent) {
+            await this.sinks.interrupt();
+        }
+        const behavior = decision.queueBehavior ?? 'enqueue';
+        if (behavior === 'clear-and-enqueue') {
+            await this.sinks.clearQueue();
+            await this.sinks.enqueue(message, 'enqueue');
+        }
+        else {
+            await this.sinks.enqueue(message, behavior);
+        }
+        return true;
+    }
+    /**
+     * 执行出站决策。
+     * @returns 是否实际发送（suppress/defer/batch 返回 false）
+     */
+    async executeOutbound(decision, payload, context) {
+        // 逃生舱优先
+        if (decision.customSender) {
+            await decision.customSender(payload, context);
+            return true;
+        }
+        switch (decision.method) {
+            case 'direct':
+                await this.sinks.send(payload, decision.type ?? 'message');
+                return true;
+            case 'suppress':
+                this.logger.debug(`[Executor] outbound suppressed: ${decision.reason ?? 'no reason'}`);
+                return false;
+            case 'defer':
+            case 'batch':
+                // defer/batch 由响应模式自行决定何时调 send，此处不发
+                this.logger.debug(`[Executor] outbound ${decision.method}: held by mode`);
+                return false;
+            default:
+                this.logger.warn(`[Executor] unknown outbound method: ${decision.method}`);
+                return false;
+        }
+    }
+}

package/dist/response-system/engines/v1/index.js

@@ -0,0 +1,21 @@
+/**
+ * V1 引擎 —— 单会话处理行为的载体。
+ *
+ * 对外只暴露 flowForChatMode：按 chatMode 取对应流（interactive / proactive）。
+ * chatMode 分流收拢于此，模式层（modes/single-session）与调用方不再散布分支。
+ */
+import { interactiveFlow } from './interactive-flow.js';
+import { proactiveFlow } from './proactive-flow.js';
+const FLOWS = {
+    interactive: interactiveFlow,
+    proactive: proactiveFlow,
+};
+/** 按 chatMode 取处理流。 */
+export function flowForChatMode(chatMode) {
+    const flow = FLOWS[chatMode];
+    if (!flow)
+        throw new Error(`[V1Engine] unknown chatMode: ${chatMode}`);
+    return flow;
+}
+export { interactiveFlow } from './interactive-flow.js';
+export { proactiveFlow } from './proactive-flow.js';

package/dist/response-system/engines/v1/interactive-flow.js

@@ -0,0 +1,27 @@
+/**
+ * V1 引擎 —— 交互流（interactive）
+ *
+ * 行为自合并前的 modes/interactive（InteractiveMode）下沉，语义不变：
+ * 输出即回复，所有消息立即处理；Runner 返回后扫描文本中的文件标记
+ * （[SEND_FILE:...]），实际发送由引擎能力 ctx.processFileMarkers 完成。
+ *
+ * flow 是无状态单例：不持有 context，全部依赖由调用点显式传入。
+ */
+export const interactiveFlow = {
+    chatMode: 'interactive',
+    handleInbound(message, ctx) {
+        ctx.logger.debug('[V1Engine] interactive inbound chatType=' + message.chatType + ' peerId=' + message.peerId);
+        return { action: 'process', queueBehavior: 'enqueue' };
+    },
+    handleOutbound(payload, ctx) {
+        ctx.logger.debug('[V1Engine] interactive outbound kind=' + (payload.kind ?? 'unknown'));
+        return { method: 'direct', type: 'message' };
+    },
+    /**
+     * Runner 返回后：处理文本中的文件标记（[SEND_FILE:...]）。
+     * interactive 特有——proactive 改用 ctl file 工具，不走标记。
+     */
+    async afterProcess(ctx) {
+        await ctx.processFileMarkers(ctx.fullText);
+    },
+};