evolcore 0.0.15 → 0.0.17

package/dist/channels/aun.js

@@ -41,6 +41,41 @@ export const AUN_HANDOFF_MARKER_FIELD = '_evolcore_handoff_id';
 const AUN_INTERACTION_CARD_TTL_MS = 24 * 60 * 60 * 1000;
 const AUN_INBOUND_DEDUP_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const IMAGE_MIME_TYPE = /^image\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/i;
+const AUN_ATTACHMENT_DOWNLOAD_ATTEMPTS = 3;
+const AUN_ATTACHMENT_RETRY_DELAYS_MS = [250, 750];
+function attachmentDownloadHost(url) {
+    try {
+        return new URL(url).host || '<unknown>';
+    }
+    catch {
+        return '<invalid-url>';
+    }
+}
+function attachmentDownloadErrorDetails(error) {
+    const value = error && typeof error === 'object' ? error : {};
+    const cause = value.cause && typeof value.cause === 'object'
+        ? value.cause
+        : {};
+    const status = typeof value.status === 'number'
+        ? value.status
+        : typeof cause.status === 'number' ? cause.status : undefined;
+    const code = typeof cause.code === 'string'
+        ? cause.code
+        : typeof value.code === 'string' ? value.code : undefined;
+    const message = typeof value.message === 'string'
+        ? value.message
+        : String(error);
+    const messageStatus = status === undefined
+        ? message.match(/\bHTTP\s+(\d{3})\b|\bDownload failed:\s*(\d{3})\b/i)
+        : null;
+    const parsedStatus = messageStatus
+        ? Number(messageStatus[1] ?? messageStatus[2])
+        : undefined;
+    return { status: status ?? (Number.isFinite(parsedStatus) ? parsedStatus : undefined), code, message };
+}
+function isRetryableAttachmentStatus(status) {
+    return status === undefined || status === 408 || status === 429 || status >= 500;
+}
 // AUN limits the complete encrypted thought envelope to 8192 bytes. The
 // encrypted group envelope grows with the number of recipient devices, so a
 // conservative plaintext budget avoids rejecting otherwise valid thoughts.
@@ -1449,6 +1484,31 @@ export class AUNChannel {
         logger.info(`${this.logPrefix()} [attachments] count=${rawAttachments.length} images=${images.length} files=${fileParts.length}`);
         return { finalText, images };
     }
+    async downloadAttachmentWithRetry(url, filename, source, download) {
+        const host = attachmentDownloadHost(url);
+        for (let attempt = 1; attempt <= AUN_ATTACHMENT_DOWNLOAD_ATTEMPTS; attempt++) {
+            try {
+                const buffer = await download();
+                if (attempt > 1) {
+                    logger.info(`${this.logPrefix()} ${source} attachment download recovered for ${filename}: attempt=${attempt} host=${host}`);
+                }
+                return buffer;
+            }
+            catch (error) {
+                const details = attachmentDownloadErrorDetails(error);
+                const status = details.status === undefined ? '-' : String(details.status);
+                const code = details.code ?? '-';
+                logger.warn(`${this.logPrefix()} ${source} attachment download failed for ${filename}: `
+                    + `attempt=${attempt}/${AUN_ATTACHMENT_DOWNLOAD_ATTEMPTS} host=${host} `
+                    + `status=${status} code=${code} error=${details.message}`);
+                if (attempt >= AUN_ATTACHMENT_DOWNLOAD_ATTEMPTS || !isRetryableAttachmentStatus(details.status))
+                    break;
+                const delayMs = AUN_ATTACHMENT_RETRY_DELAYS_MS[attempt - 1] ?? AUN_ATTACHMENT_RETRY_DELAYS_MS.at(-1) ?? 0;
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            }
+        }
+        return null;
+    }
     async downloadAttachment(att, channelId, delivery) {
         const ownerAid = att.owner_aid
             || (delivery?.chatType === 'private' ? channelId : '')
@@ -1491,34 +1551,27 @@ export class AUNChannel {
                 logger.warn(`${this.logPrefix()} create_download_ticket failed for ${filename}: ${e}`);
             }
         }
