evolcore 0.0.33 → 0.0.35-test.0

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

@@ -1,11 +1,11 @@
 import { normalizeSessionLoopConfig, resolveSessionLoopTarget, sessionLoopError } from './session-idle-monitor.js';
 import { ensureDir } from '../../utils/atomic-write.js';
-import { resolvePaths } from '../../paths.js';
+import { resolvePaths, agentThreadIndexPath } from '../../paths.js';
 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);
@@ -1485,6 +1555,20 @@ export class SessionManager {
             metaFile: `${session.id}.jsonl`,
         };
         writeThreadIndex(chatDir, threadIndex);
+        // 被动建档（收到消息时自动创建话题会话）也必须同步到 agent 级话题索引，
+        // 否则 `ec thread rename current` / list 等按索引寻址的操作会报"话题不存在"。
+        this.upsertAgentThreadIndex({
+            selfAid: selfAID ?? '',
+            threadId,
+            sessionId: session.id,
+            peer: channelId,
+            channelType: channelType ?? 'aun',
+            peerKind: effectiveChatType === 'group' ? 'group' : 'private',
+            name: session.name,
+            label: normalizeTopicLabel(label) ?? null,
+            topicStatus: session.topicStatus ?? 'pending',
+            now: session.createdAt ?? Date.now(),
+        });
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -1497,6 +1581,47 @@ export class SessionManager {
         });
         return session;
     }
