evolcore 0.0.31 → 0.0.32

package/dist/trigger/ipc-service.js

@@ -1,10 +1,8 @@
-import fs from 'fs';
-import path from 'path';
 import { getEventCatalog } from '../core/event-catalog.js';
 import { authorizeOperation, canApprovePersistentFullAccessTrigger, isCrossAgentTriggerOperationAllowed, } from '../core/auth/auth-gateway.js';
 import { auditFullAccessEvent } from '../core/auth/authorization-audit.js';
 import { assertTriggerLocalFileAuthority, daemonPrivilegedTriggerReason, } from './authorization.js';
-import { decodeTriggerScriptFile, resolveTriggerLocalPath } from './local-files.js';
+import { decodeTriggerScriptFile } from './local-files.js';
 import { applyTriggerPatch } from './patch.js';
 import { definitionRevision, normalizeTriggerDefinition, splitScriptCommand } from './validation.js';
 export function createTriggerBaseagentResolver({ daemonTriggerOwnerAid, getAgentName, getDaemonAgentName, agentMap, }) {
@@ -51,6 +49,9 @@ export function materializeTriggerCreateBaseagent(input, agentAid, dependencies)
 }
 export function createTriggerIpcExecutor(dependencies) {
     return async (cmd) => {
+        let approvedActor;
+        let approvedAgentAid;
+        let approvedOperation;
         const schedulerFor = (agentAid) => {
             const scheduler = dependencies.getScheduler(agentAid);
             if (!scheduler)
@@ -102,7 +103,10 @@ export function createTriggerIpcExecutor(dependencies) {
             return { ...definition, authorizedBy };
         };
         const authorizeTrigger = async (agentAid, operation, triggerId, contextOnly = false) => {
-            const actor = await dependencies.authenticateActor(agentAid, cmd.actorSessionId, cmd.delegationToken, cmd.delegationCommandHash, cmd.controlToken, contextOnly);
+            if (approvedActor && (agentAid !== approvedAgentAid || operation !== approvedOperation)) {
+                throw new Error('Trigger operation does not match its approved argv');
+            }
+            const actor = approvedActor ?? await dependencies.authenticateActor(agentAid, cmd.actorSessionId, cmd.delegationToken, cmd.delegationCommandHash, cmd.controlToken, contextOnly);
             if (actor.permissionMode === 'readonly' && !actor.fullAccess
                 && !['trigger.list', 'trigger.show', 'trigger.history', 'trigger.eventCatalog'].includes(operation)) {
                 throw new Error('readonly tasks cannot modify or run Triggers');
@@ -160,38 +164,48 @@ export function createTriggerIpcExecutor(dependencies) {
             }
             return actor;
         };
-        switch (cmd.type) {
-            case 'trigger.authorizeLocalFiles': {
-                if (cmd.operation !== 'trigger.create' && cmd.operation !== 'trigger.update') {
-                    throw new Error('local file authorization only supports Trigger create/update');
-                }
-                const agentAid = requireAgent(cmd.agentAid);
-                if (cmd.operation === 'trigger.update' && (typeof cmd.triggerId !== 'string' || !cmd.triggerId)) {
-                    throw new Error('missing triggerId');
-                }
-                if (typeof cmd.actorSessionId !== 'string' || !cmd.actorSessionId) {
-                    throw new Error('local Trigger file authorization requires a managed task');
-                }
-                const actor = await authorizeTrigger(agentAid, cmd.operation, cmd.triggerId, true);
-                assertTriggerLocalFileAuthority(actor);
-                if (actor.fullAccess)
-                    return { ok: true, fullAccess: true };
-                const session = await dependencies.getSessionById(cmd.actorSessionId);
-                if (!session)
-                    throw new Error('Trigger actor session is unavailable');
-                if (typeof cmd.cwd !== 'string' || !path.isAbsolute(cmd.cwd))
-                    throw new Error('missing absolute command cwd');
-                const fileScope = {
-                    selfAid: agentAid,
-                    projectPath: fs.realpathSync.native(path.resolve(session.projectPath)),
-                    sessionRuntimeDir: actor.sessionRuntimeDir,
-                    cwd: cmd.cwd,
-                };
-                fileScope.cwd = resolveTriggerLocalPath(cmd.cwd, fileScope);
-                if (!fs.statSync(fileScope.cwd).isDirectory())
-                    throw new Error('command cwd must be a directory');
-                return { ok: true, fullAccess: false, fileScope };
+        if (cmd.type === 'trigger.op') {
+            if (!Array.isArray(cmd.argv) || cmd.argv.some((value) => typeof value !== 'string')
+                || typeof cmd.actorSessionId !== 'string' || !cmd.actorSessionId) {
+                throw new Error('Managed Trigger requires argv and actorSessionId');
+            }
+            const session = await dependencies.getSessionById(cmd.actorSessionId);
+            if (!session?.selfAID)
+                throw new Error('Trigger actor session is unavailable');
+            const { resolveTriggerCommandArgv, buildTriggerCreateRequest, buildTriggerUpdateRequest } = await import('../cli/trigger-command.js');
+            const argv = cmd.argv;
+            const command = resolveTriggerCommandArgv(argv, session.selfAID);
+            cmd = { ...command, actorSessionId: cmd.actorSessionId, delegationToken: cmd.delegationToken,
+                delegationCommandHash: cmd.delegationCommandHash };
+            approvedAgentAid = requireAgent(command.agentAid);
+            approvedOperation = command.type;
+            approvedActor = await authorizeTrigger(approvedAgentAid, approvedOperation, command.triggerId);
+            const args = argv.slice(2);
+            const usesFiles = args.some(value => ['--file', '--prompt-file', '--script-path', '--script-file']
+                .some(flag => value === flag || value.startsWith(`${flag}=`)));
+            if (usesFiles)
+                assertTriggerLocalFileAuthority(approvedActor);
+            const fileScope = approvedActor.fullAccess ? undefined : {
+                selfAid: approvedAgentAid, projectPath: session.projectPath,
+                sessionRuntimeDir: approvedActor.sessionRuntimeDir, cwd: session.projectPath,
+            };
+            if (command.type === 'trigger.create') {
+                const parsed = await buildTriggerCreateRequest(args, fileScope, approvedAgentAid);
+                if (parsed.definition?.agentAid !== approvedAgentAid)
+                    throw new Error('Imported Trigger does not match the authorized Agent');
+                cmd = { ...cmd, ...parsed };
+            }
+            else if (command.type === 'trigger.update') {
+                cmd = { ...cmd, ...await buildTriggerUpdateRequest(args, fileScope, approvedAgentAid) };
+            }
+            else if (usesFiles) {
+                throw new Error('File inputs are only valid for Trigger create/update');
             }
+        }
+        else if (cmd.actorSessionId) {
+            throw new Error('Managed callers must use trigger.op with approved argv');
+        }
+        switch (cmd.type) {
             case 'trigger.list': {
                 const agentAid = requireAgent(cmd.agentAid);
                 const actor = await authorizeTrigger(agentAid, 'trigger.list');

package/dist/trigger/script-sandbox.js

@@ -6,28 +6,16 @@ import { pathToFileURL } from 'node:url';
 import { spawn } from 'node:child_process';
 import { resolveCodexCliPath } from '../agents/baseagent.js';
 import { ensureSessionRuntimeDir } from '../cli/task-context.js';
-import { resolveBubblewrapPath } from '../core/permission/sandbox-runtime.js';
-import { classifyProtectedPath, getExistingHClassMaskTargets, getExistingLClassReadOnlyTargets, isSameOrDescendant, } from '../core/permission/protected-paths.js';
+import { buildBubblewrapCommand, buildHClassGuardCommand, resolveBubblewrapPath, } from '../core/permission/sandbox-runtime.js';
+import { resolvePhaseOneExecutionSandbox } from '../core/permission/mode.js';
+import { sanitizeShellExecutionEnvironment } from '../core/permission/shell-environment.js';
+import { buildCodexProtectedFilesystemRules, classifyProtectedPath, getExistingRelationAttachmentDirs, isSameOrDescendant, } from '../core/permission/protected-paths.js';
 import { resolveRoot } from '../paths.js';
 import { buildCliLaunchCommand, killProcess, resolveCommandPath } from '../utils/cross-platform.js';
 import { TRIGGER_LOCAL_FILE_LIMIT } from './local-files.js';
-const SAFE_ENVIRONMENT_KEYS = [
-    'ComSpec', 'COMSPEC', 'LANG', 'LC_ALL', 'OS', 'PATH', 'PATHEXT',
-    'ProgramData', 'ProgramFiles', 'ProgramFiles(x86)', 'ProgramW6432',
-    'SystemDrive', 'SystemRoot', 'WINDIR',
-];
-const SYSTEM_READ_ROOTS = ['/usr/bin', '/usr/lib', '/usr/lib64', '/usr/local/bin', '/usr/local/lib', '/usr/share/locale', '/usr/share/zoneinfo', '/bin', '/sbin', '/lib', '/lib64'];
-const SYSTEM_READ_FILES = ['/etc/ld.so.cache', '/etc/localtime', '/etc/passwd', '/etc/group'];
-const CONTROL_DIRECTORY_NAMES = ['agents', 'AIDs', 'aids', 'data', 'CA', '.snapshots', 'logs', 'backups'];
 const WINDOWS_SANDBOX_SETUP_VERSION = 5;
-const WINDOWS_SANDBOX_ENV_EXCLUDES = [
+const SCRIPT_ENVIRONMENT_EXCLUDES = [
     'CODEX_HOME',
-    'EVOLCORE_DELEGATION_TOKEN',
-    'EVOLCORE_CODEX_SESSION_TOKEN',
-    'EVOLCORE_TASK_RUNTIME_CONTEXT',
-    'EVOLCORE_INSTANCE_SOCKET',
-    'EVOLCORE_DAEMON_SOCKET',
-    'EVOLCORE_IPC_SOCKET',
     'OPENAI_API_KEY',
     'CODEX_API_KEY',
     'ANTHROPIC_API_KEY',
@@ -48,6 +36,8 @@ export function buildTriggerScriptLaunch(input) {
     if (!authorization.permissionMode || authorization.permissionMode === 'fullaccess') {
         throw new Error('scoped Trigger execution requires an effective non-fullaccess permission mode');
     }
+    const sandboxDecision = resolvePhaseOneExecutionSandbox(authorization.permissionMode, authorization.role);
+    const readonly = sandboxDecision.permissionMode === 'readonly';
     if (process.platform !== 'linux' && process.platform !== 'win32') {
         throw new Error('scoped Trigger script isolation is unavailable on this host');
     }
@@ -108,9 +98,12 @@ export function buildTriggerScriptLaunch(input) {
         fs.writeFileSync(scriptPath, scriptBytes, { flag: 'wx', mode: 0o400 });
         preserveNodeModuleType(runtime, input.scriptPath, snapshotDir);
         const env = buildSandboxEnvironment(workDir);
-        const blockedPaths = protectedScriptPaths(root, input.trigger.agentAid);
         const scriptArgs = [scriptPath, ...input.scriptArgs];
         if (windowsBackend) {
+            const filesystem = buildCodexProtectedFilesystemRules(root, {
+                selfAid: input.trigger.agentAid,
+                denyLClassRead: readonly,
+            });
             const systemRoot = process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows';
             const readRoots = [
                 path.join(systemRoot, 'System32'),
@@ -122,25 +115,37 @@ export function buildTriggerScriptLaunch(input) {
                 snapshotDir,
             ].filter(value => fs.existsSync(value));
             const entries = [
-                { path: { type: 'special', value: { kind: 'root' } }, access: 'deny' },
+                { path: { type: 'special', value: { kind: 'root' } },
+                    access: sandboxDecision.state === 'off' ? 'write' : 'read' },
                 ...readRoots.map(value => filesystemEntry(value, 'read')),
-                filesystemEntry(projectPath, authorization.permissionMode === 'readonly' ? 'read' : 'write'),
+                filesystemEntry(projectPath, readonly ? 'read' : 'write'),
+                filesystemEntry(snapshotDir, 'read'),
                 filesystemEntry(workDir, 'write'),
-                ...blockedPaths.map(value => filesystemEntry(value, 'deny')),
+                filesystemEntry(windowsBackend.home, 'deny'),
+                ...Object.entries(filesystem).flatMap(([value, access]) => typeof access === 'number' ? [] : [{
+                        path: /[*?[\]]/.test(value)
+                            ? { type: 'glob_pattern', pattern: value }
+                            : { type: 'path', path: value },
+                        access,
+                    }]),
+                ...getExistingRelationAttachmentDirs(root, {
+                    selfAid: input.trigger.agentAid,
+                    onlyOtherAgents: true,
+                }).map(value => filesystemEntry(value, 'deny')),
             ];
             const sandboxState = JSON.stringify({
                 permissionProfile: {
                     type: 'managed',
-                    file_system: { type: 'restricted', entries },
-                    network: 'restricted',
+                    file_system: { type: 'restricted', entries, glob_scan_max_depth: filesystem.glob_scan_max_depth },
+                    network: 'enabled',
                 },
                 sandboxCwd: pathToFileURL(projectPath).href,
             });
             if (sandboxState.length > 20_000)
                 throw new Error('scoped Windows Trigger filesystem policy exceeds the command-line budget');
-            const shellEnvironmentPolicy = `shell_environment_policy={inherit="all",exclude=${JSON.stringify(WINDOWS_SANDBOX_ENV_EXCLUDES)},include_only=[],set={}}`;
+            const shellEnvironmentPolicy = `shell_environment_policy={inherit="all",exclude=${JSON.stringify(getScriptEnvironmentExcludes())},include_only=[],set={}}`;
             const sandboxArgs = [
-                'sandbox', '--sandbox-state-json', sandboxState, '--sandbox-state-disable-network',
+                'sandbox', '--sandbox-state-json', sandboxState,
                 '-c', 'windows.sandbox="elevated"',
                 '-c', shellEnvironmentPolicy,
             ];
@@ -154,40 +159,26 @@ export function buildTriggerScriptLaunch(input) {
             launch.prepare = signal => verifyWindowsReadIsolation(launch, sandboxArgs, runDir, workDir, signal);
             return launch;
         }
-        const args = [
-            '--die-with-parent', '--new-session', '--unshare-all', '--cap-drop', 'ALL',
-            '--tmpfs', '/', '--proc', '/proc', '--dev', '/dev', '--tmpfs', '/tmp',
-        ];
-        const readRoots = [...SYSTEM_READ_ROOTS, ...SYSTEM_READ_FILES, runtimeDir]
-            .filter(value => fs.existsSync(value));
-        const visibleRoots = [...readRoots, projectPath];
-        const directoryMountpoints = new Set();
-        for (const value of [...visibleRoots, ...blockedPaths, runDir, workDir].filter(value => fs.existsSync(value))) {
-            const stat = fs.lstatSync(value);
-            let current = stat.isDirectory() ? path.resolve(value) : path.dirname(path.resolve(value));
-            while (current !== path.parse(current).root) {
-                directoryMountpoints.add(current);
-                current = path.dirname(current);
-            }
-        }
-        for (const value of [...directoryMountpoints].sort((left, right) => left.length - right.length)) {
-            args.push('--dir', value);
-        }
-        for (const value of new Set(readRoots))
-            args.push('--ro-bind', value, value);
-        args.push(authorization.permissionMode === 'readonly' ? '--ro-bind' : '--bind', projectPath, projectPath);
-        for (const value of blockedPaths) {
-            if (!visibleRoots.some(directory => isSameOrDescendant(value, directory)) || !fs.existsSync(value))
-                continue;
-            const stat = fs.lstatSync(value);
-            if (stat.isDirectory())
-                args.push('--tmpfs', value, '--remount-ro', value);
-            else
-                args.push('--ro-bind', '/dev/null', value);
-        }
-        args.push('--ro-bind', runDir, runDir, '--bind', workDir, workDir, '--remount-ro', '/');
-        args.push('--chdir', projectPath, '--', runtime, ...scriptArgs);
-        return { command: bubblewrap, args, cwd: projectPath, env, cleanup };
+        const launch = sandboxDecision.state === 'off'
+            ? buildHClassGuardCommand(runtime, scriptArgs, root, { selfAid: input.trigger.agentAid })
+            : buildBubblewrapCommand(runtime, scriptArgs, {
+                projectPath,
+                projectWritable: !readonly,
+                root,
+                selfAid: input.trigger.agentAid,
+                exposeDaemonIpc: false,
+                denyLClassRead: readonly,
+            });
+        if (!launch)
+            throw new Error('bubblewrap is required for scoped Trigger script isolation');
+        const separator = launch.args.indexOf('--');
+        if (separator < 0)
+            throw new Error('bubblewrap launch is missing its command separator');
+        const runMountArgs = ['--ro-bind', runDir, runDir, '--bind', workDir, workDir];
+        if (!launch.args.slice(0, separator).includes('--chdir'))
+            runMountArgs.push('--chdir', projectPath);
+        launch.args.splice(separator, 0, ...runMountArgs);
+        return { ...launch, cwd: projectPath, env, cleanup };
     }
     catch (error) {
         cleanup();
@@ -331,30 +322,20 @@ function preserveNodeModuleType(runtime, scriptPath, snapshotDir) {
 }
 function buildSandboxEnvironment(workDir) {
     const env = {};
-    for (const key of SAFE_ENVIRONMENT_KEYS) {
-        const value = process.env[key];
-        if (typeof value === 'string' && value.length > 0)
+    const excluded = new Set(getScriptEnvironmentExcludes().map(key => key.toUpperCase()));
+    for (const [key, value] of Object.entries(sanitizeShellExecutionEnvironment(process.env))) {
+        if (!excluded.has(key.toUpperCase())
+            && typeof value === 'string')
             env[key] = value;
     }
-    const homeDir = process.platform === 'win32' ? path.join(workDir, 'home') : workDir;
-    if (homeDir !== workDir)
-        fs.mkdirSync(homeDir, { mode: 0o700 });
     return {
-        ...env, HOME: homeDir, USERPROFILE: homeDir,
-        APPDATA: path.join(workDir, 'appdata'), LOCALAPPDATA: path.join(workDir, 'localappdata'),
+        ...env,
         TMPDIR: workDir, TEMP: workDir, TMP: workDir, EVOLCORE_TRIGGER_SANDBOX: '1',
     };
 }
-function protectedScriptPaths(root, selfAid) {
-    const directoryRoots = CONTROL_DIRECTORY_NAMES.map(name => path.join(root, name));
-    const targets = [
-        ...directoryRoots,
-        ...getExistingHClassMaskTargets(root, { selfAid }).map(target => target.path),
-        ...getExistingLClassReadOnlyTargets(root, { selfAid }).map(target => target.path),
-        path.join(root, 'daemon.json'), path.join(root, '.env'), path.join(root, '.device_id'),
-        path.join(root, '.lock'), path.join(root, 'daemon.pid'),
-    ];
-    return [...new Set(targets)].filter(candidate => (directoryRoots.includes(candidate) || !directoryRoots.some(directory => isSameOrDescendant(candidate, directory))));
+function getScriptEnvironmentExcludes() {
+    const dynamic = Object.keys(process.env).filter(key => key.toUpperCase().startsWith('EVOLCORE_'));
+    return [...new Set([...SCRIPT_ENVIRONMENT_EXCLUDES, ...dynamic])];
 }
 function filesystemEntry(value, access) {
     return { path: { type: 'path', path: path.resolve(value) }, access };

package/kits/docs/AUTHORING.md

@@ -111,7 +111,7 @@ ECK 的 manifest 机制决定了**不同位置的内容有不同的成本量级*
 
 写入 `rules/` 前自问：**这条信息如果不注入，agent 会在多少比例的对话里做错事？**
 
-- 每轮都需要（如"不得调用 `ec restart`"）→ 进 `rules/`
+- 每轮都需要（如"不得停止或重启承载当前会话的 EvolCore 实例"）→ 进 `rules/`
 - 偶发场景才需要（如"Menu 消息有哪些字段"）→ 留 `docs/`，靠 `INDEX.md` 触发词按需命中
 
 答不上来就别进 `rules/`。最常见的隐性浪费是把偶发查阅的内容塞进规则文件，之后每轮对话都在白烧 token。

package/kits/docs/channels/aun.md

@@ -42,6 +42,14 @@ AUN keystore seed 由 EvolCore 使用固定应用值管理，不再提供配置
 
 > Gateway 不在配置里手填：连接时从 AID 自动发现（见下）。Keystore 默认落在 `$EVOLCORE_HOME`。
 
+## SDK 同步边界
+
+`@agentunion/fastaun` 管理消息/群消息的 A/T/H 水位、ACK、Push/Tail/Forward、Gap Fill、多页同步、重连恢复和 Pull Gate。EvolCore 只消费公开消息/撤回/同步事件，负责业务路由、持久化和 `(namespace, message_id)` 应用幂等；`seq` 只用于顺序、诊断和日志。菜单、普通文本、volatile 消息和应用去重记录均不能用来推导或回写 SDK 游标。
+
+不得访问或 monkey patch SDK 私有成员，包括 `_seqTracker`、`_pullV2`、`_pullGroupV2`、`_publishAppEvent`、`_dispatcher`、`_identity`、`_auth`、`_tokenStore`、`_v2E2EE`。需要补同步、确认消息或调试时，应先检查 SDK 公开 API；缺少能力应向 SDK 增补公开契约，而不是在渠道适配层改写同步状态。显式查询使用公开 RPC/facade 与独立 slot，不得推进 daemon 消费游标。
+
+`fastaun 0.5.18` 公开 `sender_device_id`，但隐藏发送方 slot。EvolCore 的菜单 token 当前仅按设备绑定，不声称具备同设备多 slot 隔离。
+
 ## 特有机制
 
 - **隐式创建**：aun 渠道由顶层 `aid` 派生，无独立配置实例；这是它与飞书等渠道最大的不同。

package/kits/docs/evolcore/INDEX.md

@@ -14,14 +14,14 @@
 2. **不确定有没有命令**时，直接 `ec <猜测的子命令> --help` 试一下（如 `ec stats --help`）
 3. **已知场景需求**（如"要给对端发消息"）→ 看下方分类表 → 定位到对应命令集
 
-托管 Agent 任务禁止调用 `ec start`、`ec stop`、`ec restart` 或 `ec restart-monitor`。这些进程生命周期命令只能由宿主终端执行；源码改动后 Agent 只应完成构建并报告需要宿主重启。
+生命周期保护仅针对承载当前会话的 EvolCore 实例；其他实例按用户授权和目标端权限处理，不限管理通道。完整规则见 `$KITS_RULES/06-channel.md`。
 
 ## 服务运维类（本地，无需 AUN）
 
 | 命令 | 用途 | 触发词 |
 |------|------|--------|
 | `ec --version` / `-v` / `-V` | 查看版本号 | 版本 |
-| `ec restart` | 宿主终端重启服务（托管 Agent 禁止调用） | 重启 |
+| `ec restart` | 重启目标 daemon（承载当前托管会话的实例受生命周期保护） | 重启 |
 | `ec status` | 查看运行状态、进程、会话、渠道连接 | 状态/查看状态 |
 | `ec logs` | 查看日志（`--level` `--module` `--raw` `--no-color`） | 日志/查看日志 |
 | `ec diagnose` | 诊断启动环境 | 诊断/环境诊断 |

package/kits/docs/evolcore/task.md

@@ -9,6 +9,8 @@ ec task resume <sessionId> --format json
 
 暂停任务会释放原有的工具门控。异常中断任务会把内部恢复提示排入同一会话，并继续原 baseagent 会话。命令只确认恢复请求已被可靠接纳，不会等待模型运行结束。
 
+恢复任务继承原任务的审批交互策略，而非因为自动恢复使用 Trigger 就禁止审批。普通会话（包括 Agent 间和群聊的 proactive 模式）允许申请审批；无人值守 Trigger 禁止申请审批。Handoff 回流同样继承发起任务的策略。继承策略不等于复用旧审批，新的待审批操作仍须发起新请求；缺少历史策略时，自动恢复和 Handoff 回流默认禁止审批，手动恢复默认允许申请。
+
 以下情况会安全结束而不创建新会话：任务已完成或正在运行、任务等待必要输入/审批、会话已删除、原 provider 会话文件不存在、渠道不可用，或任务状态已被更新。
 
 独立 CLI 必须通过 daemon 的本地 control token。托管任务使用当前任务 delegation token，并需要 Agent 管理权限；普通 Agent 只能恢复当前 Agent 的会话，daemon scope 才能恢复其它 Agent 的会话。

package/kits/docs/evolcore/trigger.md

@@ -10,9 +10,9 @@
 
 文件输入限制为 4 MiB，拒绝符号链接、junction、硬链接、路径逃逸、其他会话临时目录、密钥及其他 Agent 私有数据。普通定义导入必须属于当前 Agent；脚本只上传 `execution.script.path` 指定的单个文件，不允许覆盖 `trigger.json`、`active.json` 等管理状态。绝对 `--script-path` 会上传脚本内容并保存 Agent 内相对路径，不保留宿主绝对路径。`--help` / `-h` 在鉴权和文件读取前返回。
 
-普通脚本 Trigger 按每次执行重新核验的 Agent 授权运行，`bypass` 不等于宿主权限：项目按有效模式只读或可写，脚本使用只读快照，只有当前 run 的临时工作目录可写，不继承 daemon 凭据或 IPC 入口，网络禁用。脚本快照位置不同于持久化 Trigger 目录；需要项目资源时按工作目录定位，不能依赖 Trigger 状态文件或其他脚本附件。Node `.js` 保留原 package 的模块类型。
+普通脚本 Trigger 按每次执行重新核验的 Agent 授权运行，复用主会话的权限模式与 H/L 路径保护：`readonly` 项目只读且禁止读取 L 类路径，`auto/request` 项目可写、L 类路径只读；认证 `owner + bypass` 关闭项目写入沙箱，但仍遮蔽 H 类路径并保护 L 类路径。网络默认开放，不需要网络权限配置；保留宿主 HOME、Git/SSH 与代理环境，清除 daemon 凭据、任务 delegation 和代码注入变量。`request` 的非交互脚本不能申请额外权限，越界操作直接失败，不自动升级。脚本使用只读快照和独立临时工作目录；快照位置不同于持久化 Trigger 目录，需要项目资源时按工作目录定位。Node `.js` 保留原 package 的模块类型。
 
-- Linux：需要可用的 `bubblewrap`，使用独立根文件系统及进程/网络命名空间，仅绑定项目、最小系统运行时和当前 run。
+- Linux：需要可用的 `bubblewrap`，复用会话权限运行时的进程隔离和 H/L 路径保护，不隔离网络命名空间；受限模式将宿主根目录只读映射，按权限开放项目和当前 run 临时目录，完整保留系统依赖及 `/etc/alternatives` 链接。
 - Windows：需要支持受限读取策略的原生 Codex CLI，以及宿主已准备好的 elevated sandbox。每次启动前先用同一个临时 canary 验证“显式授权可读、撤回授权后拒绝读取”和当前 run 可写；只有权限拒绝才算通过，文件不存在、探针超时或取消均失败关闭。旧初始化、不支持的运行时或无法证明读取隔离时返回 `SCRIPT_SANDBOX_UNAVAILABLE`，不会启动用户脚本；托管任务不会自动提权、初始化沙箱或降级为宿主执行。
 - 其他平台：当前普通脚本执行失败关闭，不提供未隔离的回退。
 

package/kits/rules/01-overview.md

@@ -6,15 +6,6 @@ ECK 的总览：前置概念和框架结构。
 
 Base agent 是提供推理与生成能力的底层智能，规范值有 `claude`（Claude Code）、`codex`（Codex）、`gemini`（Gemini CLI）、`ecagent`（EvolCore 内置基座）四类。你就是当前会话的 base agent；具体是哪一类以 `[baseagent]` 段注入的 `baseAgentName` 为准，不要默认自己是 Claude Code。
 
-### 外部 Coding Agent Skills 边界
-
-当前会话由 EvolCore 托管时，不加载、不读取、不执行工作区之外的 coding-agent `SKILL.md`，包括
-`/home/evolcore/skills/eclink/SKILL.md`。该类 skill 只服务于独立运行、未接入 EvolCore 会话上下文的
-Codex/Claude Code 等独立工具实例。EvolCore 会话必须遵循本 ECK、daemon IPC 和渠道适配层提供的通信与权限路径。
-
-尤其不要在 EvolCore 会话中因为看到 AUN/agent 间通信需求，就自行读取 `eclink` skill 或直接拼接 shell
-命令调用 `ec`；发送必须经过当前会话的 delegated sender，以便锁定 self/peer、角色、审计和回执。
-
 ## AUN 是什么
 
 AUN（Agent Union Network）是 agent 间安全通信的网络协议，SDK 的 npm 包名 `@agentunion/fastaun`。

package/kits/rules/06-channel.md

@@ -45,7 +45,13 @@
 **完整命令集目录（含分类、触发词、适用场景）**：`$KITS_DOCS/evolcore/INDEX.md`。
 单个命令集的详细用法按需 Read 对应文档。
 
-托管 Agent 任务禁止调用 `ec start`、`ec stop`、`ec restart` 或 `ec restart-monitor`。这些是宿主终端的进程生命周期命令；源码改动后 Agent 只负责构建并报告需要宿主重启，不得尝试、重试或建议 Agent 自己执行 `ec restart`。
+### 当前托管实例的生命周期保护
+
+托管 Agent 不得自行停止、重启或替换承载当前会话的 EvolCore 实例，包括针对该实例的 `ec stop`、`ec restart`、`ec restart-monitor` 和会启动替代进程的 `ec start`。限制以实际目标实例为准，不按命令名称、是否同主机或调用通道一概判定；`fullaccess` 不解除自身实例保护。
+
+其他 EvolCore 实例（包括同主机的独立实例和远程实例）不属于上述保护范围，操作仍须获得用户授权并满足目标端权限。SSH、受鉴权 API 或其他获准的管理通道均可使用，不限定为 SSH；通过回连、代理或端口转发实际操作自身实例，仍受上述限制。无法确认目标是否为自身实例时，应先核实，不得仅凭“远程”调用形式认定允许。
+
+修改承载当前会话的 EvolCore 源码后，Agent 只负责构建并报告需要宿主重启；`ec agent reload` 只重载配置/persona/memory，不重载源码。
 
 共同约定：
 - 以自己的 AID 为发送者

package/kits/templates/system-fragments/commands.md

@@ -1,7 +1,7 @@
 [commands] 当前场景可用命令集（前缀 ec，以自己 AID 为发送者；完整用法 Read 对应文档）
 遇到明确触发词（费用/用量/统计/创建agent/建群/查群/群聊协作/任务分派等）优先查 INDEX.md 或直接试对应 ec 命令
 
-托管 Agent 任务禁止调用 `ec start`、`ec stop`、`ec restart` 或 `ec restart-monitor`，这些是宿主终端的进程生命周期命令。源码改动完成后只执行构建并报告需要宿主重启；不要尝试、重试或建议 Agent 自己执行 `ec restart`。`ec agent reload` 也不会重载源码。
+生命周期保护仅针对承载当前会话的 EvolCore 实例；其他实例按用户授权和目标端权限处理，不限管理通道。完整规则见 `$KITS_RULES/06-channel.md`。
 
 ec memory  记忆写入与整理（note 写入/修改/撤销/查看；consolidate 触发整理；何时写见 [memory] 段）  $KITS_DOCS/evolcore/memory.md
 ec ctl     当前会话工具（主动发消息/文件、重命名、队列、项目路径、会话状态）  $KITS_DOCS/evolcore/ctl.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolcore",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "AI Agent gateway connecting Claude, Codex, Gemini, and the bundled ecagent runner to messaging channels with multi-project session management",
   "type": "module",
   "main": "dist/index.js",