evolcore 0.0.32 → 0.0.34

package/dist/core/auth/debug-context.js

@@ -0,0 +1,139 @@
+/**
+ * debug-context.ts — 调试模式共享逻辑
+ *
+ * 供两端共用，不依赖 src/cli/：
+ *   - CLI 侧：src/cli/debug-mode.ts（resolveDebugContext）
+ *   - daemon 侧：src/ipc.ts（debug-issue-token IPC handler）
+ *
+ * 包含：
+ *   - DebugDelegationRegistry：独立 grant 通道，token 带 dbg: 前缀，不影响主 registry
+ *   - buildDebugTaskContext：从 Session 重建 TaskRuntimeContext（从 launch-consolidation.ts 迁移）
+ */
+import crypto from 'crypto';
+import { formatPeerKey } from '../relation/peer-identity.js';
+import { logger } from '../../utils/logger.js';
+// ---------------------------------------------------------------------------
+// DebugDelegationRegistry
+// ---------------------------------------------------------------------------
+/** Token TTL for debug grants — longer than production (30 min vs 5 min). */
+const DEBUG_TOKEN_TTL_MS = 30 * 60_000;
+/** Prefix that identifies a debug delegation token at the validation entry point. */
+export const DEBUG_TOKEN_PREFIX = 'dbg:';
+function sha256(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+}
+/**
+ * Standalone delegation registry for debug mode.
+ *
+ * Uses a separate Map (debugGrantsByHash) so debug tokens never touch
+ * activeHashBySession in AgentDelegationRegistry, and issuing a debug token
+ * never triggers revokeSession on a live task.
+ *
+ * Token format: `dbg:<32-byte random hex>`
+ * Hash is computed over the raw part (after the prefix) only.
+ */
+export class DebugDelegationRegistry {
+    debugGrantsByHash = new Map();
+    issue(input) {
+        const raw = crypto.randomBytes(32).toString('hex');
+        const token = `${DEBUG_TOKEN_PREFIX}${raw}`;
+        const tokenHash = sha256(raw);
+        const grant = {
+            tokenHash,
+            sessionId: input.sessionId,
+            taskId: `debug-${Date.now()}`,
+            actorId: input.actorId ?? input.selfAid,
+            channel: input.channel,
+            channelType: input.channelType,
+            chatType: input.chatType,
+            selfAid: input.selfAid,
+            peerKey: input.peerKey,
+            issuedRole: input.issuedRole ?? 'debug',
+            expiresAt: Date.now() + DEBUG_TOKEN_TTL_MS,
+        };
+        this.debugGrantsByHash.set(tokenHash, grant);
+        logger.debug(`[DebugDelegation] issued token for session=${input.sessionId}`);
+        return token;
+    }
+    validate(token, sessionId) {
+        const raw = token.startsWith(DEBUG_TOKEN_PREFIX) ? token.slice(DEBUG_TOKEN_PREFIX.length) : token;
+        const tokenHash = sha256(raw);
+        const grant = this.debugGrantsByHash.get(tokenHash);
+        if (!grant) {
+            return { ok: false, code: 'INVALID_DELEGATION', reason: 'unknown debug token', diagnosticCause: 'unknown_token' };
+        }
+        if (grant.sessionId !== sessionId) {
+            return { ok: false, code: 'INVALID_DELEGATION', reason: 'session mismatch', diagnosticCause: 'session_mismatch' };
+        }
+        if (Date.now() > grant.expiresAt) {
+            this.debugGrantsByHash.delete(tokenHash);
+            return { ok: false, code: 'INVALID_DELEGATION', reason: 'debug token expired', diagnosticCause: 'task_replaced' };
+        }
+        return { ok: true, grant };
+    }
+    /** Remove all grants for a session (called when session is unbound). */
+    revokeSession(sessionId) {
+        for (const [hash, grant] of this.debugGrantsByHash) {
+            if (grant.sessionId === sessionId) {
+                this.debugGrantsByHash.delete(hash);
+            }
+        }
+    }
+    /** Prune expired grants. */
+    pruneExpired() {
+        const now = Date.now();
+        for (const [hash, grant] of this.debugGrantsByHash) {
+            if (now > grant.expiresAt)
+                this.debugGrantsByHash.delete(hash);
+        }
+    }
+}
+export function buildDebugTaskContext(input) {
+    const { session } = input;
+    const meta = (session.metadata ?? {});
+    const sessionType = session.sessionType ?? meta.sessionType ?? 'main';
+    // channel = 类型名；channelKey = 完整实例 key。二者分开，
+    // 与 originFromActorSession 的 `session.metadata?.channelKey || session.channel` 同源。
+    let channel = session.channelType || session.channel;
+    let channelKey = meta.channelKey || session.channel;
+    let chatType = session.chatType || 'private';
+    let peerId = meta.peerId;
+    let peerKeyId = chatType === 'group'
+        ? (meta.groupId || session.channelId)
+        : (meta.peerId || session.channelId);
+    let threadId = session.threadId || undefined;
+    if (session.channelId?.startsWith('trigger:') && session.selfAID && input.getTrigger) {
+        const triggerId = session.channelId.slice('trigger:'.length);
+        const origin = input.getTrigger(session.selfAID, triggerId)?.origin;
+        if (origin?.channelType) {
+            channel = origin.channelType;
+            if (origin.channelKey)
+                channelKey = origin.channelKey;
+            chatType = origin.delivery?.chatType ?? 'private';
+            peerId = origin.peerId;
+            peerKeyId = chatType === 'group' ? origin.channelId : (origin.peerId ?? origin.channelId);
+            threadId = origin.threadId;
+        }
+    }
+    return {
+        sessionId: session.id,
+        taskId: `debug-${Date.now()}`,
+        messageId: `debug-msg-${Date.now()}`,
+        baseagent: session.baseagent,
+        channel,
+        channelKey,
+        channelId: session.channelId,
+        chatType,
+        selfAid: session.selfAID,
+        peerId,
+        peerKey: channel && peerKeyId ? formatPeerKey(channel, peerKeyId) : undefined,
+        peerName: meta.peerName,
+        peerType: meta.peerType,
+        threadId,
+        sessionType,
+        memoryMode: meta.memoryMode,
+        memoryScope: meta.memoryScope,
+        consolidationBatchDir: meta.consolidationBatchDir ?? meta.consolidationLogBase,
+        sessionRuntimeDir: input.sessionRuntimeDir,
+    };
+}

