evolcore 0.0.25 → 0.0.26

package/dist/config/config-operation-service.js

@@ -5,6 +5,9 @@ import { currentVersion, fieldSchemaDefault, isSchemaName, listSchemaNames, list
 import fs from 'fs';
 import path from 'path';
 import { resolvePaths, agentDir, agentRelationConfig } from '../paths.js';
+import { roleMenuQuery, roleMenuUpdate } from '../core/command/role-menu.js';
+import { parsePeerKey } from '../core/relation/peer-identity.js';
+import { isExplicitGroupId } from '../aun/group-identity.js';
 export const AUTHENTICATED_CONFIG_ROLE_ENV = 'EVOLCORE_AUTHENTICATED_CONFIG_ROLE';
 export function executeResolvedConfigCommand(command, options = {}) {
     try {
@@ -23,6 +26,134 @@ export function executeResolvedConfigCommand(command, options = {}) {
         return { ok: false, code: 'CONFIG_ERROR', error: error instanceof Error ? error.message : String(error) };
     }
 }
+/**
+ * Execute a config command that may use an asynchronous domain service.
+ * Relation role assignments are intentionally handled here instead of by
+ * mutateConfig(), so Role Menu remains the single write path for validation,
+ * revisions, journaling, and audit.
+ */
+export async function executeResolvedConfigCommandAsync(command, options = {}) {
+    try {
+        if (isRelationRoleCommand(command)) {
+            return await executeRelationRoleCommand(command, options);
+        }
+        return executeResolvedConfigCommand(command, options);
+    }
+    catch (error) {
+        if (error instanceof ConfigError)
+            return { ok: false, code: error.code, error: error.message, ...(error.data !== undefined ? { data: error.data } : {}) };
+        const roleError = error;
+        return {
+            ok: false,
+            code: roleError?.code || 'CONFIG_ERROR',
+            error: roleError?.message || String(error),
+            ...(roleError?.data !== undefined ? { data: roleError.data } : {}),
+        };
+    }
+}
+function isRelationRoleCommand(command) {
+    return command.kind === 'field'
+        && command.field === 'role'
+        && command.configScope === 'relation'
+        && (command.operationId === 'role.relation.read'
+            || command.operationId === 'role.assign'
+            || command.operationId === 'role.revoke');
+}
+async function executeRelationRoleCommand(op, options) {
+    if (!op.self || !op.peerKey) {
+        return { ok: false, code: 'PEER_REQUIRED', error: 'role requires --self <aid> --peer <peer-aid>' };
+    }
+    const target = roleTargetFromPeerKey(op.peerKey);
+    const context = options.roleContext ?? {
+        self: op.self,
+        actorRole: options.role || 'owner',
+        actorRoleSource: 'local-cli',
+        isDaemonOwner: false,
+        fromControlChannel: false,
+        aunAvailable: true,
+    };
+    if (context.self !== op.self) {
+        return { ok: false, code: 'SCOPE_MISMATCH', error: 'Role target does not match the receiving Agent' };
+    }
+    const targetArgs = { self: op.self, view: 'target', target };
+    const current = await roleMenuQuery(context, targetArgs);
+    const explicitRole = current?.assignment?.explicitRole
+        ?? current?.assignment?.explicitDefaultRole
+        ?? null;
+    const effectiveRole = current?.effectiveRole?.roleId
+        ?? current?.baselineRole?.roleId
+        ?? null;
+    const effectiveRoleSource = current?.effectiveRole?.source
+        ?? current?.baselineRole?.source
+        ?? 'none';
+    const roleDetails = { explicitRole, effectiveRole, effectiveRoleSource };
+    if (op.subcommand === 'get') {
+        return {
+            ok: true,
+            subcommand: 'get',
+            field: op.field,
+            value: explicitRole,
+            scope: op.configScope,
+            roleDetails,
+        };
+    }
+    const nextValue = op.subcommand === 'unset' ? null : op.value;
+    const updated = await roleMenuUpdate(context, {
+        self: op.self,
+        resource: 'assignment',
+        target,
+        expectedPolicyRevision: current.policyRevision,
+        expectedRelationRevision: current.relationRevision,
+    }, JSON.stringify(nextValue));
+    const updatedExplicitRole = updated?.assignment?.explicitRole
+        ?? updated?.assignment?.explicitDefaultRole
+        ?? null;
+    const updatedEffectiveRole = updated?.effectiveRole?.roleId
+        ?? updated?.baselineRole?.roleId
+        ?? null;
+    const updatedEffectiveRoleSource = updated?.effectiveRole?.source
+        ?? updated?.baselineRole?.source
+        ?? 'none';
+    const updatedDetails = {
+        explicitRole: updatedExplicitRole,
+        effectiveRole: updatedEffectiveRole,
+        effectiveRoleSource: updatedEffectiveRoleSource,
+    };
+    if (op.subcommand === 'unset') {
+        return {
+            ok: true,
+            subcommand: 'unset',
+            field: op.field,
+            removed: updated.changed === true,
+            scope: op.configScope,
+            roleDetails: updatedDetails,
+        };
+    }
+    return {
+        ok: true,
+        subcommand: 'set',
+        field: op.field,
+        value: updatedExplicitRole,
+        scope: op.configScope,
+        file: 'relation-config',
+        roleDetails: updatedDetails,
+    };
+}
+function roleTargetFromPeerKey(peerKey) {
+    let parsed;
+    try {
+        parsed = parsePeerKey(peerKey);
+    }
+    catch {
+        throw new ConfigError('INVALID_SELECTOR', `Invalid relation peer key: ${peerKey}`);
+    }
+    if (parsed.channelType !== 'aun') {
+        throw new ConfigError('NOT_SUPPORTED', 'Relation role assignments currently support AUN peers only');
+    }
+    return isExplicitGroupId(parsed.channelId)
+        ? { kind: 'group', groupId: parsed.channelId }
+        : { kind: 'private', peerAid: parsed.channelId };
+}
 export function executeResolvedConfigOperation(op, options = {}) {
     try {
         const missingAgent = selectedAgentError(op);
@@ -298,6 +429,13 @@ function getWithSchemaDefault(op, absent, note) {
     return { ok: true, subcommand: 'get', field: op.field, value: absent, scope: op.configScope, ...nt };
 }
 function executeSet(op, options) {
+    if (op.field === 'role') {
+        return {
+            ok: false,
+            code: 'ROLE_POLICY_MANAGED',
+            error: 'Relation role assignments require the asynchronous role assignment service',
+        };
+    }
     if (!op.route)
         return { ok: false, code: 'UNKNOWN_FIELD', error: `Unknown config field: ${op.field}` };
     const selector = selectorFor(op, options);
@@ -341,6 +479,13 @@ function executeSet(op, options) {
     };
 }
 function executeUnset(op, options) {
+    if (op.field === 'role') {
+        return {
+            ok: false,
+            code: 'ROLE_POLICY_MANAGED',
+            error: 'Relation role assignments require the asynchronous role assignment service',
+        };
+    }
     if (!op.route)
         return { ok: false, code: 'UNKNOWN_FIELD', error: `Unknown config field: ${op.field}` };
     const selector = selectorFor(op, options);

package/dist/config/contact-operation-service.js

@@ -5,6 +5,8 @@ import { agentConfig } from '../paths.js';
 import { getContactSnapshot, resolveContactView } from './contact-book.js';
 import { ContactMutationError } from './contact-book-store.js';
 import { addContact, mutateContactWithOperation } from './contact-request-service.js';
+import { expirePendingContactRequests, reviewContactRequest } from './contact-request-service.js';
+import { listStaticAgentOwners } from './peer-role-resolver.js';
 export function resolveContactCommand(argv) {
     const args = argv[0] === 'contact' ? argv.slice(1) : [...argv];
     const selfAid = String(argValue(args, '--self') || '').trim();
@@ -15,12 +17,41 @@ export function resolveContactCommand(argv) {
     if (extra.length > 0)
         return invalid('INVALID_ARGUMENT', `Unexpected contact arguments: ${extra.join(' ')}`);
     if (command === 'list') {
-        if (subcommand !== undefined || !args.includes('--blocked')) {
-            return invalid('INVALID_ARGUMENT', 'Only ec contact list --blocked is currently supported');
+        if (subcommand !== undefined) {
+            return invalid('INVALID_ARGUMENT', 'contact list does not accept a positional argument');
         }
+        const filter = args.includes('--blocked')
+            ? 'blocked'
+            : args.includes('--pending')
+                ? 'pending'
+                : args.includes('--all') ? 'all' : undefined;
+        if (!filter)
+            return invalid('INVALID_ARGUMENT', 'contact list requires --blocked, --pending, or --all');
         return {
             ok: true,
-            command: { kind: 'list-blocked', operationId: 'contact.read', selfAid, canonicalArgv: canonicalArgv(argv) },
+            command: { kind: 'list-blocked', operationId: 'contact.read', selfAid, filter, canonicalArgv: canonicalArgv(argv) },
+        };
+    }
+    if (command === 'approve' || command === 'reject' || command === 'block-request') {
+        if (!isValidAid(subcommand || '') || isExplicitGroupId(subcommand || '')) {
+            return invalid('INVALID_AID', 'primaryId must be a valid individual AID');
+        }
+        const requestId = String(argValue(args, '--request-id') || '').trim();
+        if (!requestId)
+            return invalid('INVALID_ARGUMENT', `${command} requires --request-id <request-id>`);
+        const expectedContactRevision = argValue(args, '--contact-revision')?.trim() || undefined;
+        return {
+            ok: true,
+            command: {
+                kind: 'review-request',
+                operationId: 'contact.review',
+                selfAid,
+                primaryId: subcommand,
+                requestId,
+                decision: command === 'approve' ? 'approve' : command === 'reject' ? 'reject' : 'block',
+                expectedContactRevision,
+                canonicalArgv: canonicalArgv(argv),
+            },
         };
     }
     if (command === 'block' || command === 'unblock') {
@@ -62,13 +93,63 @@ export async function executeResolvedContactCommand(command, actor = 'local-cli'
     }
     try {
         if (command.kind === 'list-blocked') {
+            await expirePendingContactRequests(command.selfAid);
             const snapshot = getContactSnapshot(command.selfAid);
+            const ids = command.filter === 'blocked'
+                ? [...snapshot.blockedIndex]
+                : [...snapshot.contacts.entries()]
+                    .filter(([, entry]) => command.filter === 'all' || entry.status === 'pending')
+                    .map(([id]) => id);
+            const items = ids.sort().map(id => contactItem(command.selfAid, id));
+            if (command.filter === 'blocked') {
+                return {
+                    ok: true,
+                    operation: 'list-blocked',
+                    selfAid: command.selfAid,
+                    contactRevision: snapshot.contactRevision,
+                    items,
+                };
+            }
             return {
                 ok: true,
-                operation: 'list-blocked',
+                operation: 'list-contacts',
                 selfAid: command.selfAid,
+                filter: command.filter,
                 contactRevision: snapshot.contactRevision,
-                items: [...snapshot.blockedIndex].sort().map(id => resolveContactView(command.selfAid, id)),
+                items,
+            };
+        }
+        if (command.kind === 'review-request') {
+            const expectedContactRevision = command.expectedContactRevision ?? getContactSnapshot(command.selfAid).contactRevision;
+            const reviewerAid = actor === 'local-cli'
+                ? listStaticAgentOwners(command.selfAid)[0]
+                : actor;
+            if (!reviewerAid) {
+                return { ok: false, code: 'NO_OWNER', error: `Agent has no owner: ${command.selfAid}` };
+            }
+            const reviewed = await reviewContactRequest({
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                requestId: command.requestId,
+                expectedContactRevision,
+                approverId: reviewerAid,
+                actorId: reviewerAid,
+                decision: command.decision,
+            });
+            if (reviewed.code !== 'approved' && reviewed.code !== 'rejected' && reviewed.code !== 'blocked') {
+                const code = reviewed.code === 'request-expired' ? 'REQUEST_EXPIRED'
+                    : reviewed.code === 'revision-conflict' ? 'CONFLICT'
+                        : reviewed.code === 'forbidden' ? 'PERMISSION_DENIED' : 'REQUEST_STALE';
+                return { ok: false, code, error: reviewed.code, data: { contactRevision: reviewed.contactRevision } };
+            }
+            return {
+                ok: true,
+                operation: 'review-request',
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                requestId: command.requestId,
+                result: reviewed.code,
+                contactRevision: reviewed.contactRevision,
             };
         }
         if (command.kind === 'set-blocked') {
@@ -129,16 +210,24 @@ function stripOptions(args) {
     const result = [];
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
-        if (arg === '--self' || arg === '--format') {
+        if (arg === '--self' || arg === '--format' || arg === '--request-id' || arg === '--contact-revision') {
             index += 1;
             continue;
         }
-        if (arg === '--blocked')
+        if (arg === '--blocked' || arg === '--pending' || arg === '--all')
             continue;
         result.push(arg);
     }
     return result;
 }
+function contactItem(selfAid, primaryId) {
+    const view = resolveContactView(selfAid, primaryId);
+    const entry = getContactSnapshot(selfAid).contacts.get(primaryId);
+    return {
+        ...view,
+        ...(entry?.pendingRequest ? { pendingRequest: { ...entry.pendingRequest } } : {}),
+    };
+}
 function canonicalArgv(argv) {
     return argv[0] === 'contact' ? [...argv] : ['contact', ...argv];
 }

package/dist/config/resolved-config-op.js

@@ -97,11 +97,12 @@ function resolveFieldCommand(argv, subcommand, options = {}) {
             reason: 'permissionMode is defined by roles; use the role policy editor',
         };
     }
-    if (field === 'role') {
+    const isRelationRole = field === 'role';
+    if (isRelationRole && selector.scope !== 'relation') {
         return {
             ok: false,
-            code: 'ROLE_POLICY_MANAGED',
-            reason: 'Relation role assignments are managed through the role assignment service',
+            code: 'RELATION_SELECTOR_REQUIRED',
+            reason: `config ${subcommand} role needs a relation target: --self <aid> --peer <peer-aid>`,
         };
     }
     if (subcommand !== 'get' && (field === 'roles' || field.startsWith('roles.'))) {
@@ -129,12 +130,14 @@ function resolveFieldCommand(argv, subcommand, options = {}) {
             reason: `Config field ${field} does not support object writes`,
         };
     }
-    const commandScope = selector.scope === 'defaults' ? 'process' : selector.scope;
+    const commandScope = isRelationRole ? 'agent' : selector.scope === 'defaults' ? 'process' : selector.scope;
     const isSafe = fieldRule.class === 'safe-scalar' || fieldRule.class === 'safe-readonly-object';
     const isManagementOperation = commandScope === 'process' || !isSafe;
-    const operationId = isManagementOperation
-        ? subcommand === 'get' ? 'config.read' : 'config.write'
-        : `config.${subcommand}`;
+    const operationId = isRelationRole
+        ? subcommand === 'get' ? 'role.relation.read' : subcommand === 'set' ? 'role.assign' : 'role.revoke'
+        : isManagementOperation
+            ? subcommand === 'get' ? 'config.read' : 'config.write'
+            : `config.${subcommand}`;
     let route;
     const routeRequired = subcommand !== 'get' || !isManagementOperation;
     try {
@@ -173,6 +176,23 @@ function resolveFieldCommand(argv, subcommand, options = {}) {
                 return parsedOwners;
             value = parsedOwners.value;
         }
+        else if (isRelationRole) {
+            const raw = rawValue.trim();
+            if (!raw)
+                return { ok: false, code: 'INVALID_CONFIG_VALUE', reason: 'Config field role cannot be empty' };
+            try {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed === 'string')
+                    value = parsed;
+                else if (parsed === null)
+                    return { ok: false, code: 'INVALID_CONFIG_VALUE', reason: 'config set role requires a role ID; use config unset role to revoke it' };
+                else
+                    return { ok: false, code: 'INVALID_CONFIG_VALUE', reason: 'Config field role must be a role ID or null' };
+            }
+            catch {
+                value = raw;
+            }
+        }
         else if (fieldRule.class === 'safe-scalar') {
             const parsedValue = parseConfigFieldValue(field, rawValue);
             if (!parsedValue.ok)

package/dist/core/agent-application-service.js

@@ -85,13 +85,14 @@ export class AgentApplicationService {
                 unique_peer_count: stats?.uniquePeerCount ?? 0,
             }
             : null;
-        const config = agent.config;
+        const config = (loadAgent(aid) ?? agent.config);
         const identity = readAgentMdIdentity(aid);
         const paths = resolvePaths();
         return {
             ok: true,
             aid,
             status: info.status || 'stopped',
+            lifecycle: config?.lifecycle ?? null,
             identity,
             config: {
                 baseagent: info.baseagent || null,

package/dist/core/auth/authorization-audit.js

@@ -333,23 +333,31 @@ function buildAuditRecord(event) {
                 : executed
                     ? (event.exitCode === undefined || event.exitCode === 0 ? 'completed' : 'failed')
                     : 'authorized');
-    const lifecycleId = event.callId ?? event.correlationId ?? event.requestId;
+    const ecwebRequestId = event.source === 'ecweb' ? event.ecwebRequestId : undefined;
+    const requestId = event.requestId ?? ecwebRequestId;
+    const correlationId = event.correlationId ?? requestId;
+    const lifecycleId = event.callId ?? correlationId ?? requestId;
     return {
         ts: event.ts,
-        eventKey: event.eventKey ?? (lifecycleId
-            ? buildAuthorizationEventKey({
-                sessionId: event.sessionId,
-                callId: event.callId,
-                correlationId: event.correlationId,
-                requestId: event.requestId,
-                operation: event.operation,
-            })
-            : undefined),
+        eventKey: event.eventKey ?? (ecwebRequestId
+            ? `ecweb:${crypto.createHash('sha256').update(JSON.stringify([
+                ecwebRequestId, event.targetAgentAid ?? event.selfAid, event.operation,
+            ])).digest('hex').slice(0, 20)}`
+            : lifecycleId
+                ? buildAuthorizationEventKey({
+                    sessionId: event.sessionId,
+                    callId: event.callId,
+                    correlationId,
+                    requestId,
+                    operation: event.operation,
+                })
+                : undefined),
         eventPhase: event.eventPhase,
         callId: event.callId,
-        correlationId: event.correlationId ?? event.requestId,
-        requestId: event.requestId,
+        correlationId,
+        requestId,
         sessionId: event.sessionId,
+        ...(event.source === 'ecweb' && !event.sessionId ? { sessionScope: 'not_applicable' } : {}),
         agentAid: redactIdentifier(event.agentAid ?? event.selfAid),
         agentName: resolveAgentName(event),
         permissionMode: normalizeAuditPermissionMode(event.permissionMode),

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

@@ -13,6 +13,7 @@ const DAEMON_OWNER_PROCESS_OPERATIONS = new Set([
     'agent.disable',
     'system.restart',
     'system.upgrade',
+    'system.paircode',
     'gateway.read',
     'gateway.write',
     'stats.peers',
@@ -204,6 +205,14 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
             matchedRule: 'self-agent-read',
         };
     }
+    // Cross-Agent reads are a management/control-plane capability. A custom
+    // role must not widen this boundary merely by granting itself agent.show.
+    if (operation === 'agent.show'
+        && !isCurrentAgentTarget(ctx)
+        && !isManagementRole(role)
+        && !hasDaemonOwnerRole(ctx)) {
+        return denyDecision(ctx, 'NOT_ALLOWED', `${operation} may only target the current Agent from a managed Agent task.`, operation, intent.scope, opMeta.dangerous, undefined, 'TARGET_SELF_ONLY');
+    }
     if (operation === 'agent.persona' && isCurrentAgentTarget(ctx)
         && (role === 'owner' || hasDaemonOwnerRole(ctx))) {
         return {
@@ -642,7 +651,9 @@ function checkResolvedConfigTarget(ctx, command) {
         }
         return { ok: true };
     }
-    if (ctx.allowExplicitRelationTarget && ctx.role === 'owner') {
+    if (ctx.allowExplicitRelationTarget
+        && (ctx.role === 'owner' || ctx.role === 'admin')
+        && (command.kind === 'field' && command.operationId.startsWith('role.'))) {
         if (!ctx.selfAid || !command.self || command.self !== ctx.selfAid) {
             return { ok: false, reason: 'Only the current agent relation can be targeted' };
         }
@@ -806,10 +817,10 @@ function checkOwnPeer(ctx) {
     }
     if (ctx.actorId) {
         if (requestedPeerId && requestedPeerId !== ctx.actorId) {
-            return { ok: false, reason: 'Only the actor peer can be targeted' };
+            return { ok: false, reason: ownPeerOnlyDenialReason(ctx, requestedPeerId) };
         }
         if (requestedPeerKeyId && requestedPeerKeyId !== ctx.actorId) {
-            return { ok: false, reason: 'Only the actor peer can be targeted' };
+            return { ok: false, reason: ownPeerOnlyDenialReason(ctx, requestedPeerKeyId) };
         }
     }
     if (!expectedPeerKey)
@@ -827,10 +838,20 @@ function checkOwnPeer(ctx) {
             candidateKeys.add(`${legacyChannelType}::${argPeer}`);
     }
     if (!candidateKeys.has(expectedPeerKey)) {
-        return { ok: false, reason: 'Only the actor peer can be targeted' };
+        return { ok: false, reason: ownPeerOnlyDenialReason(ctx, requestedPeerId ?? requestedPeerKeyId) };
     }
     return { ok: true };
 }
+function ownPeerOnlyDenialReason(ctx, requestedPeer) {
+    if (ctx.intent.operation !== 'ec.msg.send' && ctx.intent.operation !== 'ec.msg.file') {
+        return 'Only the actor peer can be targeted';
+    }
+    const currentPeer = ctx.actorId || peerIdFromArg(ctx.peerKey || '') || '当前私聊对端';
+    const target = requestedPeer || '指定目标';
+    return `当前托管会话只能联系当前私聊对端（${currentPeer}），不能联系第三方目标（${target}）。`
+        + ' 如果本次请求来自 handoff，请执行 ec handoff return <handoff-id> "<失败原因>"（已有命令）将失败原因反馈给原会话；'
+        + '否则请让目标先直接发起会话，或由 Agent owner 为当前角色配置允许 relay/第三方外联后再发送。';
+}
 function peerIdFromArg(value) {
     try {
         return parsePeerKey(value).channelId;

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

@@ -100,6 +100,13 @@ const HANDOFF_WRITE_OPERATIONS = [{
         defaultScopes: ['relation', 'agent'],
         description: 'Return the current handoff result',
         sources: ['agent-tool'],
+    }, {
+        id: 'ec.handoff.recover',
+        category: 'write-agent',
+        dangerous: true,
+        defaultScopes: ['agent'],
+        description: 'Recover an open handoff after its target session changed',
+        sources: ['agent-tool'],
     }];
 const QUEUE_OPERATIONS = [['read', 'Read the current Agent message queue'], ['clear', 'Clear the current Agent message queue'], ['cancel', 'Cancel a current Agent queued message'], ['interrupt', 'Interrupt a current Agent session']].map(([kind, description]) => ({
     id: `ec.queue.${kind}`,
@@ -446,7 +453,7 @@ const OPERATIONS = [
         dangerous: false,
         defaultScopes: ['agent'],
         description: 'Assign a role to a private or group relation',
-        sources: ['menu', 'ecweb', 'control'],
+        sources: ['menu', 'menu.cli', 'ecweb', 'control', 'agent-tool'],
     },
     {
         id: 'role.revoke',
@@ -454,7 +461,7 @@ const OPERATIONS = [
         dangerous: false,
         defaultScopes: ['agent'],
         description: 'Revoke a private or group relation role assignment',
-        sources: ['menu', 'ecweb', 'control'],
+        sources: ['menu', 'menu.cli', 'ecweb', 'control', 'agent-tool'],
     },
     {
         id: 'role.policy.read',
@@ -470,7 +477,7 @@ const OPERATIONS = [
         dangerous: false,
         defaultScopes: ['agent'],
         description: 'Read private and group relation role assignments',
-        sources: ['menu', 'ecweb', 'control'],
+        sources: ['menu', 'menu.cli', 'ecweb', 'control', 'agent-tool'],
     },
     {
         id: 'role.policy.write',
@@ -485,7 +492,7 @@ const OPERATIONS = [
         category: 'read',
         dangerous: false,
         defaultScopes: ['agent'],
-        description: 'Read the Agent contact block list',
+        description: 'Read Agent contacts, pending requests, and blocked contacts',
         sources: ['agent-tool'],
     },
     {
@@ -504,6 +511,14 @@ const OPERATIONS = [
         description: 'Block or unblock a canonical contact across bound private channels',
         sources: ['agent-tool'],
     },
+    {
+        id: 'contact.review',
+        category: 'write-agent',
+        dangerous: false,
+        defaultScopes: ['agent'],
+        description: 'Review pending Agent contact requests',
+        sources: ['agent-tool'],
+    },
     {
         id: 'connect.read',
         category: 'read',
@@ -666,6 +681,14 @@ const OPERATIONS = [
         description: '查看系统状态（敏感信息）',
         sources: ['slash', 'menu', 'menu.cli', 'agent-tool'],
     },
+    {
+        id: 'system.paircode',
+        category: 'process',
+        dangerous: true,
+        defaultScopes: ['process'],
+        description: '获取 daemon 远程控制配对码',
+        sources: ['menu', 'control'],
+    },
     {
         id: 'activity.current',
         category: 'read',
@@ -968,6 +991,14 @@ const OPERATIONS = [
         description: '通过 ec msg send 发送私聊消息',
         sources: ['agent-tool'],
     },
+    {
+        id: 'ec.menu.request',
+        category: 'write-agent',
+        dangerous: false,
+        defaultScopes: ['relation'],
+        description: 'Send an authenticated remote Control Menu request through the current Agent daemon channel',
+        sources: ['agent-tool'],
+    },
     {
         id: 'ec.msg.file',
         category: 'write-own',

package/dist/core/auth/remote-access-store.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { resolvePaths } from '../../paths.js';
 export const REMOTE_ACCESS_TOKEN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+export const DIAGNOSTIC_TOKEN_TTL_MS = 60 * 60 * 1000;
 // 与 owner 绑定二维码（BindService）的默认有效期保持一致：10 分钟。
 export const REMOTE_ACCESS_PAIRING_TTL_MS = 10 * 60 * 1000;
 export function remoteAccessTokenStorePath() {
@@ -42,7 +43,8 @@ function pruneExpired(store, now) {
     const before = store.tokens.length;
     store.tokens = store.tokens.filter(record => typeof record?.token === 'string'
         && typeof record.lastActive === 'number'
-        && now - record.lastActive < REMOTE_ACCESS_TOKEN_TTL_MS);
+        && Number.isFinite(record.lastActive)
+        && now - record.lastActive < (record.diagnostic ? DIAGNOSTIC_TOKEN_TTL_MS : REMOTE_ACCESS_TOKEN_TTL_MS));
     return store.tokens.length !== before;
 }
 function validLabel(value) {
@@ -85,6 +87,43 @@ export class RemoteAccessService {
     pairingCode = '';
     pairingExpiresAt = 0;
     pairingAuthorizedBy;
+    /** Synchronous reservation: concurrent invitations cannot issue two grants. */
+    issueDiagnosticToken(controlAid, agentAid, ownerAid, now = Date.now()) {
+        const store = loadStore();
+        pruneExpired(store, now);
+        if (store.tokens.some(record => record.diagnostic?.controlAid === controlAid)) {
+            throw Object.assign(new Error('本机已有有效诊断授权，请先执行 /diag stop 或 ec diag stop。'), { code: 'DIAG_ALREADY_ACTIVE' });
+        }
+        const record = {
+            token: crypto.randomBytes(32).toString('hex'), createdAt: now, lastActive: now,
+            label: 'diagnostic', authorizedBy: ownerAid,
+            diagnostic: { controlAid, agentAid, ownerAid, caseId: crypto.randomUUID() },
+        };
+        store.tokens.push(record);
+        saveStore(store);
+        return record;
+    }
+    getDiagnosticToken(controlAid, now = Date.now()) {
+        const store = loadStore();
+        if (pruneExpired(store, now))
+            saveStore(store);
+        return store.tokens.find(record => record.diagnostic?.controlAid === controlAid);
+    }
+    /** Expected token prevents a failed older send from revoking a newer grant. */
+    revokeDiagnosticToken(controlAid, expectedToken) {
+        const store = loadStore();
+        const pruned = pruneExpired(store, Date.now());
+        const index = store.tokens.findIndex(record => record.diagnostic?.controlAid === controlAid
+            && (expectedToken === undefined || record.token === expectedToken));
+        if (index < 0) {
+            if (pruned)
+                saveStore(store);
+            return undefined;
+        }
+        const [record] = store.tokens.splice(index, 1);
+        saveStore(store);
+        return record;
+    }
     getPairingCode(authorizedBy, now = Date.now()) {
         if (!this.pairingCode || now >= this.pairingExpiresAt) {
             this.pairingCode = String(crypto.randomInt(0, 1_000_000)).padStart(6, '0');