-        let buffer;
+        let buffer = null;
         if (downloadUrl) {
-            try {
+            buffer = await this.downloadAttachmentWithRetry(downloadUrl, filename, 'ticket', async () => {
                 const res = await fetch(downloadUrl);
                 if (!res.ok) {
-                    logger.warn(`${this.logPrefix()} Download failed for ${filename}: HTTP ${res.status}`);
-                    return null;
+                    const error = new Error(`HTTP ${res.status}`);
+                    error.status = res.status;
+                    throw error;
                 }
-                buffer = Buffer.from(await res.arrayBuffer());
-            }
-            catch (e) {
-                logger.warn(`${this.logPrefix()} Download error for ${filename}: ${e}`);
-                return null;
-            }
+                return Buffer.from(await res.arrayBuffer());
+            });
         }
-        else {
-            if (!fallbackUrl)
-                return null;
-            try {
-                const host = new URL(fallbackUrl).hostname;
-                buffer = await safeFetch(fallbackUrl, { allowedHosts: new Set([host]) });
+        if (!buffer && fallbackUrl && fallbackUrl !== downloadUrl) {
+            const host = new URL(fallbackUrl).hostname;
+            buffer = await this.downloadAttachmentWithRetry(fallbackUrl, filename, 'payload', () => safeFetch(fallbackUrl, { allowedHosts: new Set([host]) }));
+            if (buffer) {
                 logger.info(`${this.logPrefix()} Downloaded attachment via payload URL fallback: ${filename}`);
             }
-            catch (e) {
-                logger.warn(`${this.logPrefix()} Payload URL fallback failed for ${filename}: ${e}`);
-                return null;
-            }
         }
+        if (!buffer)
+            return null;
         if (att.sha256) {
             const { createHash } = await import('node:crypto');
             const actual = createHash('sha256').update(buffer).digest('hex');

package/dist/channels/daemon.js

@@ -29,14 +29,17 @@ export class DaemonChannel {
         const pendingId = ctx.attemptId ?? runId;
         const messageId = pendingId;
         const startedAt = Date.now();
-        const remainingExecutionMs = ctx.executionDeadlineAt === undefined
-            ? this.totalExecutionMs
-            : Math.max(1, ctx.executionDeadlineAt - startedAt);
+        const remainingExecutionMs = typeof ctx.executionDeadlineAt === 'number'
+            && Number.isFinite(ctx.executionDeadlineAt)
+            ? Math.max(1, ctx.executionDeadlineAt - startedAt)
+            : this.totalExecutionMs;
         const promise = new Promise((resolve) => {
             const watchdogTimer = setTimeout(() => this.watchdogTimeout(pendingId), this.watchdogMs);
             watchdogTimer.unref?.();
-            const totalExecutionTimer = setTimeout(() => this.totalExecutionTimeout(pendingId, remainingExecutionMs), remainingExecutionMs);
-            totalExecutionTimer.unref?.();
+            const totalExecutionTimer = remainingExecutionMs === undefined
+                ? undefined
+                : setTimeout(() => this.totalExecutionTimeout(pendingId, remainingExecutionMs), remainingExecutionMs);
+            totalExecutionTimer?.unref?.();
             this.pending.set(pendingId, {
                 resolve,
                 startedAt,
@@ -214,7 +217,9 @@ export class DaemonChannel {
         return await this.sessionManager.getOrCreateSession(this.channelName, channelId, projectPath, threadId, { channelKey: this.channelKey, peerId: `trigger:${trigger.id}`, peerName: trigger.name }, trigger.name, undefined, 'private', baseagent, trigger.agentAid, this.channelName, 'system');
     }
     executionDeadlineAt(startedAt = Date.now()) {
-        return startedAt + this.totalExecutionMs;
+        return this.totalExecutionMs === undefined
+            ? undefined
+            : startedAt + this.totalExecutionMs;
     }
     async getResumableConversationSession(sessionId) {
         const session = await this.sessionManager.getSessionById(sessionId);
@@ -281,7 +286,8 @@ export class DaemonChannel {
         slot.terminalClaim = { outcome, metadata };
         if (slot.watchdogTimer)
             clearTimeout(slot.watchdogTimer);
-        clearTimeout(slot.totalExecutionTimer);
+        if (slot.totalExecutionTimer)
+            clearTimeout(slot.totalExecutionTimer);
         if (slot.abortListener)
             slot.abortSignal?.removeEventListener('abort', slot.abortListener);
         return true;
@@ -347,7 +353,7 @@ export class DaemonChannel {
         slot.watchdogTimer = setTimeout(() => this.watchdogTimeout(runId), this.watchdogMs);
         slot.watchdogTimer.unref?.();
     }
-    totalExecutionTimeout(runId, totalExecutionMs = this.totalExecutionMs) {
+    totalExecutionTimeout(runId, totalExecutionMs) {
         const slot = this.pending.get(runId);
         if (!slot || slot.terminalClaim)
             return;
@@ -390,7 +396,7 @@ function normalizeWatchdogMs(value) {
 function normalizeTotalExecutionMs(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0
         ? value
-        : 60 * 60 * 1000;
+        : undefined;
 }
 function channelTypeFromKey(channelKey) {
     const idx = channelKey.indexOf('#');

package/dist/cli/init.js

@@ -444,6 +444,7 @@ export async function initTail(options = {}) {
     const daemonConfig = loadDaemonConfig();
     let controlAidReady = !!daemonConfig.aid;
     let autoStartReady = true;
+    const autoStartExplicit = options.autoStart !== undefined;
     let ownerBindingInterrupted = false;
     if (daemonConfig.aid) {
         console.log(`✓ 控制 AID 已存在: ${daemonConfig.aid}`);
@@ -596,13 +597,16 @@ export async function initTail(options = {}) {
     }
     // ec start 会接着启动 daemon，并在其 ready 后给出可用的 Agent 创建入口。
     if (options.invokedByStart)
-        return controlAidReady && autoStartReady;
+        return controlAidReady && (!autoStartExplicit || autoStartReady);
     if (!controlAidReady) {
         console.error('\n❌ EvolCore 初始化未完成：控制 AID 未配置。联网后重新运行 ec init。');
         return false;
     }
-    if (!autoStartReady)
-        return false;
+    if (!autoStartReady) {
+        if (autoStartExplicit)
+            return false;
+        console.log('  ⚠️ 登录自启配置未完成，可稍后运行 ec init --auto-start 重试');
+    }
     // 初始化完成总结
     console.log('\n✓ EvolCore 初始化完成');
     const finalCfg = loadDaemonConfig();

package/dist/cli/task-context.js

@@ -23,6 +23,7 @@ function normalizeTaskRuntimeContext(value) {
         taskId: optionalString(value.taskId),
         sessionId: optionalString(value.sessionId),
         messageId: optionalString(value.messageId),
+        baseagent: optionalString(value.baseagent),
         channel: optionalString(value.channel),
         channelId: optionalString(value.channelId),
         chatType: optionalString(value.chatType),
@@ -38,6 +39,29 @@ function normalizeTaskRuntimeContext(value) {
         causation: normalizeCausation(value.causation),
     };
 }
+/**
+ * Codex's shell carrier can leave one JSON-style escape layer in a message
+ * argument (for example, the two characters `\\` and `n`). Decode only that
+ * layer, and only for a task that is explicitly running the Codex backend.
+ * Actual line breaks and all non-Codex CLI input remain unchanged.
+ */
+export function decodeCodexMessageText(text, runtime) {
+    if (runtime?.baseagent?.trim().toLowerCase() !== 'codex')
+        return text;
+    return text.replace(/\\([nrt])/g, (_match, escape) => {
+        if (escape === 'n')
+            return '\n';
+        if (escape === 'r')
+            return '\r';
+        return '\t';
+    });
+}
+/** Apply the Codex-only normalization to a text message payload. */
+export function normalizeCodexTextPayload(payload, runtime) {
+    if (payload.type !== 'text' || typeof payload.text !== 'string')
+        return;
+    payload.text = decodeCodexMessageText(payload.text, runtime);
+}
 function optionalAbsolutePath(value) {
     if (typeof value !== 'string' || !path.isAbsolute(value))
         return undefined;
@@ -75,6 +99,27 @@ function isPrivateDirectory(directory) {
         return false;
     }
 }
+/**
+ * Resolve the platform temp root before creating a managed directory. macOS
+ * exposes its per-user temp directory through `/var`, which is a symlink to
+ * `/private/var`; walking that lexical path would otherwise reject a freshly
+ * created directory even though its real path is private. When an inherited
+ * TMPDIR was rejected, use a fixed system fallback instead of following that
+ * untrusted path back into the fallback.
+ */
+function managedTempCreationRoot(configured) {
+    const candidate = configured
+        ? process.platform === 'win32'
+            ? path.join(process.env.SystemRoot || process.env.WINDIR || 'C:\\Windows', 'Temp')
+            : '/tmp'
+        : os.tmpdir();
+    try {
+        return fs.realpathSync.native(candidate);
+    }
+    catch {
+        return path.resolve(candidate);
+    }
+}
 /**
  * Ensure the daemon has a private process-wide temporary root.
  *
@@ -95,7 +140,7 @@ export function ensureProcessManagedTempDir() {
         if (isPrivateDirectory(resolved))
             return resolved;
     }
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'evolcore-managed-tmp-'));
+    const directory = fs.mkdtempSync(path.join(managedTempCreationRoot(configured), 'evolcore-managed-tmp-'));
     try {
         fs.chmodSync(directory, 0o700);
         if (!isPrivateDirectory(directory)) {
@@ -142,8 +187,8 @@ function isRunnerOwnedSessionRuntimeDir(directory) {
 }
 /** Whether a task-provided runtime directory stays inside the process-managed
  * TMPDIR and is safe to use for transient writes. */
-export function isManagedSessionRuntimeDir(directory) {
-    const tmpDir = process.env.TMPDIR?.trim();
+export function isManagedSessionRuntimeDir(directory, managedRoot) {
+    const tmpDir = (managedRoot ?? process.env.TMPDIR)?.trim();
     if (!directory || !path.isAbsolute(directory) || !tmpDir || !path.isAbsolute(tmpDir))
         return false;
     const root = path.resolve(tmpDir);

package/dist/config/config-manager.js

@@ -1120,6 +1120,7 @@ export function resolveEffective(sel, opts = {}) {
         models: config.models,
         projects: config.projects,
         capabilities: config.capabilities,
+        readonlySourceDiagnostics: config.readonlySourceDiagnostics,
         observable: config.observable,
         extra_backup: config.extra_backup,
         // Runtime configuration parameters

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

@@ -0,0 +1,149 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+// 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 MIXED_TEXT_LOG_RE = /^daemon(?:-[^.]+)?\.log$/;
+/** Validate and de-duplicate structured event streams by lifecycle identity. */
+export function inspectStructuredLogs(logDir, options = {}) {
+    const issues = [];
+    const records = [];
+    let files = [];
+    try {
+        files = fs.readdirSync(logDir).filter(name => STRUCTURED_LOG_RE.test(name)
+            && (options.includeMessages || !name.startsWith('messages')));
+    }
+    catch {
+        return { files: 0, records: 0, uniqueRecords: 0, duplicates: 0, issues };
+    }
+    for (const file of files) {
+        let lines;
+        try {
+            lines = fs.readFileSync(path.join(logDir, file), 'utf8').split('\n');
+        }
+        catch {
+            continue;
+        }
+        lines.forEach((line, index) => {
+            let raw = line.trim();
+            if (!raw)
+                return;
+            // daemon logs mix human-readable entries with structured audit lines.
+            // Ignore the former, but still validate malformed structured payloads.
+            if (MIXED_TEXT_LOG_RE.test(file)) {
+                if (raw.startsWith('[CommandAuditRecord] '))
+                    raw = raw.slice('[CommandAuditRecord] '.length);
+                else if (!raw.startsWith('{'))
+                    return;
+            }
+            let value;
+            try {
+                const parsed = JSON.parse(raw);
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                    throw new Error('not object');
+                value = parsed;
+            }
+            catch {
+                issues.push({ file, line: index + 1, reason: 'invalid_json' });
+                return;
+            }
+            const key = structuredRecordKey(value);
+            records.push({ file, line: index + 1, value, key });
+            if (isLifecycleRecord(value) && !hasContextValue(lifecycleField(value, 'sessionId')))
+                issues.push({ file, line: index + 1, reason: 'missing_session', key });
+            if (isLifecycleRecord(value) && !hasContextValue(lifecycleField(value, 'agentAid')))
+                issues.push({ file, line: index + 1, reason: 'missing_agent', key });
+            if (isLifecycleRecord(value) && !hasContextValue(lifecycleField(value, 'permissionMode')))
+                issues.push({ file, line: index + 1, reason: 'missing_permission_mode', key });
+            if (isCorrelatableRecord(value) && !key)
+                issues.push({ file, line: index + 1, reason: 'missing_correlation' });
+        });
+    }
+    const seen = new Set();
+    let duplicates = 0;
+    for (const record of records) {
+        if (!record.key)
+            continue;
+        const fingerprint = `${record.key}:${stableHash(record.value)}`;
+        if (seen.has(fingerprint)) {
+            duplicates++;
+            issues.push({ file: record.file, line: record.line, reason: 'mirror_duplicate', key: record.key });
+        }
+        else
+            seen.add(fingerprint);
+    }
+    return { files: files.length, records: records.length, uniqueRecords: records.length - duplicates, duplicates, issues };
+}
+function structuredRecordKey(value) {
+    const nested = nestedRecord(value);
+    const correlation = firstDefined(value, nested, [
+        'correlationId', 'correlation_id', 'callId', 'call_id', 'toolUseId', 'tool_use_id',
+        'requestId', 'request_id', 'msgId', 'operationId',
+    ]);
+    if (!correlation)
+        return undefined;
+    return `${canonicalEventType(value)}:${String(correlation)}`;
+}
+function isLifecycleRecord(value) {
+    const type = canonicalEventType(value);
+    return type === 'tool_use' || type === 'tool_result';
+}
+function isCorrelatableRecord(value) {
+    const nested = nestedRecord(value);
+    return isLifecycleRecord(value)
+        || firstDefined(value, nested, ['requestId', 'request_id', 'correlationId', 'correlation_id']) !== undefined;
+}
+function stableHash(value) {
+    const nested = nestedRecord(value);
+    const canonical = {
+        type: canonicalEventType(value),
+        toolName: firstDefined(value, nested, ['toolName', 'tool', 'name']),
+        callId: firstDefined(value, nested, ['callId', 'call_id', 'toolUseId', 'tool_use_id']),
+        correlationId: firstDefined(value, nested, ['correlationId', 'correlation_id']),
+        requestId: firstDefined(value, nested, ['requestId', 'request_id']),
+        sessionId: firstDefined(value, nested, ['sessionId', 'session_id']),
+        agentAid: firstDefined(value, nested, ['agentAid', 'agent_aid', 'selfAid']),
+        permissionMode: firstDefined(value, nested, ['permissionMode', 'permission_mode']),
+        isError: firstDefined(value, nested, ['isError', 'is_error']) ?? (value.ok === false || nested?.ok === false ? true : undefined),
+        errorCode: firstDefined(value, nested, ['errorCode', 'error_code']),
+        input: firstDefined(value, nested, ['input']),
+        result: firstDefined(value, nested, ['result', 'content']),
+        error: firstDefined(value, nested, ['error', 'errorMessage']),
+    };
+    return crypto.createHash('sha256').update(JSON.stringify(canonical)).digest('hex').slice(0, 16);
+}
+function lifecycleField(value, field) {
+    const nested = nestedRecord(value);
+    if (field === 'sessionId')
+        return firstDefined(value, nested, ['sessionId', 'session_id']);
+    if (field === 'agentAid')
+        return firstDefined(value, nested, ['agentAid', 'agent_aid', 'selfAid']);
+    return firstDefined(value, nested, ['permissionMode', 'permission_mode']);
+}
+function nestedRecord(value) {
+    return value.event && typeof value.event === 'object' && !Array.isArray(value.event)
+        ? value.event
+        : undefined;
+}
+function firstDefined(value, nested, fields) {
+    for (const field of fields) {
+        if (value[field] !== undefined && value[field] !== null)
+            return value[field];
+        if (nested?.[field] !== undefined && nested[field] !== null)
+            return nested[field];
+    }
+    return undefined;
+}
+function canonicalEventType(value) {
+    const nested = nestedRecord(value);
+    const raw = value.type ?? nested?.type;
+    if (raw === 'tool:use' || raw === 'tool_use')
+        return 'tool_use';
+    if (raw === 'tool:result' || raw === 'tool_result')
+        return 'tool_result';
+    return String(raw ?? 'record');
+}
+function hasContextValue(value) {
+    return value !== undefined && value !== null && value !== '' && value !== 'unknown';
+}

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

@@ -7,6 +7,7 @@ export function auditCommandAuthorization(event) {
         event.decision === 'deny' ||
         (event.decision === 'allow' && event.dangerous) ||
         (event.source === 'agent-tool' && event.operation.startsWith('config.')) ||
+        event.operation === 'codex.approval' ||
         event.operation.startsWith('role.') ||
         event.operation === 'cli.exec.raw';
     if (!shouldAudit)
@@ -30,11 +31,13 @@ export function auditToolPreflightDenial(input) {
         decisionSource: 'policy',
         toolName: input.toolName,
         policyCode: input.policyCode,
+        protectionClass: input.protectionClass ?? protectionClassForPolicy(input.policyCode),
+        matchedPath: input.matchedPath ?? extractAuditPath(input.summary),
         reason: input.reason,
         argsSummary: input.summary ? { summary: input.summary } : undefined,
-        sessionId: input.sessionId,
-        agentAid: input.agentAid,
-        permissionMode: input.permissionMode,
+        sessionId: input.sessionId ?? 'unknown',
+        agentAid: input.agentAid ?? 'unknown',
+        permissionMode: input.permissionMode ?? 'unknown',
         channel: input.channel,
         actorId: input.actorId,
         role: input.role ?? 'unknown',
@@ -44,6 +47,35 @@ export function auditToolPreflightDenial(input) {
         taskId: input.taskId,
     });
 }
+/**
+ * Emit one canonical, structured record for every Codex app-server approval
+ * decision. The app-server's request id is the lifecycle key; method and
+ * decision source make policy, user, and infrastructure denials distinct.
+ */
+export function auditCodexApprovalDecision(input) {
+    auditCommandAuthorization({
+        ts: Date.now(),
+        source: 'agent-tool',
+        operation: 'codex.approval',
+        scope: input.toolName === 'PermissionGrant' ? 'agent' : 'filesystem',
+        dangerous: input.toolName === 'PermissionGrant',
+        decision: input.decision,
+        decisionSource: input.decisionSource,
+        requestId: input.requestId,
+        correlationId: input.correlationId ?? input.requestId,
+        sessionId: input.sessionId ?? 'unknown',
+        agentAid: input.agentAid ?? 'unknown',
+        permissionMode: input.permissionMode ?? 'unknown',
+        toolName: input.toolName,
+        approvalMethod: input.method,
+        policyCode: input.policyCode,
+        protectionClass: protectionClassForPolicy(input.policyCode),
+        reason: input.reason,
+        role: input.role ?? 'unknown',
+        taskId: input.taskId,
+        argsSummary: { method: input.method, executed: false },
+    });
+}
 function buildAuditRecord(event) {
     return {
         ts: event.ts,
@@ -53,7 +85,10 @@ function buildAuditRecord(event) {
         agentAid: redactIdentifier(event.agentAid ?? event.selfAid),
         permissionMode: event.permissionMode,
         toolName: event.toolName,
+        approvalMethod: event.approvalMethod,
         policyCode: event.policyCode ?? event.code,
+        protectionClass: event.protectionClass,
+        matchedPath: event.matchedPath,
         decisionSource: event.decisionSource,
         source: event.source,
         operation: event.operation,
@@ -88,6 +123,9 @@ function redactIdentifier(value) {
     return crypto.createHash('sha256').update(value).digest('hex').slice(0, 12);
 }
 function logAuditEvent(record) {
+    // Keep one machine-readable stream independent from daemon text rotation;
+    // daily analysis can de-duplicate it against events/channel mirrors.
+    writeCommandAuditRecord(record);
     // A role-management snapshot fans out into several successful read checks.
     // Keep those available for verbose ECWeb diagnostics without flooding INFO.
     const routineEcwebRoleRead = record.source === 'ecweb'
@@ -116,6 +154,8 @@ function logAuditEvent(record) {
         record.permissionMode ? `permissionMode=${record.permissionMode}` : null,
         record.toolName ? `tool=${record.toolName}` : null,
         record.policyCode ? `policy=${record.policyCode}` : null,
+        record.protectionClass ? `protectionClass=${record.protectionClass}` : null,
+        record.matchedPath ? `matchedPath=${JSON.stringify(record.matchedPath)}` : null,
         record.decisionSource ? `decisionSource=${record.decisionSource}` : null,
         record.code ? `code=${record.code}` : null,
         record.matchedRule ? `rule=${record.matchedRule}` : null,
@@ -151,6 +191,21 @@ export function auditRoleMutation(record) {
     logger.info(`[RoleMutationAudit] ${JSON.stringify(payload)}`);
 }
 let roleMutationWriter;
+let commandAuditWriter;
+function writeCommandAuditRecord(record) {
+    try {
+        const logDir = resolvePaths().logs;
+        if (commandAuditWriter?.logDir !== logDir) {
+            commandAuditWriter?.writer.close();
+            commandAuditWriter = {
+                logDir,
+                writer: new LogWriter({ baseName: 'command-audit', logDir, rotation: 'daily', retention: { days: 30 } }),
+            };
+        }
+        commandAuditWriter.writer.write(JSON.stringify(record));
+    }
+    catch { }
+}
 function writeRoleMutationAudit(payload) {
     try {
         const logDir = resolvePaths().logs;
@@ -170,3 +225,18 @@ function writeRoleMutationAudit(payload) {
     }
     catch { }
 }
+function protectionClassForPolicy(policyCode) {
+    if (!policyCode)
+        return undefined;
+    if (/^h_class|^readonly_h_class|h_class_protection/i.test(policyCode))
+        return 'H';
+    if (/^l_class|^readonly_l_class|l_class_protection/i.test(policyCode))
+        return 'L';
+    return undefined;
+}
+function extractAuditPath(summary) {
+    if (!summary)
+        return undefined;
+    const match = summary.match(/(?:^|\s)(\/[^\s'"`;]+|[A-Za-z]:[\\/][^\s'"`;]+|(?:src|ecagent|ecweb|scripts|tests?)\/[^\s'"`;]+)/);
+    return match?.[1];
+}

package/dist/core/event-catalog.js

@@ -329,6 +329,7 @@ const CATALOG = [
             { path: 'sessionId', type: 'string' },
             { path: 'toolName', type: 'string' },
             { path: 'isError', type: 'boolean', optional: true },
+            { path: 'errorCode', type: 'string', optional: true },
             { path: 'agentName', type: 'string', optional: true },
             { path: 'callId', type: 'string', optional: true },
             { path: 'correlationId', type: 'string', optional: true },