evolclaw 3.1.11 → 3.3.0

package/dist/core/daemon-file-cache.js

@@ -0,0 +1,216 @@
+/**
+ * FileCache —— 统一的文件缓存（daemon-only）。
+ *
+ * daemon 每条消息处理时读大量文件（manifest、fragment、md、working memory、
+ * 关系级 preferences 等）。本类统一缓存"文件 → 解析后内容"，按策略门控变化检查。
+ *
+ * 设计与边界详见 docs/file-cache-design.md：
+ *  - 不接管 EvolAgent 的 merged config（agent/defaults 由 EvolAgent 持有权威副本）。
+ *  - daemon-only：CLI 短命进程仍直读最新盘值，不用本缓存。
+ *  - 只缓存"文件 → 解析后内容"，不缓存按 vars 渲染后的结果。
+ *
+ * 策略（reload/重启永远全量失效，无视策略；策略只决定"平时每次读怎么检查"）：
+ *  - on-reload：平时不检查，直接用缓存（kits 文件、persona）。靠 reload/重启刷新。
+ *  - manual：同 on-reload，额外支持显式 invalidate(file) 单刷。
+ *  - mtime：每次读 statSync 门控 mtime，变了自动重读（working.md、preferences.json）。
+ *
+ * 容量：项数可无界增长的组（如 relation-prefs，每 peer 一文件）设 LRU 硬上限
+ * （见 GROUP_CAPS），命中/写入移到末尾、超限驱逐同组最旧项；无 timer。
+ * 项数固定的组（kits、per-agent 身份层）不设限。
+ *
+ * 监控：内置命中/读盘/驱逐/失效计数（总计 + 按 group + 按 policy），stats() 导出
+ * 快照供 watch web 的 Cache 页展示（经 IPC 'cache-stats'）。计数是整数自增，热路径无感。
+ */
+import fs from 'fs';
+const GROUP_NONE = '(none)'; // group 未指定时的归类键
+function newCounters() {
+    return { gets: 0, hits: 0, misses: 0, statChecks: 0, reReads: 0, evictions: 0, invalidations: 0 };
+}
+/**
+ * 按组的容量上限（LRU）。只有"项数可无界增长"的组才设限——典型是关系级
+ * preferences，每个 peer 一个文件，daemon 长跑接触的 peer 越来越多。
+ * kits（项数随包固定）、per-agent 身份层（agent 数量有限）不设限，不在此表即无限。
+ * 命中/写入都把 key 移到 Map 末尾（Map 保留插入序 → 头部即最久未用），
+ * 超限时从头部驱逐同组最旧项。无 timer，确定性 bound。
+ */
+const GROUP_CAPS = {
+    'relation-prefs': 512,
+};
+export class FileCache {
+    cache = new Map();
+    // 监控计数器（总计 + 按 group + 按 policy）。group 未指定归入 GROUP_NONE。
+    since = Date.now();
+    totals = newCounters();
+    byGroup = new Map();
+    byPolicy = {
+        'on-reload': newCounters(), 'manual': newCounters(), 'mtime': newCounters(),
+    };
+    /** 取（或建）某 group 的计数器。 */
+    groupCounters(group) {
+        const key = group ?? GROUP_NONE;
+        let c = this.byGroup.get(key);
+        if (!c) {
+            c = newCounters();
+            this.byGroup.set(key, c);
+        }
+        return c;
+    }
+    /** 同一事件按 总计/group/policy 三维各加一次。delta 缺省 1。 */
+    bump(group, policy, field, delta = 1) {
+        this.totals[field] += delta;
+        this.groupCounters(group)[field] += delta;
+        this.byPolicy[policy][field] += delta;
+    }
+    /**
+     * 读取并缓存文件。loader 把原始内容（UTF-8 字符串；文件不存在时为 null）转成目标值。
+     * 同一 file 的 policy/group 以首次注册为准。
+     * opts.read 可注入自定义读取器（如 atomicRead 保留崩溃恢复）；缺省 readFileOrNull。
+     */
+    get(file, loader, opts) {
+        const existing = this.cache.get(file);
+        const read = opts.read ?? readFileOrNull;
+        this.bump(opts.group, opts.policy, 'gets');
+        if (opts.policy === 'mtime') {
+            const mtimeMs = statMtime(file);
+            this.bump(opts.group, opts.policy, 'statChecks');
+            if (existing && existing.mtimeMs === mtimeMs) {
+                this.bump(opts.group, opts.policy, 'hits');
+                this.touch(file, existing);
+                return existing.value;
+            }
+            // 已有条目但 mtime 变了 → 带外改后重读（区别于首次 miss）
+            if (existing)
+                this.bump(opts.group, opts.policy, 'reReads');
+            this.bump(opts.group, opts.policy, 'misses');
+            const raw = read(file);
+            const value = loader(raw);
+            this.store(file, { policy: 'mtime', group: opts.group, mtimeMs, value, bytes: approxBytes(raw) });
+            return value;
+        }
+        // on-reload / manual：命中即用，不检查文件
+        if (existing) {
+            this.bump(opts.group, opts.policy, 'hits');
+            this.touch(file, existing);
+            return existing.value;
+        }
+        this.bump(opts.group, opts.policy, 'misses');
+        const raw = read(file);
+        const value = loader(raw);
+        this.store(file, { policy: opts.policy, group: opts.group, value, bytes: approxBytes(raw) });
+        return value;
+    }
+    /** 命中时把 key 移到 Map 末尾，维持 LRU 顺序（仅对设了容量上限的组有意义）。 */
+    touch(file, entry) {
+        if (entry.group === undefined || GROUP_CAPS[entry.group] === undefined)
+            return;
+        this.cache.delete(file);
+        this.cache.set(file, entry);
+    }
+    /** 写入并对设限组做 LRU 驱逐（踢同组最久未用项）。 */
+    store(file, entry) {
+        this.cache.delete(file); // 确保重写时移到末尾
+        this.cache.set(file, entry);
+        const cap = entry.group !== undefined ? GROUP_CAPS[entry.group] : undefined;
+        if (cap === undefined)
+            return;
+        // Map 按插入序遍历，头部即最久未用；驱逐同组超出容量的最旧项。
+        let count = 0;
+        for (const e of this.cache.values())
+            if (e.group === entry.group)
+                count++;
+        if (count <= cap)
+            return;
+        for (const [k, e] of this.cache) {
+            if (count <= cap)
+                break;
+            if (e.group === entry.group) {
+                this.cache.delete(k);
+                count--;
+                this.bump(e.group, e.policy, 'evictions');
+            }
+        }
+    }
+    /** 读纯文本的便捷封装（文件不存在返回 null）。 */
+    getText(file, opts) {
+        return this.get(file, (raw) => raw, opts);
+    }
+    /** 单文件失效（manual 策略单刷 / 精确失效）。 */
+    invalidate(file) {
+        const entry = this.cache.get(file);
+        if (this.cache.delete(file) && entry)
+            this.bump(entry.group, entry.policy, 'invalidations');
+    }
+    /** 按组失效（reload 钩子失效一组，如 'kits' / 'agent-files:<aid>'）。 */
+    invalidateGroup(group) {
+        for (const [file, entry] of this.cache) {
+            if (entry.group === group) {
+                this.cache.delete(file);
+                this.bump(entry.group, entry.policy, 'invalidations');
+            }
+        }
+    }
+    /** 全量失效（reload / 升级兜底）。 */
+    invalidateAll() {
+        for (const entry of this.cache.values())
+            this.bump(entry.group, entry.policy, 'invalidations');
+        this.cache.clear();
+    }
+    /** 当前缓存条目数（诊断用）。 */
+    size() {
+        return this.cache.size;
+    }
+    /**
+     * 运行时统计快照（监控用）。累计计数 O(1) 取出；占用（size/内存/容量）即时遍历
+     * 当前 entries 算出——条目数有限（kits 固定、relation-prefs 有 LRU 上限），便宜。
+     */
+    stats() {
+        const occupancy = {};
+        for (const entry of this.cache.values()) {
+            const key = entry.group ?? GROUP_NONE;
+            let occ = occupancy[key];
+            if (!occ) {
+                occ = { size: 0, bytes: 0, cap: GROUP_CAPS[key] ?? null };
+                occupancy[key] = occ;
+            }
+            occ.size++;
+            occ.bytes += entry.bytes;
+        }
+        const byGroup = {};
+        for (const [k, c] of this.byGroup)
+            byGroup[k] = { ...c };
+        return {
+            since: this.since,
+            size: this.cache.size,
+            totals: { ...this.totals },
+            byGroup,
+            byPolicy: {
+                'on-reload': { ...this.byPolicy['on-reload'] },
+                'manual': { ...this.byPolicy['manual'] },
+                'mtime': { ...this.byPolicy['mtime'] },
+            },
+            occupancy,
+        };
+    }
+}
+function statMtime(file) {
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return null; // 文件不存在
+    }
+}
+function readFileOrNull(file) {
+    try {
+        return fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/** 缓存值内存占用近似：用读入的原始字符串长度（字节级近似），null 记 0。 */
+function approxBytes(raw) {
+    return raw === null ? 0 : raw.length;
+}
+/** daemon 单例。CLI 进程不应使用本实例。 */
+export const fileCache = new FileCache();

package/dist/core/evolagent-registry.js

@@ -300,6 +300,9 @@ export class EvolAgentRegistry {
             }
             // swap config 后再起新 channel —— startChannel hook 需要看到新 config
             oldAgent.swapConfig(raw, merged);
+            // 热重载也刷新身份层缓存（persona / working 等 fileCache 'agent-files:<aid>' 组），
+            // 使 personal 文件改动经 reload 即时生效，不必重启。
+            oldAgent.invalidatePersonaCache();
             for (const ch of toAdd) {
                 await hooks.startChannel(oldAgent, ch);
                 addedSuccessfully.push(ch);
@@ -353,6 +356,7 @@ export class EvolAgentRegistry {
     toInfo(agent) {
         return {
             name: agent.name,
+            aid: agent.aid,
             status: agent.status,
             channels: agent.channelInstanceNames(),
             projectPath: agent.projectPath,

package/dist/core/evolagent.js

@@ -1,9 +1,9 @@
 import path from 'path';
-import fs from 'fs';
 import { logger } from '../utils/logger.js';
 import { saveAgent } from '../config-store.js';
 import { formatChannelKey, tryParseChannelKey } from './channel-loader.js';
 import { agentPersonalDir } from '../paths.js';
+import { fileCache } from './daemon-file-cache.js';
 /**
  * EvolAgent —— 一个 self-agent 的运行时表示。
  *
@@ -213,40 +213,45 @@ export class EvolAgent {
         this.merged.dispatch = value;
         this.persist();
     }
+    /** 读取观察者模式开关（默认 false）。 */
+    getObservable() {
+        return this.merged.observable === true;
+    }
+    /** 设置观察者模式开关：开启后入站/出站消息各转发一份给 owners[]。 */
+    setObservable(value) {
+        if (value)
+            this.rawAgent.observable = true;
+        else
+            delete this.rawAgent.observable;
+        this.merged.observable = value;
+        this.persist();
+    }
     // ── Personal layer ────────────────────────────────────────────────────
-    _personaCache = undefined;
+    /** 本 agent 身份层文件在 fileCache 的组名（带 aid，避免 reload 单个 agent 误失效他人）。 */
+    agentFilesGroup() {
+        return `agent-files:${this.aid}`;
+    }
     /**
-     * 读取 personal/persona.md 内容（缓存，首次调用时从磁盘读）。
-     * 文件不存在返回 null。
+     * 读取 personal/persona.md 内容。走 fileCache（mtime 门控）：persona 没有任何
+     * 写入命令、由 agent 自己带外改写，与 working memory 同样改了即应生效，故每次读
+     * stat 比对、变了自动重读。文件不存在返回 null。
      */
     getPersona() {
-        if (this._personaCache !== undefined)
-            return this._personaCache;
         const personaPath = path.join(agentPersonalDir(this.aid), 'persona.md');
-        try {
-            this._personaCache = fs.readFileSync(personaPath, 'utf-8').trim() || null;
-        }
-        catch {
-            this._personaCache = null;
-        }
-        return this._personaCache;
+        return fileCache.get(personaPath, (raw) => (raw === null ? null : (raw.trim() || null)), { policy: 'mtime', group: this.agentFilesGroup() });
     }
     /**
-     * 读取 personal/memory/working.md 内容（不缓存，每次会话开始时读）。
+     * 读取 personal/memory/working.md 内容。走 fileCache（mtime 门控）：
+     * agent 在对话中改写 working memory、不触发 reload，故每次读 stat 比对、
+     * 变了自动重读，既即时反映又避免无谓重读。
      */
     getWorkingMemory() {
         const workingPath = path.join(agentPersonalDir(this.aid), 'memory', 'working.md');
-        try {
-            const content = fs.readFileSync(workingPath, 'utf-8').trim();
-            return content || null;
-        }
-        catch {
-            return null;
-        }
+        return fileCache.get(workingPath, (raw) => (raw === null ? null : (raw.trim() || null)), { policy: 'mtime', group: this.agentFilesGroup() });
     }
-    /** 清除 persona 缓存（reload 后重新读取） */
+    /** 清除本 agent 身份层缓存（reload 后重新读取）。只失效自己的文件组，不波及他人。 */
     invalidatePersonaCache() {
-        this._personaCache = undefined;
+        fileCache.invalidateGroup(this.agentFilesGroup());
     }
     // ── Context（喂给 message-processor / command-handler） ──────────────
     getContext(_channelKey, chatType, globalChatmode) {

package/dist/core/interaction-router.js

@@ -68,6 +68,14 @@ export class InteractionRouter {
         const handler = this.handlers.get(response.id);
         if (!handler)
             return false;
+        // Initiator 校验（集中式 backstop）：非发起者的操作直接丢弃，不消费 handler、不解除等待，
+        // 让真正的发起者仍可继续操作。身份只信渠道传入的已认证 operatorId（来自消息信封，非 payload 自报）。
+        // 渠道层若已自行校验（如飞书的 reject toast），此处不会重复命中（operatorId 已匹配）。
+        if (handler.initiatorId && response.operatorId
+            && response.operatorId !== handler.initiatorId) {
+            logger.info(`[InteractionRouter] rejected non-initiator: operator=${response.operatorId} initiator=${handler.initiatorId} id=${response.id}`);
+            return false;
+        }
         if (handler.timer)
             clearTimeout(handler.timer);
         this.handlers.delete(response.id);

package/dist/core/message/command-handler-agent-control.js

@@ -0,0 +1,215 @@
+import { agentCreateNonInteractive, agentDelete, agentEnable, agentDisable, agentList, agentShow, agentSet, agentReload, } from '../../cli/agent.js';
+import { logger } from '../../utils/logger.js';
+import { resolvePaths } from '../../paths.js';
+import path from 'path';
+import { loadAgent, saveAgent } from '../../config-store.js';
+import { CreateStatusWriter, readCreateStatus } from './create-status.js';
+/** 把 cli/agent.ts 的 error 字符串映射为结构化错误码 */
+function classifyError(error) {
+    if (/already exists/i.test(error))
+        return 'CONFLICT';
+    if (/not found/i.test(error))
+        return 'NOT_FOUND';
+    if (/invalid|must be|required|缺少/i.test(error))
+        return 'INVALID_ARGS';
+    return 'INTERNAL';
+}
+/** 后台异步：实际创建 agent + 落 model/chatmode，全程写构建进度（D3）。
+ *  失败仅写日志 + create-status，不回传（受理即返回）。
+ *  agentSet key 对照 cli/agent.ts 的 setNestedValue：
+ *  model → 'models.default'（ModelsBlock.default）；chatmode → 'chatmode'（ChatmodeBlock 对象）。 */
+async function runCreateInBackground(opts) {
+    const agentDir = path.join(resolvePaths().agentsDir, opts.aid);
+    const w = new CreateStatusWriter(agentDir, opts.aid);
+    let curPhase = 'validating'; // 跟踪当前环节，供 catch 兜底时标注正确 phase
+    try {
+        // onPhase 把 agentCreateNonInteractive 内部环节（0-3、5）映射到进度文件
+        const res = await agentCreateNonInteractive({
+            aid: opts.aid, name: opts.name, baseagent: opts.baseagent,
+            project: opts.project, owner: opts.owner,
+            onPhase: (phase, state, detail) => {
+                if (state === 'begin') {
+                    curPhase = phase;
+                    w.begin(phase);
+                }
+                else if (state === 'done')
+                    w.done(phase, detail);
+                else if (state === 'warn')
+                    w.warn(phase, detail);
+                else if (state === 'failed')
+                    w.finishFailed(phase, detail ?? 'failed');
+            },
+        });
+        if (!('ok' in res) || res.ok !== true) {
+            // 硬失败：onPhase('failed') 已写终态；这里仅兜底日志（防回调未覆盖的 return 路径）
+            const err = res.error;
+            logger.warn(`[agent-control] create ${opts.aid} failed: ${err}`);
+            return;
+        }
+        // 环节 4：applying_config（model/chatmode，agentCreateNonInteractive 之外）
+        if (opts.model || opts.chatmode) {
+            curPhase = 'applying_config';
+            w.begin('applying_config');
+            let warned;
+            if (opts.model) {
+                const r = await agentSet(opts.aid, 'models.default', opts.model);
+                if (!('ok' in r) || !r.ok)
+                    warned = `model: ${r.error}`;
+            }
+            if (opts.chatmode) {
+                const r = await agentSet(opts.aid, 'chatmode', JSON.stringify(opts.chatmode));
+                if (!('ok' in r) || !r.ok)
+                    warned = `${warned ? warned + '; ' : ''}chatmode: ${r.error}`;
+            }
+            if (warned) {
+                logger.warn(`[agent-control] applying_config ${opts.aid}: ${warned}`);
+                w.warn('applying_config', warned);
+            }
+            else
+                w.done('applying_config');
+        }
+        w.finishReady();
+        logger.info(`[agent-control] create ${opts.aid} ready`);
+    }
+    catch (e) {
+        const msg = e?.message || String(e);
+        logger.warn(`[agent-control] create ${opts.aid} threw at ${curPhase}: ${msg}`);
+        w.finishFailed(curPhase, msg); // 兜底终态，标注真实失败环节
+    }
+}
+/** name=agent 的 menu.action 执行。peerId 自动填为新 agent 的 owner。
+ *  create 受理即返回（D3）；delete/enable/disable 同步等结果。
+ *  调用方负责传入已兜底的 args.project（见 command-handler 装配）。 */
+export async function execAgentAction(action, args, peerId) {
+    const a = args ?? {};
+    if (action === 'create') {
+        if (!peerId)
+            return { error: '缺少发起者 AID（无法绑定 owner）', code: 'INVALID_ARGS' };
+        if (!a.aid || !a.name || !a.baseagent) {
+            return { error: '缺少必填参数：aid / name / baseagent', code: 'INVALID_ARGS' };
+        }
+        if (!a.project || typeof a.project !== 'string') {
+            return { error: 'project 缺失且无法兜底（需 defaults.projects.rootPath/defaultPath）', code: 'INVALID_ARGS' };
+        }
+        // D3: 受理即返回，重副作用转后台
+        // 受理即返回；后台 promise fire-and-forget。runCreateInBackground 内部有 try/catch，
+        // 但 CreateStatusWriter 构造（mkdir/写盘）在 try 之前，故再加一层兜底防未处理拒绝。
+        void runCreateInBackground({
+            aid: a.aid, name: a.name, baseagent: a.baseagent,
+            project: a.project, owner: peerId,
+            model: a.model, chatmode: a.chatmode,
+        }).catch(e => logger.error(`[agent-control] runCreateInBackground unhandled ${a.aid}: ${e?.message || e}`));
+        return { data: { accepted: true, aid: a.aid } };
+    }
+    if (action === 'delete') {
+        if (!a.aid)
+            return { error: '缺少 aid', code: 'INVALID_ARGS' };
+        const res = await agentDelete(a.aid, false);
+        if (!('ok' in res) || res.ok !== true)
+            return { error: res.error, code: classifyError(res.error) };
+        return { data: { aid: res.aid, purged: res.purged } };
+    }
+    if (action === 'enable' || action === 'disable') {
+        if (!a.aid)
+            return { error: '缺少 aid', code: 'INVALID_ARGS' };
+        const res = action === 'enable' ? await agentEnable(a.aid) : await agentDisable(a.aid);
+        if (!('ok' in res) || res.ok !== true)
+            return { error: res.error, code: classifyError(res.error) };
+        return { data: { aid: res.aid, enabled: res.enabled, reloaded: res.reloaded } };
+    }
+    if (action === 'reload') {
+        if (!a.aid)
+            return { error: '缺少 aid', code: 'INVALID_ARGS' };
+        const res = await agentReload(a.aid);
+        if (!('ok' in res) || res.ok !== true)
+            return { error: res.error, code: classifyError(res.error) };
+        return { data: { aid: a.aid, reloaded: true } };
+    }
+    if (action === 'update') {
+        return await execAgentUpdate(a);
+    }
+    return { error: `不支持的 action: ${action}`, code: 'INVALID_ARGS' };
+}
+/** name=agent 的 menu.action=update：仅落盘 config patch，不触发 reload。
+ *  直接 loadAgent + saveAgent（不走 agentSet，避免其内部自动 evolagent.reload）——
+ *  重载由用户在 Agents 页操作列手动触发（带任务执行检查）。
+ *  AUN 渠道绑定 agent 顶层 aid，不可通过 patch 编辑：拒绝改 aid、拒绝 channels 数组里出现 aun 条目。
+ *  可写字段：baseagents / projects / owners / chatmode / channels（非 aun）。 */
+export async function execAgentUpdate(args) {
+    const a = args ?? {};
+    if (!a.aid)
+        return { error: '缺少 aid', code: 'INVALID_ARGS' };
+    const p = a.patch ?? {};
+    if (p.aid !== undefined) {
+        return { error: 'aid 不可修改（AUN 身份绑定，如需换 AID 请删除后重建）', code: 'INVALID_ARGS' };
+    }
+    if (Array.isArray(p.channels) && p.channels.some((c) => c?.type === 'aun')) {
+        return { error: 'AUN 渠道不可通过 patch 编辑（由 agent aid 隐式管理）', code: 'INVALID_ARGS' };
+    }
+    const config = loadAgent(a.aid);
+    if (!config)
+        return { error: `Agent "${a.aid}" not found`, code: 'NOT_FOUND' };
+    let touched = false;
+    if (p.baseagents !== undefined) {
+        config.baseagents = p.baseagents;
+        touched = true;
+    }
+    if (p.projects !== undefined) {
+        config.projects = p.projects;
+        touched = true;
+    }
+    if (p.owners !== undefined) {
+        config.owners = p.owners;
+        touched = true;
+    }
+    if (p.chatmode !== undefined) {
+        config.chatmode = p.chatmode;
+        touched = true;
+    }
+    if (p.channels !== undefined) {
+        config.channels = p.channels;
+        touched = true;
+    }
+    if (!touched)
+        return { error: 'patch 为空，无可写字段', code: 'INVALID_ARGS' };
+    try {
+        saveAgent(config);
+    }
+    catch (e) {
+        return { error: e?.message || String(e), code: classifyError(e?.message || String(e)) };
+    }
+    return { data: { aid: a.aid, saved: true } };
+}
+/** project 兜底：显式值 > rootPath 合成 > defaultPath > undefined */
+export function resolveProjectPath(explicit, aid, defaults) {
+    if (explicit && explicit.trim())
+        return explicit;
+    const root = defaults?.projects?.rootPath;
+    if (root)
+        return path.join(root, aid.split('.')[0]);
+    return defaults?.projects?.defaultPath;
+}
+/** name=agent 的 menu.query：查单个 agent 详情，附构建进度（D3）。 */
+export async function execAgentQuery(args) {
+    const aid = args?.aid;
+    if (!aid)
+        return { error: '缺少 aid', code: 'INVALID_ARGS' };
+    const res = await agentShow(aid);
+    if (!('ok' in res) || res.ok !== true)
+        return { error: res.error, code: classifyError(res.error) };
+    // 叠加构建进度（create 受理后、ready 前可见；ready 后文件仍在，可反映软失败 warn）
+    const agentDir = path.join(resolvePaths().agentsDir, aid);
+    const progress = readCreateStatus(agentDir);
+    return { data: progress ? { ...res, createProgress: progress } : res };
+}
+/** name=agent 的 menu.options：列出 agent（enabled 默认 / all） */
+export async function execAgentOptions(args) {
+    const scope = args?.options === 'all' ? 'all' : 'enabled';
+    const res = await agentList();
+    if (!('ok' in res) || res.ok !== true)
+        return { error: res.error, code: classifyError(res.error) };
+    const agents = scope === 'all'
+        ? res.agents
+        : res.agents.filter((x) => x.status !== 'disabled');
+    return { data: { agents, scope } };
+}

package/dist/core/message/create-status.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+const FILE = 'create-status.json';
+export function readCreateStatus(agentDir) {
+    try {
+        const raw = fs.readFileSync(path.join(agentDir, FILE), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** 删除构建进度文件（agent 删除时清理）。非 purge 删除只移除 config.json，
+ *  故需显式清理本文件，避免目录残留陈旧进度。 */
+export function removeCreateStatus(agentDir) {
+    try {
+        fs.rmSync(path.join(agentDir, FILE), { force: true });
+    }
+    catch { /* ignore */ }
+}
+/** 构建进度写入器。每次状态变更原子落盘（写临时文件 + rename）。 */
+export class CreateStatusWriter {
+    agentDir;
+    status;
+    constructor(agentDir, aid) {
+        this.agentDir = agentDir;
+        const now = Date.now();
+        this.status = { aid, status: 'in_progress', currentPhase: null, steps: [], error: null, startedAt: now, updatedAt: now };
+        fs.mkdirSync(agentDir, { recursive: true });
+        this.flush();
+    }
+    begin(phase) {
+        this.status.currentPhase = phase;
+        this.status.steps.push({ phase, state: 'in_progress', ts: Date.now() });
+        this.flush();
+    }
+    done(phase, detail) { this.mark(phase, 'done', detail); }
+    warn(phase, detail) { this.mark(phase, 'warn', detail); }
+    finishReady() { this.status.status = 'ready'; this.status.currentPhase = null; this.flush(); }
+    finishFailed(phase, error) {
+        this.mark(phase, 'failed', error);
+        this.status.status = 'failed';
+        this.status.error = error;
+        this.status.currentPhase = null;
+        this.flush();
+    }
+    mark(phase, state, detail) {
+        const step = [...this.status.steps].reverse().find(s => s.phase === phase);
+        if (step) {
+            step.state = state;
+            if (detail)
+                step.detail = detail;
+            step.ts = Date.now();
+        }
+        else {
+            this.status.steps.push({ phase, state, detail, ts: Date.now() });
+        }
+        this.flush();
+    }
+    flush() {
+        this.status.updatedAt = Date.now();
+        const file = path.join(this.agentDir, FILE);
+        const tmp = `${file}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(this.status, null, 2));
+        fs.renameSync(tmp, file);
+    }
+}

package/dist/core/message/im-renderer.js

@@ -308,21 +308,24 @@ export class IMRenderer {
             clearTimeout(this.timer);
             this.timer = undefined;
         }
-        // 上下文错误短语过滤：剔除错误关键词本身，保留前后内容
-        const ctxErrPattern = /prompt is too long|input is too long|context too long|context limit|context_length_exceeded|上下文过长/gi;
-        const stripCtxErr = (s) => s.replace(ctxErrPattern, '').trim();
-        this.textBuffer = stripCtxErr(this.textBuffer);
-        this.allText = stripCtxErr(this.allText);
-        for (const item of this.itemsQueue) {
-            if (item.kind === 'text')
-                item.text = stripCtxErr(item.text);
-        }
-        // 文件标记过滤
-        if (this.opts.fileMarkerPattern) {
-            this.textBuffer = this.textBuffer.replace(this.opts.fileMarkerPattern, '').trim();
+        if (isFinal) {
+            // 上下文错误短语过滤：剔除错误关键词本身，保留前后内容。
+            // 只在最终 flush 清理，避免中间定时 flush trim 掉 Markdown 块级换行。
+            const ctxErrPattern = /prompt is too long|input is too long|context too long|context limit|context_length_exceeded|上下文过长/gi;
+            const stripCtxErr = (s) => s.replace(ctxErrPattern, '').trim();
+            this.textBuffer = stripCtxErr(this.textBuffer);
+            this.allText = stripCtxErr(this.allText);
             for (const item of this.itemsQueue) {
                 if (item.kind === 'text')
-                    item.text = item.text.replace(this.opts.fileMarkerPattern, '');
+                    item.text = stripCtxErr(item.text);
+            }
+            // 文件标记过滤
+            if (this.opts.fileMarkerPattern) {
+                this.textBuffer = this.textBuffer.replace(this.opts.fileMarkerPattern, '').trim();
+                for (const item of this.itemsQueue) {
+                    if (item.kind === 'text')
+                        item.text = item.text.replace(this.opts.fileMarkerPattern, '');
+                }
             }
         }
         // 清掉空 text items
@@ -356,6 +359,25 @@ export class IMRenderer {
             this.lastFlush = Date.now();
             this.flushCount++;
         }
+        // 1.5 非最终定时 flush：把已累积的文本块作为独立 result.text 发出。
+        //   每个 text 事件本身是完整语义块（runner 已合并流式 delta），工具调用前的
+        //   文本一向作为独立气泡发送（见 message-processor 的 flushText 调用）。
+        //   这里补上「文本块后面没有紧跟 tool_use」的情况——例如 readonly 拒绝写文件时
+        //   SDK 直接拒绝、不产生 tool_use 事件，文本会一直滞留 buffer，直到下一个
+        //   tool_use 才被 flushText 带出，并与其后的文本合并成一条（用户侧表现为：
+        //   第一条文本等待一分多钟后才和第二条凑成一条发出）。定时器到期即发，根除滞留。
+        if (!isFinal && this.textBuffer.length > 0) {
+            const text = this.textBuffer;
+            this.textBuffer = '';
+            const payload = { kind: 'result.text', text, isFinal: false };
+            this.sentContent = true;
+            this.sendChain = this.sendChain
+                .then(() => this.opts.send(payload))
+                .catch(e => logger.warn('[IMRenderer] timed result.text send failed:', e));
+            await this.sendChain;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
         // 2. isFinal=true 时单独发最终回复文本
         if (isFinal && finalText.length > 0) {
             const payload = { kind: 'result.text', text: finalText, isFinal: true };