package/dist/core/auth/delegation-diagnostics.js

@@ -0,0 +1,414 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { isDelegationDiagnosticsEnabled } from '../../config-store.js';
+import { resolvePaths } from '../../paths.js';
+import { PRODUCT_DISPLAY_NAME } from '../../product.js';
+import { stableWriteJson } from '../../utils/atomic-write.js';
+import { logger } from '../../utils/logger.js';
+import { LogWriter } from '../../utils/log-writer.js';
+const contexts = new AsyncLocalStorage();
+const DAY_MS = 86_400_000;
+const EVENT_RETENTION_DAYS = 180;
+const STATE_RETENTION_MS = 90 * DAY_MS;
+const MESSAGES = {
+    missing_token: '当前请求未携带任务授权凭据。',
+    unknown_token: '在保留的诊断记录中无法识别授权凭据，无法确认其是否曾存在或已被清理。',
+    session_mismatch: '授权凭据不属于当前会话，请在正确的活动任务中重新发起命令。',
+    task_replaced: '当前任务授权已被替换，请在新的活动任务中重新发起命令。',
+    task_revoked: '任务授权已因任务结束、中断或策略变更被撤销，请重新发起任务。',
+    approval_not_found: '已识别会话凭据，但未找到当前命令的匹配审批。',
+    approval_expired: '当前命令的审批已过期，请在活动任务中重新申请审批。',
+    approval_consumed: '当前命令的审批使用次数已耗尽，请勿重放旧请求。',
+    command_hash_mismatch: '提交的命令参数与命令指纹不一致，当前请求已被拒绝。',
+    daemon_restarted: `授权来自先前的 ${PRODUCT_DISPLAY_NAME} 实例，请重新发起任务授权，不要重试旧请求。`,
+};
+export function delegationDiagnosticMessage(cause) {
+    return `(${cause}) ${MESSAGES[cause]}`;
+}
+export async function withDelegationDiagnosticContext(context, callback) {
+    return contexts.run(context, async () => {
+        const result = await callback();
+        if (!result || typeof result !== 'object' || !context.diagnostic)
+            return result;
+        const response = result;
+        if (response.ok !== false || typeof response.error !== 'string'
+            || !response.error.includes(context.diagnostic.reason))
+            return result;
+        const error = response.error;
+        return {
+            ...response,
+            error: error.startsWith(`(${context.diagnostic.diagnosticCause})`)
+                ? error
+                : `(${context.diagnostic.diagnosticCause}) ${error}`,
+            diagnosticCause: context.diagnostic.diagnosticCause,
+            ...(context.diagnostic.diagnosticEventId ? { diagnosticEventId: context.diagnostic.diagnosticEventId } : {}),
+        };
+    });
+}
+function stateKey(state) {
+    return JSON.stringify([state.kind, state.tokenHash, state.sessionId, state.commandHash ?? '']);
+}
+function fingerprint(value) {
+    return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value) ? value : undefined;
+}
+function reference(value) {
+    return typeof value === 'string' && value.length > 0 && value.length <= 512 && !/[\s\x00-\x1f\x7f]/.test(value)
+        ? value : undefined;
+}
+function readState(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const state = value;
+    if (!['task', 'session', 'approval'].includes(state.kind) || !fingerprint(state.tokenHash)
+        || !reference(state.sessionId) || !reference(state.taskId) || !reference(state.runtimeEpoch)
+        || !Number.isFinite(state.updatedAt)
+        || !['active', 'replaced', 'revoked', 'expired', 'consumed'].includes(state.status)
+        || state.kind === 'approval' && (!fingerprint(state.commandHash) || !fingerprint(state.activeTokenHash)))
+        return undefined;
+    const sanitized = {
+        kind: state.kind, tokenHash: state.tokenHash, sessionId: state.sessionId, taskId: state.taskId,
+        runtimeEpoch: state.runtimeEpoch, status: state.status, updatedAt: state.updatedAt,
+    };
+    for (const field of ['selfAid', 'peerKey', 'actorId', 'issuedRole', 'permissionMode', 'threadId', 'messageId']) {
+        const safe = reference(state[field]);
+        if (safe)
+            sanitized[field] = safe;
+    }
+    for (const field of ['commandHash', 'activeTokenHash']) {
+        const safe = fingerprint(state[field]);
+        if (safe)
+            sanitized[field] = safe;
+    }
+    for (const field of ['expiresAt', 'remainingUses', 'sequence']) {
+        const numeric = state[field];
+        if (typeof numeric === 'number' && Number.isSafeInteger(numeric) && numeric >= 0)
+            sanitized[field] = numeric;
+    }
+    if (state.credentialType === 'task' || state.credentialType === 'codex-session')
+        sanitized.credentialType = state.credentialType;
+    if (state.revocationReason && ['completed', 'interrupted', 'replaced', 'policy_revoked', 'failed', 'revoked'].includes(state.revocationReason)) {
+        sanitized.revocationReason = state.revocationReason;
+    }
+    return sanitized;
+}
+export class DelegationDiagnostics {
+    runtimeEpoch;
+    states = new Map();
+    credentialsByHash = new Map();
+    indexPath;
+    logDir;
+    writer;
+    lastCleanup = 0;
+    lastArchiveCleanup = 0;
+    persistenceState;
+    sequence = 0;
+    lastWarnings = new Map();
+    constructor(runtimeEpoch) {
+        this.runtimeEpoch = runtimeEpoch;
+        const paths = resolvePaths();
+        this.logDir = paths.logs;
+        this.indexPath = path.join(paths.dataDir, 'delegation-diagnostics', 'index.json');
+        this.load();
+        this.record('runtime.started');
+        this.save();
+    }
+    close() {
+        this.writer?.close();
+    }
+    put(event, input) {
+        const state = readState({ ...input, updatedAt: Date.now(), sequence: ++this.sequence });
+        if (!state) {
+            this.warn('诊断状态格式无效，记录已跳过', new Error('invalid state'));
+            return;
+        }
+        this.store(state);
+        this.record(event, { state });
+        this.save();
+    }
+    find(kind, tokenHash, sessionId, commandHash) {
+        const recent = this.states.get(stateKey({ kind, tokenHash, sessionId, commandHash }));
+        if (recent && this.retained(recent))
+            return recent;
+        return undefined;
+    }
+    findCredential(tokenHash, sessionId) {
+        const matches = [...(this.credentialsByHash.get(tokenHash)?.values() ?? [])].filter(state => this.retained(state));
+        return matches.find(state => state.sessionId === sessionId)
+            ?? matches.sort((left, right) => right.updatedAt - left.updatedAt)[0];
+    }
+    classify(tokenHash, sessionId, commandHash) {
+        const credential = this.findCredential(tokenHash, sessionId);
+        if (!credential)
+            return 'unknown_token';
+        if (credential.sessionId !== sessionId)
+            return 'session_mismatch';
+        if (credential.kind === 'task')
+            return this.taskCause(credential);
+        const approval = commandHash ? this.find('approval', tokenHash, sessionId, commandHash) : undefined;
+        const activeTokenHash = approval?.activeTokenHash ?? credential.activeTokenHash;
+        const task = activeTokenHash
+            ? this.find('task', activeTokenHash, sessionId)
+            : undefined;
+        if (task && task.status !== 'active')
+            return this.taskCause(task);
+        if (credential.runtimeEpoch !== this.runtimeEpoch || approval && approval.runtimeEpoch !== this.runtimeEpoch) {
+            return 'daemon_restarted';
+        }
+        if (credential.status !== 'active')
+            return this.taskCause(credential);
+        if (!approval)
+            return 'approval_not_found';
+        if (approval.status === 'consumed')
+            return 'approval_consumed';
+        if (approval.status === 'expired' || approval.expiresAt !== undefined && approval.expiresAt <= Date.now()) {
+            return 'approval_expired';
+        }
+        if (approval.status !== 'active')
+            return this.taskCause(approval);
+        return 'approval_not_found';
+    }
+    classifyCommandHashMismatch(tokenHash, sessionId) {
+        return this.classifyCredential(tokenHash, sessionId) ?? 'command_hash_mismatch';
+    }
+    failure(cause, sessionId, tokenHash, commandHash) {
+        const reason = delegationDiagnosticMessage(cause);
+        const diagnosticEventId = this.record('validation.rejected', {
+            diagnosticCause: cause, sessionId: reference(sessionId), tokenHash: fingerprint(tokenHash), commandHash: fingerprint(commandHash),
+        });
+        const diagnostic = { diagnosticCause: cause, ...(diagnosticEventId ? { diagnosticEventId } : {}), reason };
+        const context = contexts.getStore();
+        if (context)
+            context.diagnostic = diagnostic;
+        return {
+            ok: false,
+            code: cause === 'missing_token' ? 'DELEGATION_REQUIRED'
+                : cause === 'daemon_restarted' ? 'DAEMON_RESTARTED' : 'INVALID_DELEGATION',
+            ...diagnostic,
+        };
+    }
+    accepted(sessionId, tokenHash, commandHash) {
+        this.record('validation.accepted', { sessionId: reference(sessionId), tokenHash: fingerprint(tokenHash), commandHash: fingerprint(commandHash) });
+    }
+    taskCause(state) {
+        if (state.status === 'replaced')
+            return 'task_replaced';
+        if (state.status !== 'active')
+            return 'task_revoked';
+        return state.runtimeEpoch !== this.runtimeEpoch ? 'daemon_restarted' : 'unknown_token';
+    }
+    classifyCredential(tokenHash, sessionId) {
+        const credential = this.findCredential(tokenHash, sessionId);
+        if (!credential)
+            return 'unknown_token';
+        if (credential.sessionId !== sessionId)
+            return 'session_mismatch';
+        if (credential.status === 'replaced')
+            return 'task_replaced';
+        if (credential.status !== 'active')
+            return 'task_revoked';
+        if (credential.runtimeEpoch !== this.runtimeEpoch)
+            return 'daemon_restarted';
+        if (credential.kind === 'task')
+            return undefined;
+        if (!credential.activeTokenHash)
+            return 'unknown_token';
+        const task = this.find('task', credential.activeTokenHash, sessionId);
+        if (!task)
+            return 'unknown_token';
+        if (task.status === 'replaced')
+            return 'task_replaced';
+        if (task.status !== 'active')
+            return 'task_revoked';
+        if (task.runtimeEpoch !== this.runtimeEpoch)
+            return 'daemon_restarted';
+        return undefined;
+    }
+    retained(state) {
+        if (state.runtimeEpoch === this.runtimeEpoch && state.status === 'active'
+            && (state.kind !== 'approval' || state.expiresAt !== undefined && state.expiresAt > Date.now()))
+            return true;
+        return state.updatedAt >= Date.now() - STATE_RETENTION_MS;
+    }
+    store(state) {
+        const key = stateKey(state);
+        this.states.set(key, state);
+        if (state.kind !== 'approval') {
+            let credentials = this.credentialsByHash.get(state.tokenHash);
+            if (!credentials) {
+                credentials = new Map();
+                this.credentialsByHash.set(state.tokenHash, credentials);
+            }
+            credentials.set(key, state);
+        }
+        this.sequence = Math.max(this.sequence, state.sequence ?? 0);
+    }
+    record(event, details = {}) {
+        if (!this.persistenceEnabled())
+            return undefined;
+        const context = contexts.getStore();
+        const record = {
+            version: 1, eventId: `del-audit-${crypto.randomUUID()}`, ts: Date.now(), runtimeEpoch: this.runtimeEpoch, event,
+            ...(reference(context?.requestId) ? { requestId: context.requestId } : {}),
+            ...(reference(context?.correlationId) ? { correlationId: context.correlationId } : {}),
+            ...(reference(context?.operation) ? { operation: context.operation } : {}),
+            ...details,
+        };
+        try {
+            if (!this.writer) {
+                this.writer = new LogWriter({
+                    baseName: 'delegation-audit', logDir: this.logDir, rotation: 'daily',
+                    retention: { days: EVENT_RETENTION_DAYS },
+                });
+                this.writer.close();
+            }
+            if (Date.now() - this.lastArchiveCleanup > 3_600_000) {
+                LogWriter.cleanupArchivesIn(this.logDir, 'delegation-audit', EVENT_RETENTION_DAYS * DAY_MS);
+                this.lastArchiveCleanup = Date.now();
+            }
+            this.writer.writeChecked(JSON.stringify(record));
+            return record.eventId;
+        }
+        catch (error) {
+            this.warn('审计事件写入失败', error);
+            return undefined;
+        }
+    }
+    load() {
+        try {
+            const index = JSON.parse(fs.readFileSync(this.indexPath, 'utf8'));
+            if (index.version !== 1 || !Array.isArray(index.states))
+                throw new Error('invalid diagnostic index');
+            for (const raw of index.states) {
+                const state = readState(raw);
+                if (state && this.retained(state))
+                    this.store(state);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                this.warn('诊断索引读取失败，尝试从审计事件重建', error);
+        }
+        this.scanHistory(state => {
+            if (!this.retained(state))
+                return;
+            const previous = this.states.get(stateKey(state));
+            if (!previous || (state.sequence !== undefined && previous.sequence !== undefined
+                ? state.sequence > previous.sequence : state.updatedAt > previous.updatedAt))
+                this.store(state);
+        });
+    }
+    scanHistory(visit) {
+        try {
+            if (!fs.existsSync(this.logDir))
+                return;
+            const files = fs.readdirSync(this.logDir).filter(name => /^delegation-audit(?:-\d{8})?\.log$/.test(name)).sort();
+            for (const name of files) {
+                let descriptor;
+                const consume = (line) => {
+                    if (!line.trim())
+                        return;
+                    try {
+                        const event = JSON.parse(line);
+                        const state = event.version === 1 ? readState(event.state) : undefined;
+                        if (state)
+                            visit(state);
+                    }
+                    catch (error) {
+                        this.warn(`忽略损坏的审计记录 ${name}`, error);
+                    }
+                };
+                try {
+                    descriptor = fs.openSync(path.join(this.logDir, name), 'r');
+                    const decoder = new StringDecoder('utf8');
+                    const buffer = Buffer.alloc(64 * 1024);
+                    let pending = '';
+                    let skipping = false;
+                    let bytes;
+                    while ((bytes = fs.readSync(descriptor, buffer, 0, buffer.length, null)) > 0) {
+                        pending += decoder.write(buffer.subarray(0, bytes));
+                        let newline;
+                        while ((newline = pending.indexOf('\n')) >= 0) {
+                            if (!skipping && newline <= 64 * 1024)
+                                consume(pending.slice(0, newline));
+                            pending = pending.slice(newline + 1);
+                            skipping = false;
+                        }
+                        if (pending.length > 64 * 1024) {
+                            pending = '';
+                            skipping = true;
+                            this.warn(`忽略过长的审计记录 ${name}`, new Error('oversized record'));
+                        }
+                    }
+                    if (!skipping)
+                        consume(pending + decoder.end());
+                }
+                catch (error) {
+                    this.warn(`历史审计读取失败 ${name}`, error);
+                }
+                finally {
+                    if (descriptor !== undefined)
+                        fs.closeSync(descriptor);
+                }
+            }
+        }
+        catch (error) {
+            this.warn('历史审计读取失败', error);
+        }
+    }
+    save() {
+        if (Date.now() - this.lastCleanup > 3_600_000) {
+            for (const [key, state] of this.states) {
+                if (this.retained(state))
+                    continue;
+                this.states.delete(key);
+                const credentials = this.credentialsByHash.get(state.tokenHash);
+                credentials?.delete(key);
+                if (credentials?.size === 0)
+                    this.credentialsByHash.delete(state.tokenHash);
+            }
+            this.lastCleanup = Date.now();
+        }
+        if (!this.persistenceEnabled())
+            return;
+        this.writeIndex();
+    }
+    writeIndex() {
+        try {
+            fs.mkdirSync(path.dirname(this.indexPath), { recursive: true, mode: 0o700 });
+            if (fs.existsSync(this.indexPath))
+                fs.chmodSync(this.indexPath, 0o600);
+            stableWriteJson(this.indexPath, { version: 1, states: [...this.states.values()].filter(state => this.retained(state)) });
+        }
+        catch (error) {
+            this.warn('诊断索引写入失败', error);
+        }
+    }
+    persistenceEnabled() {
+        let enabled = false;
+        try {
+            enabled = isDelegationDiagnosticsEnabled();
+        }
+        catch (error) {
+            this.warn('诊断开关读取失败，暂停持久化', error);
+        }
+        if (enabled && this.persistenceState === false)
+            this.writeIndex();
+        this.persistenceState = enabled;
+        if (enabled)
+            return true;
+        this.writer?.close();
+        this.writer = undefined;
+        return false;
+    }
+    warn(action, error) {
+        const code = error.code ?? 'storage_error';
+        const key = `${action}:${code}`;
+        if (Date.now() - (this.lastWarnings.get(key) ?? 0) < 60_000)
+            return;
+        this.lastWarnings.set(key, Date.now());
+        logger.warn(`[DelegationDiagnostics] ${action}: ${code}; index=${this.indexPath}; logs=${this.logDir}; 请检查文件权限、磁盘空间及诊断记录完整性；历史记录不参与授权。`);
+    }
+}

package/dist/core/auth/operation-authorizer.js

@@ -331,6 +331,15 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
         };
     }
     let matchResult = matchCommandPermission(operation, opMeta.category, roleDef.commandPermissions || {}, opMeta.dangerous);
