evolcore 0.0.33 → 0.0.34

package/dist/core/session/session-manager.js

@@ -5,7 +5,7 @@ import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
 import { readRunnerEventSummary } from './runner-event-summary.js';
 import { isInternalInjectedUserMessage, isToolResultMessage } from './session-transcript.js';
-import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, appendJsonlDurable, fsyncJsonlFile, readJsonFile, readLastJsonlLine, readLastJsonlLineStrict, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
+import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, appendJsonlDurable, fsyncJsonlFile, readJsonFile, readLastJsonlLine, readLastJsonlLineStrict, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, compactJsonlTail, SESSION_META_COMPACT_POLICY, } from './session-fs-store.js';
 import { sessionToFile, fileToSession, formatSessionKey, DEFAULT_THREAD_ID, normalizeTopicLabel, normalizeTopicStatus, } from './session-mapper.js';
 import { tryParseChannelKey } from '../channel-loader.js';
 import { isSystemControlChannel } from '../system-channels.js';
@@ -261,6 +261,9 @@ export class SessionManager {
     identityResolver;
     fileAdapters = new Map();
     sessionEncryptState = new Map();
+    /** findSessionFileById 的查找缓存：命中前一律 stat 校验，不作为真相源。 */
+    sessionFileIndex = new Map();
+    knownChatDirs = null;
     constructor(sessionsDir, eventBus, identityResolver) {
         ensureDir(sessionsDir);
         this.sessionsDir = sessionsDir;
@@ -627,6 +630,13 @@ export class SessionManager {
             appendJsonlDurable(metaPath, file);
         else
             appendJsonl(metaPath, file);
+        // 本次快照已落盘；压缩只回收历史行，失败不影响写入结果，原文件保持不变。
+        try {
+            compactJsonlTail(metaPath, SESSION_META_COMPACT_POLICY);
+        }
+        catch (error) {
+            logger.warn(`[SessionManager] meta compaction skipped for ${metaPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     /**
      * Session 持久化的唯一事务原语。所有 session 写操作都应经此，业务层不直接调
@@ -817,24 +827,84 @@ export class SessionManager {
         }
         return results;
     }
+    /**
+     * 按 sessionId 定位 meta 文件。逐个 id 全量 scanChatDirs 在几百个 chat 目录下
+     * 单次约 50ms，启动时批量查询（SessionIdleMonitor 恢复 170+ 会话）会同步阻塞数秒，
+     * 所以首次查询时按 readdir 建一份 id→路径索引，之后：
+     *   - 命中：stat 校验仍在才返回（文件被移进 _trash/目录被迁移时自然失效）；
+     *   - 未命中：先在已知目录里按原规则 stat 探测（覆盖索引之后新建的会话），
+     *     再重扫目录列表、只探测新出现的目录。不存在的 id 开销与原实现相当。
+     * 目录顺序与「同目录先主文件后 _threads」的优先级保持原实现语义。
+     */
     findSessionFileById(sessionId) {
-        const chatDirs = scanChatDirs(this.sessionsDir);
-        for (const { dirPath } of chatDirs) {
+        const cached = this.sessionFileIndex.get(sessionId);
+        if (cached) {
+            try {
+                fs.statSync(cached.metaPath);
+                return cached;
+            }
+            catch {
+                this.sessionFileIndex.delete(sessionId);
+            }
+        }
+        if (!this.knownChatDirs) {
+            this.rebuildSessionFileIndex();
+            const indexed = this.sessionFileIndex.get(sessionId);
+            if (indexed)
+                return indexed;
+        }
+        const probed = this.probeSessionFile(sessionId, this.knownChatDirs);
+        if (probed)
+            return probed;
+        const previous = new Set(this.knownChatDirs);
+        this.knownChatDirs = scanChatDirs(this.sessionsDir).map(entry => entry.dirPath);
+        return this.probeSessionFile(sessionId, this.knownChatDirs.filter(dir => !previous.has(dir)));
+    }
+    probeSessionFile(sessionId, chatDirs) {
+        for (const dirPath of chatDirs) {
             const mainPath = path.join(dirPath, `${sessionId}.jsonl`);
             try {
                 fs.statSync(mainPath);
-                return { chatDir: dirPath, metaPath: mainPath, isThread: false };
+                return this.rememberSessionFile(sessionId, { chatDir: dirPath, metaPath: mainPath, isThread: false });
             }
             catch { }
             const threadPath = path.join(dirPath, '_threads', `${sessionId}.jsonl`);
             try {
                 fs.statSync(threadPath);
-                return { chatDir: dirPath, metaPath: threadPath, isThread: true };
+                return this.rememberSessionFile(sessionId, { chatDir: dirPath, metaPath: threadPath, isThread: true });
             }
             catch { }
         }
         return undefined;
     }
+    rememberSessionFile(sessionId, found) {
+        this.sessionFileIndex.set(sessionId, found);
+        return found;
+    }
+    rebuildSessionFileIndex() {
+        this.sessionFileIndex.clear();
+        this.knownChatDirs = scanChatDirs(this.sessionsDir).map(entry => entry.dirPath);
+        for (const dirPath of this.knownChatDirs) {
+            for (const [dir, isThread] of [[dirPath, false], [path.join(dirPath, '_threads'), true]]) {
+                let names;
+                try {
+                    names = fs.readdirSync(dir);
+                }
+                catch {
+                    continue;
+                }
+                for (const name of names) {
+                    if (!name.endsWith('.jsonl'))
+                        continue;
+                    const id = name.slice(0, -'.jsonl'.length);
+                    // 先到先得：与逐目录探测时的优先级一致。
+                    if (!this.sessionFileIndex.has(id)) {
+                        this.sessionFileIndex.set(id, { chatDir: dirPath, metaPath: path.join(dir, name), isThread });
+                    }
+                }
+            }
+        }
+    }
     // ─── Public API ───
     getKnownThreadIds(channel) {
         const chatDirs = scanChatDirs(this.sessionsDir);

package/dist/core/skill/index-generator.js

@@ -3,6 +3,8 @@ import path from 'path';
 import { parseDocument } from 'yaml';
 import { resolveSkills } from './switch-resolver.js';
 import { logger } from '../../utils/logger.js';
+import { isDevMode } from '../../paths.js';
+import { isShippedPath, readVerifiedText } from '../file-integrity/read.js';
 /**
  * 生成索引文件（汇总 → 分组 → 落两文件）。
  *
@@ -68,11 +70,22 @@ function generateOneIndex(indexDir, filename, skills, label) {
  *
  * 直接按目录读，不走 discoverSkillDirectories——后者按父目录扫描再按 name 匹配，
  * 同名技能（本机覆盖内置）会读到另一份的 description。
+ *
+ * 内置技能是随包发布的内容：安装模式下按台账校验，带外改动会被恢复成登记版本，
+ * 恢复不了就不进索引（返回空描述），与 ECK 文档同一套策略。开发模式下不校验，
+ * agent 随手改技能可以立刻生效。
+ *
+ * 注意：这里保护的是索引里那行描述。模型拿到索引后是用 Read 工具读 SKILL.md 正文的，
+ * 那条路径不经过本函数，目前不受台账保护（等单独的 SKILL.md 加载工具接手）。
  */
 export function readSkillDescription(skillDir) {
+    const file = path.join(skillDir, 'SKILL.md');
+    const verify = isShippedPath(file) && !isDevMode();
     try {
-        const text = fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf-8');
-        const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+        const checked = readVerifiedText(file, { verify, tag: 'skill' });
+        if (!checked)
+            return '';
+        const match = checked.text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
         if (!match)
             return '';
         const doc = parseDocument(match[1]);
@@ -81,7 +94,8 @@ export function readSkillDescription(skillDir) {
         const meta = doc.toJS();
         return typeof meta?.description === 'string' ? meta.description.trim() : '';
     }
-    catch {
+    catch (err) {
+        logger.warn(`[skill] read description failed path=${file} ${err instanceof Error ? err.message : String(err)}`);
         return '';
     }
 }

package/dist/core/system-session/grants.js

@@ -0,0 +1,40 @@
+/**
+ * system-session/grants.ts — 写入目标与模块声明的可写文件逐个精确比对
+ *
+ * 输入只有 canonicalToolCall 给出的写入目标和 grants().writeFiles，不读任何 runner 的工具入参。
+ */
+import fs from 'fs';
+import { isSameOrDescendant, resolveProtectedCandidateWithoutFinalSymlink, } from '../permission/protected-paths.js';
+/**
+ * 每个写入目标都必须正好是某个声明的可写文件：
+ * - 祖先目录按 realpath 解析、最后一段按字面比较（目标若是符号链接，比较的是链接本身，不跟随）；
+ * - 目标已存在时必须是普通文件且只有一个硬链接，链接、目录、硬链接一律拒绝；
+ * - 相对路径按会话 cwd 解析。目标列表为空表示取不到路径，按拒绝处理。
+ */
+export function checkWriteTargets(targets, writeFiles, cwd) {
+    if (targets.length === 0)
+        return { ok: false, reason: 'no-target' };
+    const allowed = writeFiles.map(file => resolveProtectedCandidateWithoutFinalSymlink(file));
+    for (const target of targets) {
+        const resolved = resolveProtectedCandidateWithoutFinalSymlink(target, cwd);
+        if (!allowed.some(file => samePath(resolved, file))) {
+            return { ok: false, reason: 'outside-grant', path: resolved };
+        }
+        let stat;
+        try {
+            stat = fs.lstatSync(resolved);
+        }
+        catch (error) {
+            // 尚未创建是正常情况；其余错误（权限、父路径是文件等）一律按拒绝处理。
+            if (error.code === 'ENOENT')
+                continue;
+            return { ok: false, reason: 'not-regular-file', path: resolved };
+        }
+        if (!stat.isFile() || stat.nlink > 1)
+            return { ok: false, reason: 'not-regular-file', path: resolved };
+    }
+    return { ok: true };
+}
+function samePath(a, b) {
+    return isSameOrDescendant(a, b) && isSameOrDescendant(b, a);
+}

package/dist/core/system-session/memory.js

@@ -0,0 +1,222 @@
+/**
+ * system-session/memory.ts — 记忆整理会话模块
+ *
+ * 写入只有两条路：记忆走 `ec memory create|update|archive`；整理反馈写 B/scratch/feedback.txt，
+ * 这是本会话唯一的可写文件（见 memoryGrants）。其余路径全部只读：
+ *
+ *   B = 批次目录      R = relations/<peer>/memory      A = personal/memory
+ *   O = memory/owner/<owner>      M = 本对话 messages.jsonl（单文件）
+ *
+ *   notes      B, R/processing, R/consolidated, R/MEMORY.md, M
+ *   generalize B, A/consolidated, A/MEMORY.md, R/consolidated, M
+ *   promote    B, O/consolidated, O/MEMORY.md, R/consolidated, M
+ *   profile    B, R/consolidated, R/MEMORY.md, M
+ *   forget     B, X/consolidated, X/MEMORY.md（X=触发层级），X=relation 时加 M
+ *
+ * 详见 docs/memory/system-session-plugin-design.md §5-§8
+ */
+import path from 'path';
+import { resolveRoot } from '../../paths.js';
+import { parseCodexToolCommand } from '../permission/ec-command-parser.js';
+import { canonicalToolCall } from '../permission/tool-canonical.js';
+import { checkReadonly } from '../permission/tool-policy.js';
+import { CONSOLIDATION_MODES } from '../memory/consolidation-context.js';
+import { feedbackFilePath } from '../memory/consolidation-ops-records.js';
+import { checkWriteTargets } from './grants.js';
+export const MEMORY_SESSION_DENY_MESSAGE = '整理会话不允许执行此命令';
+const MEMORY_MANIFEST = 'eck_manifest.memory.json';
+const ALLOWED_MEMORY_SUBCOMMANDS = new Set(['create', 'update', 'archive']);
+const BASH_COMMAND_RULE = 'Bash 只允许单条 `ec memory create|update|archive`，或落在本次整理目录内的只读查询'
+    + '（不能拼接其他命令；正文含特殊字符时用单引号包住）。读文件请用 Read / Glob / Grep；'
+    + '整理反馈用文件写入工具写到任务书指定的反馈文件。';
+function layerDir(layer, ctx) {
+    const root = resolveRoot();
+    if (layer === 'agent')
+        return path.join(root, 'agents', ctx.selfAid, 'personal', 'memory');
+    if (layer === 'relation') {
+        return ctx.peerKey ? path.join(root, 'agents', ctx.selfAid, 'relations', ctx.peerKey, 'memory') : undefined;
+    }
+    return ctx.ownerAid ? path.join(root, 'memory', 'owner', ctx.ownerAid) : undefined;
+}
+/** 本模式的可读根。缺少输入事实（如无 peerKey）的条目直接不给，fail-closed。 */
+export function memoryReadRoots(ctx) {
+    const roots = [];
+    const add = (...values) => {
+        for (const value of values)
+            if (value && path.isAbsolute(value))
+                roots.push(value);
+    };
+    const consolidated = (layer) => {
+        const dir = layerDir(layer, ctx);
+        return dir ? [path.join(dir, 'consolidated'), path.join(dir, 'MEMORY.md')] : [];
+    };
+    const relation = layerDir('relation', ctx);
+    const messages = ctx.chatDir ? path.join(ctx.chatDir, 'messages.jsonl') : undefined;
+    // 批次目录已覆盖反馈文件，不必单独列出
+    add(ctx.batchDir);
+    switch (ctx.subtype) {
+        case 'notes':
+            add(relation && path.join(relation, 'processing'), ...consolidated('relation'), messages);
+            break;
+        case 'generalize':
+            add(...consolidated('agent'), relation && path.join(relation, 'consolidated'), messages);
+            break;
+        case 'promote':
+            add(...consolidated('owner'), relation && path.join(relation, 'consolidated'), messages);
+            break;
+        case 'profile':
+            add(...consolidated('relation'), messages);
+            break;
+        case 'forget':
+            if (ctx.memoryScope) {
+                add(...consolidated(ctx.memoryScope));
+                if (ctx.memoryScope === 'relation')
+                    add(messages);
+            }
+            break;
+        default:
+            break;
+    }
+    return [...new Set(roots)];
+}
+/** 文件权限声明：读按路径矩阵，写只有本批次的反馈文件一个。缺批次目录时不给任何可写文件。 */
+export function memoryGrants(ctx) {
+    return {
+        readRoots: memoryReadRoots(ctx),
+        writeFiles: ctx.batchDir && path.isAbsolute(ctx.batchDir) ? [feedbackFilePath(ctx.batchDir)] : [],
+    };
+}
+function deny(code, reason) {
+    return { allow: false, code, reason: `${MEMORY_SESSION_DENY_MESSAGE}：${reason}` };
+}
+/**
+ * 把 shell 解析失败翻译成可照做的补救动作。
+ *
+ * `ec memory create … "……"` 因正文含反引号被拒时，泛化文案会把病因指向"拼接了别的命令"，
+ * 真正的病因是正文的引号选错了，所以按 issue 精确归因。
+ */
+function shellIssueRemedy(issue) {
+    switch (issue) {
+        case 'unsafe-expansion':
+            return '自由文本参数（--desc、正文、--keywords）里的反引号或 `$` 出现在双引号内，'
+                + '会被 shell 当作命令替换或变量展开，所以无法确认它实际会执行什么。'
+                + '请把这些参数改用单引号包住（如 --desc \'……\'）。'
+                + '注意单引号内部不能再出现单引号本身，正文可以跨多行。';
+        case 'invalid-quote':
+            return '单引号包裹的正文里出现了单引号本身，导致引号提前闭合、命令无法解析。'
+                + '正文里不要写半角撇号（ASCII 0x27）：改用 `ʼ`（U+02BC）或 `＇`（U+FF07）代替，'
+                + '或换一种说法避开这个字符。不要尝试转义——'
+                + '单引号内无法转义单引号，转义与拼接一律被拒。';
+        case 'structural-newline':
+            return '命令里存在未闭合的换行结构。把正文放进单引号内即可直接换行。';
+        case 'shell-composition':
+            return '命令里含有 shell 拼接、管道或重定向（`;` `&&` `|` `$()` 等）。整理会话只允许单条 ec memory 命令。';
+        case 'unsupported-escape':
+            return '命令里使用了不受支持的转义写法。请改用单引号包住正文，避免转义。';
+        case 'lossy-cmd-shim':
+            return '命令经过 Windows cmd 包装后无法无歧义还原。请把正文改成不含换行的单条命令。';
+        case 'untrusted-shell':
+            return '命令带有不受信任的 shell 包装。请直接写 `ec memory …`，不要经由其他 shell 转发。';
+        default:
+            return undefined;
+    }
+}
+function looksLikeMemoryCommand(command) {
+    return /^\s*ec(?:\.cmd|\.exe|\.ps1)?\s+memory\s+\S/.test(command);
+}
+/** 只读路径判定：复用 checkReadonly，可读根只来自 memoryGrants。 */
+function checkReadWithinMatrix(toolName, input, ctx) {
+    return checkReadonly(toolName, input, ctx.projectPath, {
+        sessionId: ctx.sessionId,
+        selfAid: ctx.selfAid,
+        managedTempDir: ctx.managedTempDir,
+        grantedReadRoots: memoryGrants(ctx).readRoots,
+        excludeWorkspace: true,
+        allowProtectedMetadata: false,
+    });
+}
+/** 写入判定只看 canonicalToolCall 给出的目标，不读工具入参。 */
+function checkWrite(call, ctx) {
+    // shell 里的 apply_patch 跑的是 runner 自带的补丁器还是任意可执行文件，取决于 runner；
+    // 需要它的 runner 由适配层先转成 FileChange 再交给模块，模块这里一律不认。
+    if (call.via === 'shell') {
+        return deny('memory_session_shell_write_forbidden', '不能经由 shell 写文件，整理反馈请用文件写入工具写到任务书指定的反馈文件');
+    }
+    const { writeFiles } = memoryGrants(ctx);
+    if (writeFiles.length === 0) {
+        return deny('memory_session_write_no_target', '当前会话缺少批次目录，没有可写的反馈文件');
+    }
+    const result = checkWriteTargets(call.paths, writeFiles, ctx.projectPath);
+    if (result.ok)
+        return { allow: true };
+    const reason = result.reason === 'no-target'
+        ? '无法确定写入目标'
+        : result.reason === 'not-regular-file'
+            ? `写入目标不是普通文件（链接、目录或硬链接）：${result.path}`
+            : `只能写反馈文件 ${writeFiles[0]}，不能写 ${result.path}`;
+    return deny('memory_session_write_outside_grant', reason);
+}
+function isAllowedMemoryCommand(argv) {
+    return argv[0] === 'ec' && argv[1] === 'memory' && ALLOWED_MEMORY_SUBCOMMANDS.has(argv[2] ?? '');
+}
+function checkShell(input, ctx) {
+    const parsed = parseCodexToolCommand(input);
+    if (parsed.ok && isAllowedMemoryCommand(parsed.argv))
+        return { allow: true, ecCommand: true };
+    // Codex 没有 Read 工具，读任务书只能靠可证明只读的 shell 查询
+    const readonly = checkReadWithinMatrix('Bash', input, ctx);
+    if (readonly.behavior === 'allow')
+        return { allow: true };
+    if (!parsed.ok) {
+        const rawCommand = typeof input.command === 'string' ? input.command : '';
+        const remedy = shellIssueRemedy(parsed.issue);
+        if (looksLikeMemoryCommand(rawCommand) && remedy) {
+            return deny('memory_session_command_forbidden', `这条命令本身就是 \`ec memory\`，但未能解析成单条字面命令。${remedy}`);
+        }
+    }
+    return deny('memory_session_command_forbidden', BASH_COMMAND_RULE);
+}
+function checkTool(rawToolName, input, ctx) {
+    const call = canonicalToolCall(rawToolName, input);
+    switch (call.access) {
+        case 'read': {
+            const result = checkReadWithinMatrix(call.name, input, ctx);
+            return result.behavior === 'allow'
+                ? { allow: true }
+                : deny(result.policyCode ?? 'memory_session_read_outside_matrix', '只能读取本次整理的批次目录、对应记忆目录与本对话流水');
+        }
+        case 'write':
+            // 引号内恰好出现 apply_patch 字样的 ec memory 命令可能被保守识别成 shell 写入，先按 ec 命令认定
+            if (call.via === 'shell') {
+                const parsed = parseCodexToolCommand(input);
+                if (parsed.ok && isAllowedMemoryCommand(parsed.argv))
+                    return { allow: true, ecCommand: true };
+            }
+            return checkWrite(call, ctx);
+        case 'shell':
+            return checkShell(input, ctx);
+        default:
+            return deny('memory_session_tool_forbidden', `整理会话不能使用 ${rawToolName}；写记忆用 \`ec memory create|update|archive\`，整理反馈写到任务书指定的反馈文件`);
+    }
+}
+function checkCommand(argv) {
+    if (argv[0] === 'memory' && ALLOWED_MEMORY_SUBCOMMANDS.has(argv[1] ?? ''))
+        return { allow: true };
+    return deny('memory_session_command_forbidden', '只允许 `ec memory create|update|archive`');
+}
+export const memorySystemSession = {
+    type: 'memory',
+    subtypes: CONSOLIDATION_MODES,
+    supportedRunners: ['claude', 'codex', 'ecagent'],
+    manifest: () => MEMORY_MANIFEST,
+    // 不启用 runner 自带的 OS 沙箱：整理会话要读写的路径在 $EVOLCORE_HOME 下，
+    // 与会话 cwd 互为兄弟目录，沙箱的「项目目录」模型套不上。边界改由 grants 单独管。
+    runnerLaunch: (_runner, ctx) => ({
+        sandbox: 'off',
+        runnerMode: 'readonly',
+        grants: memoryGrants(ctx),
+    }),
+    grants: memoryGrants,
+    checkTool,
+    checkCommand: argv => checkCommand(argv),
+};

package/dist/core/system-session/registry.js

@@ -0,0 +1,74 @@
+/**
+ * system-session/registry.ts — 系统会话模块注册表
+ *
+ * 只登记仓库内的模块，不做运行时动态加载、不读配置。
+ */
+import { SYSTEM_SESSION_TYPES } from './types.js';
+import { memorySystemSession } from './memory.js';
+const MODULES = new Map([
+    [memorySystemSession.type, memorySystemSession],
+]);
+if (SYSTEM_SESSION_TYPES.length !== MODULES.size || SYSTEM_SESSION_TYPES.some(type => !MODULES.has(type))) {
+    throw new Error('SYSTEM_SESSION_TYPES 与系统会话注册表不一致');
+}
+export function getSystemSessionModule(type) {
+    return MODULES.get(type);
+}
+export function isSystemSessionType(type) {
+    return !!type && MODULES.has(type);
+}
+/** 从 session.metadata 读出系统会话标记；存在但不合法时拒绝降级为普通会话。 */
+export function readSystemSessionMarker(metadata) {
+    const rawValue = metadata?.systemSession;
+    if (rawValue === undefined)
+        return undefined;
+    if (!rawValue || typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+        throw new Error('系统会话标记格式非法');
+    }
+    const raw = rawValue;
+    if (typeof raw.type !== 'string' || typeof raw.subtype !== 'string') {
+        throw new Error('系统会话标记缺少 type 或 subtype');
+    }
+    const module = MODULES.get(raw.type);
+    if (!module)
+        throw new Error(`未注册的系统会话类型: ${raw.type}`);
+    if (!module.subtypes.includes(raw.subtype)) {
+        throw new Error(`系统会话 ${raw.type} 不支持 subtype: ${raw.subtype}`);
+    }
+    return { type: raw.type, subtype: raw.subtype };
+}
+/**
+ * 拉起前校验：类型与 subtype 已注册、runner 受支持。
+ * 不合法直接抛错，调用方不应降级成普通会话。
+ */
+export function assertSystemSessionLaunchable(marker, runner) {
+    const module = MODULES.get(marker.type);
+    if (!module)
+        throw new Error(`未注册的系统会话类型: ${marker.type}`);
+    if (!module.subtypes.includes(marker.subtype)) {
+        throw new Error(`系统会话 ${marker.type} 不支持 subtype: ${marker.subtype}`);
+    }
+    if (!module.supportedRunners.includes(runner)) {
+        throw new Error(`系统会话 ${marker.type} 不支持在 ${runner} 上运行（支持：${module.supportedRunners.join(', ')}）`);
+    }
+    return module;
+}
+/** 从 session.metadata 构造模块输入事实。 */
+export function buildSystemSessionContext(params) {
+    const m = params.metadata ?? {};
+    const str = (key) => (typeof m[key] === 'string' && m[key] ? m[key] : undefined);
+    const scope = str('memoryScope');
+    const batchDir = str('consolidationBatchDir');
+    return {
+        sessionId: params.sessionId,
+        subtype: params.marker.subtype,
+        selfAid: params.selfAid,
+        projectPath: params.projectPath,
+        ...(params.managedTempDir ? { managedTempDir: params.managedTempDir } : {}),
+        ...(str('peerKey') ? { peerKey: str('peerKey') } : {}),
+        ...(str('consolidationOwnerAid') ? { ownerAid: str('consolidationOwnerAid') } : {}),
+        ...(batchDir ? { batchDir } : {}),
+        ...(str('consolidationChatDir') ? { chatDir: str('consolidationChatDir') } : {}),
+        ...(scope === 'relation' || scope === 'agent' || scope === 'owner' ? { memoryScope: scope } : {}),
+    };
+}

package/dist/core/system-session/types.js

@@ -0,0 +1,14 @@
+/**
+ * system-session/types.ts — 系统会话模块接口
+ *
+ * 系统会话（记忆整理等）与角色体系无关：不带角色、不走角色权限判定。
+ * 路径、工具、ec 命令、manifest、runner 启动参数全部由对应类型的代码模块决定，
+ * 模块的结论就是最终结论，不可配置。
+ *
+ * 详见 docs/memory/system-session-plugin-design.md
+ */
+/**
+ * 已注册的系统会话类型。放在无依赖的 types.ts，供 eck / config 层判断而不引入模块实现；
+ * registry.ts 启动时校验与注册表一致。
+ */
+export const SYSTEM_SESSION_TYPES = ['memory'];

package/dist/core/thread/thread-service.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import path from 'path';
 import { agentSessionsDir, agentDir, agentThreadIndexPath, agentThreadSummariesDir, agentThreadSummaryPath } from '../../paths.js';
 import { atomicWriteJson, atomicReadJson } from '../../utils/atomic-write.js';
-import { appendJsonl, readAllJsonlLines, readLastJsonlLineStrict, chatDirPath, tryParseChannelSessionKey } from '../session/session-fs-store.js';
+import { appendJsonl, appendJsonlDurable, readAllJsonlLines, readLastJsonlLine, readLastJsonlLineStrict, chatDirPath, tryParseChannelSessionKey } from '../session/session-fs-store.js';
 import { sanitizeSessionTitle } from '../session/session-title.js';
 import { ThreadContextStorage } from './thread-context-storage.js';
 const THREAD_ID_RE = /^thread-[0-9]+-[0-9a-f]{4}-[0-9a-f]{4}$/;
@@ -631,33 +631,26 @@ export class ThreadService {
     /**
      * 把话题的当前元数据追加一行到 _threads/<sessionId>.jsonl，
      * 使 rebuildIndex 读最后一行时能拿到 rename/label/status 后的最新值。
-     * 追加的行包含 fileToSession 所需的所有字段（从第一行继承），
+     * 追加的行以最后一行（当前权威快照）为底，只覆盖话题字段，
      * 确保 readMetaLatest 读最后一行时不报 "baseagent is empty"。
+     *
+     * 不能从第一行继承：第一行是创建记录，agentSessionId 为 null、没有 turnState，
+     * 继承它会把已绑定的后端会话冲掉；而且 meta 文件超限压缩后第一行也不再是创建记录。
      */
     appendThreadSnapshot(selfAid, entry) {
         const chatDir = this.chatDirFor(selfAid, entry.peer, entry.channelType);
         const metaPath = path.join(chatDir, '_threads', `${entry.sessionId}.jsonl`);
         if (!fs.existsSync(metaPath))
             return;
-        // Read the first line to inherit required session fields (id, baseagent, channel, etc.)
-        // so that fileToSession never sees a line missing mandatory fields.
-        const allLines = readAllJsonlLines(metaPath);
-        const firstLine = allLines[0] ?? {};
+        const latest = readLastJsonlLine(metaPath) ?? {};
         const now = entry.lastActiveAt;
-        appendJsonl(metaPath, {
-            // required session fields — inherited from the original creation record
-            id: firstLine.id ?? entry.sessionId,
-            channel: firstLine.channel,
-            channelType: firstLine.channelType,
-            channelId: firstLine.channelId,
-            sessionKey: firstLine.sessionKey,
-            selfAID: firstLine.selfAID,
-            baseagent: firstLine.baseagent,
-            projectPath: firstLine.projectPath ?? '',
-            agentSessionId: firstLine.agentSessionId,
+        appendJsonlDurable(metaPath, {
+            // session fields (id, baseagent, agentSessionId, metadata, activeTask...) — from the latest snapshot
+            ...latest,
+            id: latest.id ?? entry.sessionId,
+            projectPath: latest.projectPath ?? '',
             chatType: entry.peerKind === 'group' ? 'group' : 'private',
-            metadata: firstLine.metadata ?? {},
-            activeTask: null,
+            metadata: latest.metadata ?? {},
             // topic metadata — updated values
             threadId: entry.threadId,
             channelIdAlias: entry.peer,
@@ -665,7 +658,7 @@ export class ThreadService {
             label: entry.label,
             topicStatus: entry.topicStatus,
             createdAt: entry.createdAt,
-            createdAtStr: firstLine.createdAtStr ?? '',
+            createdAtStr: latest.createdAtStr ?? '',
             updatedAt: now,
             updatedAtStr: new Date(now).toISOString(),
         });

package/dist/eck/kit-renderer.js

@@ -6,6 +6,7 @@ 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';
+import { SYSTEM_SESSION_TYPES } from '../core/system-session/types.js';
 export const DEFAULT_MANIFEST_FILE = 'eck_manifest.json';
 /**
  * 会话原型（sessionType）→ manifest 文件的内置映射。
@@ -16,9 +17,13 @@ export const BUILTIN_SESSION_MANIFESTS = {
     memory: 'eck_manifest.memory.json',
     auxiliary: 'eck_manifest.auxiliary.json',
 };
-/** 选择顺序：config 覆盖 → 内置映射 → 主 manifest。 */
+/**
+ * 选择顺序：config 覆盖 → 内置映射 → 主 manifest。
+ * 系统会话类型不接受 config 覆盖：其 manifest 由 system-session 模块决定。
+ */
 export function resolveSessionManifest(sessionType, overrides) {
-    return overrides?.[sessionType] ?? BUILTIN_SESSION_MANIFESTS[sessionType] ?? DEFAULT_MANIFEST_FILE;
+    const override = SYSTEM_SESSION_TYPES.includes(sessionType) ? undefined : overrides?.[sessionType];
+    return override ?? BUILTIN_SESSION_MANIFESTS[sessionType] ?? DEFAULT_MANIFEST_FILE;
 }
 // ── Caches ──
 const _sessionPathCache = new Map();