@evomap/evolver-proxy 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/daemon/proxyDaemon.d.ts

@@ -56,6 +56,8 @@ export interface ProxyDaemonDeps {
         dir: string;
         env?: NodeJS.ProcessEnv;
     };
+    /** V1 collaboration task operations are synchronous; tests may shorten the Hub timeout. */
+    collaborationOperationTimeoutMs?: number;
 }
 export interface ProxyTickReport {
     outbound: OutboundResult;
@@ -118,6 +120,7 @@ export declare class ProxyDaemon {
     private readonly reuseResultReporter;
     private readonly validator;
     private readonly atp;
+    private readonly collaborationFacade;
     private ipc;
     private readonly now;
     private readonly random;

package/dist/daemon/proxyDaemon.js

@@ -6,6 +6,7 @@ import { executeForceUpdate } from '../selfUpdate/executor.js';
 import { reportPendingSelfUpdateLastUpdate, reportSelfUpdateLastUpdate } from '../selfUpdate/lastUpdate.js';
 import { backfillProxyTraceUploads } from '../llm/traceBackfill.js';
 import { hubAuthFailureHint } from './selectHub.js';
+import { CollaborationFacade } from './collaborationFacade.js';
 export const DEFAULT_IPC_PORT = 19820;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 const MAX_PROXY_TICK_ERROR_LENGTH = 2_000;
@@ -28,6 +29,7 @@ export class ProxyDaemon {
     reuseResultReporter;
     validator;
     atp;
+    collaborationFacade;
     ipc;
     now;
     random;
@@ -93,9 +95,20 @@ export class ProxyDaemon {
             pumpHandlers: ['core'], // proxy 出站归 SyncEngine, 不在此双 claim
             ...(deps.lockPath ? { lockPath: deps.lockPath } : {}),
         });
+        this.collaborationFacade = new CollaborationFacade({
+            store: this.store,
+            hub: hubToUse,
+            now: this.now,
+            notifyOutbound: () => this.notifyNewOutbound(),
+            ...(deps.runtimeNamespace ? { runtimeNamespace: deps.runtimeNamespace } : {}),
+            ...(deps.collaborationOperationTimeoutMs !== undefined ? { operationTimeoutMs: deps.collaborationOperationTimeoutMs } : {}),
+        });
         this.sync = new SyncEngine({
             store: this.store, hub: hubToUse, proxyHandler, now: this.now,
             ...(deps.runtimeNamespace ? { runtimeNamespace: deps.runtimeNamespace } : {}),
+            onOutboundSucceeded: (envelope, result) => this.collaborationFacade.handleOutboundSucceeded(envelope, result),
+            onOutboundTerminal: (envelope, error) => this.collaborationFacade.handleOutboundTerminal(envelope, error),
+            normalizeInboundEnvelope: (envelope) => this.collaborationFacade.normalizeInboundEnvelope(envelope),
             ...(deps.traceBackfill ? { onOutboundFlushed: () => { this.drainProxyTraceBackfill(); } } : {}),
         });
         this.lifecycle = new LifecycleManager({
@@ -555,6 +568,8 @@ export class ProxyDaemon {
         return Number.isFinite(n) && n > 0 ? n : null;
     }
     async handleProxyRoute(ctx) {
+        if (await this.collaborationFacade.handle(ctx))
+            return true;
         const handledAtp = await this.handleAtpRoute(ctx);
         if (handledAtp)
             return true;
@@ -711,6 +726,60 @@ export class ProxyDaemon {
             ctx.json(200, { ...distill, queued: submission !== null, submission });
             return true;
         }
+        if (ctx.route === 'POST /agent/search') {
+            const body = asRecord(await ctx.readJson());
+            const directory = this.deps.hub.agentDirectory ?? hubNs.unsupportedAgentDirectoryCapability();
+            const parsed = parseAgentSearchRequest(body);
+            if (!parsed.ok) {
+                respondAgentDirectory(ctx, parsed);
+                return true;
+            }
+            const result = await directory.search(parsed.value);
+            respondAgentDirectory(ctx, result);
+            return true;
+        }
+        if (ctx.route === 'POST /agent/profile') {
+            const body = asRecord(await ctx.readJson());
+            const directory = this.deps.hub.agentDirectory ?? hubNs.unsupportedAgentDirectoryCapability();
+            let agentId;
+            let timeoutMs;
+            try {
+                agentId = hubNs.normalizeAgentId(typeof body['agent_id'] === 'string' ? body['agent_id'] : '');
+                timeoutMs = hubNs.normalizeAgentDirectoryTimeout(typeof body['timeout_ms'] === 'number' ? body['timeout_ms'] : undefined);
+            }
+            catch (error) {
+                respondAgentDirectory(ctx, invalidAgentDirectoryRequest(error));
+                return true;
+            }
+            const result = await directory.getProfile(agentId, { timeoutMs });
+            respondAgentDirectory(ctx, result);
+            return true;
+        }
+        if (ctx.route === 'POST /agent/discover') {
+            const body = asRecord(await ctx.readJson());
+            const directory = this.deps.hub.agentDirectory ?? hubNs.unsupportedAgentDirectoryCapability();
+            let request;
+            try {
+                request = hubNs.normalizeAgentTaskDiscoveryRequest({
+                    title: typeof body['title'] === 'string' ? body['title'] : '',
+                    ...(typeof body['description'] === 'string' ? { description: body['description'] } : {}),
+                    ...(Array.isArray(body['signals']) ? { signals: body['signals'] } : {}),
+                    ...(typeof body['availability'] === 'string' ? { availability: body['availability'] } : {}),
+                    ...(typeof body['sort'] === 'string' ? { sort: body['sort'] } : {}),
+                    ...(typeof body['order'] === 'string' ? { order: body['order'] } : {}),
+                    ...(typeof body['cursor'] === 'string' ? { cursor: body['cursor'] } : {}),
+                    ...(typeof body['limit'] === 'number' ? { limit: body['limit'] } : {}),
+                    ...(typeof body['timeout_ms'] === 'number' ? { timeoutMs: body['timeout_ms'] } : {}),
+                });
+            }
+            catch (error) {
+                respondAgentDirectory(ctx, invalidAgentDirectoryRequest(error));
+                return true;
+            }
+            const result = await directory.discoverForTask(request);
+            respondAgentDirectory(ctx, result);
+            return true;
+        }
     }
     async searchAssets(query) {
         const limit = Math.max(1, Math.min(Number(query.limit ?? 5), 25));
@@ -862,6 +931,48 @@ function assetKind(value) {
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
+function respondAgentDirectory(ctx, result) {
+    if (result.ok) {
+        ctx.json(200, result);
+        return;
+    }
+    const status = {
+        invalid_request: 400,
+        permission_denied: 403,
+        capability_unavailable: 501,
+        invalid_response: 502,
+        hub_unavailable: 503,
+        timeout: 504,
+    }[result.error.code];
+    ctx.json(status, result);
+}
+function parseAgentSearchRequest(body) {
+    try {
+        return { ok: true, value: hubNs.normalizeAgentSearchRequest({
+                ...(typeof body['query'] === 'string' ? { query: body['query'] } : {}),
+                ...(Array.isArray(body['signals']) ? { signals: body['signals'] } : {}),
+                ...(typeof body['availability'] === 'string' ? { availability: body['availability'] } : {}),
+                ...(typeof body['sort'] === 'string' ? { sort: body['sort'] } : {}),
+                ...(typeof body['order'] === 'string' ? { order: body['order'] } : {}),
+                ...(typeof body['cursor'] === 'string' ? { cursor: body['cursor'] } : {}),
+                ...(typeof body['limit'] === 'number' ? { limit: body['limit'] } : {}),
+                ...(typeof body['timeout_ms'] === 'number' ? { timeoutMs: body['timeout_ms'] } : {}),
+            }) };
+    }
+    catch (error) {
+        return invalidAgentDirectoryRequest(error);
+    }
+}
+function invalidAgentDirectoryRequest(error) {
+    return {
+        ok: false,
+        error: {
+            code: 'invalid_request',
+            retryable: false,
+            message: error instanceof Error ? error.message.slice(0, 120) : 'invalid_request',
+        },
+    };
+}
 function stringBody(body, key) {
     const v = body[key];
     return typeof v === 'string' && v.length > 0 ? v : undefined;

package/dist/daemon/selectHub.js

@@ -1,3 +1,4 @@
+import { resolveHubUrl as resolvePublicHubUrl } from '@evomap/evolver-adapter-public';
 /** 据 EVOMAP_HUB_MODE 选 hub 实现(public|private). 缺省 public. bin 据此挂对应 adapter. */
 export function resolveHubMode(env) {
     const m = (env['EVOMAP_HUB_MODE'] ?? 'public').toLowerCase();
@@ -6,7 +7,22 @@ export function resolveHubMode(env) {
     return m;
 }
 export function resolveHubUrl(env) {
-    return env['EVOMAP_HUB_URL'] ?? 'https://dev.evomap.ai';
+    if ((env['EVOMAP_HUB_MODE'] ?? 'public').toLowerCase() === 'private')
+        return resolvePrivateHubUrl(env);
+    return resolvePublicHubUrl(env);
+}
+function resolvePrivateHubUrl(env) {
+    return trimmed(env['EVOMAP_HUB_URL'])
+        ?? trimmed(env['A2A_HUB_URL'])
+        ?? trimmed(env['EVOLVER_DEFAULT_HUB_URL'])
+        ?? resolvePublicHubUrl({});
+}
+function trimmed(value) {
+    const v = value?.trim();
+    if (!v)
+        return undefined;
+    const normalized = v.replace(/\/+$/, '');
+    return normalized || undefined;
 }
 /**
  * Actionable hint for a hub AUTH failure (401/403), tailored to the hub's error code so it does NOT misdirect

package/dist/private/adapterLoader.d.ts

@@ -1,4 +1,4 @@
-import type { hub as hubNs } from '@evomap/evolver-core';
+import { hub as hubNs } from '@evomap/evolver-core';
 import type { HelloResult, HeartbeatOptions, HeartbeatResult } from '../lifecycle/manager.js';
 export type PrivateHubWithLifecycle = hubNs.HubCapability & {
     hello(opts: {
@@ -27,6 +27,8 @@ export interface ConnectPrivateHubOptions {
     senderId: () => string | undefined;
     env?: Record<string, string | undefined>;
     now?: () => number;
+    /** One-shot invitation token (evoinv_…) — preferred over the SSO bearer for token_required hubs. */
+    invitationToken?: string;
 }
 type DynamicImporter = (specifier: string) => Promise<unknown>;
 export interface PrivateProxyHubRuntime {
@@ -41,6 +43,9 @@ export interface ConnectPrivateProxyHubOptions {
     importer?: DynamicImporter;
 }
 export declare function resolvePrivateEnterpriseToken(env: Record<string, string | undefined>): string | undefined;
+/** One-shot invitation token (evoinv_…), matching the hub's official onboarding script (A2A_INVITATION_TOKEN).
+ *  Preferred over the enterprise token for the default token_required enrollment mode. */
+export declare function resolvePrivateInvitationToken(env: Record<string, string | undefined>): string | undefined;
 export declare function resolvePrivateEnterpriseSubject(env: Record<string, string | undefined>): string;
 export declare function connectPrivateProxyHub(opts: ConnectPrivateProxyHubOptions): Promise<PrivateProxyHubRuntime>;
 export {};

package/dist/private/adapterLoader.js

@@ -1,14 +1,21 @@
+import { hub as hubNs } from '@evomap/evolver-core';
 const DEFAULT_PRIVATE_ADAPTER_MODULE = '@evomap/evolver-adapter-private';
 export function resolvePrivateEnterpriseToken(env) {
     return firstEnv(env, 'EVOMAP_ENTERPRISE_TOKEN', 'EVOMAP_PRIVATE_HUB_TOKEN', 'PHUB_ENTERPRISE_TOKEN', 'PRIVATE_HUB_ENTERPRISE_TOKEN');
 }
+/** One-shot invitation token (evoinv_…), matching the hub's official onboarding script (A2A_INVITATION_TOKEN).
+ *  Preferred over the enterprise token for the default token_required enrollment mode. */
+export function resolvePrivateInvitationToken(env) {
+    return firstEnv(env, 'A2A_INVITATION_TOKEN');
+}
 export function resolvePrivateEnterpriseSubject(env) {
     return firstEnv(env, 'EVOMAP_ENTERPRISE_SUBJECT', 'EVOMAP_PRIVATE_SUBJECT', 'PHUB_ENTERPRISE_SUBJECT', 'USER') ?? 'evolver-proxy';
 }
 export async function connectPrivateProxyHub(opts) {
+    const invitationToken = resolvePrivateInvitationToken(opts.env);
     const token = resolvePrivateEnterpriseToken(opts.env);
-    if (!token) {
-        throw new Error('EVOMAP_HUB_MODE=private 需要 EVOMAP_ENTERPRISE_TOKEN（也兼容 EVOMAP_PRIVATE_HUB_TOKEN / PHUB_ENTERPRISE_TOKEN）');
+    if (!token && !invitationToken) {
+        throw new Error('EVOMAP_HUB_MODE=private 需要 A2A_INVITATION_TOKEN（推荐，对齐 PrivateHub onboarding）或 EVOMAP_ENTERPRISE_TOKEN（也兼容 EVOMAP_PRIVATE_HUB_TOKEN / PHUB_ENTERPRISE_TOKEN）');
     }
     const moduleName = opts.env['EVOMAP_PRIVATE_ADAPTER_MODULE']?.trim() || DEFAULT_PRIVATE_ADAPTER_MODULE;
     const connectPrivateHub = await loadConnectPrivateHub(moduleName, opts.importer ?? ((specifier) => import(specifier)));
@@ -21,11 +28,15 @@ export async function connectPrivateProxyHub(opts) {
         now,
         sso: {
             identity: () => ({ subject }),
-            exchange: async () => ({ token }),
+            exchange: async () => ({ token: token ?? '' }),
             now,
         },
+        ...(invitationToken ? { invitationToken } : {}),
     });
     assertPrivateLifecycle(hub, moduleName);
+    if (!hub.agentDirectory) {
+        hub.agentDirectory = hubNs.unsupportedAgentDirectoryCapability('private_hub_agent_directory_not_supported');
+    }
     return { hub, auth };
 }
 async function loadConnectPrivateHub(moduleName, importer) {

package/dist/router/messagesRoute.d.ts

@@ -112,6 +112,19 @@ export interface MessagesResponse {
 }
 export declare function captureTraceMetadata(value: unknown, env?: NodeJS.ProcessEnv): unknown;
 export declare function resolveTierModels(env?: NodeJS.ProcessEnv): Partial<Record<Tier, string>>;
+export type TierConfigWarningReason = 'missing_tier_models' | 'duplicate_tier_models' | 'all_tier_models_same';
+export interface TierConfigWarning {
+    event: 'router_config_warning';
+    reason: TierConfigWarningReason;
+    message: string;
+    configured_tiers: Tier[];
+    missing_tiers?: Tier[];
+    duplicate_models?: Array<{
+        model: string;
+        tiers: Tier[];
+    }>;
+}
+export declare function detectTierModelConfigWarnings(models: Partial<Record<Tier, string>>): TierConfigWarning[];
 interface ClaudeId {
     family: string;
     major: number;

package/dist/router/messagesRoute.js

@@ -34,6 +34,58 @@ export function resolveTierModels(env = process.env) {
         out.expensive = env['EVOMAP_MODEL_EXPENSIVE'];
     return out;
 }
+const TIER_ORDER = ['cheap', 'mid', 'expensive'];
+export function detectTierModelConfigWarnings(models) {
+    const configuredTiers = TIER_ORDER.filter((tier) => {
+        const model = models[tier];
+        return typeof model === 'string' && model.length > 0;
+    });
+    if (configuredTiers.length === 0)
+        return [];
+    const warnings = [];
+    const missingTiers = TIER_ORDER.filter((tier) => !configuredTiers.includes(tier));
+    if (missingTiers.length > 0) {
+        warnings.push({
+            event: 'router_config_warning',
+            reason: 'missing_tier_models',
+            message: 'Router tier config is partial; unset tiers will pass the client model through.',
+            configured_tiers: configuredTiers,
+            missing_tiers: missingTiers,
+        });
+    }
+    const byModel = new Map();
+    for (const tier of configuredTiers) {
+        const model = models[tier];
+        if (!model)
+            continue;
+        byModel.set(model, [...(byModel.get(model) ?? []), tier]);
+    }
+    const duplicateModels = Array.from(byModel.entries())
+        .filter(([, tiers]) => tiers.length > 1)
+        .map(([model, tiers]) => ({ model, tiers }));
+    const allSame = configuredTiers.length === TIER_ORDER.length
+        && duplicateModels.length === 1
+        && duplicateModels[0].tiers.length === TIER_ORDER.length;
+    if (allSame) {
+        warnings.push({
+            event: 'router_config_warning',
+            reason: 'all_tier_models_same',
+            message: 'All router tiers resolve to the same model; routing will still run but cannot change cost/latency tiers.',
+            configured_tiers: configuredTiers,
+            duplicate_models: duplicateModels,
+        });
+    }
+    else if (duplicateModels.length > 0) {
+        warnings.push({
+            event: 'router_config_warning',
+            reason: 'duplicate_tier_models',
+            message: 'Multiple router tiers resolve to the same model; routing will still run but tier separation is degraded.',
+            configured_tiers: configuredTiers,
+            duplicate_models: duplicateModels,
+        });
+    }
+    return warnings;
+}
 export function parseClaudeId(modelId) {
     if (typeof modelId !== 'string')
         return null;
@@ -386,6 +438,10 @@ export function buildMessagesHandler(opts) {
     const log = opts.logger ?? console;
     const env = opts.env ?? process.env;
     const enabled = typeof opts.routerEnabled === 'boolean' ? opts.routerEnabled : env['EVOMAP_ROUTER_ENABLED'] === '1';
+    if (enabled) {
+        for (const warning of detectTierModelConfigWarnings(resolveTierModels(env)))
+            log.warn?.(j(warning));
+    }
     // Native body capture defaults to v1-compatible full trace mode. Operators that need metadata-only rows must
     // explicitly disable it (a compliance decision; see bodyCapture.ts and docs/trace-body-capture.md).
     const captureBodies = captureBodiesEnabled(env);

package/dist/sync/engine.d.ts

@@ -19,6 +19,12 @@ export interface SyncEngineDeps {
     now: () => number;
     runtimeNamespace?: string;
     leaseMs?: number;
+    /** Finalize durable facade state after the Hub accepted one outbound envelope. */
+    onOutboundSucceeded?: (envelope: Envelope, result: unknown) => void | Promise<void>;
+    /** Cache a durable facade terminal result after SyncEngine moved the envelope to DLQ. */
+    onOutboundTerminal?: (envelope: Envelope, error: unknown) => void | Promise<void>;
+    /** Canonicalize an inbound envelope before durable insertion. */
+    normalizeInboundEnvelope?: (envelope: Envelope) => Envelope;
     onOutboundFlushed?: (result: OutboundResult) => void | Promise<void>;
     env?: NodeJS.ProcessEnv;
 }
@@ -36,11 +42,6 @@ export interface InboundResult {
     nextPollAfterMs?: number;
     hasMore: boolean;
 }
-/**
- * SyncEngine(M6-2): proxy↔hub 双向同步. 移植 v1 sync/{engine,outbound,inbound} 到 TS,
- * hub I/O 全走 HubCapability.mailbox(非裸 hubFetch). tick 方法纯逻辑(注入 now), 可对 FakeHubCapability 确定性测;
- * 定时器循环(start/stop)是薄包装, 由 M6-4 daemon 装配驱动.
- */
 export declare class SyncEngine {
     private readonly deps;
     private lastActivityAt;

package/dist/sync/engine.js

@@ -1,4 +1,5 @@
 import { mailbox, hub as hubNs } from '@evomap/evolver-core';
+import { HubClientError } from '@evomap/evolver-adapter-public';
 import { normalizeProxyTraceOutboundPayload } from '../llm/traceBackfill.js';
 import { applyTraceCollectionConfig } from '../llm/traceControl.js';
 import { hubAuthFailureHint } from '../daemon/selectHub.js';
@@ -15,8 +16,12 @@ const STATE = {
     lastError: 'sync:last_error',
     authStatus: 'hub:auth_status',
 };
-function isTerminal(err) {
-    return err instanceof hubNs.PublishRejectedError && err.terminal === true;
+function isTerminal(err, envelopeType) {
+    if (err instanceof hubNs.PublishRejectedError && err.terminal === true)
+        return true;
+    return (envelopeType === 'task_claim' || envelopeType === 'task_complete')
+        && err instanceof HubClientError
+        && (err.status === 404 || err.status === 409);
 }
 function isRetryableRejection(err) {
     return err instanceof hubNs.PublishRejectedError
@@ -27,9 +32,30 @@ function isHubUnreachable(err) {
     const e = err;
     return e?.name === 'HubUnreachableError' || e?.code === 'HUB_UNREACHABLE';
 }
+function isRetryableTransportError(err) {
+    if (isRetryableRejection(err) || isHubUnreachable(err)
+        || (err instanceof HubClientError && err.status === 429))
+        return true;
+    const e = err;
+    const rawStatus = e?.statusCode ?? e?.status;
+    const status = typeof rawStatus === 'number' ? rawStatus : Number(rawStatus);
+    if (Number.isFinite(status) && status >= 500 && status <= 599)
+        return true;
+    if (e?.retryable === true)
+        return true;
+    const signature = `${String(e?.name ?? '')} ${String(e?.code ?? '')} ${err instanceof Error ? err.message : ''}`;
+    return /\b5\d\d\b|ECONN|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|fetch/i.test(signature);
+}
 function retryAfterMs(err) {
+    const body = err instanceof HubClientError && err.body && typeof err.body === 'object' && !Array.isArray(err.body)
+        ? err.body
+        : undefined;
+    const bodyRetryMs = Number(body?.['retry_after_ms'] ?? body?.['retryAfterMs']);
+    const bodyRetrySeconds = Number(body?.['retry_after'] ?? body?.['retryAfter']);
     const retry = err?.retryAfterMs
-        ?? err?.details?.retryAfterMs;
+        ?? err?.details?.retryAfterMs
+        ?? (Number.isFinite(bodyRetryMs) ? bodyRetryMs : undefined)
+        ?? (Number.isFinite(bodyRetrySeconds) ? bodyRetrySeconds * 1_000 : undefined);
     return Math.max(1_000, typeof retry === 'number' && Number.isFinite(retry) ? retry : 60_000);
 }
 function errorMessage(err) {
@@ -74,6 +100,53 @@ function envelopeToAgentEvent(e) {
  * hub I/O 全走 HubCapability.mailbox(非裸 hubFetch). tick 方法纯逻辑(注入 now), 可对 FakeHubCapability 确定性测;
  * 定时器循环(start/stop)是薄包装, 由 M6-4 daemon 装配驱动.
  */
+function applyMailboxPushManyOutcomes(group, outcomes, deps) {
+    const byId = new Map(outcomes.map((outcome) => [outcome.id, outcome]));
+    const result = { sent: 0, failed: 0, terminal: 0, deferred: 0, completedDuplicates: 0 };
+    for (const pushed of group) {
+        const outcome = byId.get(pushed.event.id) ?? byId.get(pushed.original.id);
+        if (outcome?.status === 'failed') {
+            const msg = redactAndTruncate(outcome.reason ?? 'mailbox_push_rejected');
+            const authLike = isAuthError(msg);
+            result.firstFailure ??= msg;
+            const retryable = outcome.terminal !== true
+                && (outcome.retryable === true || (typeof outcome.retryAfterMs === 'number' && Number.isFinite(outcome.retryAfterMs)));
+            if (authLike || retryable) {
+                const nowAfterFailure = deps.now();
+                const retry = Math.max(1_000, typeof outcome.retryAfterMs === 'number' && Number.isFinite(outcome.retryAfterMs) ? outcome.retryAfterMs : 60_000);
+                result.deferredFailure ??= { msg, retryAfterMs: retry };
+                if (authLike) {
+                    result.authFailed = true;
+                    result.authErrorMessage ??= msg;
+                }
+                deps.store.defer(pushed.original.id, msg, nowAfterFailure, retry);
+                for (const duplicate of pushed.duplicates)
+                    deps.store.defer(duplicate.id, msg, nowAfterFailure, retry);
+                result.deferred += 1 + pushed.duplicates.length;
+            }
+            else {
+                const maxAttempts = outcome.terminal ? 1 : undefined;
+                deps.store.fail(pushed.original.id, msg, deps.now(), maxAttempts);
+                for (const duplicate of pushed.duplicates)
+                    deps.store.fail(duplicate.id, msg, deps.now(), maxAttempts);
+                if (outcome.terminal)
+                    result.terminal += 1 + pushed.duplicates.length;
+                else
+                    result.failed += 1 + pushed.duplicates.length;
+            }
+        }
+        else {
+            deps.store.complete(pushed.original.id, deps.now());
+            for (const duplicate of pushed.duplicates)
+                deps.store.complete(duplicate.id, deps.now());
+            if (pushed.dedupKey)
+                deps.store.markProcessed(pushed.dedupKey, { type: pushed.original.type }, deps.now());
+            result.sent += 1;
+            result.completedDuplicates += pushed.duplicates.length;
+        }
+    }
+    return result;
+}
 export class SyncEngine {
     deps;
     lastActivityAt;
@@ -133,57 +206,21 @@ export class SyncEngine {
                 try {
                     const result = await this.deps.hub.mailbox.pushMany(group.map((entry) => entry.event));
                     if (isMailboxPushManyResult(result)) {
-                        const byId = new Map(result.outcomes.map((outcome) => [outcome.id, outcome]));
-                        let firstFailure;
-                        let deferredFailure;
-                        for (const pushed of group) {
-                            const outcome = byId.get(pushed.event.id) ?? byId.get(pushed.original.id);
-                            if (outcome?.status === 'failed') {
-                                const msg = redactAndTruncate(outcome.reason ?? 'mailbox_push_rejected');
-                                const authLike = isAuthError(msg);
-                                firstFailure ??= msg;
-                                const retryable = outcome.terminal !== true
-                                    && (outcome.retryable === true || (typeof outcome.retryAfterMs === 'number' && Number.isFinite(outcome.retryAfterMs)));
-                                if (authLike || retryable) {
-                                    const nowAfterFailure = this.deps.now();
-                                    const retry = Math.max(1_000, typeof outcome.retryAfterMs === 'number' && Number.isFinite(outcome.retryAfterMs) ? outcome.retryAfterMs : 60_000);
-                                    deferredFailure ??= { msg, retryAfterMs: retry };
-                                    if (authLike) {
-                                        authFailed = true;
-                                        authErrorMessage ??= msg;
-                                    }
-                                    this.deps.store.defer(pushed.original.id, msg, nowAfterFailure, retry);
-                                    for (const duplicate of pushed.duplicates)
-                                        this.deps.store.defer(duplicate.id, msg, nowAfterFailure, retry);
-                                    deferred += 1 + pushed.duplicates.length;
-                                }
-                                else {
-                                    const maxAttempts = outcome.terminal ? 1 : undefined;
-                                    this.deps.store.fail(pushed.original.id, msg, this.deps.now(), maxAttempts);
-                                    for (const duplicate of pushed.duplicates)
-                                        this.deps.store.fail(duplicate.id, msg, this.deps.now(), maxAttempts);
-                                    if (outcome.terminal)
-                                        terminal += 1 + pushed.duplicates.length;
-                                    else
-                                        failed += 1 + pushed.duplicates.length;
-                                }
-                            }
-                            else {
-                                this.deps.store.complete(pushed.original.id, this.deps.now());
-                                for (const duplicate of pushed.duplicates)
-                                    this.deps.store.complete(duplicate.id, this.deps.now());
-                                if (pushed.dedupKey)
-                                    this.deps.store.markProcessed(pushed.dedupKey, { type: pushed.original.type }, this.deps.now());
-                                sent += 1;
-                                completedDuplicates += pushed.duplicates.length;
-                            }
-                        }
-                        if (firstFailure)
-                            this.markError(`outbound: ${firstFailure}`, isAuthError(firstFailure));
-                        if (deferredFailure) {
+                        const applied = applyMailboxPushManyOutcomes(group, result.outcomes, this.deps);
+                        sent += applied.sent;
+                        failed += applied.failed;
+                        terminal += applied.terminal;
+                        deferred += applied.deferred;
+                        completedDuplicates += applied.completedDuplicates;
+                        if (applied.authFailed)
+                            authFailed = true;
+                        authErrorMessage ??= applied.authErrorMessage;
+                        if (applied.firstFailure)
+                            this.markError(`outbound: ${applied.firstFailure}`, isAuthError(applied.firstFailure));
+                        if (applied.deferredFailure) {
                             const nowAfterFailure = this.deps.now();
                             for (const pending of batch.slice(j)) {
-                                this.deps.store.defer(pending.id, deferredFailure.msg, nowAfterFailure, deferredFailure.retryAfterMs);
+                                this.deps.store.defer(pending.id, applied.deferredFailure.msg, nowAfterFailure, applied.deferredFailure.retryAfterMs);
                                 deferred += 1;
                             }
                             break;
@@ -224,7 +261,7 @@ export class SyncEngine {
                         authErrorMessage ??= msg;
                         break;
                     }
-                    else if (isTerminal(err)) {
+                    else if (isTerminal(err, group[0].original.type)) {
                         for (const pushed of group) {
                             this.deps.store.fail(pushed.original.id, msg, this.deps.now(), 1);
                             for (const duplicate of pushed.duplicates)
@@ -233,7 +270,7 @@ export class SyncEngine {
                         }
                         i = j - 1;
                     }
-                    else if (isRetryableRejection(err) || isHubUnreachable(err)) {
+                    else if (isRetryableTransportError(err)) {
                         const nowAfterFailure = this.deps.now();
                         const retry = retryAfterMs(err);
                         for (const pushed of group) {
@@ -273,7 +310,8 @@ export class SyncEngine {
                 continue;
             }
             try {
-                await this.deps.proxyHandler(guard.envelope);
+                const handlerResult = await this.deps.proxyHandler(guard.envelope);
+                await this.deps.onOutboundSucceeded?.(e, handlerResult);
                 this.deps.store.complete(e.id, this.deps.now());
                 if (outboundDedupKey)
                     this.deps.store.markProcessed(outboundDedupKey, { type: e.type }, this.deps.now());
@@ -294,11 +332,15 @@ export class SyncEngine {
                     authErrorMessage ??= msg;
                     break;
                 }
-                else if (isTerminal(err)) {
+                else if (isTerminal(err, e.type)) {
+                    // A concurrent facade attempt may already have finalized this durable intent successfully.
+                    if (this.deps.store.getById(e.id)?.status === 'done')
+                        continue;
                     this.deps.store.fail(e.id, msg, this.deps.now(), 1); // maxAttempts=1 → 直进 DLQ, 不反复打经济端点
+                    await this.deps.onOutboundTerminal?.(e, err);
                     terminal += 1;
                 }
-                else if (isRetryableRejection(err) || isHubUnreachable(err)) {
+                else if (isRetryableTransportError(err)) {
                     const nowAfterFailure = this.deps.now();
                     const retry = retryAfterMs(err);
                     for (const pending of batch.slice(i)) {
@@ -347,7 +389,8 @@ export class SyncEngine {
                         this.deps.store.setState(CURSOR_KEY, ev.cursor);
                     continue;
                 }
-                const env = this.toEnvelope(ev);
+                const rawEnvelope = this.toEnvelope(ev);
+                const env = rawEnvelope ? (this.deps.normalizeInboundEnvelope?.(rawEnvelope) ?? rawEnvelope) : null;
                 if (env) {
                     this.deps.store.send(env);
                     this.deps.store.markProcessed(dedupKey, { type: ev.type }, this.deps.now());
@@ -450,6 +493,7 @@ export class SyncEngine {
         try {
             return mailbox.createEnvelope({
                 type: ev.type, payload: ev.payload, idempotencyKey: `inbound:${ev.id}`,
+                ...(ev.refId ? { replyTo: ev.refId } : {}),
                 ...(this.deps.runtimeNamespace ? { runtimeNamespace: this.deps.runtimeNamespace } : {}),
                 now: this.deps.now(),
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver-proxy",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.2",
   "private": false,
   "type": "module",
   "description": "系统级 mailbox/hub 同步 daemon (Node)",
@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-bedrock-runtime": "^3.1053.0",
-    "@evomap/evolver-adapter-public": "2.0.0-beta.1",
-    "@evomap/evolver-core": "2.0.0-beta.1"
+    "@evomap/evolver-adapter-public": "2.0.0-beta.2",
+    "@evomap/evolver-core": "2.0.0-beta.2"
   },
   "publishConfig": {
     "access": "public",
@@ -35,6 +35,7 @@
   },
   "files": [
     "dist/",
+    "assets/",
     "README.md",
     "package.json"
   ]