+    if (!matchResult && operation.startsWith('ec.thread.') && opMeta.category === 'read' && intent.scope === 'relation') {
+        const permission = roleDef.commandPermissions?.['session.topic.list'];
+        if (permission?.allow)
+            matchResult = {
+                permission: { ...permission, scopes: ['relation'], constraints: { ...permission.constraints, currentRelationOnly: true, targetCurrentAgentOnly: true } },
+                matchedRule: 'session.topic.list',
+                rank: 1000,
+            };
+    }
     // Agent self-service contact add deliberately reuses the same low-trust
     // relation boundary as ec.msg.send. Older per-Agent role files may still
     // contain the historical contact.* deny without an explicit contact.add
@@ -461,6 +470,14 @@ function requiresDaemonOwner(ctx, resolvedConfigCommand) {
     if (operation === 'agent.reload') {
         return !isCurrentAgentTarget(ctx);
     }
+    // Same shape as agent.reload: the current Agent's owner/admin refresh their
+    // own skill index; refreshing another Agent's index needs the daemon owner.
+    if (operation === 'skill.refresh' && hasDaemonOwnerRole(ctx)) {
+        return true;
+    }
+    if (operation === 'skill.refresh') {
+        return !isCurrentAgentTarget(ctx);
+    }
     if (operation.startsWith('trigger.')) {
         if (ctx.fromControlChannel)
             return true;
@@ -478,7 +495,7 @@ function hasDaemonOwnerRole(ctx) {
         || ctx.processRole === 'daemon-service';
 }
 function daemonOwnerDenialReasonCode(ctx) {
-    if ((ctx.intent.operation === 'agent.show' || ctx.intent.operation === 'agent.reload')
+    if ((ctx.intent.operation === 'agent.show' || ctx.intent.operation === 'agent.reload' || ctx.intent.operation === 'skill.refresh')
         && ctx.intent.scope !== 'control'
         && !ctx.fromControlChannel
         && !isCurrentAgentTarget(ctx)) {
@@ -894,6 +911,12 @@ function checkOwnPeer(ctx) {
             ? { ok: true }
             : { ok: false, reason: 'Only the current group relation can be targeted' };
     }
+    // For ec.msg.send / ec.msg.file, args.peer is the recipient (to), not a
+    // self-targeting field. Cross-topic sends are checked against their indexed
+    // target session by the managed message operation.
+    const isMsgSend = ctx.intent.operation === 'ec.msg.send' || ctx.intent.operation === 'ec.msg.file';
+    if (isMsgSend)
+        return { ok: true };
     if (ctx.actorId) {
         if (requestedPeerId && requestedPeerId !== ctx.actorId) {
             return { ok: false, reason: ownPeerOnlyDenialReason(ctx, requestedPeerId) };
@@ -928,7 +951,7 @@ function ownPeerOnlyDenialReason(ctx, requestedPeer) {
     const currentPeer = ctx.actorId || peerIdFromArg(ctx.peerKey || '') || '当前私聊对端';
     const target = requestedPeer || '指定目标';
     return `当前托管会话只能联系当前私聊对端（${currentPeer}），不能联系第三方目标（${target}）。`
-        + ' 如果本次请求来自 handoff，请执行 ec handoff return <handoff-id> "<失败原因>"（已有命令）将失败原因反馈给原会话；'
+        + ` 如果本次请求来自 handoff，请执行 ec handoff return <handoff-id> '<失败原因>'（已有命令）将失败原因反馈给原会话；`
         + '否则请让目标先直接发起会话，或由 Agent owner 为当前角色配置允许 relay/第三方外联后再发送。';
 }
 function peerIdFromArg(value) {

package/dist/core/auth/operation-catalog.js

@@ -307,6 +307,22 @@ const OPERATIONS = [
         description: '查看当前会话状态',
         sources: ['slash', 'menu', 'agent-tool'],
     },
+    {
+        id: 'session.loop.current',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation'],
+        description: '查看当前主会话或话题的 idle 触发设置',
+        sources: ['slash', 'menu', 'ecweb', 'control'],
+    },
+    {
+        id: 'session.loop.update',
+        category: 'write-own',
+        dangerous: false,
+        defaultScopes: ['relation'],
+        description: '更新当前主会话或话题的 idle 触发设置',
+        sources: ['slash', 'menu', 'ecweb', 'control'],
+    },
     {
         id: 'session.topic.current',
         category: 'read',
@@ -767,6 +783,23 @@ const OPERATIONS = [
         description: '重载 agent 配置',
         sources: ['slash', 'menu', 'agent-tool', 'control'],
     },
+    {
+        id: 'skill.refresh',
+        category: 'write-agent',
+        dangerous: false,
+        defaultScopes: ['agent', 'control'],
+        description: '重建技能索引文件',
+        sources: ['agent-tool', 'control'],
+    },
+    ...['list', 'list-peers', 'show', 'history', 'check-index', 'summary-show', 'summary-log', 'create', 'rename', 'label', 'status', 'delete', 'summary-set', 'summary-clear', 'rebuild-index'].map(action => ({
+        id: `ec.thread.${action}`,
+        category: (['list', 'list-peers', 'show', 'history', 'check-index', 'summary-show', 'summary-log'].includes(action)
+            ? 'read' : action === 'rebuild-index' ? 'write-agent' : 'write-own'),
+        dangerous: false,
+        defaultScopes: ['relation', 'agent'],
+        description: `${action} managed conversation threads`,
+        sources: ['agent-tool'],
+    })),
     {
         id: 'agent.bootstrapComplete',
         category: 'write-agent',
@@ -1174,6 +1207,22 @@ const OPERATIONS = [
         description: '通过 ec ctl file 向当前会话发送项目文件',
         sources: ['agent-tool'],
     },
+    ...['grant', 'revoke'].map(action => ({
+        id: `ec.ctl.path.${action}`,
+        category: 'write-agent',
+        dangerous: true,
+        defaultScopes: ['relation', 'agent'],
+        description: `${action} a runtime path grant for the current managed session (owner/admin only)`,
+        sources: ['agent-tool'],
+    })),
+    {
+        id: 'ec.ctl.path.list',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['relation'],
+        description: 'List runtime path grants for the current managed session',
+        sources: ['agent-tool'],
+    },
     ...['read', 'clear', 'cancel', 'interrupt'].map(action => ({
         id: `ec.ctl.queue.${action}`,
         category: action === 'read' ? 'read' : 'write-own',