evolcore 0.0.35 → 0.0.36

package/dist/agents/ecagent-runner.js

@@ -2,6 +2,7 @@ import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable, } from '../c
 // Ecagent/OpenAI API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
 import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 import fs from 'fs';
+import { assertOwnershipAuthorization } from '../core/ownership/owner-resolver.js';
 import path from 'path';
 import { AgentHarness, JsonlSessionRepo, NodeExecutionEnv, } from '../../ecagent/dist/node.js';
 import { Type, createModels, createProvider, } from '../../ecagent/dist/runtime/index.js';
@@ -16,6 +17,7 @@ import { ErrorType } from '../utils/error-utils.js';
 import { summarizeToolInputForAudit } from '../utils/tool-summary.js';
 import { auditToolPreflightDenial } from '../core/auth/authorization-audit.js';
 import { resolveEcagentConfig } from './baseagent.js';
+import { resolveProviderServiceForBaseagent } from '../config/providers.js';
 import { buildModelRequestHeaders } from './request-identity.js';
 import { appendRequestPath } from './request-identity.js';
 import { resolveModelSpec } from '../stats/billing.js';
@@ -790,6 +792,32 @@ export class EcagentRunner {
     setSendPrompt(fn) { this.sendPromptFn = fn; }
     setPermissionContext(sessionId, context) { this.permissionContexts.set(sessionId, context); }
     setCompactStartCallback(callback) { this.onCompactStart = callback; }
+    currentProviderConfig(providerOverride) {
+        const providerId = providerOverride ?? this.config.providerId;
+        if (!providerId)
+            return this.config;
+        const provider = resolveProviderServiceForBaseagent(providerId, 'ecagent', this.config.providerServiceType);
+        if (provider.style !== 'openai-compatible') {
+            throw new Error(`Provider ${providerId} uses unsupported ecagent style: ${provider.style}`);
+        }
+        if (!provider.apiKey)
+            throw new Error(`Provider ${providerId} has no API key`);
+        return {
+            ...this.config,
+            apiKey: provider.apiKey,
+            baseUrl: provider.baseUrl,
+            headers: buildModelRequestHeaders({
+                baseagent: 'ecagent',
+                baseUrl: provider.baseUrl,
+                agentAid: this.agentAid,
+                configuredHeaders: provider.headers,
+            }),
+            queryParams: provider.queryParams,
+            providerServiceType: provider.serviceType,
+            providerStyle: provider.style,
+            modelOverrides: provider.modelOverrides,
+        };
+    }
     listModes() {
         return [
             { key: 'readonly', nameZh: '只读', description: '只读操作自动执行，写入直接拒绝', available: true },
@@ -891,6 +919,7 @@ export class EcagentRunner {
         };
         let completeSent = false;
         try {
+            const connection = this.currentProviderConfig(request.modelOverride?.provider);
             await fs.promises.mkdir(request.projectPath, { recursive: true });
             const previousRuntime = this.runtimes.get(request.sessionId);
             const runtime = await this.getOrCreateRuntime(request.sessionId, request.projectPath, request.initialAgentSessionId, request.modelOverride);
@@ -908,19 +937,19 @@ export class EcagentRunner {
             if (fullaccess && !hasTrustedFullAccessContext(this.permissionContexts.get(request.sessionId))) {
                 throw new Error('Ecagent fullaccess requires a trusted per-call execution authorization');
             }
-            const model = createModel(modelId, this.config.baseUrl);
+            const model = createModel(modelId, connection.baseUrl);
             const nodeEnv = new NodeExecutionEnv({ cwd: request.projectPath, shellEnv: { ...process.env, ...request.runtimeEnv, EVOLCORE_SESSION_ID: request.sessionId, EVOLCORE_HOME: resolveRoot() } });
             const models = createModels();
-            const transport = createOpenAiTransport(this.config);
+            const transport = createOpenAiTransport(connection);
             models.setProvider(createProvider({
                 id: PROVIDER_ID,
                 name: 'EvolCore Gateway',
-                baseUrl: this.config.baseUrl,
+                baseUrl: connection.baseUrl,
                 models: [model],
                 auth: { apiKey: {
                         name: 'EvolCore gateway',
-                        login: async () => ({ type: 'api_key', key: this.config.apiKey }),
-                        resolve: async () => ({ auth: { apiKey: this.config.apiKey }, source: 'baseagents.ecagent.apiKey' }),
+                        login: async () => ({ type: 'api_key', key: connection.apiKey }),
+                        resolve: async () => ({ auth: { apiKey: connection.apiKey }, source: 'provider' }),
                     } },
                 api: transport,
             }));
@@ -933,9 +962,9 @@ export class EcagentRunner {
                 tools: createTools(nodeEnv, request.projectPath, request.runtimeEnv, request.modelOverride?.bootstrapAgentMdPath, fullaccess, request.modelOverride?.personalMdPath, this.permissionContexts.get(request.sessionId)?.systemSessionGrants),
                 systemPrompt: [DEFAULT_SYSTEM_PROMPT, request.systemPromptAppend].filter(Boolean).join('\n\n'),
                 streamOptions: {
-                    timeoutMs: this.config.timeoutMs,
-                    maxRetries: this.config.maxRetries,
-                    maxRetryDelayMs: this.config.maxRetryDelayMs,
+                    timeoutMs: connection.timeoutMs,
+                    maxRetries: connection.maxRetries,
+                    maxRetryDelayMs: connection.maxRetryDelayMs,
                 },
             });
             runtime.harness = harness;
@@ -1214,6 +1243,12 @@ export class EcagentRunner {
     }
     async authorizeTool(sessionId, projectPath, mode, toolName, input, turn) {
         const permissionContext = this.permissionContexts.get(sessionId);
+        try {
+            await assertOwnershipAuthorization(permissionContext);
+        }
+        catch (error) {
+            return { block: true, reason: error instanceof Error ? error.message : String(error) };
+        }
         const recordBlockedOperation = async (policyCode, operationInput = input, matchedPath) => {
             const summary = summarizeToolInputForAudit(toolName, operationInput).slice(0, 512);
             auditToolPreflightDenial({
@@ -1418,12 +1453,13 @@ export class EcagentRunner {
             const compactEffort = modelOverride?.effortMode === 'model_default'
                 ? undefined
                 : modelOverride?.effort ?? this.effort;
-            const model = createModel(compactModel, this.config.baseUrl);
+            const connection = this.currentProviderConfig();
+            const model = createModel(compactModel, connection.baseUrl);
             const env = new NodeExecutionEnv({ cwd: runtime.projectPath });
             const models = createModels();
-            const transport = createOpenAiTransport(this.config);
+            const transport = createOpenAiTransport(connection);
             models.setProvider(createProvider({
-                id: PROVIDER_ID, auth: { apiKey: { name: 'EvolCore gateway', login: async () => ({ type: 'api_key', key: this.config.apiKey }), resolve: async () => ({ auth: { apiKey: this.config.apiKey } }) } },
+                id: PROVIDER_ID, auth: { apiKey: { name: 'EvolCore gateway', login: async () => ({ type: 'api_key', key: connection.apiKey }), resolve: async () => ({ auth: { apiKey: connection.apiKey } }) } },
                 models: [model], api: transport,
             }));
             const harness = new AgentHarness({ env, session: runtime.session, models, model, thinkingLevel: normalizeThinkingLevel(compactEffort), tools: [] });

package/dist/agents/gemini-runner.js

@@ -1,4 +1,4 @@
-import { getCatalog, assertCatalogSelectable } from '../core/model/model-catalog.js';
+import { getRunnerCatalog, assertCatalogSelectable } from '../core/model/model-catalog.js';
 // Gemini API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
 import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 /**
@@ -20,6 +20,7 @@ import os from 'os';
 import crypto from 'crypto';
 import { hasTrustedFullAccessContext } from './runner-types.js';
 import { resolveGoogleConfig } from './baseagent.js';
+import { resolveEffective } from '../config/config-manager.js';
 import { commandExists } from '../utils/cross-platform.js';
 import { GeminiSessionFileAdapter } from '../core/session/adapters/gemini-session-file-adapter.js';
 import { logger } from '../utils/logger.js';
@@ -103,6 +104,7 @@ function isGeminiPermissionDenial(event) {
     return /(?:\btool\b.{0,80}\bis not (?:allowed|permitted|authorized)\b|not (?:allowed|permitted|authorized).{0,80}(?:policy|approval)|(?:denied|rejected|blocked).{0,80}(?:by|under|due to).{0,40}(?:policy|approval)|(?:policy|approval).{0,80}(?:denied|rejected|blocked)|(?:approval|confirmation).{0,80}required.{0,80}(?:headless|non[- ]interactive))/i.test(detail);
 }
 const GEMINI_H_CLASS_PATTERNS = [
+    String.raw `(?:^|[/\\"])providers\.json(?:_|__|\.lock(?:\.[^/\\"]*)?)?(?:[/\\"]|$)`,
     String.raw `evolcore\.json`,
     String.raw `(?:^|[/\\"])data(?:[/\\"]|$)`,
     String.raw `(?:^|[/\\"])(?:AIDs|aids)(?:[/\\"]|$)`,
@@ -316,6 +318,8 @@ export class GeminiRunner {
     name = 'gemini';
     capabilities = { fullaccess: true, clear: true, compact: false, fork: false, forkAtTurn: false, askUserQuestion: false, planApproval: false, fileRewind: 'unsupported' };
     resolved;
+    config;
+    agentAid;
     model;
     activeProcesses = new Map();
     activeStreams = new Map();
@@ -323,7 +327,9 @@ export class GeminiRunner {
     onSessionIdUpdate;
     currentMode = 'readonly';
     permissionContexts = new Map();
-    constructor(config, callbacks) {
+    constructor(config, callbacks, runtime) {
+        this.config = config;
+        this.agentAid = runtime?.agentAid;
         this.resolved = resolveGoogleConfig(config);
         this.model = stripContextWindowSuffix(this.resolved.model);
         this.onSessionIdUpdate = callbacks.onSessionIdUpdate;
@@ -331,7 +337,10 @@ export class GeminiRunner {
     // ── ModelSwitcher ──
     setModel(model) { this.model = stripContextWindowSuffix(model); }
     getModel() { return this.model; }
-    async listModels() { const catalog = await getCatalog(undefined, 'gemini'); assertCatalogSelectable(catalog); return catalog.models.map(m => m.id); }
+    getModelCatalog() {
+        return getRunnerCatalog('gemini', this.agentAid, this.currentProviderConfig());
+    }
+    async listModels() { const catalog = await this.getModelCatalog(); assertCatalogSelectable(catalog); return catalog.models.map(m => m.id); }
     // ── Effort (not applicable) ──
     setEffort(_effort) { }
     getEffort() { return undefined; }
@@ -351,14 +360,29 @@ export class GeminiRunner {
     setPermissionContext(sessionId, context) {
         this.permissionContexts.set(sessionId, context);
     }
-    buildAgentEnv(sessionId, runtimeEnv) {
+    currentProviderConfig(providerOverride) {
+        const config = this.agentAid
+            ? { agents: { gemini: resolveEffective({ self: this.agentAid }, { cache: true, expand: false }).baseagents?.gemini ?? this.config.agents?.gemini } }
+            : this.config;
+        return resolveGoogleConfig(config, providerOverride ? { provider: providerOverride } : undefined);
+    }
+    buildAgentEnv(sessionId, runtimeEnv, resolved = this.currentProviderConfig()) {
         const env = {
             ...process.env,
             EVOLCORE_SESSION_ID: sessionId,
             ...(runtimeEnv ?? {}),
         };
-        if (this.resolved.apiKey)
-            env.GOOGLE_API_KEY = this.resolved.apiKey;
+        if (resolved.apiKey) {
+            env.GEMINI_API_KEY = resolved.apiKey;
+            env.GOOGLE_API_KEY = resolved.apiKey;
+        }
+        if (resolved.providerId && resolved.baseUrl) {
+            env.GOOGLE_GEMINI_BASE_URL = resolved.baseUrl;
+            env.GOOGLE_GENAI_USE_VERTEXAI = 'false';
+            env.GOOGLE_GENAI_USE_GCA = 'false';
+            env.GEMINI_CLI_CUSTOM_HEADERS = Object.entries(resolved.headers ?? {})
+                .map(([name, value]) => `${name}: ${value}`).join(', ');
+        }
         return env;
     }
     // ── Stream management ──
@@ -380,6 +404,8 @@ export class GeminiRunner {
             error.code = 'TOPIC_TURN_LEASE_REQUIRED';
             throw error;
         }
+        const resolved = this.currentProviderConfig(modelOverride?.provider);
+        const env = this.buildAgentEnv(sessionId, runtimeEnv, resolved);
         const topicAgentSessionId = topicBinding ? modelOverride?.backend?.agentSessionId ?? null : undefined;
         const cachedSessionId = topicBinding
             ? (topicAgentSessionId && this.activeSessions.get(sessionId) === topicAgentSessionId ? topicAgentSessionId : undefined)
@@ -410,7 +436,7 @@ export class GeminiRunner {
         const geminiHome = path.join(os.homedir(), '.gemini');
         fs.mkdirSync(geminiHome, { recursive: true, mode: 0o700 });
         const selfAid = this.permissionContexts.get(sessionId)?.selfAid;
-        const sandboxProbe = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(this.resolved.cliPath, [], {
+        const sandboxProbe = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(resolved.cliPath, [], {
             projectPath,
             selfAid,
             writablePaths: [
@@ -481,8 +507,7 @@ export class GeminiRunner {
             args.push('-r', geminiSessionId);
         }
         // Spawn subprocess
-        const env = this.buildAgentEnv(sessionId, runtimeEnv);
-        const sandboxedCommand = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(this.resolved.cliPath, args, {
+        const sandboxedCommand = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(resolved.cliPath, args, {
             projectPath,
             selfAid,
             writablePaths: [
@@ -494,7 +519,7 @@ export class GeminiRunner {
             ],
             readonlyPaths: tempFiles,
         });
-        const child = spawn(sandboxedCommand?.command ?? this.resolved.cliPath, sandboxedCommand?.args ?? args, {
+        const child = spawn(sandboxedCommand?.command ?? resolved.cliPath, sandboxedCommand?.args ?? args, {
             cwd: projectPath,
             stdio: ['pipe', 'pipe', 'pipe'],
             env,
@@ -934,10 +959,9 @@ export class GeminiAgentPlugin {
     }
     createAgent(agent, callbacks) {
         const override = agent.config.baseagents?.gemini;
-        const syntheticConfig = { agents: { gemini: override } };
         const merged = {
             agents: { gemini: { ...(override || {}) } },
         };
-        return { evolagentName: agent.name, baseagent: 'gemini', agent: new GeminiRunner(merged, callbacks) };
+        return { evolagentName: agent.name, baseagent: 'gemini', agent: new GeminiRunner(merged, callbacks, { agentAid: agent.aid, agentConfig: agent.config }) };
     }
 }

package/dist/aun/aid/client.js

@@ -39,7 +39,7 @@ export function suppressSdkLogs() {
     };
 }
 // ==================== SDK package ====================
-export const MIN_AUN_CORE_SDK = [0, 5, 20];
+export const MIN_AUN_CORE_SDK = [0, 5, 22];
 export const AUN_CORE_SDK_PKG = '@agentunion/fastaun';
 function compareVersion(a, min) {
     const parts = a.split('.').map(n => parseInt(n, 10));
@@ -91,7 +91,7 @@ export function isAunSdkReady() {
     return !!(installed && isAunSdkVersionOk(installed.version));
 }
 // ==================== CA Root ====================
-export async function downloadCaRoot(aunPath, gatewayUrl, indent = '') {
+export async function downloadCaRoot(aunPath, gatewayUrl, indent = '', silent = false) {
     const caDir = path.join(aunPath, 'CA', 'root');
     const caCertPath = path.join(caDir, 'root.crt');
     if (fs.existsSync(caCertPath))
@@ -112,7 +112,8 @@ export async function downloadCaRoot(aunPath, gatewayUrl, indent = '') {
             return false;
         }
         fs.writeFileSync(caCertPath, body);
-        console.log(`${indent}✓ CA 根证书已下载`);
+        if (!silent)
+            console.log(`${indent}✓ CA 根证书已下载`);
         return true;
     }
     catch (e) {

package/dist/aun/aid/control-aid.js

@@ -4,8 +4,11 @@ import path from 'path';
 import { parseDocument } from 'yaml';
 import { aidCreate } from './index.js';
 import { DEFAULT_AID_DOMAIN, normalizeAidDomain } from './domain.js';
-import { getAidStore, SLOT } from './store.js';
-import { validateAgentMdDocument, verifyAgentMdUpload } from '@agentunion/fastaun';
+import { getAidStore, loadClient, SLOT } from './store.js';
+import { LocalTokenStore, validateAgentMdDocument, verifyAgentMdUpload, } from '@agentunion/fastaun';
+import { AUN_KEYSTORE_ENCRYPTION_SEED } from './encryption-seed-policy.js';
+import { isValidAid } from './validation.js';
+import { OwnerResolver } from '../../core/ownership/owner-resolver.js';
 import { agentMdPath, resolvePaths } from '../../paths.js';
 import { PeerIdentityCache } from '../../core/relation/peer-identity.js';
 import { agentmdPut, buildInitialAgentMd, invalidateAgentDisplayName, stripAgentMdSignature } from './agentmd.js';
@@ -107,10 +110,10 @@ function clearControlAgentPeerCaches(aid, root = resolvePaths().root) {
 /**
  * Ensure a daemon/control AID has a signed host agent.md.
  *
- * Registration in fastaun creates a default `type: agent` card. This helper
- * upgrades that card, supplements cards missing on older installations, and
- * is idempotent once the local card is canonical. Upload errors are allowed to
- * propagate to the caller so startup can log them without becoming blocked.
+ * Registration in fastaun creates an initial card. This helper upgrades that
+ * card, supplements cards missing on older installations, and is idempotent
+ * once the local card is canonical. Upload errors are allowed to propagate to
+ * the caller so startup can log them without becoming blocked.
  */
 export async function ensureControlAgentMd(aid, opts = {}) {
     const normalizedAid = String(aid ?? '').trim().replace(/^@/, '');
@@ -241,7 +244,7 @@ async function candidateExists(store, candidate) {
  * - fail-fast：查重探测失败（网关不可达）立即抛错，不掩盖成"均冲突"
  * - 注册后补发控制主机 agent.md；失败只告警，不丢弃已经注册的 AID
  */
-export async function generateControlAid(aidDomain) {
+export async function generateControlAid(aidDomain, options = {}) {
     const finalAidDomain = aidDomain === undefined
         ? resolveControlAidDomain()
         : normalizeAidDomain(aidDomain, 'aidDomain');
@@ -255,7 +258,9 @@ export async function generateControlAid(aidDomain) {
                 continue;
             }
             try {
-                const created = await aidCreate(candidate);
+                const created = await aidCreate(candidate, {
+                    type: 'host', ...(options.silent ? { silent: true } : {}),
+                });
                 try {
                     await ensureControlAgentMd(created.aid, { store: created.store });
                 }
@@ -279,6 +284,12 @@ export async function generateControlAid(aidDomain) {
                 return { aid: created.aid, gateway: created.gateway };
             }
             catch (e) {
+                // Registration may already have saved credentials before authentication
+                // failed. Keep that identity so the completed AID can be retried.
+                if (store.load(candidate).ok) {
+                    logger.warn(`[control-aid] ${candidate} 已注册，保留身份以恢复初始化: ${e}`);
+                    return { aid: candidate, gateway: '' };
+                }
                 // 查重与实际注册之间存在 TOCTOU 竞态；注册接口也可能因服务端暂时失败而拒绝，
                 // 这些情况都换一个候选继续尝试。查重阶段的网关错误仍在 candidateExists 中 fail-fast。
                 lastRegistrationError = e;
@@ -304,3 +315,254 @@ export async function generateControlAid(aidDomain) {
         store.close();
     }
 }
+const REGISTRATION_OPERATION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/** Submit an explicit Owner binding after the AID and its final agent.md exist. */
+export async function submitControlAidRegistration(aid, owner, options = {}) {
+    const ownerAid = owner.toLowerCase();
+    if (!isValidAid(aid) || !isValidAid(ownerAid) || aid.toLowerCase() === ownerAid) {
+        return { status: 'failed', error: { code: 'INVALID_OWNER', message: 'A distinct valid Owner AID is required' } };
+    }
+    const deadline = Date.now() + (options.timeoutMs ?? 15_000);
+    let records;
+    let store;
+    let client;
+    let operationId;
+    let task;
+    let connecting = false;
+    let sentOperationIds = new Set();
+    let invitationObserver;
+    const resolver = new OwnerResolver();
+    async function bounded(operation, timeoutMs = deadline - Date.now()) {
+        let timer;
+        try {
+            return await Promise.race([operation, new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(Object.assign(new Error('Registration invitation submission timed out'), {
+                        code: 'BIND_SUBMIT_TIMEOUT',
+                    })), Math.max(0, timeoutMs));
+                })]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    function readTask() {
+        const raw = records.loadOwnershipTask(aid, operationId)?.task;
+        if (!raw)
+            return;
+        if (raw.operation_id !== operationId || raw.operation !== 'bind' || raw.sub_aid !== aid
+            || raw.owner_aid !== ownerAid || raw.initiator_aid !== aid || raw.new_owner_aid !== undefined
+            || !['pending', 'completed', 'rejected', 'stopped', 'error'].includes(String(raw.status))
+            || typeof raw.step !== 'string' || !Number.isSafeInteger(raw.base_relation_version)
+            || raw.target_relation_version !== Number(raw.base_relation_version) + 1) {
+            throw Object.assign(new Error('SDK registration task does not match its original intent'), { code: 'TASK_MISMATCH' });
+        }
+        task = {
+            operation_id: operationId, operation: 'bind', sub_aid: aid, owner_aid: ownerAid,
+            base_relation_version: raw.base_relation_version,
+            target_relation_version: raw.target_relation_version,
+            status: raw.status, step: raw.step,
+            ...(typeof raw.code === 'string' ? { code: raw.code } : {}),
+            ...(typeof raw.reason === 'string' ? { reason: raw.reason } : {}),
+            ...(typeof raw.retryable === 'boolean' ? { retryable: raw.retryable } : {}),
+        };
+    }
+    function result(status, error) {
+        return { status, ...(operationId ? { operationId } : {}), ...(task ? { task } : {}), ...(error ? { error } : {}) };
+    }
+    try {
+        records = new LocalTokenStore(resolvePaths().root, { encryptionSeed: AUN_KEYSTORE_ENCRYPTION_SEED });
+        const intent = records.loadMetadata(aid)?.registration_intent;
+        const registrationIntentOwner = typeof intent?.owner === 'string' ? intent.owner.toLowerCase() : undefined;
+        // Preserve an existing SDK registration task and let the same SDK client
+        // resume it during connect before OwnerResolver checks/binds the subject.
+        if (intent && Object.prototype.hasOwnProperty.call(intent, 'owner')) {
+            if (!registrationIntentOwner) {
+                return result('unknown', {
+                    code: 'REGISTRATION_INTENT_PRESENT',
+                    message: 'Control AID has an invalid SDK registration Owner intent',
+                });
+            }
+            if (registrationIntentOwner !== ownerAid) {
+                return result('failed', { code: 'OWNER_INTENT_CONFLICT', message: 'Control AID was registered for a different Owner' });
+            }
+            if (typeof intent.operation_id === 'string' && REGISTRATION_OPERATION_ID.test(intent.operation_id)) {
+                operationId = intent.operation_id;
+                readTask();
+            }
+            if (!operationId) {
+                return result('unknown', {
+                    code: 'REGISTRATION_INTENT_PRESENT',
+                    message: 'Control AID has an SDK registration intent without a valid operation ID',
+                });
+            }
+        }
+        if (options.agentMdError) {
+            return result('failed', { code: 'CONTROL_AGENTMD_NOT_READY', message: options.agentMdError });
+        }
+        store = await bounded(getAidStore({ slotId: SLOT.cli }));
+        const ownershipTasks = records.listOwnershipTasks(aid).map(snapshot => snapshot.task);
+        const conflictingTask = ownershipTasks.find(candidate => candidate.sub_aid === aid
+            && (candidate.status === 'pending' || candidate.status === 'error' && candidate.retryable === true)
+            && !(candidate.operation === 'bind' && candidate.owner_aid === ownerAid
+                && candidate.initiator_aid === aid && candidate.new_owner_aid === undefined));
+        if (conflictingTask) {
+            return result('failed', { code: 'BIND_CONFLICT', message: 'A different active ownership task must be resolved first' });
+        }
+        client = await bounded(loadClient(store, aid));
+        connecting = true;
+        sentOperationIds = new Set();
+        invitationObserver = observeInvitationSend(client, ownerAid, sentOperationIds);
+        await bounded(client.connect({
+            connection_kind: 'long', auto_reconnect: false, background_sync: false,
+            connect_timeout: 10, call_timeout: 10,
+        }));
+        if (registrationIntentOwner === ownerAid && operationId) {
+            readTask();
+            if ((!task || task.status === 'pending') && !sentOperationIds.has(operationId)) {
+                await bounded(invitationObserver.waitFor(operationId));
+                readTask();
+            }
+            if (!task) {
+                return result('unknown', {
+                    code: 'BIND_TASK_NOT_PERSISTED',
+                    message: 'SDK did not expose the recovered registration task after connect',
+                });
+            }
+            if (task?.status === 'completed') {
+                const consensus = await bounded(client.checkOwnershipConsensus(aid));
+                if (consensus.status === 'consensus' && consensus.sub_aid === aid && consensus.owner_aid === ownerAid) {
+                    return result('already_bound');
+                }
+                return result('failed', {
+                    code: 'CONSENSUS_REQUIRED',
+                    message: 'A completed binding task has no current verified Owner consensus',
+                });
+            }
+            if (task && (['rejected', 'stopped', 'error'].includes(task.status) || task.code)) {
+                return result('failed', { code: task.code ?? 'BIND_SUBMIT_FAILED', message: task.reason ?? `Binding task ${task.status}` });
+            }
+            if (sentOperationIds.has(operationId))
+                return result('submitted');
+            return result('unknown', {
+                code: 'BIND_SUBMIT_UNKNOWN',
+                message: 'SDK is recovering the original registration task; no matching message.send acknowledgement was observed',
+            });
+        }
+        // Reuse the same service as agent-create, including its fresh consensus
+        // check, explicit SDK bind call, and persistent task projection.
+        resolver.attachClient(aid, client, true);
+        const view = await bounded(resolver.bind(aid, ownerAid));
+        if (view.consensusStatus === 'consensus' && view.ownerAid === ownerAid) {
+            return result('already_bound');
+        }
+        const returnedTask = view.task;
+        if (!returnedTask || returnedTask.operation !== 'bind' || returnedTask.sub_aid !== aid
+            || returnedTask.owner_aid !== ownerAid || returnedTask.new_owner_aid !== undefined
+            || typeof returnedTask.operation_id !== 'string' || !REGISTRATION_OPERATION_ID.test(returnedTask.operation_id)) {
+            throw Object.assign(new Error('SDK returned a binding task for a different subject or Owner'), { code: 'TASK_MISMATCH' });
+        }
+        operationId = returnedTask.operation_id;
+        readTask();
+        if (!task) {
+            throw Object.assign(new Error('SDK binding task was not persisted'), { code: 'BIND_TASK_NOT_PERSISTED' });
+        }
+        if (task.status === 'completed') {
+            const consensus = await bounded(client.checkOwnershipConsensus(aid));
+            if (consensus.status === 'consensus' && consensus.sub_aid === aid && consensus.owner_aid === ownerAid) {
+                return result('already_bound');
+            }
+            return result('failed', { code: 'CONSENSUS_REQUIRED', message: 'Completed binding has no current verified Owner consensus' });
+        }
+        if (['rejected', 'stopped', 'error'].includes(task.status)) {
+            return result('failed', { code: task.code ?? 'BIND_SUBMIT_FAILED', message: task.reason ?? `Binding task ${task.status}` });
+        }
+        if (task.code) {
+            return result('failed', { code: task.code, message: task.reason ?? 'SDK binding did not finish submitting the invitation' });
+        }
+        if (!sentOperationIds.has(operationId)) {
+            return result('unknown', { code: 'BIND_SUBMIT_UNKNOWN', message: 'SDK persisted the binding task without confirming its message.send acknowledgement' });
+        }
+        return result('submitted');
+    }
+    catch (error) {
+        const details = error;
+        const code = typeof details.stringCode === 'string' ? details.stringCode
+            : typeof details.code === 'string' ? details.code : undefined;
+        const uncertain = connecting && (code === 'BIND_SUBMIT_TIMEOUT' || !code
+            || resolver.snapshot(aid).requestStatus === 'interrupted');
+        return result(uncertain ? 'unknown' : 'failed', {
+            code: uncertain ? 'BIND_SUBMIT_UNKNOWN' : code ?? 'BIND_SUBMIT_FAILED',
+            message: details.message ?? String(error),
+        });
+    }
+    finally {
+        resolver.stop();
+        invitationObserver?.restore();
+        if (client) {
+            try {
+                await bounded(client.close(), 2_000);
+            }
+            catch (error) {
+                logger.warn(`[control-aid] ${aid} invitation client cleanup: ${error}`);
+            }
+        }
+        try {
+            store?.close();
+        }
+        finally {
+            records?.close();
+        }
+    }
+}
+function observeInvitationSend(client, ownerAid, sentOperationIds) {
+    const target = client;
+    const original = target.call;
+    if (typeof original !== 'function')
+        return { waitFor: async () => false, restore: () => { } };
+    const waiters = new Map();
+    const bound = original.bind(client);
+    const wrapped = async (method, params) => {
+        const response = await bound(method, params);
+        const recipient = typeof params?.to === 'string' ? params.to.toLowerCase() : undefined;
+        const payloadValue = params?.payload;
+        if (method === 'message.send' && recipient === ownerAid
+            && payloadValue && typeof payloadValue === 'object' && !Array.isArray(payloadValue)) {
+            const payload = payloadValue;
+            const result = response && typeof response === 'object' && !Array.isArray(response)
+                ? response : undefined;
+            if (payload.action === 'bind.request' && typeof payload.operation_id === 'string'
+                && typeof result?.message_id === 'string') {
+                sentOperationIds.add(payload.operation_id);
+                const pending = waiters.get(payload.operation_id);
+                if (pending) {
+                    waiters.delete(payload.operation_id);
+                    for (const settle of pending)
+                        settle(true);
+                }
+            }
+        }
+        return response;
+    };
+    target.call = wrapped;
+    return {
+        waitFor: operationId => {
+            if (sentOperationIds.has(operationId))
+                return Promise.resolve(true);
+            return new Promise(resolve => {
+                const pending = waiters.get(operationId) ?? new Set();
+                pending.add(resolve);
+                waiters.set(operationId, pending);
+            });
+        },
+        restore: () => {
+            if (target.call === wrapped)
+                target.call = original;
+            for (const pending of waiters.values()) {
+                for (const settle of pending)
+                    settle(false);
+            }
+            waiters.clear();
+        },
+    };
+}

package/dist/aun/aid/identity.js

@@ -224,7 +224,10 @@ export async function aidCreate(aid, opts) {
     // 新注册流程：AIDStore.register → downloadCaRoot → load → authenticate
     const store = await getAidStore({ slotId: SLOT.cli, aunPath });
     try {
-        const regResult = await store.register(aid, { type: 'agent' });
+        const regResult = await store.register(aid, {
+            type: opts?.type ?? 'agent',
+            ...(opts?.owner?.trim() ? { owner: opts.owner.trim() } : {}),
+        });
         if (!regResult.ok) {
             const e = new Error(regResult.error.message);
             e.code = regResult.error.code;
@@ -236,11 +239,11 @@ export async function aidCreate(aid, opts) {
         try {
             const { GatewayDiscovery } = await import('@agentunion/fastaun');
             const discovery = new GatewayDiscovery({});
-            gatewayUrl = await discovery.discover(`https://${aid}/.well-known/aun-gateway`);
+            gatewayUrl = await discovery.discover(`https://${aid}/.well-known/aun-gateway`, 15_000);
         }
         catch { /* fall through */ }
         if (gatewayUrl) {
-            await downloadCaRoot(aunPath, gatewayUrl);
+            await downloadCaRoot(aunPath, gatewayUrl, '', opts?.silent === true);
         }
         // 重建 store（CA 可能刚下载，需要 rootCaPath 生效）
         store.close();