evolcore 0.0.33 → 0.0.35-test.0

package/dist/cli/thread-command.js

@@ -128,9 +128,13 @@ function printItem(item) {
         const running = obj.running ? ' [运行中]' : '';
         // 内部话题（daemon 会话记录）不是真实联系人，标注出来避免误认
         const internal = obj.internal ? ' [内部会话记录·无消息]' : '';
-        console.log(`${obj.peer}/${obj.threadId}${running}${internal}`);
-        // 名称只放名称本身：状态、标签各自单独一行，避免污染标题（标题会被 summary set --name 引用）
-        console.log(`  名称: ${obj.name}`);
+        // 主会话的 threadId 是空串；显示成 /main 比留一个空尾巴好读。
+        console.log(`${obj.peer}/${obj.threadId || 'main'}${running}${internal}`);
+        // 名称只放名称本身：状态、标签各自单独一行，避免污染标题（标题会被 summary set --name 引用）。
+        // 主会话（threadId 为空）加 `[主会话]` 前缀，与普通话题区分开；前缀只在展示层加，
+        // 不进索引与 session 的 name 字段，避免被 summary set --name 当成真实标题。
+        const namePrefix = obj.threadId ? '' : '[主会话] ';
+        console.log(`  名称: ${namePrefix}${obj.name}`);
         if (obj.topicStatus)
             console.log(`  状态: ${obj.topicStatus}`);
         if (obj.label)
@@ -150,6 +154,8 @@ function printItem(item) {
             console.log(`  最后消息: ${obj.lastMsgSnippet}`);
         if (obj.msgTotal !== undefined)
             console.log(`  摘要: ${obj.summarySnippet ?? '未总结'}`);
+        if (obj.sessionId)
+            console.log(`  会话: ${obj.sessionId}`);
         console.log('');
         return;
     }
@@ -228,7 +234,11 @@ export async function runThreadCommand(args) {
         const slash = ref.lastIndexOf('/');
         if (slash < 0)
             return { peer: ref };
-        return { peer: ref.slice(0, slash), threadId: ref.slice(slash + 1) };
+        const raw = ref.slice(slash + 1);
+        // 主会话的 threadId 是空串；`<peer>/main` 是同义写法，`list` 也这样显示。
+        if (raw === 'main')
+            return { peer: ref.slice(0, slash), threadId: '' };
+        return { peer: ref.slice(0, slash), threadId: raw };
     }
     switch (sub) {
         case 'list': {
@@ -308,7 +318,7 @@ export async function runThreadCommand(args) {
         case 'create': {
             const peer = args[1];
             if (!peer || peer.startsWith('-')) {
-                console.error('用法: ec thread create <peer> --name "..."');
+                console.error(`用法: ec thread create <peer> --name '...'`);
                 process.exitCode = 1;
                 return;
             }
@@ -334,7 +344,7 @@ export async function runThreadCommand(args) {
             const ref = args[1];
             const newName = args[2];
             if (!ref || newName === undefined) {
-                console.error('用法: ec thread rename <ref> "<名称>"');
+                console.error(`用法: ec thread rename <ref> '<名称>'`);
                 process.exitCode = 1;
                 return;
             }
@@ -524,7 +534,7 @@ export async function runThreadCommand(args) {
                 if (newName === undefined) {
                     console.error('✗ 必须指定 --name <新标题>');
                     console.error('  不改名请显式传 --name -');
-                    console.error(`  例: ec thread summary set ${ref} "摘要内容" --name "话题的核心动作"`);
+                    console.error(`  例: ec thread summary set ${ref} '<摘要内容>' --name '<话题的核心动作>'`);
                     process.exitCode = 1;
                     return;
                 }

package/dist/cli/trigger-command.js

@@ -146,7 +146,7 @@ Create 参数模式支持:
   --target-chat-type <private|group>  (AUN 目标必填；channelId 同时作为群聊 ID)
   --target-session <main|thread> [--target-thread-id <threadId>]
   --trigger-thread <by-run|by-trigger>  (兼容旧值 per-run)
-  --name <名称>
+  --name <名称>  --description <文本>
 
 通用输出参数:
   --json | --format json
@@ -187,6 +187,8 @@ async function listTriggers(args, json, response) {
     }
     for (const t of triggers) {
         console.log(`${t.enabled ? 'on ' : 'off'}  ${t.id}  ${t.name}  ${sourceLabel(t)}`);
+        if (t.description)
+            console.log(`      ${t.description}`);
     }
 }
 async function showTrigger(args, json, response) {
@@ -199,6 +201,8 @@ async function showTrigger(args, json, response) {
     console.log(`${t.name} (${t.id})`);
     console.log(`agent: ${t.agentAid}`);
     console.log(`enabled: ${t.enabled}`);
+    if (t.description)
+        console.log(`description: ${t.description}`);
     console.log(`source: ${sourceLabel(t)}`);
     if (t.limits?.maxRuns !== undefined || t.limits?.maxDuration !== undefined) {
         console.log(`limits: ${[
@@ -331,6 +335,7 @@ export async function buildTriggerCreateRequest(args, fileScope, defaultAgentAid
         $schema_version: 3.1,
         agentAid,
         name: parsed.name || `trigger-${now.toString(36)}`,
+        ...(parsed.description ? { description: parsed.description } : {}),
         enabled: hasFlag(args, '--enable'),
         createdAt: now,
         updatedAt: now,

package/dist/config/config-field-policy.js

@@ -1,3 +1,4 @@
+import { SYSTEM_SESSION_TYPES } from '../core/system-session/types.js';
 const BEHAVIOR_TOP_FIELDS = new Set([
     'active_baseagent',
     'chatmode',
@@ -183,6 +184,9 @@ export function resolveConfigFieldRule(fieldPath, scope) {
     if (top === 'sessionManifests') {
         if (parts.length === 1)
             return readonlyObject('sessionManifests');
+        // 系统会话类型的 manifest 由代码决定，不可配置
+        if (parts.length === 2 && SYSTEM_SESSION_TYPES.includes(parts[1]))
+            return { class: 'unknown' };
         if (parts.length === 2 && /^[A-Za-z0-9_-]+$/.test(parts[1]))
             return scalar('sessionManifests', 'manifest-file');
         return { class: 'unknown' };

package/dist/config/config-manager.js

@@ -17,6 +17,7 @@ import crypto from 'crypto';
 import { resolvePaths, agentConfig as agentConfigPath, agentContactConfig, agentRelationConfig, agentDir, agentRelationsDir, agentRolesIndex, agentRoleConfig, } from '../paths.js';
 import { atomicReadJson, atomicWriteJson } from '../utils/atomic-write.js';
 import { fileCache } from '../core/daemon-file-cache.js';
+import { registerFile } from '../core/file-integrity/store.js';
 import { isValidAid } from '../aun/aid/validation.js';
 import { normalizeAidDomain } from '../aun/aid/domain.js';
 import { isExplicitGroupId } from '../aun/group/index.js';
@@ -764,6 +765,15 @@ export function normalizeProcessConfigCompat(value) {
         if (changed)
             normalized = { ...normalized, idleMonitor: nextIdleMonitor };
     }
+    const delegationDiagnostics = normalized.delegationDiagnostics;
+    if (delegationDiagnostics && typeof delegationDiagnostics === 'object' && !Array.isArray(delegationDiagnostics)
+        && (Object.prototype.hasOwnProperty.call(delegationDiagnostics, 'eventRetentionDays')
+            || Object.prototype.hasOwnProperty.call(delegationDiagnostics, 'stateRetentionDays'))) {
+        const nextDiagnostics = { ...delegationDiagnostics };
+        delete nextDiagnostics.eventRetentionDays;
+        delete nextDiagnostics.stateRetentionDays;
+        normalized = { ...normalized, delegationDiagnostics: nextDiagnostics };
+    }
     if (debug && typeof debug === 'object' && !Array.isArray(debug)
         && Object.prototype.hasOwnProperty.call(debug, 'flusherDiag')) {
         const nextDebug = { ...debug };
@@ -1049,6 +1059,15 @@ function finishConfigWrite(target, sel, file) {
     if (sel?.self && (target === ConfigTarget.Agent || target === ConfigTarget.RoleRegistry || target === ConfigTarget.Role)) {
         clearRoleStoreCache(sel.self);
     }
+    // 配置落盘后登记到完整性台账；台账不可用时只告警不阻断
+    if (fs.existsSync(file)) {
+        try {
+            registerFile(file);
+        }
+        catch (err) {
+            configWarn(`[file-integrity] register failed for ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     const event = { target, selector: { ...(sel ?? {}) } };
     for (const listener of configWriteListeners) {
         try {

package/dist/config/contact-book-store.js

@@ -6,6 +6,7 @@ import { isExplicitGroupId } from '../aun/group/index.js';
 import { agentConfig, agentContactAuditPath, agentContactConfig, agentDir, resolvePaths } from '../paths.js';
 import { atomicReadJson, atomicWrite, atomicWriteJson } from '../utils/atomic-write.js';
 import { fileCache } from '../core/daemon-file-cache.js';
+import { unregisterFile } from '../core/file-integrity/store.js';
 import { ensureManagedLockParent, resolveManagedLockPath } from '../core/runtime-lock.js';
 import { ConfigTarget, notifyConfigWrite, validateConfig } from './config-manager.js';
 import { parseContactAlias } from './contact-alias.js';
@@ -584,6 +585,10 @@ function applyTransactionChange(change) {
         for (const candidate of [change.file, `${change.file}_`, `${change.file}__`]) {
             fs.rmSync(candidate, { force: true });
         }
+        try {
+            unregisterFile(change.file);
+        }
+        catch { /* best-effort */ }
     }
     else {
         atomicWrite(change.file, change.after);

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

@@ -208,7 +208,10 @@ function resolveFieldCommand(argv, subcommand, options = {}) {
         else {
             if (!route)
                 return { ok: false, code: 'UNKNOWN_FIELD', reason: `Unknown config field: ${field}` };
-            value = coerceConfigValue(rawValue, route);
+            const coerced = coerceConfigValue(rawValue, route, field);
+            if (!coerced.ok)
+                return { ok: false, code: 'INVALID_CONFIG_VALUE', reason: coerced.reason };
+            value = coerced.value;
         }
     }
     return {
@@ -506,18 +509,32 @@ function buildGlobalCanonicalArgv(command) {
         argv.push('--format', command.format);
     return argv;
 }
-function coerceConfigValue(raw, route) {
+function coerceConfigValue(raw, route, field) {
     if (route.merge === 'list')
-        return [raw];
+        return { ok: true, value: [raw] };
     if (route.enum)
-        return raw;
+        return { ok: true, value: raw };
+    if (route.merge === 'dict' && field === route.field) {
+        const trimmed = raw.trim();
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return { ok: false, reason: `Config field ${route.field} requires a JSON object value` };
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return { ok: false, reason: `Config field ${route.field} requires a JSON object value` };
+        }
+        return { ok: true, value: parsed };
+    }
     if (raw === 'true')
-        return true;
+        return { ok: true, value: true };
     if (raw === 'false')
-        return false;
+        return { ok: true, value: false };
     if (/^-?\d+(\.\d+)?$/.test(raw))
-        return Number(raw);
-    return raw;
+        return { ok: true, value: Number(raw) };
+    return { ok: true, value: raw };
 }
 function parseOwnersValue(raw) {
     let values;

package/dist/config/role-service.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { atomicReadJson, atomicWriteJson } from '../utils/atomic-write.js';
 import { agentRelationConfig, agentRelationsDir, agentRoleConfig, agentRolesIndex } from '../paths.js';
+import { registerFile, unregisterFile } from '../core/file-integrity/store.js';
 import { loadSchema } from './schema-registry.js';
 import { clearRoleStoreCache, getStoredRoleRegistry, isRoleName, readRoleStore, roleRegistryExists, } from './role-store.js';
 import { expectedRoleRank, isManagementRole } from './builtin-roles.js';
@@ -38,6 +39,10 @@ export function writeRoleRegistry(selfAid, value) {
     const file = agentRolesIndex(selfAid);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     atomicWriteJson(file, { ...value, $schema_version: 1 });
+    try {
+        registerFile(file);
+    }
+    catch { /* best-effort */ }
     clearRoleStoreCache(selfAid);
 }
 export function writeRoleDefinition(selfAid, roleId, value) {
@@ -52,6 +57,10 @@ export function writeRoleDefinition(selfAid, roleId, value) {
     const file = agentRoleConfig(selfAid, roleId);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     atomicWriteJson(file, normalized);
+    try {
+        registerFile(file);
+    }
+    catch { /* best-effort */ }
     clearRoleStoreCache(selfAid);
 }
 /** Remove an agent-local override so the builtin role template is used again. */
@@ -62,6 +71,10 @@ export function resetRoleDefinition(selfAid, roleId) {
     const changed = fs.existsSync(file);
     if (changed) {
         fs.rmSync(file, { force: true });
+        try {
+            unregisterFile(file);
+        }
+        catch { /* best-effort */ }
         clearRoleStoreCache(selfAid);
     }
     return changed;

package/dist/config/runtime-env.js

@@ -43,9 +43,23 @@ function envFileValue(file, name) {
     catch { }
     return undefined;
 }
+// Registry values do not depend on the agent/project scope. Without this, every
+// agent pays its own reg.exe launches (2 hives x 3 names, ~50ms each), which
+// serializes daemon startup at roughly 150ms per Claude runner.
+const windowsValueCache = new Map();
 function windowsValue(hive, name) {
     if (process.platform !== 'win32')
         return undefined;
+    const key = `${hive}:${name}`;
+    const now = Date.now();
+    const hit = windowsValueCache.get(key);
+    if (hit && hit.expires > now)
+        return hit.value;
+    const value = readWindowsValue(hive, name);
+    windowsValueCache.set(key, { value, expires: now + 3000 });
+    return value;
+}
+function readWindowsValue(hive, name) {
     const registryPath = hive === 'user' ? 'HKCU\\Environment'
         : 'HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment';
     try {
@@ -129,9 +143,11 @@ export function setRuntimeEnvironmentOverride(aid, values) {
     else
         overrides.delete(scope);
     cache.clear();
+    windowsValueCache.clear();
 }
 export function resetRuntimeEnvironmentForTests() {
     overrides.clear();
     cache.clear();
+    windowsValueCache.clear();
     captureStartupValues();
 }

package/dist/config-store.js

@@ -19,6 +19,7 @@ import fs from 'fs';
 import path from 'path';
 import { resolvePaths, agentDir, } from './paths.js';
 import { atomicReadJson, atomicWriteJson } from './utils/atomic-write.js';
+import { registerFile as registerFileIntegrity } from './core/file-integrity/store.js';
 import { checkAgentDir, isValidAid } from './aun/aid/validation.js';
 import { normalizeAidDomain } from './aun/aid/domain.js';
 import { isValidChannelName } from './core/channel-loader.js';
@@ -60,6 +61,18 @@ export function loadDaemonConfig() {
 export function isRestartRecoveryEnabled(config = loadDaemonConfig()) {
     return config.restartRecovery?.enabled === true;
 }
+export function isDelegationDiagnosticsEnabled() {
+    const config = cfgRead(ConfigTarget.Process, undefined, { cache: true });
+    const diagnostics = config?.delegationDiagnostics;
+    if (diagnostics !== undefined && (!diagnostics || typeof diagnostics !== 'object' || Array.isArray(diagnostics))) {
+        throw new Error('daemon.json.delegationDiagnostics must be an object');
+    }
+    const enabled = diagnostics?.enabled;
+    if (enabled !== undefined && typeof enabled !== 'boolean') {
+        throw new Error('daemon.json.delegationDiagnostics.enabled must be a boolean');
+    }
+    return enabled !== false;
+}
 export function isSkillWatchEnabled(config = loadDaemonConfig()) {
     return config.skills?.watch === true;
 }
@@ -92,6 +105,10 @@ export function saveDaemonConfig(value) {
         || current.aun?.defaultAidDomain !== value.aun?.defaultAidDomain;
     const normalized = normalizeProcessConfigCompat(normalizeDaemonServices(stripLegacyAunGatewayConfig(value, configPath, message => logger.warn(message))));
     atomicWriteJson(configPath, validateDaemonConfig({ ...normalized, $schema_version: currentVersion('daemon') }, validateAidDomain));
+    try {
+        registerFileIntegrity(configPath);
+    }
+    catch { /* best-effort */ }
 }
 function validateDaemonConfig(value, validateAidDomain) {
     if (value.restartRecovery !== undefined) {
@@ -118,6 +135,19 @@ function validateDaemonConfig(value, validateAidDomain) {
             throw new Error('daemon.json.skills.watch must be a boolean');
         }
     }
+    if (value.delegationDiagnostics !== undefined) {
+        if (!value.delegationDiagnostics || typeof value.delegationDiagnostics !== 'object' || Array.isArray(value.delegationDiagnostics)) {
+            throw new Error('daemon.json.delegationDiagnostics must be an object');
+        }
+        const unknownFields = Object.keys(value.delegationDiagnostics)
+            .filter(key => key !== 'enabled');
+        if (unknownFields.length > 0) {
+            throw new Error('daemon.json.delegationDiagnostics contains unsupported fields: ' + unknownFields.join(', '));
+        }
+        if (value.delegationDiagnostics.enabled !== undefined && typeof value.delegationDiagnostics.enabled !== 'boolean') {
+            throw new Error('daemon.json.delegationDiagnostics.enabled must be a boolean');
+        }
+    }
     const minEvolVersion = value.aun?.minEvolVersion;
     if (minEvolVersion !== undefined && !parseStableSemver(minEvolVersion)) {
         throw new Error('daemon.json.aun.minEvolVersion must use stable X.Y.Z format');

package/dist/core/audit/log-integrity.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { buildToolLifecycleEventKey, normalizeToolCorrelation } from './event-key.js';
 // Logger rotation is hourly/daily, but the suffix is intentionally generic so
 // this check also covers future rotation formats without changing the audit.
-const STRUCTURED_LOG_RE = /^(?:daemon|events|channel-in|channel-out|messages|command-audit)(?:-[^.]+)?\.log$/;
+const STRUCTURED_LOG_RE = /^(?:daemon|events|channel-in|channel-out|messages|command-audit|delegation-audit)(?:-[^.]+)?\.log$/;
 const MIXED_TEXT_LOG_RE = /^daemon(?:-[^.]+)?\.log$/;
 const LEGACY_JSONL_FILE = /\.jsonl$/i;
 /** Validate and de-duplicate structured event streams by lifecycle identity. */
@@ -80,6 +80,8 @@ export function inspectStructuredLogs(logDir, options = {}) {
     return { files: files.length, records: records.length, uniqueRecords: records.length - duplicates, duplicates, issues };
 }
 function structuredRecordKey(value) {
+    if (typeof value.eventId === 'string' && value.eventId.startsWith('del-audit-'))
+        return value.eventId;
     const nested = nestedRecord(value);
     const eventKey = firstDefined(value, nested, ['eventKey', 'event_key']);
     const eventPhase = recordPhase(value);

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

@@ -6,6 +6,7 @@ import { logger } from '../../utils/logger.js';
 import { canonicalizeEvolcoreCommandArgv } from '../permission/ec-command-parser.js';
 import { MAIN_CLI_BIN } from '../../product.js';
 import { DebugDelegationRegistry, DEBUG_TOKEN_PREFIX } from './debug-context.js';
+import { DelegationDiagnostics, } from './delegation-diagnostics.js';
 export const AGENT_DELEGATION_TOKEN_ENV = 'EVOLCORE_DELEGATION_TOKEN';
 export const CODEX_SESSION_TOKEN_ENV = 'EVOLCORE_CODEX_SESSION_TOKEN';
 export const AGENT_DELEGATION_COMMAND_TTL_MS = 5 * 60_000;
@@ -22,10 +23,15 @@ export function readDelegationCredential(env = process.env) {
 }
 export class AgentDelegationRegistry {
     runtimeEpoch = crypto.randomBytes(16).toString('hex');
+    diagnostics;
     grantsByHash = new Map();
     activeHashBySession = new Map();
+    sessionTokenHashesBySession = new Map();
     approvedCommands = new Map();
     debugRegistry = new DebugDelegationRegistry();
+    constructor() {
+        this.diagnostics = new DelegationDiagnostics(this.runtimeEpoch);
+    }
     getRuntimeEpoch() {
         return this.runtimeEpoch;
     }
@@ -34,13 +40,45 @@ export class AgentDelegationRegistry {
         if (input.executionIdentity && !isValidFullAccessExecutionIdentity(input.executionIdentity)) {
             throw new Error('invalid fullaccess task execution identity');
         }
-        this.revokeSession(input.sessionId);
+        this.revokeSession(input.sessionId, 'replaced');
         const token = crypto.randomBytes(32).toString('base64url');
         const tokenHash = hashDelegationToken(token);
         this.grantsByHash.set(tokenHash, { ...input, tokenHash });
         this.activeHashBySession.set(input.sessionId, tokenHash);
+        this.diagnostics.put('task.issued', {
+            kind: 'task', tokenHash, sessionId: input.sessionId, taskId: input.taskId,
+            runtimeEpoch: this.runtimeEpoch, status: 'active', credentialType: 'task',
+            ...(input.selfAid ? { selfAid: input.selfAid } : {}),
+            ...(input.peerKey ? { peerKey: input.peerKey } : {}),
+            ...(input.actorId ? { actorId: input.actorId } : {}),
+            ...(input.issuedRole ? { issuedRole: input.issuedRole } : {}),
+            ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
+            ...(input.messageId ? { messageId: input.messageId } : {}),
+        });
         return token;
     }
+    registerSessionCredential(input) {
+        const activeTokenHash = this.activeHashBySession.get(input.sessionId);
+        const grant = activeTokenHash ? this.grantsByHash.get(activeTokenHash) : undefined;
+        if (!grant || grant.taskId !== input.taskId || !input.sessionToken)
+            return false;
+        const tokenHash = hashDelegationToken(input.sessionToken);
+        let sessionTokens = this.sessionTokenHashesBySession.get(input.sessionId);
+        if (!sessionTokens) {
+            sessionTokens = new Set();
+            this.sessionTokenHashesBySession.set(input.sessionId, sessionTokens);
+        }
+        sessionTokens.add(tokenHash);
+        this.diagnostics.put('session.bound', {
+            kind: 'session', tokenHash,
+            sessionId: input.sessionId, taskId: input.taskId, runtimeEpoch: this.runtimeEpoch,
+            status: 'active', credentialType: 'codex-session', activeTokenHash,
+            threadId: input.threadId, selfAid: grant.selfAid, peerKey: grant.peerKey,
+            actorId: grant.actorId, issuedRole: grant.issuedRole, permissionMode: grant.permissionMode,
+            ...(grant.messageId ? { messageId: grant.messageId } : {}),
+        });
+        return true;
+    }
     /** 发行 debug token（dbg: 前缀），仅 debug 模式下调用 */
     issueDebug(input) {
         return this.debugRegistry.issue(input);
@@ -60,12 +98,7 @@ export class AgentDelegationRegistry {
     }
     validateToken(token, sessionId, commandHash, consumeApproval) {
         if (!token) {
-            return {
-                ok: false,
-                code: 'DELEGATION_REQUIRED',
-                reason: 'An active task delegation token is required',
-                diagnosticCause: 'missing_token',
-            };
+            return this.diagnostics.failure('missing_token', sessionId);
         }
         const tokenHash = hashDelegationToken(token);
         const grant = this.grantsByHash.get(tokenHash);
@@ -77,10 +110,11 @@ export class AgentDelegationRegistry {
                     assertAgentPolicyAuthorization(grant.executionIdentity);
                 }
                 catch {
-                    this.revokeSession(sessionId);
-                    return { ok: false, code: 'INVALID_DELEGATION', reason: 'Agent fullaccess policy was revoked', diagnosticCause: 'task_replaced' };
+                    this.revokeSession(sessionId, 'policy_revoked');
+                    return this.diagnostics.failure('task_revoked', sessionId, tokenHash);
                 }
             }
+            this.diagnostics.accepted(sessionId, tokenHash, commandHash);
             return { ok: true, grant };
         }
         const approved = commandHash
@@ -88,20 +122,9 @@ export class AgentDelegationRegistry {
             : undefined;
         if (approved)
             return { ok: true, grant: approved };
-        const diagnosticCause = grant
-            ? grant.sessionId !== sessionId
-                ? 'session_mismatch'
-                : 'task_replaced'
-            : commandHash
-                ? 'approved_command_unavailable'
-                : 'unknown_token';
+        const diagnosticCause = this.diagnostics.classify(tokenHash, sessionId, commandHash);
         logger.warn(`[AgentDelegation] validate failed: cause=${diagnosticCause} session=${sessionId} grantSession=${grant?.sessionId ?? 'none'} taskId=${grant?.taskId ?? 'none'} hasCommandHash=${!!commandHash} tokenKnown=${!!grant} activeForSession=${this.activeHashBySession.get(sessionId) ?? 'none'} grantTokenHash=${grant?.tokenHash ?? 'none'}`);
-        return {
-            ok: false,
-            code: 'INVALID_DELEGATION',
-            reason: 'The task delegation token is invalid, revoked, or belongs to another session',
-            diagnosticCause,
-        };
+        return this.diagnostics.failure(diagnosticCause, sessionId, tokenHash, commandHash);
     }
     armApprovedCommand(input) {
         const activeTokenHash = this.activeHashBySession.get(input.sessionId);
@@ -115,10 +138,15 @@ export class AgentDelegationRegistry {
             return false;
         this.deleteExpiredApprovedCommands();
         const sessionTokenHash = hashDelegationToken(sessionToken);
+        const credential = this.diagnostics.find('session', sessionTokenHash, input.sessionId);
+        if (credential?.taskId !== input.taskId || credential.runtimeEpoch !== this.runtimeEpoch) {
+            this.registerSessionCredential({ sessionToken, sessionId: input.sessionId, taskId: input.taskId });
+        }
         const key = approvedCommandKey(sessionTokenHash, 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, {
+            sessionTokenHash,
             sessionId: input.sessionId,
             taskId: input.taskId,
             activeTokenHash,
@@ -130,25 +158,42 @@ export class AgentDelegationRegistry {
                 ? existing.remainingUses + 1
                 : 1,
         });
+        this.recordApproval('approval.issued', this.approvedCommands.get(key), 'active');
         return true;
     }
-    revokeTask(sessionId, taskId) {
+    revokeTask(sessionId, taskId, reason = 'revoked') {
         const tokenHash = this.activeHashBySession.get(sessionId);
         if (!tokenHash)
             return;
         const grant = this.grantsByHash.get(tokenHash);
         if (!grant || grant.taskId !== taskId)
             return;
-        this.grantsByHash.delete(tokenHash);
-        this.activeHashBySession.delete(sessionId);
-        this.deleteApprovedCommandsForSession(sessionId);
+        this.revokeSession(sessionId, reason);
     }
-    revokeSession(sessionId) {
+    revokeSession(sessionId, reason = 'revoked') {
         const tokenHash = this.activeHashBySession.get(sessionId);
-        if (tokenHash)
+        for (const sessionTokenHash of this.sessionTokenHashesBySession.get(sessionId) ?? []) {
+            const credential = this.diagnostics.find('session', sessionTokenHash, sessionId);
+            if (credential)
+                this.diagnostics.put('session.revoked', {
+                    ...credential, status: reason === 'replaced' ? 'replaced' : 'revoked', revocationReason: reason,
+                });
+        }
+        this.sessionTokenHashesBySession.delete(sessionId);
+        if (tokenHash) {
+            const grant = this.grantsByHash.get(tokenHash);
+            if (grant)
+                this.diagnostics.put('task.revoked', {
+                    kind: 'task', tokenHash, sessionId, taskId: grant.taskId, runtimeEpoch: this.runtimeEpoch,
+                    status: reason === 'replaced' ? 'replaced' : 'revoked', revocationReason: reason,
+                    credentialType: 'task', selfAid: grant.selfAid, peerKey: grant.peerKey,
+                    actorId: grant.actorId, issuedRole: grant.issuedRole, permissionMode: grant.permissionMode,
+                    ...(grant.messageId ? { messageId: grant.messageId } : {}),
+                });
             this.grantsByHash.delete(tokenHash);
+        }
         this.activeHashBySession.delete(sessionId);
-        this.deleteApprovedCommandsForSession(sessionId);
+        this.deleteApprovedCommandsForSession(sessionId, reason);
     }
     readApprovedCommand(sessionTokenHash, sessionId, commandHash, consume) {
         if (!isDelegationCommandHash(commandHash))
@@ -158,6 +203,7 @@ export class AgentDelegationRegistry {
         if (!approved)
             return undefined;
         if (approved.expiresAt <= Date.now()) {
+            this.recordApproval('approval.expired', approved, 'expired');
             this.approvedCommands.delete(key);
             return undefined;
         }
@@ -166,30 +212,57 @@ export class AgentDelegationRegistry {
         if (!grant
             || activeTokenHash !== approved.activeTokenHash
             || grant.taskId !== approved.taskId) {
+            this.recordApproval('approval.revoked', approved, 'replaced', 'replaced');
             this.approvedCommands.delete(key);
             return undefined;
         }
+        this.diagnostics.accepted(sessionId, sessionTokenHash, commandHash);
         if (consume) {
-            if (approved.remainingUses <= 1)
+            approved.remainingUses--;
+            this.recordApproval('approval.consumed', approved, approved.remainingUses <= 0 ? 'consumed' : 'active');
+            if (approved.remainingUses <= 0)
                 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)
+            if (approved.expiresAt <= now) {
+                this.recordApproval('approval.expired', approved, 'expired');
                 this.approvedCommands.delete(key);
+            }
         }
     }
-    deleteApprovedCommandsForSession(sessionId) {
+    deleteApprovedCommandsForSession(sessionId, reason) {
         for (const [key, approved] of this.approvedCommands) {
-            if (approved.sessionId === sessionId)
+            if (approved.sessionId === sessionId) {
+                this.recordApproval('approval.revoked', approved, reason === 'replaced' ? 'replaced' : 'revoked', reason);
                 this.approvedCommands.delete(key);
+            }
         }
     }
+    recordApproval(event, approved, status, revocationReason) {
+        this.diagnostics.put(event, {
+            kind: 'approval', tokenHash: approved.sessionTokenHash, sessionId: approved.sessionId,
+            taskId: approved.taskId, runtimeEpoch: this.runtimeEpoch, status, credentialType: 'codex-session',
+            activeTokenHash: approved.activeTokenHash, commandHash: approved.commandHash,
+            expiresAt: approved.expiresAt, remainingUses: approved.remainingUses,
+            ...(revocationReason ? { revocationReason } : {}),
+        });
+    }
+    recordDiagnosticFailure(cause, sessionId, token, commandHash) {
+        const tokenHash = token ? hashDelegationToken(token) : undefined;
+        let diagnosticCause = cause;
+        if (cause === 'command_hash_mismatch') {
+            diagnosticCause = !tokenHash ? 'missing_token'
+                : sessionId ? this.diagnostics.classifyCommandHashMismatch(tokenHash, sessionId) : 'unknown_token';
+        }
+        return this.diagnostics.failure(diagnosticCause, sessionId, tokenHash, commandHash);
+    }
+    close() {
+        this.diagnostics.close();
+    }
 }
 export function authorizeDelegatedAunMsgSend(registry, input) {
     if (!input.sessionId) {