evolcore 0.0.20 → 0.0.21

package/dist/paths.js

@@ -3,6 +3,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 import { DAEMON_CONFIG_FILENAME, DEFAULT_RUNTIME_HOME_DIRNAME, INSTANCE_SOCKET_FILENAME, RUNTIME_HOME_ENV, WINDOWS_PIPE_PREFIX, } from './product.js';
+import { migrateLegacyAgentJsonlLogs } from './core/audit/log-integrity.js';
 const isWindows = process.platform === 'win32';
 let _root = null;
 export function resolveRoot() {
@@ -118,9 +119,6 @@ export function agentVenuesDir(aid) {
 export function agentSessionsDir(aid) {
     return path.join(agentDir(aid), 'sessions');
 }
-export function agentLogsDir(aid) {
-    return path.join(agentDir(aid), 'logs');
-}
 export function agentDataDir(aid) {
     return path.join(agentDir(aid), 'data');
 }
@@ -133,6 +131,9 @@ export function agentHandoffDir(aid) {
 export function agentOutboxPath(aid) {
     return path.join(agentDataDir(aid), 'outbox.jsonl');
 }
+export function agentActivityOutboxPath(aid) {
+    return path.join(agentDataDir(aid), 'activity-outbox.jsonl');
+}
 /** Directory-safe channel instance key used by connector runtime state. */
 function encodePathKey(value) {
     return encodeURIComponent(value);
@@ -161,11 +162,66 @@ export function channelStatePath(channelKey, ...parts) {
 export function agentTriggersDir(aid) {
     return path.join(agentDir(aid), 'triggers');
 }
-function resolveInstanceSocketPath(root) {
-    if (isWindows) {
-        const hash = crypto.createHash('sha1').update(root).digest('hex').slice(0, 12);
-        return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-${hash}`;
+function stripTrailingWindowsSeparators(value) {
+    const stripped = value.replace(/[\\/]+$/g, '');
+    // Keep a drive-root separator. `C:` is a drive-relative path on Windows.
+    if (/^[a-zA-Z]:$/.test(stripped) && /^[a-zA-Z]:[\\/]+$/.test(value)) {
+        return `${stripped}\\`;
+    }
+    return stripped;
+}
+function normalizeWindowsSocketRoot(root) {
+    // Use win32 semantics explicitly: EVOLCORE_HOME can come from Git Bash even
+    // when the daemon itself runs under native Windows Node.
+    return stripTrailingWindowsSeparators(path.win32.resolve(root)).toLowerCase();
+}
+function windowsSocketPathForRoot(root) {
+    const hash = crypto.createHash('sha1').update(root).digest('hex').slice(0, 12);
+    return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-${hash}`;
+}
+/**
+ * Return the canonical and pre-normalization Windows daemon pipe names.
+ *
+ * The extra candidates keep a daemon started by an older EvolCore build
+ * reachable while it is still running after the CLI has been upgraded.
+ */
+export function getWindowsInstanceSocketPathCandidates(root) {
+    const normalized = path.win32.normalize(root);
+    const normalizedForward = stripTrailingWindowsSeparators(normalized.replace(/\\/g, '/'));
+    const canonical = normalizeWindowsSocketRoot(root);
+    const baseVariants = [
+        canonical,
+        root,
+        normalized,
+        normalizedForward,
+        canonical.replace(/\\/g, '/'),
+        root.replace(/\\/g, '/'),
+        root.replace(/\//g, '\\'),
+    ];
+    const variants = new Set();
+    for (const variant of baseVariants) {
+        const stripped = stripTrailingWindowsSeparators(variant);
+        variants.add(variant);
+        variants.add(stripped);
+        if (stripped) {
+            variants.add(`${stripped}\\`);
+            variants.add(`${stripped}/`);
+        }
     }
+    const seen = new Set();
+    const candidates = [];
+    for (const variant of variants) {
+        const socket = windowsSocketPathForRoot(variant);
+        if (seen.has(socket))
+            continue;
+        seen.add(socket);
+        candidates.push(socket);
+    }
+    return candidates;
+}
+function resolveInstanceSocketPath(root) {
+    if (isWindows)
+        return getWindowsInstanceSocketPathCandidates(root)[0];
     const filesystemPath = path.join(root, 'data', 'instance', INSTANCE_SOCKET_FILENAME);
     // Linux/macOS Unix-domain sockets have a small sockaddr path limit
     // (typically 108 bytes on Linux). Long managed TMPDIR prefixes can make a
@@ -196,6 +252,7 @@ export function ensureDataDirs() {
     fs.mkdirSync(p.outboxDir, { recursive: true });
     fs.mkdirSync(p.eckDir, { recursive: true });
     fs.mkdirSync(aidsDir(), { recursive: true });
+    migrateLegacyAgentJsonlLogs(p.agentsDir, p.logs);
     migrateFromAun();
 }
 const MIGRATION_MARKER = '.migrated-from-aun';

package/dist/response-system/context-builder.js

@@ -12,7 +12,6 @@
  * （Phase 6）真正需要时接入 Runner，当前提供明确的"未实现"占位，避免空壳代码。
  */
 import path from 'path';
-import fs from 'fs';
 export class ResponseModeContextBuilder {
     /** (sessionId::modeId) → sessionState，跨消息保持 */
     stateCache = new Map();
@@ -22,7 +21,7 @@ export class ResponseModeContextBuilder {
      */
     build(modeId, deps) {
         const sessionState = this.getOrCreateState(deps.session.id, modeId);
-        const dataDir = this.ensureDataDir(deps.agentDir, modeId);
+        const dataDir = path.join(deps.agentDir, 'response-system', modeId);
         return {
             session: deps.session,
             agentConfig: deps.agentConfig,
@@ -63,9 +62,4 @@ export class ResponseModeContextBuilder {
         }
         return state;
     }
-    ensureDataDir(agentDir, modeId) {
-        const dir = path.join(agentDir, 'response-system', modeId);
-        fs.mkdirSync(dir, { recursive: true });
-        return dir;
-    }
 }

package/dist/trigger/anomaly-store.js

@@ -252,6 +252,7 @@ function anomalyClassKey(anomaly) {
         anomaly.phase,
         anomaly.toolName,
         anomaly.policyCode,
+        anomaly.decisionSource,
         anomaly.policy,
         anomaly.agentAid,
         anomaly.sessionId,

package/dist/trigger/feedback.js

@@ -37,8 +37,11 @@ export class TriggerFeedbackDispatcher {
         const result = await this.dispatchDirect(input, renderedText, target);
         if (result.error)
             return { status: 'failed', reason: result.error.code, feedback, effects: result.effects, error: result.error };
+        const replyStatus = statusFromReply(input.reply);
         return {
-            status: statusFromReply(input.reply),
+            status: result.effects.some(effect => effect.status === 'queued') && replyStatus !== 'failed'
+                ? 'degraded'
+                : replyStatus,
             reason: reasonFromReply(input.reply),
             feedback,
             effects: result.effects,
@@ -204,6 +207,7 @@ export class TriggerFeedbackDispatcher {
                     originChannelType: input.trigger.origin?.channelType
                         ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
                     originControl: input.trigger.origin?.channelKey === 'daemon',
+                    authorizedBy: input.trigger.authorizedBy,
                 },
             };
             outcome = this.waitForTriggerOutcome(input.runId, input.attemptId, delivery.signal);
@@ -379,7 +383,7 @@ export class TriggerFeedbackDispatcher {
                     if (isAunTarget && !targetChatType(target)) {
                         throw Object.assign(new Error('AUN trigger feedback requires an explicit delivery route'), { code: 'AUN_OUTBOUND_ROUTE_REQUIRED' });
                     }
-                    await raceWithAbort(binding.adapter.send(buildEnvelope({
+                    const receipt = await raceWithAbort(binding.adapter.send(buildEnvelope({
                         taskId: `trigger:${input.runId}`,
                         channel: binding.adapter.channelKey,
                         channelId: target.channelId,
@@ -394,16 +398,60 @@ export class TriggerFeedbackDispatcher {
                         isFinal: true,
                         format: 'plain',
                     }), cancellation.signal);
-                    effects.push({
+                    const common = {
                         type: 'message.send',
-                        status: 'success',
                         channelKey: target.channelKey,
                         channelType: channelTypeFromKey(target.channelKey),
                         channelId: target.channelId,
                         attempt,
                         startedAt,
                         finishedAt: Date.now(),
-                    });
+                    };
+                    if (receipt?.status === 'sent' && receipt.messageId) {
+                        effects.push({ ...common, status: 'success', operationId: receipt.operationId, messageId: receipt.messageId });
+                        return { effects, error: null };
+                    }
+                    if (receipt?.status === 'queued') {
+                        effects.push({
+                            ...common,
+                            status: 'queued',
+                            operationId: receipt.operationId,
+                            outboxId: receipt.outboxId,
+                            error: receipt.error,
+                            code: receipt.code,
+                        });
+                        return { effects, error: null };
+                    }
+                    if (receipt?.status === 'failed') {
+                        effects.push({
+                            ...common,
+                            status: 'failed',
+                            operationId: receipt.operationId,
+                            outboxId: receipt.outboxId,
+                            error: receipt.error,
+                            code: receipt.code,
+                        });
+                        return {
+                            effects,
+                            error: {
+                                code: String(receipt.code ?? 'send_failed'),
+                                message: receipt.error,
+                            },
+                        };
+                    }
+                    if (receipt?.status === 'suppressed') {
+                        const message = `channel suppressed trigger feedback: ${receipt.reason}`;
+                        effects.push({ ...common, status: 'skipped', error: message, code: 'SEND_SUPPRESSED' });
+                        return { effects, error: { code: 'send_suppressed', message } };
+                    }
+                    if (isAunTarget) {
+                        const message = 'AUN adapter returned no delivery receipt';
+                        effects.push({ ...common, status: 'failed', error: message, code: 'MISSING_SEND_RECEIPT' });
+                        return { effects, error: { code: 'missing_send_receipt', message } };
+                    }
+                    // Non-AUN adapters are still allowed to use the legacy void result
+                    // until their receipt migration is complete.
+                    effects.push({ ...common, status: 'success' });
                     return { effects, error: null };
                 }
                 catch (err) {
@@ -527,6 +575,9 @@ export class TriggerFeedbackDispatcher {
         const status = Number(err?.status ?? err?.statusCode ?? err?.code);
         const rawCode = String(err?.code ?? err?.errorCode ?? '').toLowerCase();
         const lower = `${message} ${rawCode}`.toLowerCase();
+        if (rawCode === 'outbox_full') {
+            return { retryable: false, code: 'OUTBOX_FULL', message };
+        }
         if (status === 408 || status === 429 || status >= 500) {
             return { retryable: true, code: 'send_retryable_error', message };
         }

package/dist/trigger/history.js

@@ -2,7 +2,11 @@ import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { isManagedSessionRuntimeDir, SESSION_RUNTIME_DIR_ENV } from '../cli/task-context.js';
+import { findMessageLogOperationMessageId } from '../core/message/message-log.js';
+import { chatDirPath } from '../core/session/session-fs-store.js';
+import { resolvePaths } from '../paths.js';
 import { definitionRevision } from './validation.js';
+import * as aunOutbox from '../aun/outbox.js';
 export class TriggerHistoryStore {
     rootDir;
     agentAid;
@@ -66,7 +70,7 @@ export class TriggerHistoryStore {
                 continue;
             if (triggerId && event.triggerId !== triggerId)
                 continue;
-            out.push(event);
+            out.push(hydrateHistoryEvent(event));
         }
         return out;
     }
@@ -80,7 +84,7 @@ export class TriggerHistoryStore {
             if (!event || !isRunEvent(event))
                 continue;
             if (event.agentAid === this.agentAid && event.triggerId === triggerId) {
-                out.push(event.audit);
+                out.push(hydrateTriggerAudit(event.audit));
             }
         }
         return out;
@@ -95,7 +99,7 @@ export class TriggerHistoryStore {
             const event = parseHistoryEvent(lines[i], this.agentAid);
             if (!event || !isRunEvent(event) || !pending.has(event.triggerId))
                 continue;
-            latest.set(event.triggerId, event.audit);
+            latest.set(event.triggerId, hydrateTriggerAudit(event.audit));
             pending.delete(event.triggerId);
         }
         return latest;
@@ -125,7 +129,7 @@ export class TriggerHistoryStore {
             }
             if (!isRunEvent(event))
                 continue;
-            const record = event.audit;
+            const record = hydrateTriggerAudit(event.audit);
             if (record.status !== 'completed'
                 && record.status !== 'degraded'
                 && record.status !== 'noop'
@@ -310,6 +314,77 @@ function finiteNumber(value) {
 function nonNegativeInteger(value) {
     return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
 }
+function hydrateHistoryEvent(event) {
+    if (!isRunEvent(event))
+        return event;
+    return { ...event, audit: hydrateTriggerAudit(event.audit) };
+}
+/**
+ * Resolve queued AUN effects against the durable outbox at read time. The
+ * original audit is append-only, so this projection is what lets a later
+ * expiry become visibly failed without pretending that a missing outbox row
+ * was delivered.
+ */
+function hydrateTriggerAudit(audit) {
+    let changed = false;
+    let deliveryFailure;
+    const effects = audit.effects.map(effect => {
+        if (effect.status !== 'queued' || !effect.outboxId)
+            return effect;
+        const state = aunOutbox.deliveryState(audit.agentAid, effect.outboxId);
+        if (state.status === 'sent') {
+            changed = true;
+            return { ...effect, status: 'success', messageId: state.messageId };
+        }
+        if (state.status === 'failed') {
+            changed = true;
+            deliveryFailure ??= { code: String(state.code ?? 'OUTBOX_DELIVERY_FAILED'), message: state.error };
+            return { ...effect, status: 'failed', error: state.error, ...(state.code !== undefined ? { code: state.code } : {}) };
+        }
+        if (state.status === 'missing' && isAunEffect(effect)) {
+            const messageId = findDeliveredEffectMessageId(audit.agentAid, effect);
+            changed = true;
+            if (messageId) {
+                return { ...effect, status: 'success', messageId };
+            }
+            const code = 'OUTBOX_RESULT_MISSING';
+            const error = 'outbox delivery result is missing and no remote message_id was recorded';
+            deliveryFailure ??= { code, message: error };
+            return { ...effect, status: 'failed', error, code };
+        }
+        return effect;
+    });
+    if (!changed)
+        return audit;
+    if (!deliveryFailure) {
+        const hasQueuedEffect = effects.some(effect => effect.status === 'queued');
+        const hasFailedEffect = effects.some(effect => effect.status === 'failed');
+        const canRestoreReplyStatus = audit.status === 'degraded'
+            && !hasQueuedEffect
+            && !hasFailedEffect
+            && !audit.anomalies?.length;
+        const status = canRestoreReplyStatus
+            ? audit.reply?.outcome === 'noop' ? 'noop' : 'completed'
+            : audit.status;
+        return { ...audit, status, effects };
+    }
+    return {
+        ...audit,
+        status: 'failed',
+        reason: deliveryFailure.code,
+        effects,
+        error: deliveryFailure,
+    };
+}
+function isAunEffect(effect) {
+    return effect.channelType === 'aun' || effect.channelKey?.startsWith('aun#') === true;
+}
+function findDeliveredEffectMessageId(agentAid, effect) {
+    if (!effect.operationId || !effect.channelId)
+        return undefined;
+    const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', effect.channelId, agentAid);
+    return findMessageLogOperationMessageId(chatDir, effect.operationId);
+}
 function listAuditLogFiles(logDir) {
     let entries;
     try {

package/dist/trigger/legacy-session-history.js

@@ -1,13 +1,13 @@
-const HISTORY_CHANNELS = new Set(['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom']);
 /**
  * Turns legacy raw session-file references into the controlled history CLI.
  * The replacement deliberately keeps the explicit peer/channel scope but
  * never carries a filesystem location into a Trigger prompt.
  */
 export function rewriteLegacyTriggerSessionPaths(prompt, triggerAid) {
+    const historyChannels = new Set(['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom']);
     const legacyPath = /data\/sessions\/([A-Za-z0-9_-]+)\/([^/\s`"'<>]+)(?:\/([^/\s`"'<>]+))?\/messages\.jsonl/g;
     return prompt.replace(legacyPath, (match, channel, first, second) => {
-        if (!HISTORY_CHANNELS.has(channel))
+        if (!historyChannels.has(channel))
             return match;
         const isAun = channel === 'aun';
         const target = isAun ? second : first;

package/dist/trigger/parser.js

@@ -113,6 +113,7 @@ const PERMISSION_MODES = new Set([
     'auto',
     'request',
     'bypass',
+    'fullaccess',
 ]);
 const TRIGGER_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 function parsePermissionModeFlag(flags, opts = {}) {
@@ -124,10 +125,10 @@ function parsePermissionModeFlag(flags, opts = {}) {
     if (raw === 'inherit') {
         if (opts.allowInherit)
             return { ok: true, value: null };
-        return { ok: false, error: '--permission 创建时只能接受 readonly、auto、request 或 bypass' };
+        return { ok: false, error: '--permission 创建时只能接受 readonly、auto、request、bypass 或 fullaccess' };
     }
     if (!PERMISSION_MODES.has(raw)) {
-        return { ok: false, error: '--permission 只接受 readonly、auto、request 或 bypass' };
+        return { ok: false, error: '--permission 只接受 readonly、auto、request、bypass 或 fullaccess' };
     }
     return { ok: true, value: raw };
 }

package/dist/trigger/validation.js

@@ -13,6 +13,7 @@ const PERMISSION_MODES = new Set([
     'auto',
     'request',
     'bypass',
+    'fullaccess',
 ]);
 export function normalizeTriggerDefinition(input, opts = {}) {
     if (!isObject(input))
@@ -234,6 +235,7 @@ function normalizeV3Phase2(raw, opts) {
         enabled: raw.enabled === undefined ? true : requiredBoolean(raw.enabled, 'enabled'),
         name,
         description: optionalString(raw.description),
+        authorizedBy: optionalString(raw.authorizedBy),
         createdAt,
         updatedAt,
         origin: normalizeOrigin(raw.origin),
@@ -438,6 +440,9 @@ function normalizeExecution(value, _opts) {
         onError: normalizeOnError(raw.onError),
         noopSentinel: optionalString(raw.noopSentinel) ?? DEFAULT_NOOP_SENTINEL,
     };
+    if (execution.type === 'script' && execution.permissionMode === 'fullaccess') {
+        throw new Error('script Trigger already executes as the daemon OS user and cannot declare execution.permissionMode=fullaccess');
+    }
     return execution;
 }
 function normalizeExecutionBaseagent(value) {
@@ -478,7 +483,7 @@ function normalizeTriggerPermissionMode(value) {
     if (mode === 'edit' || mode === 'noask' || mode === 'plan') {
         return normalizePermissionModeContract(mode).mode;
     }
-    throw new Error('execution.permissionMode must be one of readonly, auto, request, bypass');
+    throw new Error('execution.permissionMode must be one of readonly, auto, request, bypass, fullaccess');
 }
 function normalizeScript(value) {
     if (!isObject(value))

package/dist/utils/atomic-write.js

@@ -75,6 +75,33 @@ export function atomicWrite(filePath, content) {
 export function atomicWriteJson(filePath, value) {
     atomicWrite(filePath, JSON.stringify(value, null, 2) + '\n');
 }
+/**
+ * Update a small protected file without replacing its directory entry.
+ *
+ * H-class sandbox mounts bind individual files by pathname. Replacing such a
+ * file with rename(2) changes the inode while bubblewrap is constructing its
+ * mount table and can make the bind/remount operation fail. This helper keeps
+ * the inode stable; callers should use it only for best-effort, daemon-owned
+ * state where a crash during the write may leave incomplete content.
+ */
+export function stableWrite(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+    const fd = fs.openSync(filePath, fs.constants.O_RDWR | fs.constants.O_CREAT | noFollow, 0o600);
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile())
+            throw new Error(`stable write target is not a regular file: ${filePath}`);
+        fs.ftruncateSync(fd, 0);
+        fs.writeFileSync(fd, content, 'utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function stableWriteJson(filePath, value) {
+    stableWrite(filePath, JSON.stringify(value, null, 2) + '\n');
+}
 /**
  * 原子读取——自动按状态恢复。文件不存在时返回 null。
  *

package/dist/utils/ecweb-utils.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { compareVersions, resolveGlobalPkg } from './npm-ops.js';
 import { isWindows as platformIsWindows, resolveCommandPath } from './cross-platform.js';
 import { MIN_ECWEB_VERSION, WEB_CLI_BIN, WEB_PACKAGE_NAME } from '../product.js';
+import { resolvePaths } from '../paths.js';
 /** EC Web owns the session-log reader, so older builds cannot safely serve a newer daemon. */
 export function isEcwebVersionSupported(version) {
     const normalized = version?.trim();
@@ -70,10 +71,23 @@ export function resolveEcwebLaunchCommand(ecwebArgs, opts = {}) {
  * 配对码是 ecweb 进程自己生成并持有的内部状态。daemon/CLI 通过 ecweb 的
  * localhost-only HTTP 接口 GET /api/pair-code 取当前码（远程访问被 ecweb 403 拒绝）。
  */
-/** 经 localhost 拉取 ecweb 当前配对码（仅本机可取）。失败返回 null。 */
-export async function fetchEcwebPairCode(port) {
+/** 经 localhost 拉取 ecweb 当前配对码（仅本机可取）。失败返回 null。
+ * authorizedBy 仅由 daemon 的 AUN 控制通道传入，用于把配对码换出的 token
+ * 绑定到实际批准的 daemon-owner；普通 CLI 取码不携带该字段。 */
+export async function fetchEcwebPairCode(port, authorizedBy) {
     try {
+        const headers = {};
+        const owner = authorizedBy?.trim();
+        if (owner)
+            headers['x-evolcore-pair-authorized-by'] = owner;
+        try {
+            const controlToken = fs.readFileSync(resolvePaths().controlToken, 'utf8').trim();
+            if (controlToken)
+                headers['x-evolcore-control-token'] = controlToken;
+        }
+        catch { }
         const resp = await fetch(`http://127.0.0.1:${port}/api/pair-code`, {
+            headers,
             signal: AbortSignal.timeout(2000),
         });
         if (!resp.ok)

package/dist/utils/error-utils.js

@@ -388,7 +388,10 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
     const warnPrefix = includeEmoji ? '⚠️ ' : '';
     const errPrefix = includeEmoji ? '❌ ' : '';
     if (msg.includes('CONTEXT_COMPACT_FAILED') || isContextTooLongText(msg)) {
-        return `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
+        const detail = msg.match(/^CONTEXT_COMPACT_FAILED:\s*(.+)$/)?.[1]?.trim();
+        return detail
+            ? `${warnPrefix}上下文过长，自动压缩失败：${detail}`
+            : `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
     }
     if (isSandboxInitializationFailure(error)) {
         return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;

package/dist/utils/logger.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import { resolvePaths } from '../paths.js';
 import { LogWriter } from './log-writer.js';
 import { classifyToolErrorCode } from '../core/permission/tool-error-code.js';
+import { normalizePermissionMode } from '../core/permission/mode.js';
 import { buildToolLifecycleEventKey } from '../core/audit/event-key.js';
 let currentLevel = process.env.LOG_LEVEL || 'INFO';
 const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
@@ -70,8 +71,25 @@ export function normalizeStructuredLog(data) {
         ?? nested?.toolUseId
         ?? nested?.tool_use_id;
     const sessionId = data.sessionId ?? data.session_id ?? nested?.sessionId ?? nested?.session_id;
-    const agentAid = data.agentAid ?? data.agent_aid ?? data.selfAid ?? nested?.agentAid ?? nested?.agent_aid;
-    const permissionMode = data.permissionMode ?? data.permission_mode ?? nested?.permissionMode ?? nested?.permission_mode;
+    const agentAid = data.agentAid ?? data.agent_aid ?? data.selfAid ?? nested?.agentAid ?? nested?.agent_aid ?? nested?.selfAid;
+    const rawAgentName = data.agentName ?? data.agent_name ?? nested?.agentName ?? nested?.agent_name;
+    // Lifecycle streams should carry both the stable AID and a display label.
+    // When a producer only knows the AID, use that same value as the label so
+    // daily joins never invent a second identity for one session.
+    const normalizedAgentName = typeof rawAgentName === 'string' ? rawAgentName.trim() : '';
+    const agentName = normalizedAgentName
+        && !['unknown', '<unknown>', '<none>', 'undefined', 'null'].includes(normalizedAgentName)
+        ? normalizedAgentName
+        : typeof agentAid === 'string' && agentAid !== 'unknown'
+            ? agentAid
+            : undefined;
+    const rawPermissionMode = data.permissionMode ?? data.permission_mode ?? nested?.permissionMode ?? nested?.permission_mode;
+    // Normalize legacy values at the log boundary. Preserve an explicit
+    // `unknown` marker for records that genuinely arrived without context.
+    const permissionMode = typeof rawPermissionMode === 'string'
+        && rawPermissionMode !== 'unknown'
+        ? normalizePermissionMode(rawPermissionMode).mode
+        : rawPermissionMode;
     const toolName = data.toolName ?? data.tool ?? data.name ?? nested?.toolName ?? nested?.name;
     const isToolResult = eventType === 'tool:result' || eventType === 'tool_result';
     const isToolUse = eventType === 'tool:use' || eventType === 'tool_use';
@@ -116,6 +134,7 @@ export function normalizeStructuredLog(data) {
         ...(correlationId ? { correlationId } : {}),
         ...(sessionId ? { sessionId } : lifecycleRecord ? { sessionId: 'unknown' } : {}),
         ...(agentAid ? { agentAid } : lifecycleRecord ? { agentAid: 'unknown' } : {}),
+        ...(agentName ? { agentName } : lifecycleRecord ? { agentName: 'unknown' } : {}),
         ...(permissionMode ? { permissionMode } : lifecycleRecord ? { permissionMode: 'unknown' } : {}),
         ...(toolName ? { toolName } : {}),
         ...(decision ? { decision } : {}),

package/dist/utils/process-tree-stats.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import { spawnSync } from 'child_process';
+import { parseCimDate } from './process-introspect.js';
 function runnerKind(name) {
     const normalized = name.toLowerCase();
     if (normalized.includes('codex'))
@@ -164,7 +165,7 @@ function readUnixPsMetrics() {
 function readWindowsMetrics() {
     const command = [
         'Get-CimInstance Win32_Process',
-        'Select-Object ProcessId,ParentProcessId,Name,WorkingSetSize,KernelModeTime,UserModeTime,CreationDate',
+        "Select-Object ProcessId,ParentProcessId,Name,WorkingSetSize,KernelModeTime,UserModeTime,@{Name='CreationDate';Expression={if ($_.CreationDate) {$_.CreationDate.ToUniversalTime().ToString('o')}}}",
         'ConvertTo-Json -Compress',
     ].join(' | ');
     const result = spawnSync('powershell', ['-NoProfile', '-Command', command], {
@@ -184,13 +185,32 @@ function readWindowsMetrics() {
             name: String(row.Name || 'unknown'),
             rss: Number(row.WorkingSetSize) || 0,
             cumulativeCpuMs: ((Number(row.KernelModeTime) || 0) + (Number(row.UserModeTime) || 0)) / 10_000,
-            startId: row.CreationDate ? String(row.CreationDate) : undefined,
+            // Keep a comparable numeric start time when PowerShell serializes CIM
+            // DateTime as either CIM text or an ISO date. The raw value remains as
+            // a fallback so PID reuse protection in ProcessTreeSampler still works
+            // when a platform returns an unfamiliar representation.
+            startId: parseWindowsCreationDate(row.CreationDate),
         })).filter((row) => row.pid > 0);
     }
     catch {
         return [];
     }
 }
+export function parseWindowsCreationDate(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const raw = String(value).trim();
+    if (!raw)
+        return undefined;
+    const cim = parseCimDate(raw);
+    if (cim !== null)
+        return cim;
+    const serializedDate = raw.match(/^\/Date\((-?\d+)(?:[+-]\d{4})?\)\/$/);
+    if (serializedDate)
+        return Number(serializedDate[1]);
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : raw;
+}
 export function readProcessMetrics() {
     if (process.platform === 'linux')
         return readLinuxMetrics();
@@ -209,9 +229,9 @@ export class ProcessTreeSampler {
         this.readMetrics = readMetrics;
         this.now = now;
     }
-    sample(associatedRootPids = []) {
+    sample(associatedRootPids = [], metricsOverride) {
         const timestamp = this.now();
-        const metrics = this.readMetrics();
+        const metrics = metricsOverride ?? this.readMetrics();
         const byPid = new Map(metrics.map(metric => [metric.pid, metric]));
         const children = new Map();
         for (const metric of metrics) {

package/dist/utils/process-tree-worker.js

@@ -0,0 +1,31 @@
+import { parentPort } from 'node:worker_threads';
+import { performance } from 'node:perf_hooks';
+import { readProcessMetrics } from './process-tree-stats.js';
+const port = parentPort;
+if (!port)
+    throw new Error('process-tree worker requires a parent port');
+port.on('message', (message) => {
+    if (message?.type !== 'sample')
+        return;
+    const startedAt = performance.now();
+    try {
+        const metrics = readProcessMetrics();
+        if (metrics.length === 0)
+            throw new Error('process enumeration returned no metrics');
+        const response = {
+            type: 'sample',
+            requestId: message.requestId,
+            metrics,
+            durationMs: Math.round((performance.now() - startedAt) * 10) / 10,
+        };
+        port.postMessage(response);
+    }
+    catch (error) {
+        port.postMessage({
+            type: 'sample-error',
+            requestId: message.requestId,
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: Math.round((performance.now() - startedAt) * 10) / 10,
+        });
+    }
+});