+    /**
+     * 把一条话题会话合并进 agent 级索引（`data/threads/index.json`）。
+     *
+     * 全局索引是 `ec thread` 各命令的寻址源；被动建档只写过 chatDir 下的
+     * `_threads/thread-index.json`，导致 `rename current` 之类找不到自己。
+     * 这里按 (peer, threadId) 幂等 upsert：已存在则只补缺失字段，不覆盖
+     * 名称/摘要等既有属性。
+     */
+    upsertAgentThreadIndex(input) {
+        if (!input.selfAid || !input.threadId)
+            return;
+        try {
+            const indexPath = agentThreadIndexPath(input.selfAid);
+            const raw = readJsonFile(indexPath);
+            const index = raw && Array.isArray(raw.threads) ? raw : { version: 1, threads: [] };
+            const existing = index.threads.find((t) => t.threadId === input.threadId
+                && String(t.peer ?? '').toLowerCase() === input.peer.toLowerCase());
+            if (existing) {
+                existing.sessionId = existing.sessionId || input.sessionId;
+                return;
+            }
+            index.threads.push({
+                threadId: input.threadId,
+                sessionId: input.sessionId,
+                peer: input.peer,
+                channelType: input.channelType,
+                peerKind: input.peerKind,
+                name: input.name || '话题会话',
+                label: input.label ?? null,
+                topicStatus: input.topicStatus,
+                createdAt: input.now,
+                lastActiveAt: input.now,
+            });
+            ensureDir(path.dirname(indexPath));
+            atomicWriteJson(indexPath, index);
+        }
+        catch (error) {
+            // 索引同步失败不能阻断消息处理：会话本身已落盘，rebuild-index 可补齐。
+            logger.warn(`[SessionManager] agent thread index upsert failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async switchProject(channel, channelId, newProjectPath, baseagent) {
         if (!baseagent) {
             throw new Error(`[SessionManager] switchProject: baseagent is empty for channel=${channel} channelId=${channelId}`);

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

@@ -94,6 +94,31 @@ export function buildCliSessionPreview(messages, backend, options = {}) {
         : null;
     return { title, hasReal: !!summary.firstRealMessage };
 }
+/**
+ * 会话/话题名称的长度常量，自动生成与手动改名共用。
+ *
+ * - `SESSION_TITLE_MAX_LEN`（80）：正文字数，超长文本截到这里再加省略号；
+ * - `SESSION_TITLE_STORED_MAX_LEN`（83）：落盘上限 = 80 + `...`。
+ *
+ * 80~83 字符的名字本身就是合法落盘形态，不再二次截断——
+ * 否则「系统自动生成的名字」会变成改一次短一点。
+ */
+export const SESSION_TITLE_MAX_LEN = 80;
+export const SESSION_TITLE_ELLIPSIS = '...';
+/** 落盘名称的硬上限（截断后的最长长度）。 */
+export const SESSION_TITLE_STORED_MAX_LEN = SESSION_TITLE_MAX_LEN + SESSION_TITLE_ELLIPSIS.length;
+/**
+ * 截断到落盘上限并补省略号；未超长时原样返回。
+ *
+ * 判据是 `SESSION_TITLE_STORED_MAX_LEN`（83）而不是正文上限（80）：
+ * 80~83 字符的名称本来就是合法落盘形态（含历史遗留），截断它们会把
+ * 「系统生成的名字原样改回去」变成「改一次短一点」。
+ */
+export function truncateSessionTitle(title) {
+    return title.length > SESSION_TITLE_STORED_MAX_LEN
+        ? `${title.slice(0, SESSION_TITLE_MAX_LEN)}${SESSION_TITLE_ELLIPSIS}`
+        : title;
+}
 export function sanitizeSessionTitle(title) {
     if (typeof title !== 'string')
         return undefined;
@@ -109,7 +134,7 @@ export function sanitizeSessionTitle(title) {
         return undefined;
     if (/^\.+$/.test(cleanTitle))
         return undefined;
-    return cleanTitle.length > 80 ? `${cleanTitle.slice(0, 80)}...` : cleanTitle;
+    return truncateSessionTitle(cleanTitle);
 }
 export function displaySessionTitle(title, fallback = '默认会话') {
     return sanitizeSessionTitle(title) || sanitizeSessionTitle(fallback) || fallback;

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,289 @@
+/**
+ * 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 fs from 'fs';
+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 { analyzeReadonlyShellQuery } from '../permission/readonly-shell-query.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`（不能与其他命令拼接）；'
+    + '或路径落在可读根内、可证明只读的查询（如 ls / cat / grep），多条查询可用 `&&` 或 `;` 连接，最多 8 段。'
+    + '读文件请用 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 === 'agent') {
+                // agent 级 forget：给所有 relation 的 consolidated 目录 + agent 自身的 consolidated
+                const relationsRoot = path.join(resolveRoot(), 'agents', ctx.selfAid, 'relations');
+                if (fs.existsSync(relationsRoot)) {
+                    for (const peerKey of fs.readdirSync(relationsRoot)) {
+                        const consolidatedDir = path.join(relationsRoot, peerKey, 'memory', 'consolidated');
+                        const indexPath = path.join(relationsRoot, peerKey, 'memory', 'MEMORY.md');
+                        if (fs.existsSync(consolidatedDir)) {
+                            add(consolidatedDir, indexPath);
+                        }
+                    }
+                }
+                add(...consolidated('agent'));
+            }
+            else if (ctx.memoryScope) {
+                // relation / owner 级 forget：只给当前层级
+                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 \'……\'）；'
+                + '若正文本身含单引号，改用 $\'…\' 语法传入（支持 \\n \\t \\\\ \\\'）。';
+        case 'invalid-quote':
+            return '命令引号未闭合或存在错误嵌套。'
+                + '普通单引号内部不能再出现单引号——含单引号的正文改用 $\'…\' 语法：'
+                + '用 \\\' 转义内部的单引号，如 $\'it\\\'s fine\'。';
+        case 'structural-newline':
+            return '命令里存在未闭合的换行结构。把正文放进单引号或 $\'…\' 内即可直接换行（$\'…\' 支持 \\n 转义）。';
+        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 };
+    const rawCommand = typeof input.command === 'string' ? input.command : '';
+    // ec 命令按 ec 解析器归因；ec 解析器的 issue 只描述 ec 命令，不能拿来解释普通 shell 查询
+    if (looksLikeMemoryCommand(rawCommand)) {
+        const remedy = parsed.ok ? undefined : shellIssueRemedy(parsed.issue);
+        if (remedy) {
+            return deny('memory_session_command_forbidden', `这条命令本身就是 \`ec memory\`，但未能解析成单条字面命令。${remedy}`);
+        }
+        return deny('memory_session_command_forbidden', `${BASH_COMMAND_RULE} 具体原因：ec memory 只允许 create / update / archive 三个子命令。`);
+    }
+    if ((parsed.ok && parsed.argv[0] === 'ec') || looksLikeEcCommand(rawCommand)) {
+        return deny('memory_session_command_forbidden', `${BASH_COMMAND_RULE} 具体原因：整理会话不能执行 ec memory create / update / archive 以外的 ec 命令。`);
+    }
+    // 普通 shell 查询：原因取自只读判定本身
+    return deny('memory_session_command_forbidden', `${BASH_COMMAND_RULE} 具体原因：${readonlyDenialHint(rawCommand, readonly.policyCode, ctx)}`);
+}
+function looksLikeEcCommand(command) {
+    return /^\s*ec(?:\.cmd|\.exe|\.ps1)?\s/.test(command);
+}
+/** 只读查询被拒的原因：与 checkReadonly 的判定分支一一对应。 */
+function readonlyDenialHint(command, policyCode, ctx) {
+    switch (policyCode) {
+        case 'readonly_workspace_escape':
+            return '命令可证明只读，但读取的路径不在可读根内。用任务书「可读根」列出的绝对路径；相对路径按会话 cwd 解析，cwd 本身不可读。';
+        case 'readonly_h_class_read':
+        case 'readonly_l_class_read':
+            return '命令读取了受保护路径，整理会话不能读。';
+        default:
+            break;
+    }
+    const analysis = analyzeReadonlyShellQuery(command, { managedTempDir: ctx.managedTempDir });
+    if (analysis.kind !== 'unproven')
+        return '命令无法证明只读。';
+    switch (analysis.reason) {
+        case 'unsupported-shell-structure':
+            return '命令含有不支持的 shell 结构：后台执行 `&`、`||`、输入重定向 `<`、换行，'
+                + '或除 `2>/dev/null` 以外的重定向（如 `2>&1`、`> file`），或连接段数、管道级数超限。'
+                + '多条查询只能用 `&&` 或 `;` 连接，最多 8 段。';
+        case 'non-literal-command':
+            return '命令参数不是字面量：未加引号的通配符（`*` `?` `[`）、变量 `$`、命令替换或无法解析的引号，'
+                + '静态确定不了会读哪些文件。列文件请用 Glob 并给绝对 path。';
+        case 'unsupported-command-or-option':
+            return '命令或选项不在只读查询白名单内。不需要 `cd`：把绝对路径直接写进命令里。'
+                + '读文件用 Read，列文件用 Glob，搜索用 Grep。';
+        case 'unsupported-pipeline-filter':
+            return '管道 `|` 后面的命令不是纯 stdin 过滤命令。';
+        case 'pipeline-filter-must-use-stdin':
+            return '管道 `|` 后面的过滤命令只能处理上一级的输出，不能再带文件路径参数。';
+        default:
+            return `命令无法证明只读（${analysis.reason}）。`;
+    }
+}
+function checkTool(rawToolName, input, ctx) {
+    const call = canonicalToolCall(rawToolName, input);
+    switch (call.access) {
+        case 'read': {
+            const result = checkReadWithinMatrix(call.name, input, ctx);
+            if (result.behavior !== 'allow') {
+                // 给出更具体的提示
+                let hint = '';
+                if (call.name === 'Glob' && !input.path) {
+                    hint = '。Glob 需要传绝对路径给 path 参数（不传时起点落在 cwd，整理会话的 cwd 不可读）';
+                }
+                else if (call.name === 'Grep' && !input.path) {
+                    hint = '。Grep 需要传绝对路径给 path 参数';
+                }
+                return deny(result.policyCode ?? 'memory_session_read_outside_matrix', `只能读取本次整理的批次目录、对应记忆目录与本对话流水${hint}`);
+            }
+            return { allow: true };
+        }
+        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),
+};