evolcore 0.0.19 → 0.0.21

package/dist/cli/task-context.js

@@ -32,6 +32,11 @@ function normalizeTaskRuntimeContext(value) {
         peerName: optionalString(value.peerName),
         peerType: optionalString(value.peerType),
         peerRole: optionalString(value.peerRole),
+        processRole: optionalProcessRole(value.processRole),
+        dataScope: optionalDataScope(value.dataScope),
+        authorizedBy: optionalString(value.authorizedBy),
+        executionSource: value.executionSource === 'fullaccess-command' || value.executionSource === 'trigger'
+            ? value.executionSource : undefined,
         threadId: optionalString(value.threadId),
         sessionRuntimeDir: optionalAbsolutePath(value.sessionRuntimeDir),
         runtimeLockDir: optionalAbsolutePath(value.runtimeLockDir),
@@ -39,6 +44,13 @@ function normalizeTaskRuntimeContext(value) {
         causation: normalizeCausation(value.causation),
     };
 }
+function optionalProcessRole(value) {
+    return value === 'daemon-owner' || value === 'daemon-service' || value === 'fullaccess-run' || value === 'none'
+        ? value : undefined;
+}
+function optionalDataScope(value) {
+    return value === 'relation' || value === 'agent' || value === 'daemon' ? value : undefined;
+}
 /**
  * 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
@@ -198,6 +210,40 @@ export function isManagedSessionRuntimeDir(directory, managedRoot) {
         return false;
     return isPrivateDirectory(root) && isPrivateDirectory(resolved);
 }
+/**
+ * Resolve the session-owned temporary root for a managed child process.
+ *
+ * A direct runner call without task context is intentionally left alone for
+ * backwards-compatible tests and low-level integrations. Once the daemon has
+ * injected the task-context marker, however, falling back to the daemon's
+ * process-wide TMPDIR would break session isolation. Require the injected
+ * value to be present, identical to TMPDIR, and still owned by a trusted
+ * managed namespace before any runner-side helper writes a file.
+ */
+export function getManagedTaskTempDir(runtimeEnv) {
+    if (typeof runtimeEnv?.[TASK_RUNTIME_CONTEXT_ENV] !== 'string')
+        return undefined;
+    const configured = runtimeEnv[SESSION_RUNTIME_DIR_ENV]?.trim();
+    const inherited = runtimeEnv.TMPDIR?.trim();
+    const context = parseTaskRuntimeContext(runtimeEnv[TASK_RUNTIME_CONTEXT_ENV]);
+    const contextDir = context?.sessionRuntimeDir;
+    const processRoot = process.env.TMPDIR?.trim();
+    const trusted = configured
+        && inherited
+        && path.isAbsolute(configured)
+        && path.isAbsolute(inherited)
+        && path.resolve(configured) === path.resolve(inherited)
+        // The process root is shared by all sessions. It may contain a session
+        // directory, but must never itself become the task's TMPDIR capability.
+        && (!processRoot || !path.isAbsolute(processRoot) || path.resolve(configured) !== path.resolve(processRoot))
+        && contextDir
+        && path.resolve(contextDir) === path.resolve(configured)
+        && (isManagedSessionRuntimeDir(configured) || isRunnerOwnedSessionRuntimeDir(configured));
+    if (!trusted) {
+        throw new Error('managed session TMPDIR is unavailable or untrusted');
+    }
+    return path.resolve(configured);
+}
 /**
  * Create a private runtime directory below the process-provided TMPDIR.
  * There is deliberately no os.tmpdir() fallback: managed sessions must not

package/dist/cli/trigger-command.js

@@ -110,7 +110,7 @@ Create 参数模式支持:
   --baseagent <name>  (仅 --exec trigger-session)
   --model <模型>  --effort <low|medium|high|xhigh|max>
   --max-runs <次数>  --max-duration <时长: 30s|15m|2h|1d>
-  --permission <readonly|auto|request|bypass>（省略则继承当前身份配置）
+  --permission <readonly|auto|request|bypass|fullaccess>（省略则继承当前身份配置；fullaccess 仅 daemon-owner 且 feature flag 开启时可用）
   --tz <时区> (仅 cron)
   --target-channel <channelKey> --target-channel-id <ID>  (AUN 可简写为 aun)
   --target-chat-type <private|group>  (AUN 目标必填；channelId 同时作为群聊 ID)

package/dist/cli/watch-logs.js

@@ -1,15 +1,22 @@
 import path from 'path';
+const WATCH_LOG_FILE = /\.(?:log|jsonl|out)(?:\..+)?$/;
+/** Whether a file is a supported input for the interactive log watcher. */
+export function isWatchLogFile(file) {
+    return WATCH_LOG_FILE.test(path.basename(file));
+}
 /** 去掉轮转后缀（按小时、按日及旧版带连字符日期）。入参可为文件名或绝对路径。 */
 export function shortLogName(file) {
-    return path.basename(file, '.log')
+    const baseName = path.basename(file);
+    const stem = baseName.replace(WATCH_LOG_FILE, '');
+    return stem
         .replace(/-\d{8}(?:-\d{2})?$/, '') // -YYYYMMDD[-HH]（按日/小时轮转）
         .replace(/-\d{4}-\d{2}-\d{2}$/, ''); // -YYYY-MM-DD（按日轮转，如 ts-sdk）
 }
