evolcore 0.0.20 → 0.0.21

package/dist/config-store.js

@@ -23,15 +23,42 @@ import { checkAgentDir, isValidAid } from './aun/aid/validation.js';
 import { normalizeAidDomain } from './aun/aid/domain.js';
 import { isValidChannelName } from './core/channel-loader.js';
 import { CONFIG_SCHEMA_VERSION } from './types.js';
-import { ConfigTarget, assertNoLegacyAunGatewayConfig, read as cfgRead, stripLegacyAunGatewayConfig, write as cfgWrite, } from './config/config-manager.js';
+import { ConfigTarget, assertNoLegacyAunGatewayConfig, read as cfgRead, normalizeProcessConfigCompat, stripLegacyAunGatewayConfig, write as cfgWrite, } from './config/config-manager.js';
 import { expandVars, buildEnvResolver } from './config/merge.js';
 import { isAgentLifecycle } from './config/lifecycle.js';
 import { logger } from './utils/logger.js';
 import { parseStableSemver } from './utils/stable-semver.js';
+import { isSupportedBaseagent } from './agents/baseagent.js';
+import { normalizeDaemonServices } from './config/daemon-services.js';
+import { currentVersion } from './config/schema-registry.js';
+const SERVICE_METADATA_SENSITIVE_KEY = /(?:^|[_-])(endpoint|url|uri|token|access[_-]?token|authorization|cookie|secret|password|private[_-]?key|key|cert|certificate)(?:$|[_-])/i;
+function assertLocalServiceEndpoint(value, fieldPath) {
+    if (typeof value !== 'string' || value.trim() === '' || value.length > 2048) {
+        throw new Error(`${fieldPath} must be a URL string`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(value.trim());
+    }
+    catch {
+        throw new Error(`${fieldPath} must be a valid URL`);
+    }
+    if (!['http:', 'https:', 'ws:', 'wss:'].includes(parsed.protocol)) {
+        throw new Error(`${fieldPath} must use http, https, ws, or wss`);
+    }
+    const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (host !== 'localhost' && !/^127(?:\.\d{1,3}){3}$/.test(host)) {
+        throw new Error(`${fieldPath} must point to localhost or 127.0.0.0/8`);
+    }
+}
 /** 读 {root}/daemon.json。文件不存在返回 {}，不报错。 */
 export function loadDaemonConfig() {
     const raw = atomicReadJson(resolvePaths().daemonConfig);
-    return validateDaemonConfig(stripLegacyAunGatewayConfig(raw ?? {}, resolvePaths().daemonConfig, message => logger.warn(message)), false);
+    const sanitized = stripLegacyAunGatewayConfig(raw ?? {}, resolvePaths().daemonConfig, message => logger.warn(message));
+    return validateDaemonConfig(normalizeProcessConfigCompat(normalizeDaemonServices(sanitized)), false);
+}
+export function isFullAccessEnabled(config = loadDaemonConfig()) {
+    return config.fullaccess?.enabled === true;
 }
 let eckSnapshotsConfigCache;
 /** Parse the process-level snapshot gate once for the current daemon lifecycle. */
@@ -60,9 +87,22 @@ export function saveDaemonConfig(value) {
     // daemon.json updates fail because of a persisted, unused legacy value.
     const validateAidDomain = current === null
         || current.aun?.defaultAidDomain !== value.aun?.defaultAidDomain;
-    atomicWriteJson(configPath, validateDaemonConfig(stripLegacyAunGatewayConfig(value, configPath, message => logger.warn(message)), validateAidDomain));
+    const normalized = normalizeProcessConfigCompat(normalizeDaemonServices(stripLegacyAunGatewayConfig(value, configPath, message => logger.warn(message))));
+    atomicWriteJson(configPath, validateDaemonConfig({ ...normalized, $schema_version: currentVersion('daemon') }, validateAidDomain));
 }
 function validateDaemonConfig(value, validateAidDomain) {
+    if (value.fullaccess !== undefined) {
+        if (!value.fullaccess || typeof value.fullaccess !== 'object' || Array.isArray(value.fullaccess)) {
+            throw new Error('daemon.json.fullaccess must be an object');
+        }
+        const unknownFullAccessFields = Object.keys(value.fullaccess).filter(key => key !== 'enabled');
+        if (unknownFullAccessFields.length > 0) {
+            throw new Error(`daemon.json.fullaccess contains unsupported fields: ${unknownFullAccessFields.join(', ')}`);
+        }
+        if (value.fullaccess.enabled !== undefined && typeof value.fullaccess.enabled !== 'boolean') {
+            throw new Error('daemon.json.fullaccess.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');
@@ -75,6 +115,80 @@ function validateDaemonConfig(value, validateAidDomain) {
     if (defaultEncrypt !== undefined && typeof defaultEncrypt !== 'boolean') {
         throw new Error('daemon.json.aun.defaultEncrypt must be a boolean');
     }
+    if (value.services !== undefined && !Array.isArray(value.services)) {
+        throw new Error('daemon.json.services must be an array');
+    }
+    const serviceNames = new Set();
+    for (const [index, rawService] of (value.services ?? []).entries()) {
+        if (!rawService || typeof rawService !== 'object' || Array.isArray(rawService)) {
+            throw new Error(`daemon.json.services[${index}] must be an object`);
+        }
+        const service = rawService;
+        const unknownServiceFields = Object.keys(service).filter((key) => !['name', 'enabled', 'port', 'proxy'].includes(key));
+        if (unknownServiceFields.length > 0) {
+            throw new Error(`daemon.json.services[${index}] contains unsupported fields: ${unknownServiceFields.join(', ')}`);
+        }
+        if (typeof service.name !== 'string' || !/^[a-z0-9_-]+$/.test(service.name)) {
+            throw new Error(`daemon.json.services[${index}].name must match [a-z0-9_-]+`);
+        }
+        if (serviceNames.has(service.name)) {
+            throw new Error(`daemon.json.services contains duplicate name: ${service.name}`);
+        }
+        serviceNames.add(service.name);
+        if (typeof service.enabled !== 'boolean') {
+            throw new Error(`daemon.json.services[${service.name}].enabled must be a boolean`);
+        }
+        if (service.port !== undefined && (!Number.isInteger(service.port) || service.port < 1 || service.port > 65535)) {
+            throw new Error(`daemon.json.services[${service.name}].port must be an integer from 1 to 65535`);
+        }
+        if (service.proxy !== undefined) {
+            if (!service.proxy || typeof service.proxy !== 'object' || Array.isArray(service.proxy)) {
+                throw new Error(`daemon.json.services[${service.name}].proxy must be an object`);
+            }
+            const unknownProxyFields = Object.keys(service.proxy).filter((key) => !['enabled', 'source', 'endpoint', 'serviceType', 'visibility', 'metadata'].includes(key));
+            if (unknownProxyFields.length > 0) {
+                throw new Error(`daemon.json.services[${service.name}].proxy contains unsupported fields: ${unknownProxyFields.join(', ')}`);
+            }
+            if (service.proxy.enabled !== undefined && typeof service.proxy.enabled !== 'boolean') {
+                throw new Error(`daemon.json.services[${service.name}].proxy.enabled must be a boolean`);
+            }
+            if (service.proxy.source !== undefined && !['instance', 'static'].includes(service.proxy.source)) {
+                throw new Error(`daemon.json.services[${service.name}].proxy.source must be "instance" or "static"`);
+            }
+            if (service.proxy.endpoint !== undefined) {
+                assertLocalServiceEndpoint(service.proxy.endpoint, `daemon.json.services[${service.name}].proxy.endpoint`);
+            }
+            if (service.proxy.serviceType !== undefined && !['http', 'websocket', 'ssh'].includes(service.proxy.serviceType)) {
+                throw new Error(`daemon.json.services[${service.name}].proxy.serviceType must be http, websocket, or ssh`);
+            }
+            if (service.proxy.visibility !== undefined
+                && !['public', 'private', 'aun-auth'].includes(service.proxy.visibility)) {
+                throw new Error(`daemon.json.services[${service.name}].proxy.visibility must be public, private, or aun-auth`);
+            }
+            if (service.proxy.metadata !== undefined) {
+                if (!service.proxy.metadata || typeof service.proxy.metadata !== 'object' || Array.isArray(service.proxy.metadata)) {
+                    throw new Error(`daemon.json.services[${service.name}].proxy.metadata must be an object`);
+                }
+                for (const [key, metadataValue] of Object.entries(service.proxy.metadata)) {
+                    if (!key || key.length > 256 || SERVICE_METADATA_SENSITIVE_KEY.test(key)
+                        || typeof metadataValue !== 'string' || metadataValue.length > 8192) {
+                        throw new Error(`daemon.json.services[${service.name}].proxy.metadata must contain string key-value pairs`);
+                    }
+                }
+            }
+            if (service.proxy.enabled === true) {
+                if (!['instance', 'static'].includes(service.proxy.source ?? '')) {
+                    throw new Error(`daemon.json.services[${service.name}].proxy.source must be "instance" or "static"`);
+                }
+                if (service.proxy.source === 'static' && !service.proxy.endpoint) {
+                    throw new Error(`daemon.json.services[${service.name}].proxy.endpoint is required when source is "static"`);
+                }
+                if (!['public', 'private', 'aun-auth'].includes(service.proxy.visibility ?? '')) {
+                    throw new Error(`daemon.json.services[${service.name}].proxy.visibility must be public, private, or aun-auth`);
+                }
+            }
+        }
+    }
     if (validateAidDomain && value.aun?.defaultAidDomain !== undefined) {
         const defaultAidDomain = normalizeAidDomain(value.aun.defaultAidDomain, 'daemon.json.aun.defaultAidDomain');
         return { ...value, aun: { ...value.aun, defaultAidDomain } };
@@ -176,13 +290,31 @@ function deepMergeObject(base, overlay) {
 function isPlainObject(v) {
     return v !== null && typeof v === 'object' && !Array.isArray(v);
 }
-// ── 自动迁移（已删除）─────────────────────────────────────────────────
-//
-// 旧 data/daemon.json / agents/<name>.json → 新结构的一次性迁移已随配置体系 v2 退场
-// （fresh init，不做兼容过渡，见 docs/config-system-design-v2.md §七）。
-// 保留空壳仅为调用点签名兼容——startup 不再调用。
 export function autoMigrateIfNeeded() {
-    /* no-op: legacy migration removed (config-system v2 fresh init) */
+    const file = resolvePaths().daemonConfig;
+    const raw = atomicReadJson(file);
+    if (!raw)
+        return;
+    const needsLegacyMigration = raw.ecweb !== undefined || raw.serviceProxy !== undefined;
+    const daemonSchemaVersion = currentVersion('daemon');
+    const needsVersionBump = typeof raw.$schema_version !== 'number' || raw.$schema_version < daemonSchemaVersion;
+    // Never rewrite a configuration produced by a newer daemon.  In particular,
+    // a future file may still carry compatibility fields; normalizing those
+    // fields and then calling saveDaemonConfig would otherwise force its schema
+    // version back to the current one and potentially discard future fields.
+    if (typeof raw.$schema_version === 'number' && raw.$schema_version > daemonSchemaVersion) {
+        if (needsLegacyMigration) {
+            logger.warn(`[migrate] daemon.json schema version ${raw.$schema_version} is newer than supported ${daemonSchemaVersion}; skip legacy service migration`);
+        }
+        return;
+    }
+    if (!needsLegacyMigration && !needsVersionBump)
+        return;
+    const sanitized = stripLegacyAunGatewayConfig(raw, file, message => logger.warn(message));
+    saveDaemonConfig(normalizeDaemonServices(sanitized));
+    logger.info(needsLegacyMigration
+        ? '[migrate] daemon.json ecweb/serviceProxy -> services[]'
+        : `[migrate] daemon.json schema version -> ${daemonSchemaVersion}`);
 }
 /**
  * @deprecated Use ConfigManager.read(ConfigTarget.Agent, { self: aid }, { expand: true, cache: true }) instead.
@@ -304,6 +436,16 @@ export function validateAgentConfig(cfg) {
     const errs = [];
     if (!cfg.aid || !isValidAid(cfg.aid))
         errs.push(`invalid aid: ${cfg.aid}`);
+    if (cfg.active_baseagent !== undefined && !isSupportedBaseagent(cfg.active_baseagent)) {
+        errs.push(`unsupported active_baseagent: ${cfg.active_baseagent} (choose claude/codex/gemini/ecagent)`);
+    }
+    if (cfg.baseagents && typeof cfg.baseagents === 'object') {
+        for (const name of Object.keys(cfg.baseagents)) {
+            if (!isSupportedBaseagent(name)) {
+                errs.push(`unsupported baseagent config: ${name} (choose claude/codex/gemini/ecagent)`);
+            }
+        }
+    }
     if (cfg.lifecycle !== undefined && !isAgentLifecycle(cfg.lifecycle)) {
         errs.push(`invalid lifecycle: ${String(cfg.lifecycle)}`);
     }

package/dist/core/agent-application-service.js

@@ -0,0 +1,279 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { agentMdPath, resolvePaths, } from '../paths.js';
+import { loadAgent, saveAgent, } from '../config-store.js';
+import { ConfigTarget, ensureFile as cfgEnsure, initConfigManager, read as cfgRead, write as cfgWrite, } from '../config/config-manager.js';
+import { executeResolvedConfigCommand, } from '../config/config-operation-service.js';
+import { resolveConfigCommand } from '../config/resolved-config-op.js';
+import { AgentReloadBusyError } from './agent-reload-coordinator.js';
+import { logger } from '../utils/logger.js';
+function toPosix(value) {
+    if (!value)
+        return null;
+    return value.replace(/\\/g, '/');
+}
+function readAgentMdIdentity(aid) {
+    try {
+        const content = fs.readFileSync(agentMdPath(aid), 'utf8');
+        const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+        if (!frontmatter)
+            return { name: null, description: null };
+        const value = (key) => {
+            const match = frontmatter.match(new RegExp(`^${key}:\\s*["']?(.+?)["']?\\s*$`, 'm'));
+            return match?.[1]?.trim() || null;
+        };
+        return { name: value('name'), description: value('description') };
+    }
+    catch {
+        return { name: null, description: null };
+    }
+}
+function errorFrom(error, fallback = 'agent operation failed') {
+    const message = error instanceof Error ? error.message : String(error || fallback);
+    const code = error instanceof AgentReloadBusyError
+        ? error.code
+        : (error?.code || undefined);
+    const busyCount = error instanceof AgentReloadBusyError ? error.busyCount : undefined;
+    return {
+        ok: false,
+        error: message,
+        ...(code ? { code } : {}),
+        ...(busyCount === undefined ? {} : { busyCount }),
+    };
+}
+/**
+ * Core-owned agent application facade. It contains no role resolution: callers
+ * must authorize the operation before invoking it. External CLI callers use
+ * the IPC adapter and therefore do not instantiate this class.
+ */
+export class AgentApplicationService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    list() {
+        return this.deps.registry.list();
+    }
+    /** Raw registry projection used by the evolagent.show IPC adapter. */
+    info(aid) {
+        // Keep the same race guard as the legacy IPC adapter: a list entry is not
+        // enough to claim that the live runtime handle still exists.
+        if (!this.deps.registry.get(aid))
+            return null;
+        return this.deps.registry.list().find(agent => agent.aid === aid) ?? null;
+    }
+    async show(aid) {
+        const info = this.info(aid);
+        const agent = this.deps.registry.get(aid);
+        if (!info || !agent)
+            return { ok: false, error: `Agent "${aid}" not found`, code: 'NOT_FOUND' };
+        const aidState = (this.deps.aunAids?.() ?? []).find(state => (state.aid === aid || state.agentName === aid));
+        const stats = (this.deps.aunAidStats?.() ?? []).find(snapshot => snapshot.aid === aid);
+        const connection = aidState
+            ? {
+                status: aidState.status || 'unknown',
+                uptime_ms: (aidState.status === 'connected' && aidState.lastConnectedAt)
+                    ? Date.now() - aidState.lastConnectedAt
+                    : null,
+                reconnect_count: aidState.reconnectCount ?? 0,
+                messages_received: stats?.messagesReceived ?? 0,
+                messages_sent: stats?.messagesSent ?? 0,
+                bytes_received: stats?.bytesReceived ?? 0,
+                bytes_sent: stats?.bytesSent ?? 0,
+                last_received_at: stats?.lastReceivedAt ? new Date(stats.lastReceivedAt).toISOString() : null,
+                last_sent_at: stats?.lastSentAt ? new Date(stats.lastSentAt).toISOString() : null,
+                unique_peer_count: stats?.uniquePeerCount ?? 0,
+            }
+            : null;
+        const config = agent.config;
+        const identity = readAgentMdIdentity(aid);
+        const paths = resolvePaths();
+        return {
+            ok: true,
+            aid,
+            status: info.status || 'stopped',
+            identity,
+            config: {
+                baseagent: info.baseagent || null,
+                model: info.model || null,
+                effort: info.effort || null,
+                chatmode: config?.chatmode ?? null,
+                channels: info.channels ?? [],
+            },
+            connection,
+            sessions: {
+                active: info.activeSessions ?? 0,
+                last_activity: info.lastActivity ? new Date(info.lastActivity).toISOString() : null,
+            },
+            paths: {
+                config: toPosix(path.join(paths.agentsDir, aid, 'config.json')),
+                agent_md: toPosix(agentMdPath(aid)),
+                project: toPosix(info.projectPath || null),
+                data: toPosix(path.join(paths.agentsDir, aid, 'data')),
+            },
+        };
+    }
+    async create(options) {
+        return await this.deps.create(options);
+    }
+    async load(aid) {
+        try {
+            await this.deps.hotLoad(aid);
+            return { ok: true, aid };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    async reload(aid, options = {}) {
+        try {
+            if (!aid) {
+                if (options.force) {
+                    return { ok: false, code: 'INVALID_ARGS', error: '--force requires a target Agent AID' };
+                }
+                return { ok: true, results: await this.deps.resync() };
+            }
+            await this.deps.reload(aid, options);
+            return { ok: true };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    async resync() {
+        try {
+            return { ok: true, results: await this.deps.resync() };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    async start(aid) {
+        try {
+            if (!this.deps.registry.startAgent)
+                return { ok: false, error: 'startAgent unavailable', code: 'NOT_CONFIGURED' };
+            await this.deps.registry.startAgent(aid, this.deps.hooks);
+            return { ok: true, aid };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    async stop(aid) {
+        try {
+            if (!this.deps.registry.stopAgent)
+                return { ok: false, error: 'stopAgent unavailable', code: 'NOT_CONFIGURED' };
+            await this.deps.registry.stopAgent(aid, this.deps.hooks);
+            return { ok: true, aid };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    async setConfig(aid, key, rawValue) {
+        try {
+            initConfigManager();
+            const resolved = resolveConfigCommand(['config', 'set', key, rawValue, '--self', aid]);
+            if (!resolved.ok)
+                return { ok: false, code: resolved.code, error: resolved.reason };
+            const result = executeResolvedConfigCommand(resolved.command);
+            if (!result.ok)
+                return { ok: false, code: result.code, error: result.error };
+            if (result.subcommand !== 'set') {
+                return { ok: false, code: 'UNEXPECTED_RESULT', error: 'config set returned an unexpected result' };
+            }
+            const reloadResult = await this.reload(aid);
+            return {
+                ok: true,
+                aid,
+                key,
+                value: result.value,
+                reloaded: reloadResult.ok,
+            };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    async enable(aid, force = false) {
+        return await this.setEnabled(aid, true, force);
+    }
+    async disable(aid, force = false) {
+        return await this.setEnabled(aid, false, force);
+    }
+    async setEnabled(aid, enabled, force) {
+        let config;
+        try {
+            config = loadAgent(aid);
+        }
+        catch (error) {
+            return errorFrom(error, 'failed to read agent config');
+        }
+        if (!config)
+            return { ok: false, error: `Agent "${aid}" not found`, code: 'NOT_FOUND' };
+        const previousEnabled = config.enabled;
+        try {
+            config.enabled = enabled;
+            saveAgent(config);
+        }
+        catch (error) {
+            return errorFrom(error, 'failed to save agent config');
+        }
+        const result = await this.reload(aid, { force });
+        if (!result.ok && result.code === 'AGENT_BUSY') {
+            if (previousEnabled === undefined)
+                delete config.enabled;
+            else
+                config.enabled = previousEnabled;
+            try {
+                saveAgent(config);
+            }
+            catch (error) {
+                logger.error(`[agent-service] failed to roll back ${aid} enabled state: ${error instanceof Error ? error.message : String(error)}`);
+                return errorFrom(error, 'failed to roll back agent config');
+            }
+            return result;
+        }
+        // Keep the historical CLI contract: a persisted toggle succeeds even when
+        // the daemon is unavailable or a best-effort hot reload fails.
+        return { ok: true, aid, enabled, reloaded: result.ok };
+    }
+    async delete(aid, purge = false) {
+        const paths = resolvePaths();
+        const agentDir = path.join(paths.agentsDir, aid);
+        const configPath = path.join(agentDir, 'config.json');
+        if (!fs.existsSync(configPath))
+            return { ok: false, error: `Agent "${aid}" not found`, code: 'NOT_FOUND' };
+        try {
+            if (purge) {
+                fs.rmSync(agentDir, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(configPath);
+                const { removeCreateStatus } = await import('./message/create-status.js');
+                removeCreateStatus(agentDir);
+            }
+            let stopped = false;
+            try {
+                const result = await this.resync();
+                if (result.ok)
+                    stopped = result.results.some(item => item.includes(aid));
+            }
+            catch (error) {
+                logger.warn(`[agent-service] resync after delete ${aid} failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return { ok: true, aid, purged: purge, stopped };
+        }
+        catch (error) {
+            return errorFrom(error);
+        }
+    }
+    /** Raw config read/write helpers reserved for Core-owned command handlers. */
+    readConfig(aid) {
+        return cfgRead(ConfigTarget.Agent, { self: aid });
+    }
+    writeConfig(aid, config) {
+        cfgEnsure(ConfigTarget.Agent, { self: aid });
+        cfgWrite(ConfigTarget.Agent, config, { self: aid });
+    }
+}

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

@@ -5,6 +5,7 @@ import path from 'node:path';
 // 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$/;
+const LEGACY_JSONL_FILE = /\.jsonl$/i;
 /** Validate and de-duplicate structured event streams by lifecycle identity. */
 export function inspectStructuredLogs(logDir, options = {}) {
     const issues = [];
@@ -157,3 +158,104 @@ function canonicalEventType(value) {
 function hasContextValue(value) {
     return value !== undefined && value !== null && value !== '' && value !== 'unknown';
 }
+function nonEmptyLogLines(content) {
+    return content.split(/\r?\n/).filter(line => line.length > 0);
+}
+/** Move legacy agents/<aid>/logs/*.jsonl into the deployment-level logs directory. */
+export function migrateLegacyAgentJsonlLogs(agentsDir, logsDir) {
+    const result = {
+        filesRemoved: 0, linesMerged: 0, duplicateLinesSkipped: 0, directoriesRemoved: 0,
+    };
+    const sourcesByName = new Map();
+    let agents;
+    try {
+        agents = fs.readdirSync(agentsDir, { withFileTypes: true });
+    }
+    catch {
+        return result;
+    }
+    for (const agent of agents) {
+        if (!agent.isDirectory())
+            continue;
+        const logDir = path.join(agentsDir, agent.name, 'logs');
+        let entries;
+        try {
+            entries = fs.readdirSync(logDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !LEGACY_JSONL_FILE.test(entry.name))
+                continue;
+            const sources = sourcesByName.get(entry.name) ?? [];
+            sources.push({ filePath: path.join(logDir, entry.name), logDir });
+            sourcesByName.set(entry.name, sources);
+        }
+    }
+    for (const [fileName, sources] of sourcesByName) {
+        const targetPath = path.join(logsDir, fileName);
+        let targetContent = '';
+        try {
+            if (fs.existsSync(targetPath))
+                targetContent = fs.readFileSync(targetPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const targetLineCounts = new Map();
+        for (const line of nonEmptyLogLines(targetContent))
+            targetLineCounts.set(line, (targetLineCounts.get(line) ?? 0) + 1);
+        const readableSources = [];
+        const missingLines = [];
+        for (const source of sources) {
+            let sourceLines;
+            try {
+                sourceLines = nonEmptyLogLines(fs.readFileSync(source.filePath, 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            readableSources.push(source);
+            const sourceLineCounts = new Map();
+            for (const line of sourceLines)
+                sourceLineCounts.set(line, (sourceLineCounts.get(line) ?? 0) + 1);
+            for (const [line, count] of sourceLineCounts) {
+                const alreadyPresent = targetLineCounts.get(line) ?? 0;
+                const missing = Math.max(0, count - alreadyPresent);
+                for (let index = 0; index < missing; index += 1)
+                    missingLines.push(line);
+                if (missing > 0)
+                    targetLineCounts.set(line, count);
+                result.duplicateLinesSkipped += count - missing;
+            }
+        }
+        try {
+            if (missingLines.length > 0) {
+                fs.mkdirSync(logsDir, { recursive: true });
+                const separator = targetContent.length > 0 && !targetContent.endsWith('\n') ? '\n' : '';
+                fs.appendFileSync(targetPath, `${separator}${missingLines.join('\n')}\n`, 'utf8');
+                result.linesMerged += missingLines.length;
+            }
+        }
+        catch {
+            continue;
+        }
+        for (const source of readableSources) {
+            try {
+                fs.unlinkSync(source.filePath);
+                result.filesRemoved += 1;
+            }
+            catch { }
+        }
+    }
+    const legacyDirs = new Set([...sourcesByName.values()].flat().map(source => source.logDir));
+    for (const logDir of legacyDirs) {
+        try {
+            fs.rmdirSync(logDir);
+            result.directoriesRemoved += 1;
+        }
+        catch { }
+    }
+    return result;
+}

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

@@ -8,6 +8,9 @@ export class AgentDelegationRegistry {
     activeHashBySession = new Map();
     approvedCommands = new Map();
     issue(input) {
+        if (input.executionIdentity && !isValidFullAccessExecutionIdentity(input.executionIdentity)) {
+            throw new Error('invalid fullaccess task execution identity');
+        }
         this.revokeSession(input.sessionId);
         const token = crypto.randomBytes(32).toString('base64url');
         const tokenHash = hashDelegationToken(token);
@@ -134,7 +137,7 @@ export function authorizeDelegatedAunMsgSend(registry, input) {
     if (!validation.ok)
         return validation;
     const grant = validation.grant;
-    if (grant.selfAid !== input.aid) {
+    if (grant.selfAid !== input.aid && !hasTrustedFullAccessDelegation(grant)) {
         return { ok: false, code: 'INVALID_DELEGATION', reason: 'Delegation self agent does not match sender' };
     }
     if (grant.messageId && grant.messageId !== input.messageId) {
@@ -157,6 +160,7 @@ export function authorizeDelegatedAunMsgSend(registry, input) {
         conversationId: channelId,
         processOwners: [],
         fromControlChannel: false,
+        ...trustedExecutionIdentityInput(grant),
     });
     const subject = { ...builtSubject, peerKey: grant.peerKey };
     const decision = authorizeOperation({
@@ -180,6 +184,32 @@ export function authorizeDelegatedAunMsgSend(registry, input) {
     }
     return { ok: true, grant };
 }
+/** Build the only AuthGateway input shape accepted for a task-held fullaccess claim. */
+export function trustedExecutionIdentityInput(grant) {
+    return grant.executionIdentity && isValidFullAccessExecutionIdentity(grant.executionIdentity)
+        ? {
+            trustedProcessRole: 'fullaccess-run',
+            trustedFullAccessAuthorization: grant.executionIdentity,
+        }
+        : {};
+}
+export function hasTrustedFullAccessDelegation(grant) {
+    return !!grant.executionIdentity && isValidFullAccessExecutionIdentity(grant.executionIdentity);
+}
+function isValidFullAccessExecutionIdentity(identity) {
+    if (identity.permissionMode !== 'fullaccess'
+        || identity.processRole !== 'fullaccess-run'
+        || identity.dataScope !== 'daemon')
+        return false;
+    if (identity.source === 'fullaccess-command') {
+        return typeof identity.authorizedBy === 'string' && identity.authorizedBy.length > 0;
+    }
+    return identity.source === 'trigger'
+        && typeof identity.authorizedBy === 'string' && identity.authorizedBy.length > 0
+        && typeof identity.triggerId === 'string' && identity.triggerId.length > 0
+        && typeof identity.runId === 'string' && identity.runId.length > 0
+        && typeof identity.attemptId === 'string' && identity.attemptId.length > 0;
+}
 function hashDelegationToken(token) {
     return crypto.createHash('sha256').update(token).digest('hex');
 }