evolcore 0.0.28 → 0.0.29

package/dist/core/task/task-activity-store.js

@@ -0,0 +1,219 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { agentTaskActivityDir } from '../../paths.js';
+import { MENU_RESPONSE_MAX_BYTES, MENU_RESPONSE_SAFETY_MARGIN_BYTES } from '../command/menu-protocol.js';
+const LIST_TEXT_BYTES = 1024;
+const LIST_LIMIT = 100;
+const MARKER = '[中间内容已省略]';
+const RESPONSE_DATA_BUDGET = MENU_RESPONSE_MAX_BYTES - MENU_RESPONSE_SAFETY_MARGIN_BYTES - 2 * 1024;
+function safeTaskId(taskId) {
+    if (!/^task-[A-Za-z0-9._:-]+$/.test(taskId))
+        throw new Error('Invalid taskId');
+    return encodeURIComponent(taskId);
+}
+function taskDir(selfAid) {
+    return agentTaskActivityDir(selfAid);
+}
+function taskFile(selfAid, taskId) {
+    return path.join(taskDir(selfAid), `${safeTaskId(taskId)}.jsonl`);
+}
+function metaLine(meta) {
+    return JSON.stringify({ type: 'meta', ...meta });
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function utf8Slice(value, maxBytes, fromEnd = false) {
+    if (Buffer.byteLength(value, 'utf8') <= maxBytes)
+        return value;
+    const chars = Array.from(value);
+    let used = 0;
+    const selected = [];
+    const ordered = fromEnd ? chars.reverse() : chars;
+    for (const char of ordered) {
+        const size = Buffer.byteLength(char, 'utf8');
+        if (used + size > maxBytes)
+            break;
+        selected.push(char);
+        used += size;
+    }
+    return fromEnd ? selected.reverse().join('') : selected.join('');
+}
+function compactText(value, maxBytes) {
+    if (Buffer.byteLength(value, 'utf8') <= maxBytes)
+        return value;
+    const markerBytes = Buffer.byteLength(MARKER, 'utf8');
+    const headBytes = Math.min(600, Math.max(0, Math.floor((maxBytes - markerBytes) * 0.75)));
+    const tailBytes = Math.max(0, maxBytes - markerBytes - headBytes);
+    const paragraphs = value.split(/\n\s*\n/u).map(part => part.trim()).filter(Boolean);
+    if (paragraphs.length > 1) {
+        const head = utf8Slice(paragraphs.slice(0, 1).join('\n\n'), headBytes);
+        const tail = utf8Slice(paragraphs.slice(-1).join('\n\n'), tailBytes, true);
+        return `${head}${MARKER}${tail}`;
+    }
+    return `${utf8Slice(value, headBytes)}${MARKER}${utf8Slice(value, tailBytes, true)}`;
+}
+function walkStrings(value, pathName, visit) {
+    if (!value || typeof value !== 'object')
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        const childPath = pathName ? `${pathName}.${key}` : key;
+        if (typeof child === 'string')
+            visit(value, key, childPath, child);
+        else
+            walkStrings(child, childPath, visit);
+    }
+}
+function projectItem(item, maxTextBytes) {
+    const projected = clone(item);
+    const truncatedFields = [];
+    walkStrings(projected, '', (parent, key, fieldPath, value) => {
+        const originalBytes = Buffer.byteLength(value, 'utf8');
+        if (originalBytes <= maxTextBytes)
+            return;
+        const compacted = compactText(value, maxTextBytes);
+        parent[key] = compacted;
+        truncatedFields.push({ path: fieldPath, originalBytes, returnedBytes: Buffer.byteLength(compacted, 'utf8') });
+    });
+    return { item: projected, truncatedFields };
+}
+function readJsonl(selfAid, taskId) {
+    const file = taskFile(selfAid, taskId);
+    if (!fs.existsSync(file))
+        return { records: [] };
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+    let meta;
+    const records = [];
+    for (const line of lines) {
+        try {
+            const value = JSON.parse(line);
+            if (value.type === 'meta')
+                meta = value;
+            else if (value.version === 1 && value.activityId && value.taskId && value.item)
+                records.push(value);
+        }
+        catch {
+            break;
+        }
+    }
+    return { meta, records };
+}
+function writeAtomic(file, content) {
+    const temp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+    fs.writeFileSync(temp, content, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+export class TaskActivityStore {
+    selfAid;
+    constructor(selfAid) {
+        this.selfAid = selfAid;
+    }
+    ensureMeta(input) {
+        const now = Date.now();
+        const current = readJsonl(this.selfAid, input.taskId).meta;
+        if (current)
+            return current;
+        const meta = {
+            version: 1,
+            taskId: input.taskId,
+            selfAid: this.selfAid,
+            sessionId: input.sessionId,
+            channel: input.channel,
+            channelId: input.channelId,
+            chatType: input.chatType,
+            ...(input.groupId ? { groupId: input.groupId } : {}),
+            ...(input.peerId ? { peerId: input.peerId } : {}),
+            taskStatus: input.taskStatus ?? 'running',
+            createdAt: now,
+            updatedAt: now,
+        };
+        fs.mkdirSync(taskDir(this.selfAid), { recursive: true, mode: 0o700 });
+        writeAtomic(taskFile(this.selfAid, input.taskId), `${metaLine(meta)}\n`);
+        return meta;
+    }
+    createTask(input) {
+        return this.ensureMeta(input);
+    }
+    append(input) {
+        const file = taskFile(this.selfAid, input.taskId);
+        const existingLoaded = readJsonl(this.selfAid, input.taskId);
+        const existing = input.activityId ? existingLoaded.records.find(record => record.activityId === input.activityId) : undefined;
+        if (existing)
+            return existing;
+        this.ensureMeta(input);
+        const loaded = readJsonl(this.selfAid, input.taskId);
+        const record = {
+            version: 1,
+            activityId: input.activityId ?? `activity-${crypto.randomUUID().replace(/-/g, '')}`,
+            taskId: input.taskId,
+            seq: loaded.records.length,
+            createdAt: Date.now(),
+            item: clone(input.item),
+        };
+        const meta = loaded.meta;
+        if (!meta)
+            throw new Error('Task metadata unavailable');
+        const updatedMeta = { ...meta, updatedAt: Date.now() };
+        writeAtomic(taskFile(this.selfAid, input.taskId), `${metaLine(updatedMeta)}\n${loaded.records.map(item => JSON.stringify(item)).join('\n')}${loaded.records.length ? '\n' : ''}${JSON.stringify(record)}\n`);
+        return record;
+    }
+    updateStatus(taskId, status) {
+        const loaded = readJsonl(this.selfAid, taskId);
+        if (!loaded.meta)
+            return;
+        const meta = { ...loaded.meta, taskStatus: status, updatedAt: Date.now() };
+        const lines = [metaLine(meta), ...loaded.records.map(record => JSON.stringify(record))];
+        writeAtomic(taskFile(this.selfAid, taskId), `${lines.join('\n')}\n`);
+    }
+    readList(taskId, offset, limit) {
+        const loaded = readJsonl(this.selfAid, taskId);
+        if (!loaded.meta)
+            throw Object.assign(new Error('Task not found'), { code: 'NOT_FOUND' });
+        const boundedLimit = Math.min(Math.max(1, Math.floor(limit)), LIST_LIMIT);
+        const safeOffset = Math.max(0, Math.floor(offset));
+        const items = [];
+        const responseBase = () => ({ view: 'activities', taskId, offset: safeOffset, limit: boundedLimit, total: loaded.records.length, hasMore: false, taskStatus: loaded.meta.taskStatus, updatedAt: loaded.meta.updatedAt, items });
+        for (const record of loaded.records.slice(safeOffset, safeOffset + boundedLimit)) {
+            const projection = projectItem(record.item, LIST_TEXT_BYTES);
+            const candidate = { activityId: record.activityId, seq: record.seq, createdAt: record.createdAt, item: projection.item, truncatedFields: projection.truncatedFields, contentAvailable: true };
+            items.push(candidate);
+            const candidateResponse = responseBase();
+            candidateResponse.hasMore = safeOffset + items.length < loaded.records.length;
+            if (Buffer.byteLength(JSON.stringify(candidateResponse), 'utf8') > RESPONSE_DATA_BUDGET) {
+                items.pop();
+                if (items.length === 0)
+                    throw Object.assign(new Error('Activity cannot fit in a Menu response'), { code: 'RESPONSE_TOO_LARGE' });
+                break;
+            }
+        }
+        return { view: 'activities', taskId, offset: safeOffset, limit: boundedLimit, total: loaded.records.length, hasMore: safeOffset + items.length < loaded.records.length, taskStatus: loaded.meta.taskStatus, updatedAt: loaded.meta.updatedAt, items };
+    }
+    readDetail(taskId, activityId) {
+        const loaded = readJsonl(this.selfAid, taskId);
+        if (!loaded.meta)
+            throw Object.assign(new Error('Task not found'), { code: 'NOT_FOUND' });
+        const record = loaded.records.find(item => item.activityId === activityId);
+        if (!record)
+            throw Object.assign(new Error('Activity not found'), { code: 'ACTIVITY_NOT_FOUND' });
+        let maxBytes = Number.MAX_SAFE_INTEGER;
+        let projection = projectItem(record.item, maxBytes);
+        const responseBytes = () => Buffer.byteLength(JSON.stringify({
+            view: 'activity', taskId, taskStatus: loaded.meta.taskStatus, updatedAt: loaded.meta.updatedAt,
+            activity: { activityId: record.activityId, seq: record.seq, createdAt: record.createdAt, item: projection.item, contentMode: projection.truncatedFields.length ? 'compressed' : 'full', truncatedFields: projection.truncatedFields },
+        }), 'utf8');
+        if (responseBytes() > RESPONSE_DATA_BUDGET)
+            maxBytes = Math.floor(RESPONSE_DATA_BUDGET / 2);
+        while (responseBytes() > RESPONSE_DATA_BUDGET && maxBytes >= 32) {
+            projection = projectItem(record.item, maxBytes);
+            maxBytes = Math.floor(maxBytes / 2);
+        }
+        if (responseBytes() > RESPONSE_DATA_BUDGET) {
+            throw Object.assign(new Error('Activity cannot fit in a Menu response'), { code: 'RESPONSE_TOO_LARGE' });
+        }
+        return { view: 'activity', taskId, taskStatus: loaded.meta.taskStatus, updatedAt: loaded.meta.updatedAt, activity: { activityId: record.activityId, seq: record.seq, createdAt: record.createdAt, item: projection.item, contentMode: projection.truncatedFields.length ? 'compressed' : 'full', truncatedFields: projection.truncatedFields } };
+    }
+    getMeta(taskId) {
+        return readJsonl(this.selfAid, taskId).meta;
+    }
+}

package/dist/eck/kit-renderer.js

@@ -6,7 +6,20 @@ import { logger } from '../utils/logger.js';
 import { clearRoleStoreCache } from '../config/role-store.js';
 import { resolveAgentLifecycle } from '../config/lifecycle.js';
 import { loadManifest, loadManifestMeta, invalidateManifestCache, evaluateWhen, renderTemplate, renderLoopSection, resolvePathWithDiag, loadSectionFiles, loadChildTemplate, buildPathMappings, shortenPath, } from './manifest-engine.js';
-const DEFAULT_MANIFEST_FILE = 'eck_manifest.json';
+export const DEFAULT_MANIFEST_FILE = 'eck_manifest.json';
+/**
+ * 会话原型（sessionType）→ manifest 文件的内置映射。
+ * 核心会话类型不依赖 agent config 即可找到自己的 manifest；config.sessionManifests 仅作可选覆盖。
+ */
+export const BUILTIN_SESSION_MANIFESTS = {
+    main: DEFAULT_MANIFEST_FILE,
+    memory: 'eck_manifest.memory.json',
+    auxiliary: 'eck_manifest.auxiliary.json',
+};
+/** 选择顺序：config 覆盖 → 内置映射 → 主 manifest。 */
+export function resolveSessionManifest(sessionType, overrides) {
+    return overrides?.[sessionType] ?? BUILTIN_SESSION_MANIFESTS[sessionType] ?? DEFAULT_MANIFEST_FILE;
+}
 // ── Caches ──
 const _sessionPathCache = new Map();
 function getSessionCache(sessionId) {
@@ -77,11 +90,17 @@ export function renderKitSections(ctx, manifestFile = DEFAULT_MANIFEST_FILE) {
     const skippedByCap = []; // 因总闸超限未加载的 section id
     for (const section of sections) {
         const rawPath = section.type === 'file' ? (section.file ?? '') : (section.path ?? '');
+        if (section.type === 'file' && !section.file) {
+            // 字段写错（如写成 path）时引擎会丢段。用真实字段名记账，别让诊断显示成
+            // "路径为空"——那会误导排查方向。加载期另有 warnInvalidSections 告警。
+            logger.warn(`[KitRenderer] section "${section.id}" 是 type=file 但缺少 file 字段，将被跳过`);
+        }
         const diag = {
             id: section.id, description: section.description, type: section.type, rawPath,
             pattern: section.pattern, needsInjection: section.needsInjection, when: section.when,
             enabled: section.enabled !== false, whenPassed: false, resolvedPath: null,
             resolveStatus: 'no-path', fileCount: 0, used: false, injected: false,
+            optional: section.optional,
         };
         // 总闸已触发：后续命中的段一律不加载，只记录 id
         if (capReached) {
@@ -203,6 +222,7 @@ const PARAM_DESCRIPTIONS = {
     EVOLCORE_HOME: '用户数据根目录',
     PACKAGE_ROOT: 'evolcore 包根目录',
     CURRENT_PROJECT: '当前项目完整路径',
+    AGENT_DIR: '当前 agent 数据根目录',
     PERSONAL_DIR: '当前 agent 个人数据目录',
     RELATIONS_DIR: '当前 agent 关系数据目录',
     VENUES_DIR: '当前 agent 环境数据目录',
@@ -227,7 +247,7 @@ const PARAM_DESCRIPTIONS = {
     chatType: '聊天类型（private=私聊 / group=群聊 / null=本地开发）',
     channel: '渠道类型（aun/feishu/wechat/dingtalk/qqbot/wecom）',
     venueUid: '场所唯一标识（预留）',
-    mentionMode: '群 @ 处理模式（mention-only=被@才响应 / disabled=所有消息都响应）',
+    mentionMode: '群 @ 处理模式（mention-only=被@才响应 / disabled=所有消息都响应 / auto=按上下文判断）',
     groupHistoryAvailable: '本地群历史读取能力是否可用',
     clientType: '客户端类型（desktop/web/mobile）',
     permissionMode: '权限模式（readonly/auto/request/bypass；旧值会安全迁移）',
@@ -306,7 +326,14 @@ function formatManifestDiagnostics(ctx, diagnostics) {
     };
     const used = diagnostics.filter(d => d.used).length;
     const skippedWhen = diagnostics.filter(d => d.resolveStatus === 'skipped-when').length;
-    const errors = diagnostics.filter(d => d.resolveStatus === 'unresolved-vars' || d.resolveStatus === 'not-exist').length;
+    // optional=true 的段 not-exist 不算错误（Q1 决策：空集索引缺失是正常态）
+    const errors = diagnostics.filter(d => {
+        if (d.resolveStatus === 'unresolved-vars')
+            return true;
+        if (d.resolveStatus === 'not-exist')
+            return d.optional !== true;
+        return false;
+    }).length;
     const lines = [];
     lines.push(`# ECK Manifest Diagnostics`);
     lines.push('');

package/dist/eck/manifest-engine.js

@@ -46,11 +46,11 @@ function loadAndMergeManifest(filename) {
         return [];
     }
     if (!fs.existsSync(eckPath))
-        return sortSections(base.sections);
+        return sortSections(warnInvalidSections(base.sections, filename));
     try {
         const override = JSON.parse(fs.readFileSync(eckPath, 'utf-8'));
         if (override.mode === 'replace')
-            return sortSections(override.sections);
+            return sortSections(warnInvalidSections(override.sections, filename));
         const merged = new Map();
         for (const s of base.sections)
             merged.set(s.id, { ...s });
@@ -62,13 +62,35 @@ function loadAndMergeManifest(filename) {
             const existing = merged.get(s.id);
             merged.set(s.id, existing ? { ...existing, ...s } : s);
         }
-        return sortSections([...merged.values()]);
+        return sortSections(warnInvalidSections([...merged.values()], filename));
     }
     catch (err) {
         logger.warn(`[ManifestEngine] Failed to load eck override for ${filename}, using kits only: ${err}`);
-        return sortSections(base.sections);
+        return sortSections(warnInvalidSections(base.sections, filename));
     }
 }
+/**
+ * 校验段声明的路径字段是否可被引擎读取。
+ *
+ * `type=file` 只认 `file`，`type=directory` 只认 `path`（见 loadSectionFiles）。
+ * 字段名写错（例如把 file 段写成 path）时引擎原样丢段——可选段还是静默的，
+ * 排查极难。这里在加载期统一告警，把「配错了」与「文件不存在」区分开。
+ */
+function warnInvalidSections(sections, filename) {
+    for (const s of sections) {
+        if (s.enabled === false)
+            continue;
+        if (s.type === 'file' && !s.file) {
+            const wrong = s.path ? `（疑似误用 path="${s.path}"，file 段须写 file 字段）` : '';
+            logger.warn(`[ManifestEngine] ${filename}: section "${s.id}" 是 type=file 但缺少 file 字段，该段会被跳过${wrong}`);
+        }
+        else if (s.type === 'directory' && !s.path) {
+            const wrong = s.file ? `（疑似误用 file="${s.file}"，directory 段须写 path 字段）` : '';
+            logger.warn(`[ManifestEngine] ${filename}: section "${s.id}" 是 type=directory 但缺少 path 字段，该段会被跳过${wrong}`);
+        }
+    }
+    return sections;
+}
 function sortSections(sections) {
     return sections.slice().sort((a, b) => a.order - b.order);
 }