-/** 从 .log 文件名列表推导去重、字母序的类型列表。 */
+/** 从支持的日志文件名列表推导去重、字母序的类型列表。 */
 export function deriveLogTypes(files) {
     const set = new Set();
     for (const f of files) {
-        if (!f.endsWith('.log'))
+        if (!isWatchLogFile(f))
             continue;
         set.add(shortLogName(f));
     }

package/dist/config/builtin-roles.js

@@ -32,6 +32,7 @@ export function getBuiltinRolesConfig() {
 export function getManagementCommandPermissions(role) {
     return {
         'contact.read': { allow: true, scopes: ['agent'] },
+        'contact.add': { allow: true, scopes: ['relation'], constraints: { ownPeerOnly: true, privateOnly: true } },
         'contact.block': { allow: true, scopes: ['agent'], constraints: { requireAgentAdmin: true } },
         'connect.write': { allow: true, scopes: ['agent'], constraints: { requireAgentAdmin: true } },
         'connect.access.write': { allow: true, scopes: ['agent'], constraints: { requireAgentOwner: true } },

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

@@ -17,6 +17,8 @@ const BEHAVIOR_TOP_FIELDS = new Set([
 const BASEAGENT_BEHAVIOR_FIELDS = new Set([
     'model',
     'effort',
+    'auxiliaryModel',
+    'auxiliaryEffort',
     'reasoning',
     'agentProgressSummaries',
     'excludeDynamicSections',
@@ -25,7 +27,7 @@ const BASEAGENT_BEHAVIOR_FIELDS = new Set([
     'mode',
     'useVertex',
 ]);
-const SUPPORTED_BASEAGENTS = new Set(['claude', 'codex', 'gemini', 'ecagent', 'hermes']);
+const SUPPORTED_BASEAGENTS = new Set(['claude', 'codex', 'gemini', 'ecagent']);
 const SENSITIVE_TOP_FIELDS = new Set([
     '$schema_version',
     'aid',
@@ -75,10 +77,17 @@ export function resolveConfigFieldRule(fieldPath) {
         const [, baseagent, leaf] = parts;
         if (!SUPPORTED_BASEAGENTS.has(baseagent))
             return { class: 'unknown' };
-        const permissionKey = `baseagents.${baseagent}.${leaf === 'reasoning' ? 'effort' : leaf}`;
-        if (leaf === 'model' && parts.length === 3)
+        const normalizedLeaf = leaf === 'reasoning'
+            ? 'effort'
+            : leaf === 'auxiliaryModel'
+                ? 'model'
+                : leaf === 'auxiliaryEffort'
+                    ? 'effort'
+                    : leaf;
+        const permissionKey = `baseagents.${baseagent}.${normalizedLeaf}`;
+        if ((leaf === 'model' || leaf === 'auxiliaryModel') && parts.length === 3)
             return scalar(permissionKey, 'string');
-        if ((leaf === 'effort' || leaf === 'reasoning') && parts.length === 3)
+        if ((leaf === 'effort' || leaf === 'reasoning' || leaf === 'auxiliaryEffort') && parts.length === 3)
             return scalar(permissionKey, 'effort');
         if (baseagent === 'claude' && (leaf === 'agentProgressSummaries' || leaf === 'excludeDynamicSections') && parts.length === 3) {
             return scalar(permissionKey, 'boolean');
@@ -199,7 +208,9 @@ export function relationFieldWriteOperation(fieldPath) {
         return 'mentionmode.update';
     if (/^baseagents\.[^.]+\.model$/.test(field))
         return 'model.use';
-    if (/^baseagents\.[^.]+\.(?:effort|reasoning)$/.test(field)) {
+    if (/^baseagents\.[^.]+\.auxiliaryModel$/.test(field))
+        return 'model.use';
+    if (/^baseagents\.[^.]+\.(?:effort|reasoning|auxiliaryEffort)$/.test(field)) {
         return 'model.effort';
     }
     return undefined;

package/dist/config/config-manager.js

@@ -29,6 +29,75 @@ import { clearRoleStoreCache, isRoleName } from './role-store.js';
 import { writeRoleDefinition, writeRoleRegistry } from './role-service.js';
 import { mutateContactBookTransactionSync } from './contact-book-store.js';
 import { DAEMON_SCHEMA_NAME } from '../product.js';
+import { normalizeDaemonServices } from './daemon-services.js';
+// AUN gateway discovery belongs to fastaun. Keep the retired gatewayUrl
+// compatibility handling beside the rest of the configuration read/write
+// policy so all config callers share one implementation.
+const warnedLegacyGatewayFiles = new Set();
+export function legacyAunGatewayConfigPaths(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    const record = value;
+    const paths = [];
+    if (record.aun && typeof record.aun === 'object' && !Array.isArray(record.aun)
+        && Object.prototype.hasOwnProperty.call(record.aun, 'gatewayUrl')) {
+        paths.push('/aun/gatewayUrl');
+    }
+    if (Array.isArray(record.channels)) {
+        record.channels.forEach((channel, index) => {
+            if (channel && typeof channel === 'object'
+                && channel.type === 'aun'
+                && Object.prototype.hasOwnProperty.call(channel, 'gatewayUrl')) {
+                paths.push(`/channels/${index}/gatewayUrl`);
+            }
+        });
+    }
+    return paths;
+}
+export function legacyAunGatewayConfigError(file, paths) {
+    return `${file}: AUN gatewayUrl at ${paths.join(', ')} ${paths.length === 1 ? 'is' : 'are'} no longer supported; `
+        + 'fastaun owns gateway discovery';
+}
+/** Reject newly submitted gateway overrides. Legacy persisted values are handled on read. */
+export function assertNoLegacyAunGatewayConfig(value, file) {
+    const paths = legacyAunGatewayConfigPaths(value);
+    if (paths.length > 0)
+        throw new Error(legacyAunGatewayConfigError(file, paths));
+}
+/** Remove retired AUN gateway overrides without mutating the input. */
+export function stripLegacyAunGatewayConfig(value, file, warn) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const record = value;
+    const next = { ...record };
+    let changed = false;
+    if (record.aun && typeof record.aun === 'object' && !Array.isArray(record.aun)
+        && Object.prototype.hasOwnProperty.call(record.aun, 'gatewayUrl')) {
+        const { gatewayUrl: _legacyGatewayUrl, ...aun } = record.aun;
+        next.aun = aun;
+        changed = true;
+    }
+    if (Array.isArray(record.channels)) {
+        const channels = record.channels.map(channel => {
+            if (!channel || typeof channel !== 'object'
+                || channel.type !== 'aun'
+                || !Object.prototype.hasOwnProperty.call(channel, 'gatewayUrl'))
+                return channel;
+            const { gatewayUrl: _legacyGatewayUrl, ...rest } = channel;
+            changed = true;
+            return rest;
+        });
+        if (changed)
+            next.channels = channels;
+    }
+    if (!changed)
+        return value;
+    if (!warnedLegacyGatewayFiles.has(file)) {
+        warnedLegacyGatewayFiles.add(file);
+        warn(`[config] ${file}: AUN gatewayUrl is no longer supported and will be ignored; fastaun owns gateway discovery`);
+    }
+    return next;
+}
 export function shouldFailFastForMissingOwners(env = process.env) {
     const value = (env.EVOLCORE_REQUIRE_OWNERS || '').trim().toLowerCase();
     return value === '1' || value === 'true' || value === 'yes';
@@ -114,6 +183,7 @@ export function assertRoleConfigV4Ready() {
             issues.push({ file, detail: `invalid JSON: ${error instanceof Error ? error.message : String(error)}` });
             return;
         }
+        value = stripLegacyAunGatewayConfig(value, file, message => configWarn(message));
         const actualVersion = value && typeof value === 'object'
             ? value.$schema_version
             : undefined;
@@ -207,7 +277,10 @@ export function assertRoleConfigV5Ready() {
         if (!fs.existsSync(agentFile))
             continue;
         const agent = readJson(agentFile);
-        const agentVersion = agent?.$schema_version;
+        const sanitizedAgent = agent
+            ? stripLegacyAunGatewayConfig(agent, agentFile, message => configWarn(message))
+            : agent;
+        const agentVersion = sanitizedAgent?.$schema_version;
         let agentSchema = null;
         if (typeof agentVersion === 'number' && agentVersion >= 5) {
             try {
@@ -215,8 +288,8 @@ export function assertRoleConfigV5Ready() {
             }
             catch { }
         }
-        if (!agent || !agentSchema || !agentSchema.validate(agent)) {
-            if (agent)
+        if (!sanitizedAgent || !agentSchema || !agentSchema.validate(sanitizedAgent)) {
+            if (sanitizedAgent)
                 issues.push({
                     file: agentFile,
                     detail: agentSchema
@@ -266,6 +339,7 @@ export function assertContactBookV2Ready() {
             issues.push({ file, detail: `invalid JSON: ${error instanceof Error ? error.message : String(error)}` });
             return;
         }
+        value = stripLegacyAunGatewayConfig(value, file, message => configWarn(message));
         const candidates = Array.isArray(schemas) ? schemas : [schemas];
         if (!candidates.some(schema => schema.validate(value))) {
             const detail = (candidates.at(-1)?.validate.errors ?? [])
@@ -519,13 +593,16 @@ export function read(target, sel, opts = {}) {
     }
     if (raw === null)
         return null;
+    raw = stripLegacyAunGatewayConfig(raw, file, message => configWarn(message));
     // schema 版本迁移（read 时若 $schema_version < current）
     const migrated = migrateIfNeeded(target, raw, file);
-    const normalized = target === ConfigTarget.Agent
-        ? normalizeAgentConfigForRead(migrated, sel?.self)
-        : target === ConfigTarget.Relation
-            ? foldLegacyProactiveBlock(migrated)
-            : migrated;
+    const normalized = target === ConfigTarget.Process
+        ? normalizeProcessConfigCompat(normalizeDaemonServices(migrated))
+        : target === ConfigTarget.Agent
+            ? normalizeAgentConfigForRead(migrated, sel?.self)
+            : target === ConfigTarget.Relation
+                ? foldLegacyProactiveBlock(migrated)
+                : migrated;
     // Agent read compatibility may move the legacy top-level `agents` block to
     // `baseagents`, so canonicalize effort after that structural migration.
     const canonicalized = normalizeBaseagentEffortCompat(normalized);
@@ -606,12 +683,11 @@ function normalizeAgentConfigForWrite(value) {
     if (mutable.aid && !isValidAid(mutable.aid)) {
         throw new ConfigError('VALIDATION_ERROR', `Invalid aid "${mutable.aid}" (must be a valid multi-level domain like mybot.agentid.pub)`);
     }
-    // 规范化 projects 字段：只保留 rootPath 和 defaultPath
+    // 规范化 projects 字段：只保留唯一公开项目路径 defaultPath。
+    // defaults.projects.rootPath 已废弃，不能继续成为有效运行时参数。
     if (mutable.projects && typeof mutable.projects === 'object') {
         const projects = mutable.projects;
         const normalized = {};
-        if (typeof projects.rootPath === 'string')
-            normalized.rootPath = projects.rootPath;
         if (typeof projects.defaultPath === 'string')
             normalized.defaultPath = projects.defaultPath;
         if (Object.keys(normalized).length > 0) {
@@ -624,19 +700,58 @@ function normalizeAgentConfigForWrite(value) {
     return mutable;
 }
 function normalizeProcessConfigForWrite(value) {
-    const configuredAidDomain = value.aun?.defaultAidDomain;
+    let normalized;
+    try {
+        normalized = normalizeProcessConfigCompat(normalizeDaemonServices(value));
+    }
+    catch (error) {
+        throw new ConfigError('DAEMON_SERVICES_MIGRATION_REQUIRED', error instanceof Error ? error.message : String(error));
+    }
+    const configuredAidDomain = normalized.aun?.defaultAidDomain;
     if (configuredAidDomain === undefined)
-        return value;
+        return normalized;
     try {
         return {
-            ...value,
-            aun: { ...value.aun, defaultAidDomain: normalizeAidDomain(configuredAidDomain, 'aun.defaultAidDomain') },
+            ...normalized,
+            aun: { ...normalized.aun, defaultAidDomain: normalizeAidDomain(configuredAidDomain, 'aun.defaultAidDomain') },
         };
     }
     catch (error) {
         throw new ConfigError('VALIDATION_ERROR', error instanceof Error ? error.message : String(error));
     }
 }
+/**
+ * Normalize renamed process-level settings while keeping old daemon.json files
+ * readable after an upgrade. New values take precedence when both keys exist.
+ */
+export function normalizeProcessConfigCompat(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return value;
+    const idleMonitor = value.idleMonitor;
+    const debug = value.debug;
+    let changed = false;
+    let normalized = value;
+    if (idleMonitor && typeof idleMonitor === 'object' && !Array.isArray(idleMonitor)) {
+        const nextIdleMonitor = { ...idleMonitor };
+        if (nextIdleMonitor.apiRetryTimeout === undefined && nextIdleMonitor.retryAttemptTimeout !== undefined) {
+            nextIdleMonitor.apiRetryTimeout = nextIdleMonitor.retryAttemptTimeout;
+            changed = true;
+        }
+        if (Object.prototype.hasOwnProperty.call(nextIdleMonitor, 'retryAttemptTimeout')) {
+            delete nextIdleMonitor.retryAttemptTimeout;
+            changed = true;
+        }
+        if (changed)
+            normalized = { ...normalized, idleMonitor: nextIdleMonitor };
+    }
+    if (debug && typeof debug === 'object' && !Array.isArray(debug)
+        && Object.prototype.hasOwnProperty.call(debug, 'flusherDiag')) {
+        const nextDebug = { ...debug };
+        delete nextDebug.flusherDiag;
+        normalized = { ...normalized, debug: nextDebug };
+    }
+    return normalized;
+}
 function normalizeRelationConfigForWrite(value) {
     const mutable = normalizeBaseagentEffortCompat({ ...value });
     normalizeShowActivitiesCompat(mutable);
@@ -702,9 +817,12 @@ export function write(target, value, sel, opts = {}) {
     const schema = target === ConfigTarget.Contact && requestedVersion === 2
         ? loadSchema('contact-book', 2)
         : loadSchema(TARGET_SCHEMA[target]);
+    const retiredGatewayPaths = legacyAunGatewayConfigPaths(value);
+    if (retiredGatewayPaths.length > 0) {
+        throw new ConfigError('AUN_GATEWAY_URL_REMOVED', legacyAunGatewayConfigError(file, retiredGatewayPaths), { paths: retiredGatewayPaths });
+    }
     const withVer = ensureSchemaVersion(value, schema.version);
-    const migrated = withVer;
-    const canonicalized = normalizeBaseagentEffortCompat(migrated);
+    const canonicalized = normalizeBaseagentEffortCompat(withVer);
     // Agent config 写入规范化（aid 校验、projects 字段清理）
     const normalized = target === ConfigTarget.Agent
         ? normalizeAgentConfigForWrite(canonicalized)
@@ -908,7 +1026,11 @@ function ensureSchemaVersion(value, version) {
 }
 function validateOrThrow(schema, value, target) {
     const ok = schema.validate(value);
-    const scopeErrors = [...validateProcessOnlyFields(target, value), ...validateProcessAidDomain(target, value)];
+    const scopeErrors = [
+        ...validateProcessOnlyFields(target, value),
+        ...validateProcessAidDomain(target, value),
+        ...validateProcessServiceNames(target, value),
+    ];
     if (!ok || scopeErrors.length > 0) {
         const errs = [
             ...scopeErrors,
@@ -949,6 +1071,24 @@ function validateProcessAidDomain(target, value) {
         return [`/aun/defaultAidDomain ${error instanceof Error ? error.message : String(error)}`];
     }
 }
+function validateProcessServiceNames(target, value) {
+    if (target !== ConfigTarget.Process || !value || typeof value !== 'object')
+        return [];
+    const services = value.services;
+    if (!Array.isArray(services))
+        return [];
+    const seen = new Set();
+    const errors = [];
+    services.forEach((service, index) => {
+        if (!service || typeof service !== 'object' || typeof service.name !== 'string')
+            return;
+        if (seen.has(service.name))
+            errors.push(`/services/${index}/name duplicates service name ${JSON.stringify(service.name)}`);
+        else
+            seen.add(service.name);
+    });
+    return errors;
+}
 /**
  * responseModeParams 桶专项校验。
  *
@@ -999,8 +1139,28 @@ export function validateConfig(target, value) {
         ? loadSchema('contact-book', 2)
         : loadSchema(TARGET_SCHEMA[target]);
     const withVer = ensureSchemaVersion(value, schema.version);
-    const ok = schema.validate(withVer);
-    const errors = [...validateProcessOnlyFields(target, withVer), ...validateProcessAidDomain(target, withVer)];
+    let normalized = withVer;
+    try {
+        if (target === ConfigTarget.Process)
+            normalized = normalizeProcessConfigCompat(normalizeDaemonServices(withVer));
+    }
+    catch (error) {
+        return [error instanceof Error ? error.message : String(error)];
+    }
+    const ok = schema.validate(normalized);
+    const errors = [
+        ...validateProcessOnlyFields(target, normalized),
+        ...validateProcessAidDomain(target, normalized),
+        ...validateProcessServiceNames(target, normalized),
+    ];
+    if (target === ConfigTarget.Defaults || target === ConfigTarget.Agent || target === ConfigTarget.Relation) {
+        try {
+            validateResponseModeParams(normalized?.responseModeParams, target);
+        }
+        catch (error) {
+            errors.push(error instanceof ConfigError ? error.message : String(error));
+        }
+    }
     if (ok && errors.length === 0)
         return [];
     return [
@@ -1014,10 +1174,22 @@ export function validateConfig(target, value) {
     ];
 }
 export function validateConfigFile(target, sel) {
-    const value = atomicReadJson(targetPath(target, sel));
+    const file = targetPath(target, sel);
+    const value = atomicReadJson(file);
     if (value === null)
         return { exists: false, errors: [] };
-    return { exists: true, errors: validateConfig(target, value) };
+    // Persisted pre-removal files remain readable: validate the same sanitized
+    // view used by runtime reads, while new writes are still rejected by write().
+    let sanitized;
+    try {
+        sanitized = target === ConfigTarget.Process
+            ? normalizeDaemonServices(stripLegacyAunGatewayConfig(value, file, message => configWarn(message)))
+            : stripLegacyAunGatewayConfig(value, file, message => configWarn(message));
+    }
+    catch (error) {
+        return { exists: true, errors: [error instanceof Error ? error.message : String(error)] };
+    }
+    return { exists: true, errors: validateConfig(target, sanitized) };
 }
 function fileCacheAvailable() {
     try {
@@ -1078,13 +1250,40 @@ export function resolveAgentConfig(sel, opts = {}) {
     const agentConfig = sel.self ? read(ConfigTarget.Agent, sel, opts) : null;
     const relationConfig = (sel.self && sel.peerKey) ? read(ConfigTarget.Relation, sel, opts) : null;
     const layers = [
-        stripStaticOwnerField(read(ConfigTarget.Defaults, undefined, opts)),
+        stripStaticOwnerField(normalizeDefaultsBehaviorCompat(read(ConfigTarget.Defaults, undefined, opts))),
         agentConfig,
         stripRelationRoleData(stripStaticOwnerField(relationConfig)),
     ];
     const merged = mergeLayers(layers, fields);
     return merged;
 }
+/**
+ * defaults.schema keeps the historical `config` object as the process-wide
+ * response behavior compatibility surface. Make those values participate in
+ * the normal agent/relation merge chain without leaking the compatibility
+ * container itself into EffectiveAgentConfig.
+ *
+ * Explicit canonical fields (if a future schema adds them) always win. A
+ * single default chat mode applies to the three peer categories because this
+ * compatibility field predates the per-category `chatmode` dictionary.
+ */
+export function normalizeDefaultsBehaviorCompat(defaults) {
+    if (!defaults || !defaults.config || typeof defaults.config !== 'object' || Array.isArray(defaults.config))
+        return defaults;
+    const { config, ...rest } = defaults;
+    const normalized = { ...rest };
+    const chatMode = config.chatMode;
+    if (!normalized.chatmode && (chatMode === 'interactive' || chatMode === 'proactive')) {
+        normalized.chatmode = { private: chatMode, group: chatMode, nothuman: chatMode };
+    }
+    if (normalized.mentionMode === undefined && (config.mentionMode === 'disabled' || config.mentionMode === 'mention-only')) {
+        normalized.mentionMode = config.mentionMode;
+    }
+    if (normalized.show_activities === undefined && ['all', 'text', 'none'].includes(config.show_activities)) {
+        normalized.show_activities = config.show_activities;
+    }
+    return normalized;
+}
 function stripStaticOwnerField(config) {
     if (!config)
         return config;
@@ -1108,6 +1307,7 @@ function stripRelationRoleData(config) {
  */
 export function resolveEffective(sel, opts = {}) {
     const config = resolveAgentConfig(sel, opts);
+    const observableDefault = loadSchema('agent-config').fields.get('observable')?.default;
     const effective = {
         $schema_version: config.$schema_version ?? currentVersion('agent-config'),
         aid: config.aid ?? sel.self ?? '',
@@ -1121,7 +1321,9 @@ export function resolveEffective(sel, opts = {}) {
         projects: config.projects,
         capabilities: config.capabilities,
         readonlySourceDiagnostics: config.readonlySourceDiagnostics,
-        observable: config.observable,
+        // Schema defaults are not applied by AJV during reads; apply the current
+        // factory default here so omitted observable fields are enabled at runtime.
+        observable: config.observable ?? (typeof observableDefault === 'boolean' ? observableDefault : true),
         extra_backup: config.extra_backup,
         // Runtime configuration parameters
         active_baseagent: config.active_baseagent,

package/dist/config/config-operation-service.js

@@ -287,8 +287,7 @@ function relPath(absolute) {
 }
 /**
  * 各存储层都无值时的兜底：若 schema 为该字段声明了 `default`，展示出厂默认并标记
- * schemaDefault=true（仅影响 `ec config get` 的展示；运行时 resolveEffective 不受影响，
- * 未设值仍为 undefined，以保留协议层回退等既有语义）。
+ * schemaDefault=true。运行时 resolveEffective 也会应用 Agent schema 的 observable 默认值。
  */
 function getWithSchemaDefault(op, absent, note) {
     const nt = note ? { note } : {};

package/dist/config/contact-operation-service.js

@@ -4,7 +4,7 @@ import { isExplicitGroupId } from '../aun/group-identity.js';
 import { agentConfig } from '../paths.js';
 import { getContactSnapshot, resolveContactView } from './contact-book.js';
 import { ContactMutationError } from './contact-book-store.js';
-import { mutateContactWithOperation } from './contact-request-service.js';
+import { addContact, mutateContactWithOperation } from './contact-request-service.js';
 export function resolveContactCommand(argv) {
     const args = argv[0] === 'contact' ? argv.slice(1) : [...argv];
     const selfAid = String(argValue(args, '--self') || '').trim();
@@ -39,6 +39,21 @@ export function resolveContactCommand(argv) {
             },
         };
     }
+    if (command === 'add') {
+        if (!isValidAid(subcommand || '') || isExplicitGroupId(subcommand || '')) {
+            return invalid('INVALID_AID', 'primaryId must be a valid individual AID');
+        }
+        return {
+            ok: true,
+            command: {
+                kind: 'add',
+                operationId: 'contact.add',
+                selfAid,
+                primaryId: subcommand,
+                canonicalArgv: canonicalArgv(argv),
+            },
+        };
+    }
     return invalid('UNKNOWN_COMMAND', `Unknown contact command: ${positional.join(' ')}`);
 }
 export async function executeResolvedContactCommand(command, actor = 'local-cli') {
@@ -81,6 +96,22 @@ export async function executeResolvedContactCommand(command, actor = 'local-cli'
                 contactRevision: result.contactRevision,
             };
         }
+        if (command.kind === 'add') {
+            const result = await addContact({
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                actorId: actor,
+            });
+            return {
+                ok: true,
+                operation: 'add',
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                status: 'active',
+                changed: result.changed,
+                contactRevision: result.contactRevision,
+            };
+        }
         return { ok: false, code: 'CONTACT_OPERATION_FAILED', error: 'Unsupported contact operation' };
     }
     catch (error) {

package/dist/config/contact-request-service.js

@@ -38,6 +38,50 @@ export async function mutateContactWithOperation(input) {
     const { value: _value, ...mutationResult } = result;
     return mutationResult;
 }
+/**
+ * Add a canonical AUN contact as active through the Contact Book transaction.
+ * Existing pending/declined entries are intentionally promoted here, while a
+ * blocked entry remains a hard stop and must be explicitly unblocked first.
+ */
+export async function addContact(input) {
+    const primaryId = String(input.primaryId || '').trim();
+    if (!isValidAid(primaryId)) {
+        throw new ContactMutationError('INVALID_AID', `Invalid contact AID: ${primaryId}`);
+    }
+    const at = new Date(input.now ?? Date.now()).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contact, contactRevision }) => {
+        if (input.expectedContactRevision !== undefined && input.expectedContactRevision !== contactRevision) {
+            throw new ContactMutationError('CONFLICT', 'Contact book changed since it was read', {
+                expectedContactRevision: input.expectedContactRevision,
+                contactRevision,
+            });
+        }
+        if (contact.contacts[primaryId]?.status === 'blocked') {
+            throw new ContactMutationError('CONTACT_BLOCKED', `Contact is blocked: ${primaryId}`);
+        }
+        const mutations = [
+            { type: 'set-status', primaryId, status: 'active' },
+        ];
+        if (input.displayName !== undefined) {
+            mutations.push({ type: 'set-display-name', primaryId, displayName: input.displayName });
+        }
+        return {
+            mutation: mutations.length === 1 ? mutations[0] : { type: 'batch', mutations },
+            actor: input.actorId,
+            value: undefined,
+            beforeCommit: ({ contactRevision: nextRevision }) => operationLogChange(logFile, [operationRecord({
+                    at,
+                    op: 'manual-add',
+                    primaryId,
+                    actorId: input.actorId,
+                    contactRevision: nextRevision,
+                })]),
+        };
+    });
+    const { value: _value, ...mutationResult } = result;
+    return mutationResult;
+}
 export async function submitContactRequest(input) {
     const applicantAid = String(input.applicantAid || '').trim();
     const owners = listAgentOwners(input.selfAid);