evolcore 0.0.33 → 0.0.34

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/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) {