@evomap/evolver-proxy 2.0.0-beta.9 → 2.0.1

package/dist/daemon/collaborationFacade.js

@@ -353,16 +353,19 @@ export class CollaborationFacade {
     async mailboxPoll(ctx) {
         const body = asRecord(await ctx.readJson());
         const type = optionalString(body['type']);
-        const direction = optionalDirection(body['direction']);
+        const channel = optionalString(body['channel']);
+        const direction = optionalDirection(body['direction']) ?? 'inbound';
         const limit = boundedMailboxPollLimit(body['limit']);
-        const messages = this.deps.store.list({
-            status: 'pending',
-            runtimeNamespace: this.deps.runtimeNamespace ?? 'default',
-            ...(type ? { type } : {}),
-            ...(direction ? { direction } : {}),
-            limit,
-        })
-            .map((message) => TASK_RESULT_TYPES.has(message.type) ? v1Message(message) : message);
+        const runtimeNamespace = legacyMailboxRuntimeNamespace(channel, this.deps.runtimeNamespace ?? 'default');
+        const messages = runtimeNamespace === undefined
+            ? []
+            : this.deps.store.list({
+                status: 'pending',
+                runtimeNamespace,
+                ...(type ? { type } : {}),
+                direction,
+                limit,
+            }).map(v1Message);
         ctx.json(200, { messages, count: messages.length });
         return true;
     }
@@ -671,18 +674,19 @@ function v1Message(message) {
     return {
         id: message.id,
         message_id: message.id,
-        channel: 'evomap-hub',
+        channel: message.runtimeNamespace === 'default' ? 'evomap-hub' : message.runtimeNamespace,
         direction: message.direction,
         type: message.type === 'dm_outbound' || isDirectDialogMessage(message) ? 'dm' : message.type,
         status: message.status === 'done' ? (message.direction === 'inbound' ? 'delivered' : 'synced') : message.status,
         payload: message.payload,
-        priority: 'normal',
-        ref_id: message.replyTo,
+        priority: message.priority,
+        ref_id: message.replyTo ?? message.correlationId,
         created_at: message.createdAt,
         synced_at: message.status === 'done' ? message.updatedAt : null,
         expires_at: message.ttlAt,
         retry_count: message.attempts,
-        error: null,
+        next_retry_at: message.nextRetryAt,
+        error: message.lastError,
     };
 }
 function writeOperationError(ctx, error) {
@@ -794,6 +798,12 @@ function optionalString(value) {
 function optionalDirection(value) {
     return value === 'inbound' || value === 'outbound' || value === 'local' ? value : undefined;
 }
+function legacyMailboxRuntimeNamespace(requestedChannel, runtimeNamespace) {
+    if (requestedChannel === undefined || requestedChannel === 'evomap-hub' || requestedChannel === runtimeNamespace) {
+        return runtimeNamespace;
+    }
+    return undefined;
+}
 function requiredValue(record, ...keys) {
     for (const key of keys) {
         const value = optionalString(record[key]);

package/dist/daemon/proxyDaemon.d.ts

@@ -3,11 +3,14 @@ import { SyncEngine, type OutboundResult, type InboundResult } from '../sync/eng
 import { LifecycleManager, type HelloLifecycleMode, type HelloResult, type HeartbeatOptions, type HeartbeatResult, type HeartbeatTickResult } from '../lifecycle/manager.js';
 import { type SelfUpdateDeps } from '../selfUpdate/executor.js';
 import type { AtpOrderConsentGate } from './atpConsent.js';
+import { type PublishRecallVerifierPort } from './publishRecallVerifier.js';
 type HubCapability = hubNs.HubCapability;
 type AssetStoreProvider = assetstore.AssetStoreProvider;
 export declare const DEFAULT_IPC_PORT = 19820;
 export interface ProxyDaemonDeps {
     hub: HubCapability;
+    /** Immutable Hub selection for IPC callers that must fail closed across public/private runtimes. */
+    hubMode?: 'public' | 'private';
     /** 二选一: 传 storePath 让 ProxyDaemon 建 store, 或传已建 store(供 hub senderId 共享同一 node_id). */
     storePath?: string;
     store?: mailbox.MailboxStore;
@@ -16,6 +19,16 @@ export interface ProxyDaemonDeps {
     ipcHost?: string;
     runtimeNamespace?: string;
     now?: () => number;
+    /** Hub lifecycle heartbeat cadence. LifecycleManager applies its 30s safety floor and backoff policy. */
+    heartbeatIntervalMs?: number;
+    /** Remote asset-search cache TTL. Local asset-store reads are never cached. */
+    assetSearchCacheTtlMs?: number;
+    /** Maximum number of remote asset-search results cached by this daemon. */
+    assetSearchCacheMax?: number;
+    /** Time after cache expiry during which a rate-limited search may serve stale remote results. */
+    assetSearchStaleGraceMs?: number;
+    /** Maximum time the compatibility HTTP request waits before returning a durable pending receipt. */
+    assetSubmitResponseTimeoutMs?: number;
     /** Random source for heartbeat force_update staggering. Defaults to Math.random; tests inject a deterministic value. */
     random?: () => number;
     /** 注入 adapter 的 /a2a/hello + heartbeat wire 调用(M6-6 提供; M6-4 测试用 fake). evolverVersion 随报供 hub 观测. */
@@ -58,6 +71,10 @@ export interface ProxyDaemonDeps {
     };
     /** V1 collaboration task operations are synchronous; tests may shorten the Hub timeout. */
     collaborationOperationTimeoutMs?: number;
+    /** Optional test/composition seam. Production defaults to the restart-safe verifier backed by this daemon's store. */
+    publishRecallVerifier?: PublishRecallVerifierPort;
+    /** Optional deterministic sanitizer environment for composition tests. Production omits this to scan process.env. */
+    publishSanitizeEnv?: Record<string, string | undefined>;
 }
 export interface ProxyTickReport {
     outbound: OutboundResult;
@@ -75,8 +92,12 @@ export interface ProxyTickError {
 export interface ProxyHealth {
     running: boolean;
     ipcListening: boolean;
+    lifecycleArmed: boolean;
     nodeId?: string;
     lastWriteAt: number;
+    lastTickAt?: number;
+    nextTickDueAt?: number;
+    consecutiveFailures: number;
 }
 export interface AtpProxyClient {
     placeOrder(opts: {
@@ -121,9 +142,21 @@ export declare class ProxyDaemon {
     private readonly validator;
     private readonly atp;
     private readonly collaborationFacade;
+    private readonly publishRecallVerifier;
+    private readonly proxyHandler;
     private ipc;
     private readonly now;
     private readonly random;
+    private readonly assetSearchCacheTtlMs;
+    private readonly assetSearchCacheMax;
+    private readonly assetSearchStaleGraceMs;
+    private readonly assetSubmitResponseTimeoutMs;
+    private readonly synchronousAssetSubmitScope;
+    private readonly shadowMode;
+    private readonly assetSearchCache;
+    private readonly assetSearchInflight;
+    private readonly synchronousAssetSubmitInflight;
+    private assetSearchCooldownUntil;
     private nextHeartbeatAt;
     private heartbeatFailures;
     private heartbeatGeneration;
@@ -132,6 +165,10 @@ export declare class ProxyDaemon {
     /** A poke that arrived between ticks (no sleep in flight) parks the wake here so it is not lost. */
     private wakeRunnerPending;
     private started;
+    private lifecycleArmed;
+    private lastTickAt;
+    private nextTickDueAt;
+    private consecutiveTickFailures;
     private storeClosed;
     private forceUpdateTriggerInFlight;
     private forceUpdateLastTriggeredAt;
@@ -157,6 +194,7 @@ export declare class ProxyDaemon {
     /** 下一轮建议延时: inbound 背压/idle 与 outbound pending cadence 取更快者. */
     nextDelay(last: InboundResult): number;
     setWakeHandler(wake: (() => void) | undefined): void;
+    setExpectedNextTick(delayMs: number | undefined): void;
     notifyNewOutbound(): void;
     /**
      * Expedite the next heartbeat: clear the failure backoff, mark the heartbeat due now, and wake an
@@ -189,6 +227,20 @@ export declare class ProxyDaemon {
     private stateNumber;
     private handleProxyRoute;
     private searchAssets;
+    private searchRemoteAssets;
+    private cacheRemoteAssetSearch;
+    private publishAssetSubmitSynchronously;
+    private createSynchronousAssetSubmitEnvelope;
+    private currentHubMode;
+    private handleHubModeBoundOutbound;
+    private publishSynchronousBundle;
+    private waitForSynchronousAssetSubmit;
+    private executeSynchronousAssetSubmit;
+    private handleSynchronousProxyOutbound;
+    private readSynchronousAssetSubmitOutcome;
+    private cacheSynchronousAssetSubmitSuccess;
+    private cacheSynchronousAssetSubmitTerminal;
+    private writeSynchronousAssetSubmitOutcome;
     private handleAtpRoute;
     private writeAtpJson;
 }