evolcore 0.0.32 → 0.0.34

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';
 /**
  * 生成索引文件（汇总 → 分组 → 落两文件）。
  *
@@ -42,6 +44,9 @@ function generateOneIndex(indexDir, filename, skills, label) {
     const sep = path.sep;
     const header = `[skills-${label}] 本 Agent 已启用 ${skills.length} 个${label === 'builtin' ? '内置' : '本机'}技能。
 
+加载方式: EC 技能用 Read 工具读取上面对应的 SKILL.md 全文后按内容执行；
+  它们不是宿主工具自带的技能或斜杠命令，用 Skill/斜杠命令加载会报 Unknown skill/未知命令。
+
 路径规则:
   根目录: ${rootDir}
   技能目录 = 根目录 + "${sep}" + 技能名
@@ -65,11 +70,22 @@ function generateOneIndex(indexDir, filename, skills, label) {
  *
  * 直接按目录读，不走 discoverSkillDirectories——后者按父目录扫描再按 name 匹配，
  * 同名技能（本机覆盖内置）会读到另一份的 description。
+ *
+ * 内置技能是随包发布的内容：安装模式下按台账校验，带外改动会被恢复成登记版本，
+ * 恢复不了就不进索引（返回空描述），与 ECK 文档同一套策略。开发模式下不校验，
+ * agent 随手改技能可以立刻生效。
+ *
+ * 注意：这里保护的是索引里那行描述。模型拿到索引后是用 Read 工具读 SKILL.md 正文的，
+ * 那条路径不经过本函数，目前不受台账保护（等单独的 SKILL.md 加载工具接手）。
  */
-function readSkillDescription(skillDir) {
+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]);
@@ -78,7 +94,8 @@ 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/skill/startup.js

@@ -2,6 +2,28 @@ import { generateSkillIndexes } from './index-generator.js';
 import { globalSkillWatcher } from './global-watcher.js';
 import { logger } from '../../utils/logger.js';
 import { invalidateKitCache } from '../../eck/kit-renderer.js';
