evolcore 0.0.3 → 0.0.5

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

@@ -0,0 +1,331 @@
+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';
+import { listAgentOwners } from './access-policy.js';
+import { ContactMutationError, mutateContactBookPrepared, } from './contact-book-store.js';
+export const CONTACT_REQUEST_TTL_MS = 20 * 60 * 1000;
+export const CONTACT_REQUEST_WINDOW_MS = 60 * 60 * 1000;
+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 async function mutateContactWithOperation(input) {
+    const at = new Date(input.now ?? Date.now()).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contactRevision }) => {
+        if (input.expectedContactRevision !== undefined && input.expectedContactRevision !== contactRevision) {
+            throw new ContactMutationError('CONFLICT', 'Contact book changed since it was read', {
+                expectedContactRevision: input.expectedContactRevision,
+                contactRevision,
+            });
+        }
+        return {
+            mutation: input.mutation,
+            actor: input.actorId,
+            value: undefined,
+            beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                    at,
+                    op: input.operation,
+                    primaryId: input.primaryId,
+                    actorId: input.actorId,
+                    contactRevision: nextRevision,
+                })]),
+        };
+    });
+    const { value: _value, ...mutationResult } = result;
+    return mutationResult;
+}
+export async function submitContactRequest(input) {
+    const applicantAid = String(input.applicantAid || '').trim();
+    const owners = listAgentOwners(input.selfAid);
+    if (!isValidAid(applicantAid)) {
+        return { code: 'invalid-applicant', contactRevision: '' };
+    }
+    if (owners.includes(applicantAid)) {
+        return { code: 'owner', contactRevision: '' };
+    }
+    if (owners.length === 0) {
+        return { code: 'no-owner', contactRevision: '' };
+    }
+    const note = normalizeNote(input.note);
+    if (note === null) {
+        return { code: 'invalid-note', contactRevision: '' };
+    }
+    const nowMs = input.now ?? Date.now();
+    const nowIso = new Date(nowMs).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contact }) => {
+        const expiration = collectExpiredMutations(contact, nowMs);
+        const effectiveEntry = effectiveEntryAfterExpirations(contact.contacts[applicantAid], nowMs);
+        if (effectiveEntry?.status === 'blocked') {
+            return preparedWithExpirations(expiration, { code: 'blocked', contactRevision: '' }, logFile);
+        }
+        if (effectiveEntry && (effectiveEntry.status === undefined || effectiveEntry.status === 'active')) {
+            return preparedWithExpirations(expiration, { code: 'already-contact', contactRevision: '' }, logFile);
+        }
+        const operations = readOperationLog(logFile);
+        const windowStart = nowMs - CONTACT_REQUEST_WINDOW_MS;
+        const recentCount = operations.filter(record => (record.primaryId === applicantAid
+            && (record.op === 'request' || record.op === 'resubmit')
+            && 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);
+        }
+        const counts = countRequestRecordsAfterExpirations(contact, nowMs);
+        const isExistingPending = effectiveEntry?.status === 'pending';
+        if (!isExistingPending && (counts.pending >= CONTACT_REQUEST_MAX_PENDING
+            || counts.retained >= CONTACT_REQUEST_MAX_RETAINED)) {
+            return preparedWithExpirations(expiration, { code: 'capacity', contactRevision: '' }, logFile);
+        }
+        const requestId = `creq_${crypto.randomUUID().replace(/-/g, '')}`;
+        const expiresAt = new Date(nowMs + CONTACT_REQUEST_TTL_MS).toISOString();
+        const op = isExistingPending ? 'resubmit' : 'request';
+        const value = {
+            code: isExistingPending ? 'resubmitted' : 'submitted',
+            requestId,
+            submittedAt: nowIso,
+            expiresAt,
+            contactRevision: '',
+        };
+        const mutations = [
+            ...expiration.mutations,
+            {
+                type: 'set-request',
+                primaryId: applicantAid,
+                request: { id: requestId, submittedAt: nowIso, expiresAt },
+            },
+        ];
+        return {
+            mutation: { type: 'batch', mutations },
+            actor: applicantAid,
+            value,
+            beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, [
+                ...expiration.events.map(event => ({ ...event, contactRevision })),
+                operationRecord({
+                    at: nowIso,
+                    op,
+                    primaryId: applicantAid,
+                    requestId,
+                    sourceChannelKey: input.sourceChannelKey,
+                    ...(note ? { note } : {}),
+                    contactRevision,
+                }),
+            ]),
+        };
+    });
+    return { ...result.value, contactRevision: result.contactRevision };
+}
+export async function reviewContactRequest(input) {
+    const nowMs = input.now ?? Date.now();
+    const nowIso = new Date(nowMs).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    try {
+        const result = await mutateContactBookPrepared(input.selfAid, ({ contact, contactRevision }) => {
+            const owners = listStaticAgentOwners(input.selfAid, { fresh: true });
+            const admins = listStaticAgentAdmins(input.selfAid, { fresh: true });
+            const selectedManager = input.reviewerRole === undefined
+                && input.actorId === input.approverId
+                && (owners.includes(input.approverId) || admins.includes(input.approverId));
+            const managementReviewer = input.actorId === input.approverId
+                && ((input.reviewerRole === 'admin' && admins.includes(input.actorId))
+                    || (input.reviewerRole === 'owner' && owners.includes(input.actorId)));
+            if (!selectedManager && !managementReviewer) {
+                return preparedNoop({ code: 'forbidden', contactRevision });
+            }
+            if (contactRevision !== input.expectedContactRevision) {
+                return preparedNoop({ code: 'revision-conflict', contactRevision });
+            }
+            const entry = contact.contacts[input.primaryId];
+            if (!entry || entry.status !== 'pending' || entry.pendingRequest?.id !== input.requestId) {
+                return preparedNoop({ code: 'request-stale', contactRevision });
+            }
+            if (Date.parse(entry.pendingRequest.expiresAt) <= nowMs) {
+                const mutation = {
+                    type: 'expire-request',
+                    primaryId: input.primaryId,
+                    requestId: input.requestId,
+                    now: nowIso,
+                };
+                return {
+                    mutation,
+                    actor: input.actorId,
+                    value: { code: 'request-expired', contactRevision },
+                    beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                            at: nowIso,
+                            op: 'expire',
+                            primaryId: input.primaryId,
+                            requestId: input.requestId,
+                            contactRevision: nextRevision,
+                        })]),
+                };
+            }
+            const code = input.decision === 'approve'
+                ? 'approved'
+                : input.decision === 'reject'
+                    ? 'rejected'
+                    : 'blocked';
+            return {
+                mutation: {
+                    type: 'review-request',
+                    primaryId: input.primaryId,
+                    requestId: input.requestId,
+                    decision: input.decision,
+                    now: nowIso,
+                },
+                actor: input.actorId,
+                value: { code, contactRevision },
+                beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                        at: nowIso,
+                        op: input.decision === 'approve' ? 'approve' : input.decision === 'reject' ? 'reject' : 'block',
+                        primaryId: input.primaryId,
+                        requestId: input.requestId,
+                        actorId: input.actorId,
+                        contactRevision: nextRevision,
+                    })]),
+            };
+        });
+        return { ...result.value, contactRevision: result.contactRevision };
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError && error.code === 'REQUEST_EXPIRED') {
+            return { code: 'request-expired', contactRevision: input.expectedContactRevision };
+        }
+        throw error;
+    }
+}
+export async function expirePendingContactRequests(selfAid, now = Date.now()) {
+    const nowIso = new Date(now).toISOString();
+    const logFile = agentContactOperations(selfAid);
+    const result = await mutateContactBookPrepared(selfAid, ({ contact }) => {
+        const expiration = collectExpiredMutations(contact, now);
+        if (expiration.mutations.length === 0)
+            return preparedNoop(0);
+        return {
+            mutation: { type: 'batch', mutations: expiration.mutations },
+            actor: 'contact-request-expiry',
+            value: expiration.mutations.length,
+            beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+        };
+    });
+    return result.value;
+}
+export async function listPendingContactRequests(selfAid, now = Date.now()) {
+    await expirePendingContactRequests(selfAid, now);
+    const result = await mutateContactBookPrepared(selfAid, ({ contact, contactRevision }) => preparedNoop(Object.entries(contact.contacts)
+        .filter(([, entry]) => entry.status === 'pending' && entry.pendingRequest)
+        .map(([primaryId, entry]) => ({
+        primaryId,
+        requestId: entry.pendingRequest.id,
+        submittedAt: entry.pendingRequest.submittedAt,
+        expiresAt: entry.pendingRequest.expiresAt,
+        contactRevision,
+    }))));
+    return result.value;
+}
+export function findContactRequestNote(selfAid, requestId) {
+    const records = readOperationLog(agentContactOperations(selfAid));
+    return [...records].reverse().find(record => (record.requestId === requestId
+        && (record.op === 'request' || record.op === 'resubmit')))?.note;
+}
+function normalizeNote(value) {
+    const note = String(value ?? '').trim();
+    if (note.length > CONTACT_REQUEST_NOTE_MAX_LENGTH)
+        return null;
+    return note;
+}
+function collectExpiredMutations(book, now) {
+    const mutations = [];
+    const events = [];
+    for (const [primaryId, entry] of Object.entries(book.contacts)) {
+        if (entry.status !== 'pending' || !entry.pendingRequest)
+            continue;
+        if (Date.parse(entry.pendingRequest.expiresAt) > now)
+            continue;
+        mutations.push({
+            type: 'expire-request',
+            primaryId,
+            requestId: entry.pendingRequest.id,
+            now: new Date(now).toISOString(),
+        });
+        events.push(operationRecord({
+            at: new Date(now).toISOString(),
+            op: 'expire',
+            primaryId,
+            requestId: entry.pendingRequest.id,
+            contactRevision: '',
+        }));
+    }
+    return { mutations, events };
+}
+function effectiveEntryAfterExpirations(entry, now) {
+    if (entry?.status === 'pending' && entry.pendingRequest && Date.parse(entry.pendingRequest.expiresAt) <= now) {
+        return { ...entry, status: 'declined', pendingRequest: undefined, declinedAt: entry.pendingRequest.expiresAt };
+    }
+    return entry;
+}
+function countRequestRecordsAfterExpirations(book, now) {
+    let pending = 0;
+    let declined = 0;
+    for (const entry of Object.values(book.contacts)) {
+        const effective = effectiveEntryAfterExpirations(entry, now);
+        if (effective?.status === 'pending')
+            pending += 1;
+        else if (effective?.status === 'declined')
+            declined += 1;
+    }
+    return { pending, retained: pending + declined };
+}
+function preparedWithExpirations(expiration, value, logFile) {
+    if (expiration.mutations.length === 0)
+        return preparedNoop(value);
+    return {
+        mutation: { type: 'batch', mutations: expiration.mutations },
+        actor: 'contact-request-expiry',
+        value,
+        beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+    };
+}
+function preparedNoop(value) {
+    return { value };
+}
+function readOperationLog(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return [];
+        throw new ContactMutationError('CONTACT_OPERATION_LOG_INVALID', `Cannot read contact operation log: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const records = [];
+    for (const [index, line] of raw.split('\n').entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            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')
+                throw new Error('invalid record');
+            records.push(record);
+        }
+        catch (error) {
+            throw new ContactMutationError('CONTACT_OPERATION_LOG_INVALID', `Invalid contact operation log record at line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return records;
+}
+function appendOperationRecords(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');
+}
+function operationRecord(input) {
+    return { id: `evt_${crypto.randomUUID().replace(/-/g, '')}`, ...input };
+}

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

@@ -133,7 +133,9 @@ export function roleToSessionIdentity(role) {
 export function checkRoleAccess(role, selfAid) {
     if (!role)
         return false;
-    if (isManagementRole(role))
+    // Owner access is an invariant. Admin access is role policy, just like the
+    // user roles, so a local admin definition may explicitly disable it.
+    if (role === 'owner')
         return true;
     const definition = getRoleDefinition(role, selfAid);
     return !!definition && (definition.allowAccess ?? true);

package/dist/config/schema-registry.js

@@ -14,6 +14,7 @@ import fs from 'fs';
 import path from 'path';
 import Ajv from 'ajv';
 import { kitsSchemasDir } from '../paths.js';
+import { createErrorCapturingReader, fileCache } from '../core/daemon-file-cache.js';
 let _ajv = null;
 function ajv() {
     if (!_ajv) {
@@ -21,13 +22,23 @@ function ajv() {
     }
     return _ajv;
 }
-let _meta = null;
+/**
+ * schema 随包发布，运行期不查盘 → fileCache 的 on-reload 策略，归入 'kits' 组
+ * （与 manifest/fragment 同组，一次 invalidateGroup('kits') 全刷）。
+ * 刷新时机只有三个：进程重启、`ec agent reload`、resync——后两者在调 registry.reload
+ * 之前先 invalidateKitCache()。带外改 schema 文件而不做上述任一动作，进程不会看见。
+ */
+const SCHEMA_CACHE_OPTS = { policy: 'on-reload', group: 'kits' };
 export function loadMeta() {
-    if (_meta)
-        return _meta;
     const p = path.join(kitsSchemasDir(), '_meta.json');
-    _meta = JSON.parse(fs.readFileSync(p, 'utf-8'));
-    return _meta;
+    const reader = createErrorCapturingReader();
+    return fileCache.get(p, (raw) => {
+        // errno 文案自带路径，不再重复拼 p；原始异常挂 cause，保住 code/path/errno
+        if (raw === null) {
+            throw new Error(`[schema] cannot read meta: ${reader.lastError()}`, { cause: reader.lastErrorCause() });
+        }
+        return JSON.parse(raw);
+    }, { ...SCHEMA_CACHE_OPTS, read: reader.read });
 }
 /** 某 schema 的当前版本号（来自 _meta.json）。 */
 export function currentVersion(name) {
@@ -84,7 +95,6 @@ export function readRawSchema(name, version) {
     }
     return JSON.parse(fs.readFileSync(file, 'utf-8'));
 }
-const _cache = new Map();
 function schemaFilePath(name, version) {
     return path.join(kitsSchemasDir(), `${name}.schema.${version}.json`);
 }
@@ -117,22 +127,35 @@ function inferMerge(spec) {
 /** 加载指定版本的 schema entry（带 ajv 编译 + 字段表）。 */
 export function loadSchema(name, version) {
     const ver = version ?? currentVersion(name);
-    const key = `${name}@${ver}`;
-    const cached = _cache.get(key);
-    if (cached)
-        return cached;
     const file = schemaFilePath(name, ver);
-    const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
-    const entry = {
-        logicalName: name,
-        version: ver,
-        scope: raw['x-scope'] || name,
-        raw,
-        validate: ajv().compile(raw),
-        fields: extractFields(raw),
-    };
-    _cache.set(key, entry);
-    return entry;
+    const reader = createErrorCapturingReader();
+    return fileCache.get(file, (rawText) => {
+        // errno 文案自带路径，不再重复拼 file；原始异常挂 cause，保住 code/path/errno
+        if (rawText === null) {
+            throw new Error(`[schema] cannot read schema file: ${reader.lastError()}`, { cause: reader.lastErrorCause() });
+        }
+        const raw = JSON.parse(rawText);
+        return {
+            logicalName: name,
+            version: ver,
+            scope: raw['x-scope'] || name,
+            raw,
+            validate: compileSchema(raw),
+            fields: extractFields(raw),
+        };
+    }, { ...SCHEMA_CACHE_OPTS, read: reader.read });
+}
+/**
+ * 每个 schema 文件都带 `$id`，而 ajv 对同一实例重复注册同名 `$id` 会抛
+ * "schema with key or id ... already exists"。缓存失效后会重新 JSON.parse 出
+ * 一个新对象（ajv 的对象级缓存认不出），因此编译前先按 `$id` 撤销旧注册，
+ * 让 reload → 重新编译这条路径可重复执行。
+ */
+function compileSchema(raw) {
+    const id = raw?.$id;
+    if (typeof id === 'string')
+        ajv().removeSchema(id);
+    return ajv().compile(raw);
 }
 /** extra_backup 不得指向 .env（构建期校验）——遍历声明里的 pattern。 */
 export function assertExtraBackupNotEnv(extraBackup) {
@@ -146,9 +169,11 @@ export function assertExtraBackupNotEnv(extraBackup) {
         }
     }
 }
-/** 测试用：清空缓存。 */
+/**
+ * 测试用：清空缓存。schema 与 _meta 都存在 fileCache 的 'kits' 组，
+ * 连同 ajv 实例一起重建（丢弃已注册的 $id，避免跨用例串味）。
+ */
 export function _resetSchemaCache() {
-    _cache.clear();
-    _meta = null;
+    fileCache.invalidateGroup('kits');
     _ajv = null;
 }

package/dist/config-store.js

@@ -25,10 +25,11 @@ import { CONFIG_SCHEMA_VERSION } from './types.js';
 import { ConfigTarget, read as cfgRead, write as cfgWrite } from './config/config-manager.js';
 import { expandVars, buildEnvResolver } from './config/merge.js';
 import { logger } from './utils/logger.js';
+import { parseStableSemver } from './utils/stable-semver.js';
 /** 读 {root}/daemon.json。文件不存在返回 {}，不报错。 */
 export function loadDaemonConfig() {
     const raw = atomicReadJson(resolvePaths().daemonConfig);
-    return raw ?? {};
+    return validateDaemonConfig(raw ?? {});
 }
 let eckSnapshotsConfigCache;
 /** Parse the process-level snapshot gate once for the current daemon lifecycle. */
@@ -49,7 +50,18 @@ export function isEckSnapshotsEnabled() {
 }
 /** 原子写入 {root}/daemon.json。调用方负责传完整对象（含要保留的字段）。 */
 export function saveDaemonConfig(value) {
-    atomicWriteJson(resolvePaths().daemonConfig, value);
+    atomicWriteJson(resolvePaths().daemonConfig, validateDaemonConfig(value));
+}
+function validateDaemonConfig(value) {
+    const minEvolVersion = value.aun?.minEvolVersion;
+    if (minEvolVersion !== undefined && !parseStableSemver(minEvolVersion)) {
+        throw new Error('daemon.json.aun.minEvolVersion must use stable X.Y.Z format');
+    }
+    const menuTokenRequired = value.aun?.menuTokenRequired;
+    if (menuTokenRequired !== undefined && typeof menuTokenRequired !== 'boolean') {
+        throw new Error('daemon.json.aun.menuTokenRequired must be a boolean');
+    }
+    return value;
 }
 const SUPPORTED_CHANNEL_TYPES = new Set([
     'aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom',

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

@@ -2,9 +2,11 @@ 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 class AgentDelegationRegistry {
     grantsByHash = new Map();
     activeHashBySession = new Map();
+    approvedCommands = new Map();
     issue(input) {
         this.revokeSession(input.sessionId);
         const token = crypto.randomBytes(32).toString('base64url');
@@ -13,7 +15,7 @@ export class AgentDelegationRegistry {
         this.activeHashBySession.set(input.sessionId, tokenHash);
         return token;
     }
-    validate(token, sessionId) {
+    validate(token, sessionId, commandHash) {
         if (!token) {
             return {
                 ok: false,
@@ -23,16 +25,49 @@ export class AgentDelegationRegistry {
         }
         const tokenHash = hashDelegationToken(token);
         const grant = this.grantsByHash.get(tokenHash);
-        if (!grant
-            || grant.sessionId !== sessionId
-            || this.activeHashBySession.get(sessionId) !== tokenHash) {
-            return {
-                ok: false,
-                code: 'INVALID_DELEGATION',
-                reason: 'The task delegation token is invalid, revoked, or belongs to another session',
-            };
+        if (grant
+            && grant.sessionId === sessionId
+            && this.activeHashBySession.get(sessionId) === tokenHash) {
+            return { ok: true, grant };
         }
-        return { ok: true, grant };
+        const approved = commandHash
+            ? this.consumeApprovedCommand(tokenHash, sessionId, commandHash)
+            : undefined;
+        if (approved)
+            return { ok: true, grant: approved };
+        return {
+            ok: false,
+            code: 'INVALID_DELEGATION',
+            reason: 'The task delegation token is invalid, revoked, or belongs to another session',
+        };
+    }
+    armApprovedCommand(input) {
+        const activeTokenHash = this.activeHashBySession.get(input.sessionId);
+        if (!activeTokenHash)
+            return false;
+        const grant = activeTokenHash ? this.grantsByHash.get(activeTokenHash) : undefined;
+        if (!grant || grant.taskId !== input.taskId)
+            return false;
+        if (!input.carrierToken || !isDelegationCommandHash(input.commandHash))
+            return false;
+        this.deleteExpiredApprovedCommands();
+        const carrierTokenHash = hashDelegationToken(input.carrierToken);
+        const key = approvedCommandKey(carrierTokenHash, input.sessionId, input.commandHash);
+        const existing = this.approvedCommands.get(key);
+        const ttlMs = Math.max(1, Math.min(input.ttlMs ?? AGENT_DELEGATION_COMMAND_TTL_MS, AGENT_DELEGATION_COMMAND_TTL_MS));
+        this.approvedCommands.set(key, {
+            sessionId: input.sessionId,
+            taskId: input.taskId,
+            activeTokenHash,
+            commandHash: input.commandHash,
+            expiresAt: Date.now() + ttlMs,
+            remainingUses: existing
+                && existing.activeTokenHash === activeTokenHash
+                && existing.expiresAt > Date.now()
+                ? existing.remainingUses + 1
+                : 1,
+        });
+        return true;
     }
     revokeTask(sessionId, taskId) {
         const tokenHash = this.activeHashBySession.get(sessionId);
@@ -43,19 +78,59 @@ export class AgentDelegationRegistry {
             return;
         this.grantsByHash.delete(tokenHash);
         this.activeHashBySession.delete(sessionId);
+        this.deleteApprovedCommandsForSession(sessionId);
     }
     revokeSession(sessionId) {
         const tokenHash = this.activeHashBySession.get(sessionId);
         if (tokenHash)
             this.grantsByHash.delete(tokenHash);
         this.activeHashBySession.delete(sessionId);
+        this.deleteApprovedCommandsForSession(sessionId);
+    }
+    consumeApprovedCommand(carrierTokenHash, sessionId, commandHash) {
+        if (!isDelegationCommandHash(commandHash))
+            return undefined;
+        const key = approvedCommandKey(carrierTokenHash, sessionId, commandHash);
+        const approved = this.approvedCommands.get(key);
+        if (!approved)
+            return undefined;
+        if (approved.expiresAt <= Date.now()) {
+            this.approvedCommands.delete(key);
+            return undefined;
+        }
+        const activeTokenHash = this.activeHashBySession.get(sessionId);
+        const grant = activeTokenHash ? this.grantsByHash.get(activeTokenHash) : undefined;
+        if (!grant
+            || activeTokenHash !== approved.activeTokenHash
+            || grant.taskId !== approved.taskId) {
+            this.approvedCommands.delete(key);
+            return undefined;
+        }
+        if (approved.remainingUses <= 1)
+            this.approvedCommands.delete(key);
+        else
+            approved.remainingUses--;
+        return grant;
+    }
+    deleteExpiredApprovedCommands() {
+        const now = Date.now();
+        for (const [key, approved] of this.approvedCommands) {
+            if (approved.expiresAt <= now)
+                this.approvedCommands.delete(key);
+        }
+    }
+    deleteApprovedCommandsForSession(sessionId) {
+        for (const [key, approved] of this.approvedCommands) {
+            if (approved.sessionId === sessionId)
+                this.approvedCommands.delete(key);
+        }
     }
 }
 export function authorizeDelegatedAunMsgSend(registry, input) {
     if (!input.sessionId) {
         return { ok: false, code: 'DELEGATION_REQUIRED', reason: 'Origin session is required' };
     }
-    const validation = registry.validate(input.delegationToken, input.sessionId);
+    const validation = registry.validate(input.delegationToken, input.sessionId, input.delegationCommandHash);
     if (!validation.ok)
         return validation;
     const grant = validation.grant;
@@ -109,3 +184,22 @@ export function authorizeDelegatedAunMsgSend(registry, input) {
 function hashDelegationToken(token) {
     return crypto.createHash('sha256').update(token).digest('hex');
 }
+function approvedCommandKey(carrierTokenHash, sessionId, commandHash) {
+    return JSON.stringify([carrierTokenHash, sessionId, commandHash]);
+}
+function isDelegationCommandHash(value) {
+    return /^[a-f0-9]{64}$/.test(value);
+}
+export function hashDelegatedCommandArgv(argv) {
+    if (argv.length === 0 || argv.some(value => typeof value !== 'string' || value.includes('\0')))
+        return undefined;
+    return crypto.createHash('sha256')
+        .update('evolcore-agent-delegation-command-v1\0')
+        .update(JSON.stringify(argv))
+        .digest('hex');
+}
+export function hashCurrentDelegatedCommand(processArgv = process.argv) {
+    if (processArgv.length < 3)
+        return undefined;
+    return hashDelegatedCommandArgv(['ec', ...processArgv.slice(2)]);
+}

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

@@ -21,6 +21,9 @@ function buildAuditRecord(event) {
         operation: event.operation,
         scope: event.scope,
         dangerous: event.dangerous,
+        name: event.name,
+        action: event.action,
+        args: event.args?.argv ? { argv: [...event.args.argv] } : undefined,
         actorId: redactIdentifier(event.actorId),
         selfAid: redactIdentifier(event.selfAid),
         peerKey: redactIdentifier(event.peerKey),
@@ -61,6 +64,9 @@ function logAuditEvent(record) {
     const message = [
         `[CommandAudit:${marker}]`,
         `operation=${record.operation}`,
+        record.name ? `name=${record.name}` : null,
+        record.action ? `action=${record.action}` : null,
+        record.args?.argv ? `args.argv=${JSON.stringify(record.args.argv)}` : null,
         `role=${record.role}`,
         `actor=${record.actorId || 'unknown'}`,
         record.taskId ? `task=${record.taskId}` : null,