evolcore 0.0.11 → 0.0.13

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

@@ -1,6 +1,5 @@
 import crypto from 'crypto';
 import fs from 'fs';
-import path from 'path';
 import { isValidAid } from '../aun/aid/validation.js';
 import { agentContactOperations } from '../paths.js';
 import { listStaticAgentAdmins, listStaticAgentOwners } from './peer-role-resolver.js';
@@ -12,6 +11,7 @@ export const CONTACT_REQUEST_MAX_PER_WINDOW = 3;
 export const CONTACT_REQUEST_MAX_PENDING = 100;
 export const CONTACT_REQUEST_MAX_RETAINED = 1000;
 export const CONTACT_REQUEST_NOTE_MAX_LENGTH = 500;
+export const CONTACT_REQUEST_ID_MAX_LENGTH = 128;
 export async function mutateContactWithOperation(input) {
     const at = new Date(input.now ?? Date.now()).toISOString();
     const logFile = agentContactOperations(input.selfAid);
@@ -26,7 +26,7 @@ export async function mutateContactWithOperation(input) {
             mutation: input.mutation,
             actor: input.actorId,
             value: undefined,
-            beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+            beforeCommit: ({ contactRevision: nextRevision }) => operationLogChange(logFile, [operationRecord({
                     at,
                     op: input.operation,
                     primaryId: input.primaryId,
@@ -73,7 +73,17 @@ export async function submitContactRequest(input) {
             && Date.parse(record.at) > windowStart
             && Date.parse(record.at) <= nowMs)).length;
         if (recentCount >= CONTACT_REQUEST_MAX_PER_WINDOW) {
-            return preparedWithExpirations(expiration, { code: 'rate-limited', contactRevision: '' }, logFile);
+            return preparedWithExpirations(expiration, {
+                code: 'rate-limited',
+                ...(effectiveEntry?.status === 'pending' && effectiveEntry.pendingRequest
+                    ? {
+                        requestId: effectiveEntry.pendingRequest.id,
+                        submittedAt: effectiveEntry.pendingRequest.submittedAt,
+                        expiresAt: effectiveEntry.pendingRequest.expiresAt,
+                    }
+                    : {}),
+                contactRevision: '',
+            }, logFile);
         }
         const counts = countRequestRecordsAfterExpirations(contact, nowMs);
         const isExistingPending = effectiveEntry?.status === 'pending';
@@ -103,13 +113,14 @@ export async function submitContactRequest(input) {
             mutation: { type: 'batch', mutations },
             actor: applicantAid,
             value,
-            beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, [
+            beforeCommit: ({ contactRevision }) => operationLogChange(logFile, [
                 ...expiration.events.map(event => ({ ...event, contactRevision })),
                 operationRecord({
                     at: nowIso,
                     op,
                     primaryId: applicantAid,
                     requestId,
+                    expiresAt,
                     sourceChannelKey: input.sourceChannelKey,
                     ...(note ? { note } : {}),
                     contactRevision,
@@ -143,6 +154,10 @@ export async function reviewContactRequest(input) {
             if (!entry || entry.status !== 'pending' || entry.pendingRequest?.id !== input.requestId) {
                 return preparedNoop({ code: 'request-stale', contactRevision });
             }
+            const requestMetadata = {
+                requestId: entry.pendingRequest.id,
+                expiresAt: entry.pendingRequest.expiresAt,
+            };
             if (Date.parse(entry.pendingRequest.expiresAt) <= nowMs) {
                 const mutation = {
                     type: 'expire-request',
@@ -153,8 +168,8 @@ export async function reviewContactRequest(input) {
                 return {
                     mutation,
                     actor: input.actorId,
-                    value: { code: 'request-expired', contactRevision },
-                    beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                    value: { code: 'request-expired', contactRevision, ...requestMetadata },
+                    beforeCommit: ({ contactRevision: nextRevision }) => operationLogChange(logFile, [operationRecord({
                             at: nowIso,
                             op: 'expire',
                             primaryId: input.primaryId,
@@ -177,8 +192,8 @@ export async function reviewContactRequest(input) {
                     now: nowIso,
                 },
                 actor: input.actorId,
-                value: { code, contactRevision },
-                beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                value: { code, contactRevision, ...requestMetadata },
+                beforeCommit: ({ contactRevision: nextRevision }) => operationLogChange(logFile, [operationRecord({
                         at: nowIso,
                         op: input.decision === 'approve' ? 'approve' : input.decision === 'reject' ? 'reject' : 'block',
                         primaryId: input.primaryId,
@@ -208,7 +223,7 @@ export async function expirePendingContactRequests(selfAid, now = Date.now()) {
             mutation: { type: 'batch', mutations: expiration.mutations },
             actor: 'contact-request-expiry',
             value: expiration.mutations.length,
-            beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+            beforeCommit: ({ contactRevision }) => operationLogChange(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
         };
     });
     return result.value;
@@ -226,6 +241,91 @@ export async function listPendingContactRequests(selfAid, now = Date.now()) {
     }))));
     return result.value;
 }
+/** Return only the authenticated applicant's own admission/request state. */
+export async function queryOwnContactRequestStatus(input) {
+    const applicantAid = String(input.applicantAid || '').trim();
+    if (!isValidAid(applicantAid))
+        return protocolResult('NOT_ALLOWED');
+    const now = input.now ?? Date.now();
+    const rawRequestId = input.requestId;
+    if (rawRequestId !== undefined && typeof rawRequestId !== 'string')
+        return protocolResult('NOT_ALLOWED');
+    const requestedRequestId = rawRequestId?.trim();
+    if (requestedRequestId !== undefined
+        && (!requestedRequestId || requestedRequestId.length > CONTACT_REQUEST_ID_MAX_LENGTH)) {
+        return protocolResult('NOT_ALLOWED');
+    }
+    const owners = listAgentOwners(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contact }) => {
+        const logFile = agentContactOperations(input.selfAid);
+        const expiration = collectExpiredMutations(contact, now);
+        const entry = effectiveEntryAfterExpirations(contact.contacts[applicantAid], now);
+        const operations = readOperationLog(logFile).filter(record => record.primaryId === applicantAid);
+        const latestRequestOperation = [...operations].reverse().find(record => (!!record.requestId
+            && (record.op === 'request' || record.op === 'resubmit' || record.op === 'approve'
+                || record.op === 'reject' || record.op === 'expire' || record.op === 'block')));
+        if (requestedRequestId !== undefined && latestRequestOperation?.requestId !== requestedRequestId) {
+            return preparedNoop(protocolResult('NOT_ALLOWED'));
+        }
+        const requestMetadata = requestMetadataFor(operations, latestRequestOperation?.requestId);
+        let value;
+        if (owners.includes(applicantAid)
+            || (entry && (entry.status === undefined || entry.status === 'active'))) {
+            value = protocolResult('APPROVED', requestMetadata);
+        }
+        else if (entry?.status === 'blocked') {
+            value = protocolResult('NOT_ALLOWED');
+        }
+        else if (entry?.status === 'pending' && entry.pendingRequest) {
+            value = protocolResult('PENDING', {
+                requestId: entry.pendingRequest.id,
+                expiresAt: entry.pendingRequest.expiresAt,
+            });
+        }
+        else if (entry?.status === 'declined') {
+            value = protocolResult('EXPIRED', {
+                requestId: latestRequestOperation?.op === 'expire' ? latestRequestOperation.requestId : requestMetadata.requestId,
+                expiresAt: entry.declinedAt ?? requestMetadata.expiresAt,
+            });
+        }
+        else if (latestRequestOperation?.op === 'reject') {
+            value = protocolResult('REJECTED', requestMetadata);
+        }
+        else if (latestRequestOperation?.op === 'expire') {
+            value = protocolResult('EXPIRED', requestMetadata);
+        }
+        else if (owners.length === 0) {
+            value = protocolResult('NOT_ALLOWED');
+        }
+        else {
+            value = protocolResult('CONTACT_REQUIRED');
+        }
+        if (expiration.mutations.length === 0)
+            return preparedNoop(value);
+        return {
+            mutation: { type: 'batch', mutations: expiration.mutations },
+            actor: 'contact-request-expiry',
+            value,
+            beforeCommit: ({ contactRevision }) => operationLogChange(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+        };
+    });
+    return result.value;
+}
+export function contactRequestSubmissionProtocolResult(result) {
+    const metadata = { requestId: result.requestId, expiresAt: result.expiresAt };
+    switch (result.code) {
+        case 'submitted':
+        case 'resubmitted':
+            return protocolResult('SUBMITTED', metadata);
+        case 'already-contact':
+        case 'owner':
+            return protocolResult('APPROVED', metadata);
+        case 'rate-limited':
+            return protocolResult('RATE_LIMITED', metadata);
+        default:
+            return protocolResult('NOT_ALLOWED', metadata);
+    }
+}
 export function findContactRequestNote(selfAid, requestId) {
     const records = readOperationLog(agentContactOperations(selfAid));
     return [...records].reverse().find(record => (record.requestId === requestId
@@ -237,6 +337,24 @@ function normalizeNote(value) {
         return null;
     return note;
 }
+function requestMetadataFor(operations, requestId) {
+    if (!requestId)
+        return {};
+    const submitted = [...operations].reverse().find(record => (record.requestId === requestId && (record.op === 'request' || record.op === 'resubmit')));
+    const submittedAt = submitted ? Date.parse(submitted.at) : Number.NaN;
+    return {
+        requestId,
+        expiresAt: submitted?.expiresAt
+            ?? (Number.isFinite(submittedAt) ? new Date(submittedAt + CONTACT_REQUEST_TTL_MS).toISOString() : undefined),
+    };
+}
+function protocolResult(status, metadata = {}) {
+    return {
+        status,
+        requestId: metadata.requestId ?? null,
+        expiresAt: metadata.expiresAt ?? null,
+    };
+}
 function collectExpiredMutations(book, now) {
     const mutations = [];
     const events = [];
@@ -286,7 +404,7 @@ function preparedWithExpirations(expiration, value, logFile) {
         mutation: { type: 'batch', mutations: expiration.mutations },
         actor: 'contact-request-expiry',
         value,
-        beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+        beforeCommit: ({ contactRevision }) => operationLogChange(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
     };
 }
 function preparedNoop(value) {
@@ -310,7 +428,14 @@ function readOperationLog(file) {
             const record = JSON.parse(line);
             if (!record || typeof record !== 'object' || typeof record.at !== 'string'
                 || !Number.isFinite(Date.parse(record.at)) || typeof record.op !== 'string'
-                || typeof record.primaryId !== 'string')
+                || !['request', 'resubmit', 'approve', 'reject', 'expire', 'block', 'unblock', 'manual-add'].includes(record.op)
+                || typeof record.primaryId !== 'string' || !isValidAid(record.primaryId)
+                || (record.requestId !== undefined && typeof record.requestId !== 'string')
+                || (record.expiresAt !== undefined && (!isValidIsoDate(record.expiresAt)))
+                || (record.actorId !== undefined && typeof record.actorId !== 'string')
+                || (record.sourceChannelKey !== undefined && typeof record.sourceChannelKey !== 'string')
+                || (record.note !== undefined && (typeof record.note !== 'string' || record.note.length > CONTACT_REQUEST_NOTE_MAX_LENGTH))
+                || typeof record.contactRevision !== 'string')
                 throw new Error('invalid record');
             records.push(record);
         }
@@ -320,11 +445,32 @@ function readOperationLog(file) {
     }
     return records;
 }
-function appendOperationRecords(file, records) {
+function isValidIsoDate(value) {
+    return Number.isFinite(Date.parse(value));
+}
+function operationLogChange(file, records) {
     if (records.length === 0)
-        return;
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.appendFileSync(file, `${records.map(record => JSON.stringify(record)).join('\n')}\n`, 'utf8');
+        return undefined;
+    // Validate the existing log while the Contact Book lock is held. The log is
+    // part of the same journal transaction as contact.json, so a malformed log
+    // must fail closed before either file is changed.
+    readOperationLog(file);
+    let before;
+    try {
+        before = fs.readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            before = null;
+        else
+            throw error;
+    }
+    const prefix = before && !before.endsWith('\n') ? `${before}\n` : (before ?? '');
+    return {
+        file,
+        before,
+        after: `${prefix}${records.map(record => JSON.stringify(record)).join('\n')}\n`,
+    };
 }
 function operationRecord(input) {
     return { id: `evt_${crypto.randomUUID().replace(/-/g, '')}`, ...input };

package/dist/config/mention-mode.js

@@ -1,27 +1,11 @@
-/**
- * mentionMode ↔ AUN 协议 dispatch_mode 词汇翻译（单一事实源）。
- *
- * 配置层用 mentionMode（disabled / mention-only），AUN 协议层用 dispatch_mode
- * （broadcast / mention）。二者语义等价，仅词汇不同：
- *   - mention-only（只处理被 @ 的消息）≡ mention（仅被 @ 时响应）
- *   - disabled（关闭 mention 过滤）    ≡ broadcast（全部响应）
- *
- * 仅在协议边界（AUN resolver、render fallback）翻译；配置层、命令层一律用
- * mentionMode 词汇。
- */
-/** config → AUN 协议词汇；未知/未设值返回 undefined（回退服务端 dispatch_mode）。 */
-export function mentionModeToDispatch(mode) {
-    if (mode === 'mention-only')
-        return 'mention';
-    if (mode === 'disabled')
-        return 'broadcast';
-    return undefined;
-}
-/** AUN 协议词汇 → config；未知返回 undefined。 */
-export function dispatchToMentionMode(dispatch) {
-    if (dispatch === 'mention')
-        return 'mention-only';
-    if (dispatch === 'broadcast')
+/** AUN `mention_mode` and EvolCore `mentionMode` share these wire values. */
+export function normalizeMentionMode(mode) {
+    if (typeof mode !== 'string')
+        return undefined;
+    const normalized = mode.trim().toLowerCase();
+    if (normalized === 'disabled')
         return 'disabled';
+    if (normalized === 'mention-only' || normalized === 'mention_only')
+        return 'mention-only';
     return undefined;
 }

package/dist/config/peer-role-resolver.js

@@ -123,8 +123,12 @@ export function resolvePeerRoleDetail(ctx) {
     const winner = selectHighestRank(candidates, ctx.selfAid);
     if (winner)
         return resultFor(winner.role, winner.source, actor, ctx.selfAid);
-    return roleRegistryExists(ctx.selfAid) && roleExists('visitor', ctx.selfAid)
-        ? resultFor('visitor', 'builtin-fallback', actor, ctx.selfAid)
+    // Group members get the normal interactive member policy when no explicit
+    // group/actor/default assignment exists. Private conversations retain the
+    // read-only visitor fallback.
+    const fallbackRole = ctx.chatType === 'group' ? 'member' : 'visitor';
+    return roleRegistryExists(ctx.selfAid) && roleExists(fallbackRole, ctx.selfAid)
+        ? resultFor(fallbackRole, 'builtin-fallback', actor, ctx.selfAid)
         : resultFor(null, 'none', actor, ctx.selfAid);
 }
 export function roleToSessionIdentity(role) {

package/dist/config/role-migration-startup.js

@@ -0,0 +1,53 @@
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { getPackageRoot, resolvePaths } from '../paths.js';
+import { assertRoleConfigV4Ready, assertRoleConfigV5Ready, ConfigError } from './config-manager.js';
+/** Apply the one-off v4 role config migration before daemon startup. */
+export async function ensureRoleConfigV4OnStartup() {
+    try {
+        assertRoleConfigV4Ready();
+        return null;
+    }
+    catch (error) {
+        if (!(error instanceof ConfigError) || error.code !== 'ROLE_CONFIG_MIGRATION_REQUIRED')
+            throw error;
+    }
+    const home = resolvePaths().root;
+    const script = path.join(getPackageRoot(), 'kits', 'migrations', 'migrate-role-config-v4.mjs');
+    try {
+        const migration = await import(pathToFileURL(script).href);
+        const result = migration.runMigration({ home, apply: true });
+        assertRoleConfigV4Ready();
+        return result;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new ConfigError('ROLE_CONFIG_MIGRATION_FAILED', `Automatic role config v4 migration failed: ${detail}\n` +
+            `Fix the reported config or run manually:\n` +
+            `node kits/migrations/migrate-role-config-v4.mjs --apply --home ${JSON.stringify(home)}`, { cause: error });
+    }
+}
+/** Apply the standalone v5 role registry migration before daemon startup. */
+export async function ensureRoleConfigV5OnStartup() {
+    try {
+        assertRoleConfigV5Ready();
+        return null;
+    }
+    catch (error) {
+        if (!(error instanceof ConfigError) || error.code !== 'ROLE_CONFIG_V5_MIGRATION_REQUIRED')
+            throw error;
+    }
+    const home = resolvePaths().root;
+    const script = path.join(getPackageRoot(), 'kits', 'migrations', 'migrate-role-config-v5.mjs');
+    try {
+        const migration = await import(pathToFileURL(script).href);
+        const result = migration.runMigration({ home, apply: true });
+        assertRoleConfigV5Ready();
+        return result;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new ConfigError('ROLE_CONFIG_V5_MIGRATION_FAILED', `Automatic standalone role migration failed: ${detail}\n` +
+            `node kits/migrations/migrate-role-config-v5.mjs --apply --home ${JSON.stringify(home)}`, { cause: error });
+    }
+}

package/dist/config/role-store.js

@@ -113,7 +113,7 @@ function readRegistry(selfAid, diagnostics) {
                     code: 'INVALID_ROLE_ASSIGNMENT',
                     roleId: selected,
                     file: path.relative(resolvePaths().root, file),
-                    message: `defaultRoles.${scene} references invalid or unregistered role ${selected}; using visitor fallback`,
+                    message: `defaultRoles.${scene} references invalid or unregistered role ${selected}; using ${scene === 'group' ? 'member' : 'visitor'} fallback`,
                 });
                 defaultRoles[scene] = null;
             }

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

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 import { authorizeOperation, buildAuthSubject } from './auth-gateway.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
 export const AGENT_DELEGATION_TOKEN_ENV = 'EVOLCORE_DELEGATION_TOKEN';
-export const AGENT_DELEGATION_COMMAND_TTL_MS = 60_000;
+export const AGENT_DELEGATION_COMMAND_TTL_MS = 5 * 60_000;
 export class AgentDelegationRegistry {
     grantsByHash = new Map();
     activeHashBySession = new Map();
@@ -155,7 +155,6 @@ export function authorizeDelegatedAunMsgSend(registry, input) {
         channelId,
         chatType: grant.chatType,
         conversationId: channelId,
-        identity: { role: grant.issuedRole, mode: 'interactive' },
         processOwners: [],
         fromControlChannel: false,
     });

package/dist/core/auth/auth-gateway.js

@@ -4,6 +4,22 @@ import { formatPeerKey } from '../relation/peer-identity.js';
 import { authorizeCommand, authorizeResolvedConfigCommand } from './operation-authorizer.js';
 import { auditCommandAuthorization } from './authorization-audit.js';
 import { hasTrustedPrincipal } from './authenticated-actor.js';
+import { resolveRuntimePermissionMode } from '../role/runtime-policy.js';
+const CROSS_AGENT_READ_OPERATIONS = new Set([
+    'trigger.list',
+    'trigger.show',
+    'trigger.history',
+]);
+export function isCrossAgentTriggerOperationAllowed(input) {
+    if (input.control || input.taskAgentAid === input.targetAgentAid)
+        return true;
+    if (!input.taskAgentAid || !input.targetManagement)
+        return false;
+    return CROSS_AGENT_READ_OPERATIONS.has(input.operation);
+}
+export function isCrossAgentTriggerReadOperation(operation) {
+    return CROSS_AGENT_READ_OPERATIONS.has(operation);
+}
 export function buildAuthSubject(input) {
     const chatType = input.chatType === 'group' ? 'group' : 'private';
     const actorId = input.actorId;
@@ -27,6 +43,8 @@ export function buildAuthSubject(input) {
     return {
         selfAid: input.selfAid,
         actorId,
+        requestId: input.requestId,
+        sessionId: input.sessionId,
         channel: input.channel,
         channelType: input.channelType,
         channelId: input.channelId,
@@ -41,6 +59,8 @@ export function buildAuthSubject(input) {
         allowAccess: isDaemonOwner || (suppliedRole
             ? checkRoleAccess(suppliedRole, input.selfAid)
             : roleDetail.allowAccess && checkRoleAccess(role, input.selfAid)),
+        permissionMode: input.permissionMode
+            ?? resolveRuntimePermissionMode({ selfAid: input.selfAid, role }).effectiveValue,
     };
 }
 function isProcessOwner(input) {
@@ -144,6 +164,15 @@ function resolveRoleDetail(input) {
 function auditDecision(params, decision) {
     auditCommandAuthorization({
         ts: Date.now(),
+        ...params.auditMetadata,
+        requestId: params.auditMetadata?.requestId ?? params.subject.requestId,
+        sessionId: params.auditMetadata?.sessionId ?? params.subject.sessionId,
+        agentAid: params.auditMetadata?.agentAid ?? params.subject.selfAid,
+        permissionMode: params.auditMetadata?.permissionMode
+            ?? (decision.allow ? decision.permissionMode ?? params.subject.permissionMode : params.subject.permissionMode),
+        toolName: params.auditMetadata?.toolName,
+        policyCode: params.auditMetadata?.policyCode ?? (decision.allow ? undefined : decision.code),
+        decisionSource: params.auditMetadata?.decisionSource ?? (decision.allow ? 'command' : 'policy'),
         source: params.source,
         operation: params.intent.operation,
         scope: params.intent.scope,
@@ -161,6 +190,5 @@ function auditDecision(params, decision) {
         reason: decision.allow ? undefined : decision.reason,
         matchedRule: decision.matchedRule,
         argsSummary: params.intent.args,
-        ...params.auditMetadata,
     });
 }

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

@@ -17,6 +17,13 @@ export function auditCommandAuthorization(event) {
 function buildAuditRecord(event) {
     return {
         ts: event.ts,
+        requestId: event.requestId,
+        sessionId: event.sessionId,
+        agentAid: redactIdentifier(event.agentAid ?? event.selfAid),
+        permissionMode: event.permissionMode,
+        toolName: event.toolName,
+        policyCode: event.policyCode ?? event.code,
+        decisionSource: event.decisionSource,
         source: event.source,
         operation: event.operation,
         scope: event.scope,
@@ -71,6 +78,13 @@ function logAuditEvent(record) {
         `actor=${record.actorId || 'unknown'}`,
         record.taskId ? `task=${record.taskId}` : null,
         record.messageId ? `message=${record.messageId}` : null,
+        record.requestId ? `request=${record.requestId}` : null,
+        record.sessionId ? `session=${record.sessionId}` : null,
+        record.agentAid ? `agent=${record.agentAid}` : null,
+        record.permissionMode ? `permissionMode=${record.permissionMode}` : null,
+        record.toolName ? `tool=${record.toolName}` : null,
+        record.policyCode ? `policy=${record.policyCode}` : null,
+        record.decisionSource ? `decisionSource=${record.decisionSource}` : null,
         record.code ? `code=${record.code}` : null,
         record.matchedRule ? `rule=${record.matchedRule}` : null,
         record.dangerous ? 'dangerous=true' : null,
@@ -78,6 +92,7 @@ function logAuditEvent(record) {
         .filter(Boolean)
         .join(' ');
     logger[level](message);
+    logger[level](`[CommandAuditRecord] ${JSON.stringify(record)}`);
     if (record.reason)
         logger[level](`  reason: ${record.reason}`);
     if (record.argvHash)

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

@@ -170,13 +170,13 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
         dangerous: opMeta.dangerous,
         matchedRule,
         constraints: permission.constraints,
+        permissionMode: permission.permissionMode,
     };
 }
 function matchCommandPermission(operation, category, commandPerms, isDangerous) {
-    const namespace = operation.split('.')[0];
     const matches = [];
     for (const [rule, permission] of Object.entries(commandPerms)) {
-        const rank = getRuleRank(rule, permission, operation, namespace, category, isDangerous);
+        const rank = getRuleRank(rule, permission, operation, category, isDangerous);
         if (rank > 0) {
             matches.push({ permission, matchedRule: rule, rank });
         }
@@ -186,12 +186,17 @@ function matchCommandPermission(operation, category, commandPerms, isDangerous)
     matches.sort((a, b) => b.rank - a.rank);
     return matches[0];
 }
-function getRuleRank(rule, permission, operation, namespace, category, isDangerous) {
+function getRuleRank(rule, permission, operation, category, isDangerous) {
     const denyOffset = permission.allow ? 0 : 1;
     if (rule === operation)
         return 1000 + denyOffset;
-    if (rule === `${namespace}.*`)
-        return 800 + denyOffset;
+    if (rule.endsWith('.*')) {
+        const prefix = rule.slice(0, -1);
+        if (operation.startsWith(prefix)) {
+            const depth = rule.slice(0, -2).split('.').length;
+            return 800 + Math.min((depth - 1) * 20, 180) + denyOffset;
+        }
+    }
     if (rule.startsWith('category:') && rule.slice('category:'.length) === category)
         return 600 + denyOffset;
     if (rule === 'dangerous:*' && isDangerous)
@@ -230,7 +235,7 @@ function checkConstraints(ctx, constraints, resolvedConfigCommand) {
         const sameGroup = constraints.currentRelationOnly ? ' and may only target that same group' : '';
         return {
             ok: false,
-            reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, source_chat=${ctx.chatType ?? 'unknown'}, target_group=${target}. This role may send group messages only from a group-chat task${sameGroup}; the target being a group is not sufficient.`,
+            reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, source_chat=${ctx.chatType ?? 'unknown'}, target_group=${target}. This role may access group operations only from a group-chat task${sameGroup}; the target being a group is not sufficient.`,
         };
     }
     if (constraints.requireDaemonOwner && !ctx.isDaemonOwner) {
@@ -401,7 +406,7 @@ function checkCurrentRelation(ctx, resolvedConfigCommand) {
                 const targetGroup = stringArg(ctx.intent.args.targetId) ?? peerIdFromArg(requestedPeer);
                 return {
                     ok: false,
-                    reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, current_group=${currentGroup}, target_group=${targetGroup}. This role may send only to the current group; cross-group sends require admin or owner permission.`,
+                    reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, current_group=${currentGroup}, target_group=${targetGroup}. This role may access only the current group; cross-group access requires admin or owner permission.`,
                 };
             }
             return { ok: false, reason: 'Only the current relation can be targeted' };
@@ -498,6 +503,25 @@ function checkOwnPeer(ctx) {
         return { ok: true };
     const requestedPeerId = argPeer ? peerIdFromArg(argPeer) : undefined;
     const requestedPeerKeyId = argPeerKey ? peerIdFromArg(argPeerKey) : undefined;
+    if (ctx.chatType === 'group') {
+        if (!expectedPeerKey)
+            return { ok: false, reason: 'Cannot verify peer ownership' };
+        const candidateKeys = new Set();
+        if (argPeerKey)
+            candidateKeys.add(argPeerKey);
+        if (argPeer) {
+            candidateKeys.add(argPeer);
+            const channelType = parseChannelType(expectedPeerKey);
+            if (channelType)
+                candidateKeys.add(formatPeerKey(channelType, argPeer));
+            const legacyChannelType = parseLegacyChannelType(expectedPeerKey);
+            if (legacyChannelType)
+                candidateKeys.add(`${legacyChannelType}::${argPeer}`);
+        }
+        return candidateKeys.has(expectedPeerKey)
+            ? { ok: true }
+            : { ok: false, reason: 'Only the current group relation can be targeted' };
+    }
     if (ctx.actorId) {
         if (requestedPeerId && requestedPeerId !== ctx.actorId) {
             return { ok: false, reason: 'Only the actor peer can be targeted' };