+import { isSkillWatchEnabled } from '../../config-store.js';
+/**
+ * 监控开关（daemon.json `skills.watch`，默认 false），daemon 启动时读一次。
+ *
+ * 关闭时不创建任何 chokidar watcher：Windows 上 chokidar 每个文件/目录各占一个
+ * 目录句柄（本机实测 ~/.evolcore/skills 约 3400 个），子目录因此无法被资源管理器
+ * 删除或重命名。关闭后改完技能需执行 `ec skill refresh <aid>`（refreshSkillIndex）。
+ * 监控与手动刷新互不冲突，打开开关后两者可同时使用。
+ */
+let watchEnabled;
+function skillWatchEnabled() {
+    if (watchEnabled === undefined) {
+        try {
+            watchEnabled = isSkillWatchEnabled();
+        }
+        catch (e) {
+            logger.warn(`[skill] 读取 skills.watch 失败，按关闭处理: ${e instanceof Error ? e.message : String(e)}`);
+            watchEnabled = false;
+        }
+    }
+    return watchEnabled;
+}
 /**
  * daemon 启动时，启动全局监控器。
  *
@@ -11,6 +33,10 @@ import { invalidateKitCache } from '../../eck/kit-renderer.js';
  * - agent 收到消息需要组装系统上下文时，检查并按需生成索引
  */
 export function startSkillWatcher() {
+    if (!skillWatchEnabled()) {
+        logger.info('[skill] 技能目录监控已关闭（daemon.json skills.watch=false），改动技能后请执行 ec skill refresh <aid>');
+        return;
+    }
     // 启动全局监控器（监控内置和本机技能目录）
     globalSkillWatcher.start();
     // 注册防抖回调：内置和本机技能变化时标记所有 agent 为脏并失效缓存
@@ -36,6 +62,8 @@ export function startSkillWatcher() {
  * 重复调用会 re-arm debounce timer 造成 2 秒自激循环。
  */
 export function watchAgentSkills(aid) {
+    if (!skillWatchEnabled())
+        return;
     globalSkillWatcher.watchAgent(aid);
     globalSkillWatcher.onDebouncedChange(`agent:${aid}`, () => {
         logger.info(`[skill] Agent ${aid} 技能目录有变化，标记为脏状态并失效缓存`);
@@ -65,6 +93,19 @@ export function ensureSkillIndexUpToDate(agentDir, aid) {
         }
     }
 }
+/**
+ * 手动刷新指定 agent 的技能索引（`ec skill refresh <aid>` 的 daemon 侧实现）。
+ *
+ * 与懒加载入口不同：无条件重建，失败直接抛出（由 IPC 返回给调用方），
+ * 成功后清掉该 agent 的脏标记，避免下一轮对话再重建一次。
+ */
+export function refreshSkillIndex(agentDir, aid) {
+    generateSkillIndexes(agentDir);
+    globalSkillWatcher.markAgentChecked(aid);
+    globalSkillWatcher.markAgentClean(aid);
+    invalidateKitCache();
+    logger.info(`[skill] 已手动刷新 agent ${aid} 的技能索引`);
+}
 /**
  * 停止全局监控器（daemon 关闭时调用）
  */

package/dist/core/skill/switch-resolver.js

@@ -2,6 +2,58 @@ import fs from 'fs';
 import path from 'path';
 import { getPackageRoot } from '../../paths.js';
 import { resolveRoot } from '../../paths.js';
+/**
+ * 覆盖链求值：给定技能名与三级开关，判定最终是否启用、由谁决定。
+ *
+ * `resolveSkills`（只要启用集合）与 `resolveAllSkillStates`（要全量+归因）
+ * 共用这一份实现，避免两条路径对同一条覆盖链给出不同答案。
+ */
+function evaluateSkillSwitch(name, sets) {
+    const b = getSwitch(sets.builtin, name);
+    const hasBuiltinLock = b.locked === true;
+    if (hasBuiltinLock) {
+        return { enabled: b.enabled === true, decidedBy: 'builtin(locked)', locked: true, overridable: false };
+    }
+    if (name in sets.agent) {
+        return { enabled: getSwitch(sets.agent, name).enabled === true, decidedBy: 'agent', locked: false, overridable: true };
+    }
+    if (name in sets.local) {
+        return { enabled: getSwitch(sets.local, name).enabled === true, decidedBy: 'local', locked: false, overridable: true };
+    }
+    if (name in sets.builtin) {
+        return { enabled: b.enabled === true, decidedBy: 'builtin', locked: false, overridable: true };
+    }
+    // 三级都没有显式开关 → 缺省禁用（装完必须显式启用）
+    return { enabled: false, decidedBy: 'default(缺省禁用)', locked: false, overridable: true };
+}
+/** 读取三级开关文件 */
+function readSkillSwitchSets(paths) {
+    return {
+        builtin: readSwitchesFile(path.join(paths.builtin, '.switches.json')),
+        local: readSwitchesFile(path.join(paths.local, '.switches.json')),
+        agent: readSwitchesFile(path.join(paths.agent, '.switches.json')),
+    };
+}
+/**
+ * 全量解析：返回所有已安装技能（含未启用），带开关归因。
+ *
+ * 与 `resolveSkills` 的区别是保留禁用技能——斜杠菜单和 `ec skill list`
+ * 需要展示"装了但没开"的技能，否则用户看不出为什么某个技能没生效。
+ */
+export function resolveAllSkillStates(agentDir, override) {
+    const paths = getSkillPaths(agentDir, override);
+    const builtinNames = scanSkillNames(paths.builtin);
+    const localNames = scanSkillNames(paths.local);
+    const sets = readSkillSwitchSets(paths);
+    const out = [];
+    for (const name of new Set([...builtinNames, ...localNames])) {
+        // 本机有 SKILL.md 即算本机技能（本机覆盖内置）
+        const source = localNames.has(name) ? 'local' : 'builtin';
+        const skillDir = path.join(source === 'local' ? paths.local : paths.builtin, name);
+        out.push({ name, source, skillDir, ...evaluateSkillSwitch(name, sets) });
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
 function getSkillPaths(agentDir, override) {
     return {
         builtin: override?.builtin ?? path.join(getPackageRoot(), 'kits', 'skills'),
@@ -73,41 +125,15 @@ export function resolveSkills(agentDir, override) {
     const localNames = scanSkillNames(paths.local);
     const allNames = new Set([...builtinNames, ...localNames]);
     // ② 读取三级汇总开关文件
-    const builtinSwitches = readSwitchesFile(path.join(paths.builtin, '.switches.json'));
-    const localSwitches = readSwitchesFile(path.join(paths.local, '.switches.json'));
-    const agentSwitches = readSwitchesFile(path.join(paths.agent, '.switches.json'));
+    const sets = readSkillSwitchSets(paths);
     const results = [];
     for (const name of allNames) {
         // ③ 判断来源：本机有 SKILL.md → local，否则 builtin
         const source = localNames.has(name) ? 'local' : 'builtin';
         const skillRoot = source === 'local' ? paths.local : paths.builtin;
         const skillDir = path.join(skillRoot, name);
-        // ④ 覆盖链求值（design §4.1）
-        const builtinSwitch = getSwitch(builtinSwitches, name);
-        // 内置 locked 时，直接由内置 enabled 决定
-        if (builtinSwitch.locked) {
-            if (builtinSwitch.enabled) {
-                results.push({ name, source, enabled: true, skillDir });
-            }
-            continue;
-        }
-        // 否则从 Agent 级往下找第一个存在的开关
-        const agentSwitch = getSwitch(agentSwitches, name);
-        if (name in agentSwitches) {
-            if (agentSwitch.enabled) {
-                results.push({ name, source, enabled: true, skillDir });
-            }
-            continue;
-        }
-        const localSwitch = getSwitch(localSwitches, name);
-        if (name in localSwitches) {
-            if (localSwitch.enabled) {
-                results.push({ name, source, enabled: true, skillDir });
-            }
-            continue;
-        }
-        // 三级都没有显式开关 → 用缺省（enabled:false，装完必须显式启用）
-        if (builtinSwitch.enabled) {
+        // ④ 覆盖链求值（与 resolveAllSkillStates 共用）
+        if (evaluateSkillSwitch(name, sets).enabled) {
             results.push({ name, source, enabled: true, skillDir });
         }
     }

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'];