evolcore 0.0.35 → 0.0.37

package/dist/core/auth/debug-context.js

@@ -12,6 +12,7 @@
 import crypto from 'crypto';
 import { formatPeerKey } from '../relation/peer-identity.js';
 import { logger } from '../../utils/logger.js';
+import { sessionTopicThreadId } from '../thread/topic-id.js';
 // ---------------------------------------------------------------------------
 // DebugDelegationRegistry
 // ---------------------------------------------------------------------------
@@ -101,7 +102,7 @@ export function buildDebugTaskContext(input) {
     let peerKeyId = chatType === 'group'
         ? (meta.groupId || session.channelId)
         : (meta.peerId || session.channelId);
-    let threadId = session.threadId || undefined;
+    let threadId = sessionTopicThreadId(session);
     if (session.channelId?.startsWith('trigger:') && session.selfAID && input.getTrigger) {
         const triggerId = session.channelId.slice('trigger:'.length);
         const origin = input.getTrigger(session.selfAID, triggerId)?.origin;

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

@@ -1,4 +1,4 @@
-import { authorizeOperation, buildAuthSubject } from './auth-gateway.js';
+import { authorizeFreshOperation as authorizeOperation, buildAuthSubject } from './auth-gateway.js';
 import { trustedExecutionIdentityInput } from './agent-delegation.js';
 import { isManagementRole } from '../../config/builtin-roles.js';
 import { parsePeerKey } from '../relation/peer-identity.js';
@@ -35,7 +35,7 @@ export function createDelegationAuthorizer({ agentDelegationRegistry, sessionMan
             && !(operation === 'agent.show' && isManagementRole(subject.role))) {
             return { ok: false, code: 'SCOPE_MISMATCH', error: 'only the current Agent can be targeted' };
         }
-        const decision = authorizeOperation({
+        const decision = await authorizeOperation({
             source: 'agent-tool',
             subject,
             intent: {

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

@@ -89,7 +89,7 @@ function readState(value) {
     }
     if (state.credentialType === 'task' || state.credentialType === 'codex-session')
         sanitized.credentialType = state.credentialType;
-    if (state.revocationReason && ['completed', 'interrupted', 'replaced', 'policy_revoked', 'failed', 'revoked'].includes(state.revocationReason)) {
+    if (state.revocationReason && ['completed', 'tool_completed', 'interrupted', 'replaced', 'policy_revoked', 'failed', 'revoked'].includes(state.revocationReason)) {
         sanitized.revocationReason = state.revocationReason;
     }
     return sanitized;
@@ -166,6 +166,9 @@ export class DelegationDiagnostics {
         if (approval.status === 'expired' || approval.expiresAt !== undefined && approval.expiresAt <= Date.now()) {
             return 'approval_expired';
         }
+        // Provider finished the tool item without spending it; the task itself is still live.
+        if (approval.revocationReason === 'tool_completed')
+            return 'approval_not_found';
         if (approval.status !== 'active')
             return this.taskCause(approval);
         return 'approval_not_found';

package/dist/core/auth/operation-authorizer.js

@@ -115,7 +115,8 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
     // still has to name a known operation and pass structural command parsing,
     // but relation/Agent role rules, source lists, and daemon-owner gates are
     // not meaningful limits for code already approved for host-level execution.
-    if (ctx.processRole === 'fullaccess-run' && ctx.dataScope === 'daemon') {
+    if (ctx.processRole === 'fullaccess-run' && ctx.dataScope === 'daemon'
+        && operation !== 'ec.aid.bind' && operation !== 'ec.aid.bind.status') {
         return {
             allow: true,
             operation,
@@ -136,6 +137,14 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
     if (!sourceAllowed) {
         return denyDecision(ctx, 'NOT_ALLOWED', `Operation ${operation} is not available from source ${ctx.source}`, operation, intent.scope, opMeta.dangerous);
     }
+    if (operation === 'ec.aid.bind' || operation === 'ec.aid.bind.status') {
+        const permitted = intent.scope === 'agent' && ctx.processRole !== 'fullaccess-run' && ctx.processRole !== 'daemon-service'
+            && (ctx.isDaemonOwner === true || ctx.processRole === 'daemon-owner'
+                || (isCurrentAgentTarget(ctx) && (role === 'owner' || (operation === 'ec.aid.bind.status' && role === 'admin'))));
+        if (!permitted)
+            return denyDecision(ctx, 'NOT_ALLOWED', 'Protocol Owner binding requires the subject Owner or daemon Owner', operation, intent.scope, opMeta.dangerous);
+        return { allow: true, operation, scope: intent.scope, role, dangerous: opMeta.dangerous, matchedRule: 'protocol-owner-binding' };
+    }
     if (ctx.processRole === 'daemon-service') {
         // ECWeb uses the authenticated daemon service for its read-only menu
         // bootstrap (model/effort, agent metadata, trigger views, etc.). These

package/dist/core/auth/operation-catalog.js

@@ -388,6 +388,14 @@ const OPERATIONS = [
         description: '获取文件内容（需路径沙箱检查）',
         sources: ['slash', 'menu'],
     },
+    {
+        id: 'file.search',
+        category: 'read',
+        dangerous: false,
+        defaultScopes: ['filesystem'],
+        description: '搜索当前项目文件（需文件权限和项目路径沙箱检查）',
+        sources: ['menu'],
+    },
     {
         id: 'file.root.agent',
         category: 'read',
@@ -798,7 +806,9 @@ const OPERATIONS = [
         dangerous: false,
         defaultScopes: ['relation', 'agent'],
         description: `${action} managed conversation threads`,
-        sources: ['agent-tool'],
+        sources: (['summary-show', 'summary-log'].includes(action)
+            ? ['agent-tool', 'menu.cli']
+            : ['agent-tool']),
     })),
     {
         id: 'agent.bootstrapComplete',
@@ -1111,6 +1121,14 @@ const OPERATIONS = [
         description: 'Inspect the current Agent local AID identity and signing state',
         sources: ['agent-tool'],
     },
+    {
+        id: 'ec.aid.bind', category: 'write-agent', dangerous: true, defaultScopes: ['agent'],
+        description: 'Request a protocol Owner binding using the subject SDK client', sources: ['agent-tool', 'menu.cli'],
+    },
+    {
+        id: 'ec.aid.bind.status', category: 'read', dangerous: false, defaultScopes: ['agent'],
+        description: 'Refresh the protocol Owner consensus and binding task projection', sources: ['agent-tool', 'menu.cli'],
+    },
     {
         id: 'ec.aid.lookup',
         category: 'read',

package/dist/core/bootstrap-service.js

@@ -1,4 +1,5 @@
 import { hasSuppliedInitialization } from '../cli/agent-create.js';
+import { ownerResolver, OWNERSHIP_AUTHORIZATION_MAX_AGE_MS } from './ownership/owner-resolver.js';
 import fs from 'fs';
 import path from 'path';
 import { randomBytes } from 'crypto';
@@ -10,7 +11,6 @@ import { loadAgent, saveAgent } from '../config-store.js';
 import { resolveAgentLifecycle, withLifecycleForWrite } from '../config/lifecycle.js';
 import { renderTemplate } from '../eck/manifest-engine.js';
 import { activeBaseagent } from './model/config-scope.js';
-import { getFirstStaticAgentOwner } from '../config/peer-role-resolver.js';
 import { buildEnvelope } from './message/message-utils.js';
 import { BOOTSTRAP_MESSAGE_TTL_MS, BOOTSTRAP_NOTIFICATION_WINDOW_MS, bootstrapInitialMessageOperationId, bootstrapInitialMessageOperationPrefix, bootstrapInitialRetryOperationId, cancelPendingBootstrapPrompts, postBootstrapWelcomeStatus, postBootstrapWelcomeOperationId, } from './bootstrap-messages.js';
 import { findLatestMessageLogOperation } from './message/message-log.js';
@@ -19,15 +19,24 @@ import { chatDirPath } from './session/session-fs-store.js';
 /** Coordinate the write-ahead completion welcome with the lifecycle commit. */
 export async function completeBootstrapWithWelcome(service, aid, welcome, sessions) {
     const lifecycle = service.lifecycleOf(aid);
-    if (lifecycle !== 'bootstrapping' && lifecycle !== 'active') {
+    const config = loadAgent(aid);
+    const suppliedOwnerPending = lifecycle === 'ownerpending' && config?.initialization?.mode === 'supplied';
+    if (lifecycle !== 'bootstrapping' && lifecycle !== 'active' && !suppliedOwnerPending) {
         const result = service.completeBootstrap(aid);
         return { ...result, reloaded: false };
     }
-    if (lifecycle === 'bootstrapping') {
+    if (lifecycle === 'bootstrapping' || suppliedOwnerPending) {
         // Existing per-Owner records are immutable retry snapshots. New interactive
         // Bootstrap completions require the welcome text prepared by the Agent.
-        const config = loadAgent(aid);
-        const deliveries = config?.owners?.length ? postBootstrapWelcomeStatus(aid, config.owners).deliveries : [];
+        await ownerResolver.refresh(aid, { maxAgeMs: OWNERSHIP_AUTHORIZATION_MAX_AGE_MS });
+        const owners = ownerResolver.protocolOwners(aid);
+        if (owners.length === 0) {
+            return {
+                ok: false, code: 'OWNER_CONSENSUS_PENDING', reloaded: false,
+                error: `Fresh Ownership consensus is required before activating ${aid}`,
+            };
+        }
+        const deliveries = owners.length ? postBootstrapWelcomeStatus(aid, owners).deliveries : [];
         const alreadyPrepared = deliveries.length > 0 && deliveries.every(delivery => delivery.status !== 'not_prepared');
         if (config?.initialization?.mode !== 'supplied' && !alreadyPrepared) {
             try {
@@ -108,7 +117,7 @@ export async function completeBootstrapWithWelcome(service, aid, welcome, sessio
             mainSession ??= ownerSession;
         }
     }
-    const result = service.completeBootstrap(aid);
+    const result = service.completeBootstrap(aid, { allowSuppliedOwnerPending: suppliedOwnerPending });
     if (!result.ok)
         return { ...result, reloaded: false };
     if (!welcome) {
@@ -129,7 +138,7 @@ export async function completeBootstrapWithWelcome(service, aid, welcome, sessio
         logger.warn(`[Bootstrap] Completion committed; welcome reconciliation failed for ${aid}: ${message}`);
         welcomeResult = { deliveries: [], error: message };
         try {
-            welcomeResult = { ...postBootstrapWelcomeStatus(aid, loadAgent(aid)?.owners ?? []), error: message };
+            welcomeResult = { ...postBootstrapWelcomeStatus(aid, ownerResolver.protocolOwners(aid)), error: message };
         }
         catch {
             // A local store failure must not turn an already committed lifecycle
@@ -151,6 +160,8 @@ export function createBootstrapOwnerBoundHandler({ getService, agentRegistry, ch
         if (!service)
             return;
         const instance = channelInstances.find(candidate => {
+            if (candidate.channelType !== 'aun')
+                return false;
             const owner = agentRegistry.resolveByChannel(candidate.adapter.channelKey)
                 ?? agentRegistry.resolveByChannel(candidate.adapter.channelName);
             return owner?.aid === agentAid;
@@ -182,7 +193,8 @@ export function createBootstrapCompletionHandler({ service, agentRegistry, chann
         });
         const welcome = aunInstance?.channel;
         const owningAgent = agentRegistry.get(aid);
-        const firstOwnerAid = getFirstStaticAgentOwner(aid);
+        await ownerResolver.refresh(aid, { maxAgeMs: OWNERSHIP_AUTHORIZATION_MAX_AGE_MS });
+        const firstOwnerAid = ownerResolver.owner(aid);
         const sessions = aunInstance && firstOwnerAid && owningAgent
             ? {
                 ensurePostBootstrapMainSession: async (owner) => {
@@ -224,7 +236,8 @@ export class BootstrapService {
         const aid = agent?.aid || ctx.agentAid;
         if (!aid)
             return false;
-        if (hasSuppliedInitialization(aid) || loadAgent(aid)?.initialization)
+        const loadedConfig = loadAgent(aid) || agent?.config;
+        if (hasSuppliedInitialization(aid) || loadedConfig?.initialization)
             return false;
         const key = aid;
         if (this.inFlight.has(key))
@@ -233,7 +246,6 @@ export class BootstrapService {
         let lifecycleStarted = false;
         let notificationPersisted = false;
         let attemptedOperationId;
-        const loadedConfig = loadAgent(aid) || agent?.config;
         if (!loadedConfig) {
             this.inFlight.delete(key);
             return false;
@@ -243,15 +255,21 @@ export class BootstrapService {
             this.inFlight.delete(key);
             return false;
         }
-        if (lifecycle !== 'created' && lifecycle !== 'bootstrapping') {
+        if (lifecycle !== 'created' && lifecycle !== 'ownerpending' && lifecycle !== 'bootstrapping') {
             this.inFlight.delete(key);
             logger.warn(`[Bootstrap] Refusing invalid lifecycle for ${aid}: ${String(loadedConfig.lifecycle)}`);
             return false;
         }
         const config = { ...loadedConfig, lifecycle };
-        const starting = lifecycle === 'created';
+        const starting = lifecycle !== 'bootstrapping';
         const channelType = ctx.channelType || this.channelTypeFromKey(ctx.channelKey);
+        if (channelType === 'aun')
+            await ownerResolver.refresh(aid, { maxAgeMs: OWNERSHIP_AUTHORIZATION_MAX_AGE_MS });
         const configuredRecipient = this.resolveConfiguredRecipient(config, ctx.channelKey, channelType);
+        if (channelType === 'aun' && (!configuredRecipient || ownerResolver.owner(aid) !== configuredRecipient)) {
+            this.inFlight.delete(key);
+            return false;
+        }
         const recipientId = ctx.recipientId || configuredRecipient;
         if (!recipientId) {
             this.inFlight.delete(key);
@@ -261,10 +279,9 @@ export class BootstrapService {
             this.inFlight.delete(key);
             return false;
         }
-        // Bootstrap is initiated by connection/owner binding, not by a reply to
-        // an existing group message. `owners[]` contains personal Owner AIDs, so
-        // the first prompt must always use the private message route. Inbound
-        // group context must never change this initial delivery target.
+        // Bootstrap is initiated by connection/Owner binding, not by a reply to
+        // an existing group message. The initial prompt always uses a private
+        // route to the protocol-confirmed Owner.
         const delivery = { chatType: 'private' };
         const channelId = channelType === 'aun'
             ? recipientId
@@ -382,7 +399,7 @@ export class BootstrapService {
             this.inFlight.delete(key);
         }
     }
-    completeBootstrap(aid) {
+    completeBootstrap(aid, options = {}) {
         const agent = this.agentRegistry.get(aid);
         const loadedConfig = loadAgent(aid) || agent?.config;
         if (!loadedConfig)
@@ -390,7 +407,9 @@ export class BootstrapService {
         const lifecycle = resolveAgentLifecycle(loadedConfig);
         if (lifecycle === 'active')
             return { ok: true, aid, transitioned: false };
-        if (lifecycle !== 'bootstrapping') {
+        const suppliedOwnerPending = options.allowSuppliedOwnerPending === true
+            && lifecycle === 'ownerpending' && loadedConfig.initialization?.mode === 'supplied';
+        if (lifecycle !== 'bootstrapping' && !suppliedOwnerPending) {
             return {
                 ok: false,
                 code: 'INVALID_LIFECYCLE',
@@ -426,8 +445,12 @@ export class BootstrapService {
             throw new Error(`Agent "${aid}" disappeared while updating lifecycle`);
         saveAgent(withLifecycleForWrite(cfg, lifecycle));
     }
-    resolveConfiguredRecipient(config, _channelKey, _channelType) {
-        return config.owners?.[0];
+    resolveConfiguredRecipient(config, channelKey, channelType) {
+        if (channelType === 'aun' || channelKey === 'aun' || channelKey.startsWith('aun#'))
+            return ownerResolver.owner(config.aid);
+        const channel = config.channels?.find(item => item.type !== 'aun'
+            && (item.type === channelKey || `${item.type}#${config.aid}#${item.name}` === channelKey));
+        return channel?.owner ?? channel?.owners?.[0];
     }
     defaultChannelIdForConnection(channelType, recipientId) {
         if (channelType === 'aun')

package/dist/core/channel-loader.js

@@ -62,7 +62,6 @@ export class ChannelLoader {
             type: 'aun',
             name: aunEffName,
             aid: agent.aid,
-            owner: agent.getOwner(aunEffName),
             enabled: true,
             keystorePath: agent.config.aun?.keystorePath,
         };

package/dist/core/channel-runtime.js

@@ -1,5 +1,7 @@
 import path from 'path';
+import { getOwners } from './ownership/owner-resolver.js';
 import fs from 'fs';
+import { removeRestartRequest } from '../utils/restart-safety.js';
 import { tryParseChannelKey } from './channel-loader.js';
 import { agentMdPath } from '../paths.js';
 import { registerAdapterInteractions } from './interaction-router.js';
@@ -13,6 +15,7 @@ import { getFirstStaticAgentOwner } from '../config/peer-role-resolver.js';
 import { isManagementRole } from '../config/builtin-roles.js';
 import { pendingInterruptHints } from './message/pending-hints.js';
 import { logger } from '../utils/logger.js';
+import { sessionLocalTopicId } from './thread/topic-id.js';
 export function createAgentStorageClientResolver(channelInstances) {
     return (channelKey, targetAid) => {
         const instance = channelInstances.find(candidate => candidate.channelType === 'aun'
@@ -145,7 +148,7 @@ export function registerChannelInstance(inst, dependencies) {
             const owningAgent = resolveOwningAgent(channelKey, inst.adapter.channelName);
             return {
                 observable: owningAgent?.getObservable() ?? false,
-                owners: owningAgent ? Array.from(new Set(owningAgent.config.owners ?? [])) : [],
+                owners: owningAgent ? getOwners(owningAgent.aid) : [],
             };
         });
     }
@@ -163,6 +166,7 @@ export function createChannelStartupNotifications({ channelInstances, agentRegis
     const onlineNoticeSent = new Set();
     let pendingRestartNoticeInFlight = null;
     let pendingRestartNoticeSent = false;
+    let pendingRestartRetry;
     const sendOnlineNoticeForChannel = (inst) => {
         const name = inst.adapter.channelName;
         const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey) ?? agentRegistry.resolveByChannel(name);
@@ -219,6 +223,20 @@ export function createChannelStartupNotifications({ channelInstances, agentRegis
             if (pendingRestartNoticeSent || !fs.existsSync(pendingFile))
                 return;
             const pending = JSON.parse(fs.readFileSync(pendingFile, 'utf-8'));
+            if (pending.requestId && pending.requesterPid) {
+                if (pending.requesterPid === process.pid)
+                    return;
+                if (pending.status !== 'ready' || pending.daemonPid !== process.pid) {
+                    if (!pendingRestartRetry) {
+                        pendingRestartRetry = setTimeout(() => {
+                            pendingRestartRetry = undefined;
+                            void trySendPendingRestartNotice();
+                        }, 1_000);
+                        pendingRestartRetry.unref();
+                    }
+                    return;
+                }
+            }
             const adapter = commandHandler.getAdapter(pending.channel)
                 ?? channelInstances.find(inst => inst.adapter.channelKey === pending.channel)?.adapter;
             if (!adapter)
@@ -237,7 +255,10 @@ export function createChannelStartupNotifications({ channelInstances, agentRegis
             });
             if (!restartDelivery.valid) {
                 logger.warn(`[Restart] Discarding pending notification without a valid persisted delivery route: channel=${pending.channel} channelId=${pending.channelId}`);
-                fs.rmSync(pendingFile, { force: true });
+                if (pending.requestId)
+                    removeRestartRequest(pendingFile, pending.requestId);
+                else
+                    fs.rmSync(pendingFile, { force: true });
                 return;
             }
             const replyContext = {
@@ -271,7 +292,12 @@ export function createChannelStartupNotifications({ channelInstances, agentRegis
                 subtype: restartNotice.subtype,
             });
             pendingRestartNoticeSent = true;
-            fs.rmSync(pendingFile, { force: true });
+            if (pendingRestartRetry)
+                clearTimeout(pendingRestartRetry);
+            if (pending.requestId)
+                removeRestartRequest(pendingFile, pending.requestId);
+            else
+                fs.rmSync(pendingFile, { force: true });
             logger.info(`[Restart] Notification sent via ${pending.channel}`);
         })();
         try {
@@ -390,7 +416,7 @@ export function wrapChannelSend(inst, dependencies) {
                             from: owningAgent?.aid ?? envelope.agentName ?? session.selfAID ?? 'self',
                             to: String(target || envelope.channelId),
                             sessionId: session.id,
-                            threadId: envelope.replyContext?.threadId || session.threadId || '',
+                            threadId: envelope.replyContext?.localTopicId || sessionLocalTopicId(session) || '',
                             chatType: isGroup ? 'group' : 'private',
                             groupId: isGroup ? String(session.metadata?.groupId || session.channelId) : null,
                             msgId: `${envelope.taskId || 'out'}_${Date.now()}`,