evolclaw 3.1.11 → 3.3.0

package/dist/core/stats/writer.js

@@ -0,0 +1,115 @@
+/**
+ * writer.ts — 写入 usage_events 和 context_breakdown。
+ */
+import { getDb } from './db.js';
+export function insertUsageEvent(evolclawHome, event) {
+    const db = getDb(evolclawHome);
+    if (!db)
+        return;
+    try {
+        // 明细 INSERT + rollup UPSERT 包进同一事务：进程在两者间崩溃也不会让 rollup 与明细漂移。
+        db.exec('BEGIN');
+        db.prepare(`
+      INSERT INTO usage_events
+        (ts, agent_aid, peer_key, peer_type, session_id, model, billing_fn,
+         input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+         cache_hit_tokens, cache_miss_tokens, image_tokens, total_context_tokens,
+         turns, duration_ms, context_window_pct)
+      VALUES
+        (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(event.ts, event.agent_aid, event.peer_key, event.peer_type ?? null, event.session_id ?? null, event.model, event.billing_fn, event.input_tokens, event.output_tokens, event.cache_creation_tokens, event.cache_read_tokens, event.cache_hit_tokens ?? null, event.cache_miss_tokens ?? null, event.image_tokens ?? null, event.total_context_tokens ?? null, event.turns, event.duration_ms ?? null, event.context_window_pct ?? null);
+        // 写时增量：累加到日级预聚合表（grain 与 db.ts rebuildDailyRollup 一致）。
+        db.prepare(`
+      INSERT INTO usage_daily
+        (day, agent_aid, peer_key, peer_type, session_id, model, billing_fn,
+         input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+         cache_hit_tokens, cache_miss_tokens, image_tokens, total_context_tokens,
+         turns, calls)
+      VALUES
+        (strftime('%Y-%m-%d', ?/1000, 'unixepoch', 'localtime'),
+         ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+      ON CONFLICT(day, agent_aid, peer_key, session_id, model, billing_fn) DO UPDATE SET
+        peer_type             = excluded.peer_type,
+        input_tokens          = input_tokens          + excluded.input_tokens,
+        output_tokens         = output_tokens         + excluded.output_tokens,
+        cache_creation_tokens = cache_creation_tokens + excluded.cache_creation_tokens,
+        cache_read_tokens     = cache_read_tokens     + excluded.cache_read_tokens,
+        cache_hit_tokens      = cache_hit_tokens      + excluded.cache_hit_tokens,
+        cache_miss_tokens     = cache_miss_tokens     + excluded.cache_miss_tokens,
+        image_tokens          = image_tokens          + excluded.image_tokens,
+        total_context_tokens  = total_context_tokens  + excluded.total_context_tokens,
+        turns                 = turns                 + excluded.turns,
+        calls                 = calls                 + 1
+    `).run(event.ts, event.agent_aid, event.peer_key, event.peer_type ?? '', event.session_id ?? '', event.model, event.billing_fn, event.input_tokens, event.output_tokens, event.cache_creation_tokens, event.cache_read_tokens, event.cache_hit_tokens ?? 0, event.cache_miss_tokens ?? 0, event.image_tokens ?? 0, event.total_context_tokens ?? 0, event.turns);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        // 写入失败不影响主流程
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        import('../../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertUsageEvent failed: ${e}`));
+    }
+}
+export function insertContextBreakdown(evolclawHome, bd) {
+    const db = getDb(evolclawHome);
+    if (!db)
+        return;
+    try {
+        db.prepare(`
+      INSERT INTO context_breakdown
+        (ts, agent_aid, session_id, turn_count, model, max_tokens,
+         system_prompt, system_tools, mcp_tools, custom_agents,
+         memory_files, skills, messages, free_space, total_estimated)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(bd.ts, bd.agent_aid, bd.session_id, bd.turn_count, bd.model, bd.max_tokens, bd.system_prompt ?? null, bd.system_tools ?? null, bd.mcp_tools ?? null, bd.custom_agents ?? null, bd.memory_files ?? null, bd.skills ?? null, bd.messages ?? null, bd.free_space ?? null, bd.total_estimated ?? null);
+    }
+    catch (e) {
+        import('../../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertContextBreakdown failed: ${e}`));
+    }
+}
+export function insertMessageEvent(evolclawHome, event) {
+    const db = getDb(evolclawHome);
+    if (!db)
+        return;
+    try {
+        db.prepare(`
+      INSERT INTO message_events
+        (ts, agent_aid, peer_key, direction, msg_type, bytes, encrypted, chatmode)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(event.ts, event.agent_aid, event.peer_key, event.direction, event.msg_type ?? null, event.bytes, event.encrypted ? 1 : 0, event.chatmode ?? null);
+    }
+    catch (e) {
+        import('../../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertMessageEvent failed: ${e}`));
+    }
+}
+/** 批量写入大模型调用明细。单事务；失败不影响主流程。 */
+export function insertModelCalls(evolclawHome, rows) {
+    if (!rows.length)
+        return;
+    const db = getDb(evolclawHome);
+    if (!db)
+        return;
+    try {
+        const stmt = db.prepare(`
+      INSERT INTO model_calls
+        (ts, task_id, session_id, agent_session_id, agent_aid, peer_key, call_index, model,
+         request_id, message_id, input_tokens, output_tokens, cache_creation_tokens,
+         cache_read_tokens, degraded)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        db.exec('BEGIN');
+        for (const r of rows) {
+            stmt.run(r.ts, r.task_id, r.session_id ?? null, r.agent_session_id ?? null, r.agent_aid, r.peer_key, r.call_index, r.model, r.request_id ?? null, r.message_id ?? null, r.input_tokens, r.output_tokens, r.cache_creation_tokens, r.cache_read_tokens, r.degraded);
+        }
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        import('../../utils/logger.js').then(({ logger }) => logger.warn(`[StatsWriter] insertModelCalls failed: ${e}`));
+    }
+}

package/dist/core/trigger/manager.js

@@ -90,6 +90,30 @@ export class TriggerManager {
     getById(id) {
         return this.triggers.get(id);
     }
+    /**
+     * 按 id 从磁盘重读单条 trigger（不走内存缓存）。
+     * 用于触发时刻取最新数据，消除内存/磁盘漂移。
+     * 读盘失败或不存在时返回 undefined（调用方回退到内存副本）。
+     */
+    getByIdFresh(id) {
+        if (!fs.existsSync(this.triggersPath))
+            return undefined;
+        try {
+            const raw = fs.readFileSync(this.triggersPath, 'utf8');
+            const data = JSON.parse(raw);
+            return data.triggers?.[id];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * 从磁盘重新加载到内存 Map（外部编辑 triggers.json 后调用）。
+     * 等价于 load()，语义上强调"丢弃内存副本、以磁盘为准"。
+     */
+    reloadFromDisk() {
+        return this.load();
+    }
     getByName(name) {
         for (const t of this.triggers.values()) {
             if (t.name === name)
@@ -154,6 +178,16 @@ export class TriggerManager {
         t.updatedAt = Date.now();
         this.save();
     }
+    updateResult(id, outcome) {
+        const t = this.triggers.get(id);
+        if (!t)
+            return;
+        t.lastResult = outcome;
+        if (outcome === 'failed')
+            t.failCount = (t.failCount ?? 0) + 1;
+        t.updatedAt = Date.now();
+        this.save();
+    }
     updateNextFireAt(id, nextFireAt) {
         const t = this.triggers.get(id);
         if (!t)

package/dist/core/trigger/parser.js

@@ -105,8 +105,11 @@ export function parseTriggerUpdate(args) {
     }
     else if (hasCron) {
         const raw = flags.get('cron');
-        if (!validateCronExpr(raw))
-            return { ok: false, error: `无效的 cron 表达式："${raw}"` };
+        if (!validateCronExpr(raw)) {
+            const truncated = /^[\d*/,-]+$/.test(raw) && /--cron\s+\S+\s+[*\d]/.test(args);
+            const hint = truncated ? '（看起来 cron 表达式被空格截断了，请用引号包裹，如 --cron \'*/15 * * * *\'）' : '（需 5 段：分 时 日 月 周，如 */15 * * * *）';
+            return { ok: false, error: `无效的 cron 表达式："${raw}" ${hint}` };
+        }
         result.scheduleType = 'cron';
         result.scheduleValue = raw;
     }
@@ -191,7 +194,10 @@ export function parseTriggerSet(args) {
     else {
         const raw = flags.get('cron');
         if (!validateCronExpr(raw)) {
-            return { ok: false, error: `无效的 cron 表达式："${raw}"` };
+            // Detect likely space-truncation: raw looks like one cron segment and args contains space-separated * or digits after it
+            const truncated = /^[\d*/,-]+$/.test(raw) && /--cron\s+\S+\s+[*\d]/.test(args);
+            const hint = truncated ? '（看起来 cron 表达式被空格截断了，请用引号包裹，如 --cron \'*/15 * * * *\'）' : '（需 5 段：分 时 日 月 周，如 */15 * * * *）';
+            return { ok: false, error: `无效的 cron 表达式："${raw}" ${hint}` };
         }
         scheduleType = 'cron';
         scheduleValue = raw;

package/dist/core/trigger/scheduler.js

@@ -130,7 +130,7 @@ export class TriggerScheduler {
     register(trigger) {
         this.heap.push(trigger);
         this.resetTimer();
-        this.eventBus.publish({ type: 'trigger:registered', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId });
+        this.eventBus.publish({ type: 'trigger:registered', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId, targetChannel: trigger.targetChannel, targetChannelId: trigger.targetChannelId, scheduleType: trigger.scheduleType, scheduleValue: trigger.scheduleValue });
     }
     cancel(id) {
         this.heap.remove(id);
@@ -141,7 +141,7 @@ export class TriggerScheduler {
         this.heap.remove(trigger.id);
         this.heap.push(trigger);
         this.resetTimer();
-        this.eventBus.publish({ type: 'trigger:updated', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId });
+        this.eventBus.publish({ type: 'trigger:updated', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId, scheduleType: trigger.scheduleType, scheduleValue: trigger.scheduleValue });
     }
     stop() {
         if (this.timer) {
@@ -172,7 +172,7 @@ export class TriggerScheduler {
             if (trigger.scheduleType === 'cron' && this.inflightCron.has(trigger.id)) {
                 // Previous run still in flight — skip this occurrence, reschedule the next one.
                 logger.warn(`[${this.aid}] Cron trigger ${trigger.name} still running, skipping`);
-                this.eventBus.publish({ type: 'trigger:skipped', triggerId: trigger.id, reason: 'overlap' });
+                this.eventBus.publish({ type: 'trigger:skipped', triggerId: trigger.id, name: trigger.name, reason: 'overlap', targetChannel: trigger.targetChannel, targetChannelId: trigger.targetChannelId });
                 const next = this.nextCronFireAt(trigger.scheduleValue, Date.now());
                 this.manager.updateNextFireAt(trigger.id, next);
                 this.heap.push({ ...trigger, nextFireAt: next });
@@ -198,31 +198,34 @@ export class TriggerScheduler {
         return next;
     }
     fireTrigger(trigger, now) {
-        const messageId = `trigger:${trigger.id}:${now}`;
-        const msg = this.buildSyntheticMessage(trigger, messageId);
-        logger.info(`[${this.aid}] Firing trigger: ${trigger.name} (${trigger.id})`);
+        // 触发时刻以磁盘为真相源：heap 里的副本可能因外部编辑而过期。
+        // 用 id 重读磁盘最新版，读盘失败则回退到 heap 副本。
+        const fresh = this.manager.getByIdFresh(trigger.id) ?? trigger;
+        const messageId = `trigger:${fresh.id}:${now}`;
+        const msg = this.buildSyntheticMessage(fresh, messageId);
+        logger.info(`[${this.aid}] Firing trigger: ${fresh.name} (${fresh.id})`);
         // Update stats before moving to done so history captures the updated count
-        this.manager.updateFireStats(trigger.id, now);
-        if (trigger.scheduleType === 'cron') {
-            this.inflightCron.add(trigger.id);
+        this.manager.updateFireStats(fresh.id, now);
+        if (fresh.scheduleType === 'cron') {
+            this.inflightCron.add(fresh.id);
             // Re-schedule next occurrence (outside the firing window — see nextCronFireAt)
-            const next = this.nextCronFireAt(trigger.scheduleValue, now);
-            this.manager.updateNextFireAt(trigger.id, next);
-            this.heap.push({ ...trigger, nextFireAt: next });
+            const next = this.nextCronFireAt(fresh.scheduleValue, now);
+            this.manager.updateNextFireAt(fresh.id, next);
+            this.heap.push({ ...fresh, nextFireAt: next });
         }
         else {
             // delay/at: one-shot, move to done
-            this.manager.moveToDone(trigger.id, 'fired');
+            this.manager.moveToDone(fresh.id, 'fired');
         }
-        this.eventBus.publish({ type: 'trigger:fired', triggerId: trigger.id, name: trigger.name, fireTime: now });
+        this.eventBus.publish({ type: 'trigger:fired', triggerId: fresh.id, name: fresh.name, fireTime: now, targetChannel: fresh.targetChannel, targetChannelId: fresh.targetChannelId, scheduleType: fresh.scheduleType });
         if (this.fireCallback) {
-            this.fireCallback(msg, trigger);
+            this.fireCallback(msg, fresh);
         }
     }
     // Called by MessageProcessor when a trigger message completes/fails/is interrupted
-    onTriggerComplete(triggerId, _outcome) {
-        // Only clear inflight state — message-processor already published the relevant events
+    onTriggerComplete(triggerId, outcome) {
         this.inflightCron.delete(triggerId);
+        this.manager.updateResult(triggerId, outcome);
     }
     buildSyntheticMessage(trigger, messageId) {
         const base = {

package/dist/{agents → eck}/kit-renderer.js

@@ -61,7 +61,11 @@ export function renderKitSections(ctx) {
         }
         const files = loadSectionFiles(section, ctx.vars, sessionCache);
         diag.fileCount = files.length;
+        // 路径解析成功但读出 0 文件 → 文件/目录不存在（存在性不再单独 syscall，
+        // 由内容读取顺带得到；详见 manifest-engine.resolvePathWithDiag）。
         if (files.length === 0) {
+            if (diag.resolveStatus === 'ok')
+                diag.resolveStatus = 'not-exist';
             diagnostics.push(diag);
             continue;
         }
@@ -125,7 +129,7 @@ const PARAM_DESCRIPTIONS = {
     peerName: '对端显示名',
     peerRole: '对端角色（owner/admin/guest/anonymous）',
     peerType: '对端类型（human/agent）',
-    sameDevice: '对端与本端同一物理设备（E2EE 消息 proximity，仅加密消息有值）',
+    sameDevice: '对端与本端同一物理设备（SDK 0.4.9 起明文/密文消息均可携带，具体字段以网关下发为准）',
     sameNetwork: '对端与本端在同一网络内',
     sameEgressIp: '对端与本端共享同一出口 IP',
     groupId: '群组 ID（群聊时）',

package/dist/{agents → eck}/manifest-engine.js

@@ -5,24 +5,25 @@ import fs from 'fs';
 import path from 'path';
 import { kitsDir, resolveRoot, getPackageRoot } from '../paths.js';
 import { logger } from '../utils/logger.js';
-// ── Manifest loading / cache (keyed by filename) ──
-const _manifestCache = new Map();
-/** 清空所有 manifest 缓存（manifest 结构变更后调用）。 */
+import { fileCache } from '../core/daemon-file-cache.js';
+// ── Manifest loading / cache ──
+// manifest 定义随包发布、运行期靠 reload/重启刷新 → on-reload（group 'kits'）。
+// base + eck override 合成结果以 base 文件路径为键缓存；loader 内读两个文件。
+/** 清空所有 manifest 缓存（manifest 结构变更后调用，由 invalidateKitCache 串联）。 */
 export function invalidateManifestCache() {
-    _manifestCache.clear();
+    fileCache.invalidateGroup('kits');
 }
 /**
  * 加载并合并 manifest。基础文件在 $KITS/<filename>，
  * 覆盖文件在 $EVOLCLAW_HOME/eck/<filename>（可选）。结果按 order 升序缓存。
  */
 export function loadManifest(filename) {
-    const cached = _manifestCache.get(filename);
-    if (cached)
-        return cached;
-    const sections = loadAndMergeManifest(filename);
-    _manifestCache.set(filename, sections);
-    logger.info(`[ManifestEngine] Loaded ${filename}: ${sections.length} sections`);
-    return sections;
+    const kitsPath = path.join(kitsDir(), filename);
+    return fileCache.get(kitsPath, () => {
+        const sections = loadAndMergeManifest(filename);
+        logger.info(`[ManifestEngine] Loaded ${filename}: ${sections.length} sections`);
+        return sections;
+    }, { policy: 'on-reload', group: 'kits' });
 }
 function loadAndMergeManifest(filename) {
     const kitsPath = path.join(kitsDir(), filename);
@@ -58,10 +59,29 @@ function loadAndMergeManifest(filename) {
 function sortSections(sections) {
     return sections.slice().sort((a, b) => a.order - b.order);
 }
+/**
+ * 从 manifest 抽出每个 modeType 标了 isDefault 的 modeName。
+ * 供 message-renderer 在 agent config.render 未配某类型时回退。
+ * 同一 modeType 有多个 isDefault 时取 order 最小（已排序）的第一个。
+ */
+export function defaultModeNames(sections) {
+    const out = {};
+    for (const s of sections) {
+        if (s.modeType && s.isDefault && s.modeName && out[s.modeType] === undefined) {
+            out[s.modeType] = s.modeName;
+        }
+    }
+    return out;
+}
 // ── When condition evaluation ──
 export function evaluateWhen(when, vars) {
     if (when === 'always')
         return true;
+    // 复合条件优先：and / or 递归求值。
+    if (when.and)
+        return when.and.every(c => evaluateWhen(c, vars));
+    if (when.or)
+        return when.or.some(c => evaluateWhen(c, vars));
     if (when.var !== undefined) {
         const val = vars[when.var];
         if (when.eq !== undefined) {
@@ -86,9 +106,72 @@ export function evaluateWhen(when, vars) {
     return true;
 }
 export function isTruthy(val) {
+    if (Array.isArray(val))
+        return val.length > 0; // 空数组视为假，使 {{?arr}} / {{#each}} 落空
     return val !== undefined && val !== null && val !== false && val !== '' && val !== 0;
 }
 // ── Template rendering ──
+/**
+ * 展开 {{#each KEY}}BODY{{/each}} 循环块（在条件/变量替换之前跑）。
+ * - vars[KEY] 为非空数组才展开；每个元素构造子作用域：
+ *     对象元素 → { ...vars, ...el }（字段可用 {{field}} 访问）
+ *     标量元素 → { ...vars, '.': el }（{{.}} 访问当前元素）
+ *   另注入 {{@index}}（0 基序号）。
+ * - body 经完整 renderTemplate 递归渲染，天然支持嵌套 each / 条件。
+ * - 非数组或空数组 → 整块渲染为空串。
+ * 用深度扫描定位**最外层** each 块（正则无法平衡嵌套），从外向内展开。
+ */
+function resolveEach(template, vars, stripBlankLines) {
+    const OPEN = /\{\{#each\s+([A-Za-z_]\w*)\}\}/g;
+    let result = '';
+    let cursor = 0;
+    OPEN.lastIndex = 0;
+    let m;
+    while ((m = OPEN.exec(template)) !== null) {
+        const blockStart = m.index;
+        const key = m[1];
+        const bodyStart = OPEN.lastIndex;
+        // 从 bodyStart 起按深度找配对的 {{/each}}
+        const TOKEN = /\{\{#each\s+[A-Za-z_]\w*\}\}|\{\{\/each\}\}/g;
+        TOKEN.lastIndex = bodyStart;
+        let depth = 1;
+        let bodyEnd = -1;
+        let blockEnd = -1;
+        let t;
+        while ((t = TOKEN.exec(template)) !== null) {
+            if (t[0].startsWith('{{#each'))
+                depth++;
+            else {
+                depth--;
+                if (depth === 0) {
+                    bodyEnd = t.index;
+                    blockEnd = TOKEN.lastIndex;
+                    break;
+                }
+            }
+        }
+        if (bodyEnd === -1)
+            break; // 无配对，剩余原样输出
+        // 输出块前的原文
+        result += template.slice(cursor, blockStart);
+        const body = template.slice(bodyStart, bodyEnd);
+        const arr = vars[key];
+        if (Array.isArray(arr)) {
+            for (let i = 0; i < arr.length; i++) {
+                const el = arr[i];
+                const scope = (el && typeof el === 'object' && !Array.isArray(el))
+                    ? { ...vars, ...el, '@index': i }
+                    : { ...vars, '.': el, '@index': i };
+                result += renderTemplate(body, scope, stripBlankLines);
+            }
+        }
+        // 数组以外（含 undefined / 非数组）→ 整块跳过（不输出）
+        cursor = blockEnd;
+        OPEN.lastIndex = blockEnd;
+    }
+    result += template.slice(cursor);
+    return result;
+}
 function resolveConditions(template, vars) {
     // 只匹配**最内层** {{?...}}...{{/}} 块（逐字符负向前瞻排除嵌套），do/while 由内向外消解。
     const inner = /\{\{\?(\w+)(?:(!=|=)([^}]*))?\}\}((?:(?!\{\{\?)[^])*?)\{\{\/\}\}/;
@@ -111,11 +194,15 @@ function resolveConditions(template, vars) {
  * 紧凑）；false 时保留空行（消息正文用，正文多段结构不能被压扁）。
  */
 export function renderTemplate(template, vars, stripBlankLines = true) {
-    let result = resolveConditions(template, vars);
-    result = result.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    let result = resolveEach(template, vars, stripBlankLines);
+    result = resolveConditions(result, vars);
+    // 变量替换：支持普通名、当前元素 {{.}}、循环序号 {{@index}}。
+    result = result.replace(/\{\{(\.|@index|\w+)\}\}/g, (_match, key) => {
         const val = vars[key];
-        if (!isTruthy(val))
-            return '';
+        if (!isTruthy(val) && val !== 0)
+            return ''; // 0 是有效序号/值，保留
+        if (val === 0)
+            return '0';
         return String(val);
     });
     if (stripBlankLines)
@@ -146,11 +233,10 @@ export function resolvePathWithDiag(rawPath, vars) {
     if (unresolved.length > 0) {
         return { resolved, status: 'unresolved-vars', unresolvedTokens: unresolved };
     }
-    // 路径规范化：模板里 ../ 等相对片段折叠成真实路径
+    // 路径规范化：模板里 ../ 等相对片段折叠成真实路径。
+    // 不再在此 existsSync——存在性由随后经 fileCache 的内容读取顺带得到（file
+    // section 读出 null 即不存在），避免每 section 每消息一次 syscall。
     resolved = path.normalize(resolved);
-    if (!fs.existsSync(resolved)) {
-        return { resolved, status: 'not-exist', unresolvedTokens: unresolved };
-    }
     return { resolved, status: 'ok', unresolvedTokens: unresolved };
 }
 function resolvePath(rawPath, vars) {
@@ -174,29 +260,35 @@ export function loadSectionFiles(section, vars, sessionCache) {
     return [];
 }
 function loadFileSection(filePath, vars, sessionCache) {
+    void sessionCache; // 内容跨 session 共享，改走全局 fileCache（on-reload）
     const resolved = resolvePath(filePath, vars);
     if (!resolved)
         return null;
-    if (sessionCache.has(resolved))
-        return [resolved, sessionCache.get(resolved)];
-    try {
-        const content = fs.readFileSync(resolved, 'utf-8');
-        sessionCache.set(resolved, content);
-        return [resolved, content];
-    }
-    catch {
-        return null;
-    }
+    // 内容跨 session 共享：用全局 fileCache（on-reload，reload/重启时失效），
+    // 不再按 session 重复缓存同一文件内容。
+    const content = fileCache.getText(resolved, { policy: 'on-reload', group: 'kits' });
+    return content === null ? null : [resolved, content];
 }
 function readDirectoryFiles(dirPath, pattern) {
     const glob = pattern || '*.md';
-    try {
-        const files = fs.readdirSync(dirPath).filter(f => matchGlob(f, glob)).sort();
-        return files.map(f => [f, fs.readFileSync(path.join(dirPath, f), 'utf-8')]);
-    }
-    catch {
-        return [];
+    // 目录列表 + 各文件内容均走 fileCache（on-reload）。目录列表以 "<dir>|<glob>"
+    // 为键缓存文件名数组；各文件内容走 fileCache.getText 共享。
+    const names = fileCache.get(`${dirPath} ${glob}`, () => {
+        try {
+            return fs.readdirSync(dirPath).filter(f => matchGlob(f, glob)).sort();
+        }
+        catch {
+            return [];
+        }
+    }, { policy: 'on-reload', group: 'kits' });
+    const out = [];
+    for (const f of names) {
+        const fp = path.join(dirPath, f);
+        const content = fileCache.getText(fp, { policy: 'on-reload', group: 'kits' });
+        if (content !== null)
+            out.push([f, content]);
     }
+    return out;
 }
 function matchGlob(filename, pattern) {
     const regex = pattern

package/dist/{agents → eck}/message-renderer.js

@@ -10,7 +10,7 @@ import path from 'path';
 import { randomUUID } from 'crypto';
 import { eckDebugDir } from '../paths.js';
 import { logger } from '../utils/logger.js';
-import { loadManifest, evaluateWhen, renderTemplate, loadSectionFiles, } from './manifest-engine.js';
+import { loadManifest, evaluateWhen, renderTemplate, loadSectionFiles, defaultModeNames, } from './manifest-engine.js';
 const MESSAGE_MANIFEST_FILE = 'eck_message_manifest.json';
 // ── time formatting (per IANA timezone) ──
 function timeParts(epochMs, timeZone, opts) {
@@ -35,6 +35,19 @@ export function formatLocalTime(epochMs, timeZone) {
 // ── single item render ──
 function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
     const sections = loadManifest(MESSAGE_MANIFEST_FILE);
+    // 各 modeType 当前激活的 modeName：agent config.render（经 sessionVars.renderModes 透传）
+    // 覆盖 manifest 里标 isDefault 的缺省。详见 docs/observer-insert-design.md 第二部分。
+    const defaults = defaultModeNames(sections);
+    const configured = (sessionVars.renderModes && typeof sessionVars.renderModes === 'object' && !Array.isArray(sessionVars.renderModes))
+        ? sessionVars.renderModes
+        : {};
+    const activeMode = (type) => {
+        const c = configured[type];
+        if (typeof c === 'string' && c)
+            return c;
+        return defaults[type];
+    };
+    const isOwnerHint = item.kind === 'owner-hint';
     // item-level vars: session vars overlaid with this message's own sender/timestamp.
     const itemVars = {
         ...sessionVars,
@@ -44,7 +57,19 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
         sameDevice: item.sameDevice ?? sessionVars.sameDevice,
         sameNetwork: item.sameNetwork ?? sessionVars.sameNetwork,
         sameEgressIp: item.sameEgressIp ?? sessionVars.sameEgressIp,
+        // 模板引擎不支持数组循环：被 @ 的 AID 预先 join 成串，空则 undefined 使 {{?mentionAids}} 落空。
+        mentionAids: (item.mentionAids && item.mentionAids.length > 0) ? item.mentionAids.join(',') : undefined,
         now: formatLocalTime(item.timestamp ?? Date.now(), sessionVars.timezone ? String(sessionVars.timezone) : undefined),
+        // 渲染模式命中变量（manifest section 的 when 用它选中唯一模式）
+        renderMode_private: activeMode('private'),
+        renderMode_group: activeMode('group'),
+        renderMode_inject: activeMode('inject'),
+        // owner 插话提示标记 + 信封头字段
+        isOwnerHint,
+        ownerAid: isOwnerHint ? (item.ownerAid ?? undefined) : undefined,
+        injectTime: isOwnerHint
+            ? formatLocalTime(item.injectTime ?? item.timestamp ?? Date.now(), sessionVars.timezone ? String(sessionVars.timezone) : undefined)
+            : undefined,
         // content held as a per-call random sentinel, swapped back post-render.
         // Using a UUID means no real message can collide with it.
         content: contentSentinel,