@evomap/evolver-proxy 2.0.0-beta.18 → 2.0.0-beta.19

package/dist/bin/evolver-proxy.d.ts

@@ -107,6 +107,7 @@ interface ProxyLoopDaemon {
     nextDelay: (last: InboundResult) => number;
     sleep?: (delayMs: number) => Promise<void>;
     setWakeHandler?: (wake: (() => void) | undefined) => void;
+    setExpectedNextTick?: (delayMs: number | undefined) => void;
 }
 interface ProxyLoopLogger {
     write: (chunk: string) => unknown;
@@ -121,6 +122,16 @@ export interface ProxyLoopOptions {
     maxConsecutiveTickFailures?: number;
 }
 export declare function runProxyLoop(daemon: ProxyLoopDaemon, options?: ProxyLoopOptions): Promise<void>;
+export declare function runManagedProxyLoop(options: {
+    daemon: ProxyLoopDaemon & StartupStoppableDaemon;
+    store: StartupClosableStore;
+    notifier: {
+        readyOrThrow(): Promise<void>;
+        stop(): void;
+    };
+    runLoop?: (daemon: ProxyLoopDaemon, options?: ProxyLoopOptions) => Promise<void>;
+    logger?: ProxyLoopLogger;
+}): Promise<void>;
 interface CreateProxyDaemonDepsOptions {
     runtime: HubRuntime;
     store: mailbox.MailboxStore;

package/dist/bin/evolver-proxy.js

@@ -13,10 +13,12 @@ import { traceCollectionEnabled } from '../llm/traceConfig.js';
 import { connectPrivateProxyHub, resolvePrivateEnterpriseToken, resolvePrivateInvitationToken, resolvePrivateNodeSecret, } from '../private/adapterLoader.js';
 import { PrivateNodeCredentialStore, PrivateNodeCredentialReadError, } from '../private/nodeCredentialStore.js';
 import { createAtpOrderConsentGate } from '../daemon/atpConsent.js';
+import { SystemdNotifier } from '../daemon/systemdNotifier.js';
 import { resolveProxyStorePath } from './proxyStorePath.js';
 import { publishProxySettings } from './proxySettings.js';
 import { expandHomePath, loadEnvFileFromEnv } from './envFile.js';
 import { readLegacyNodeId, resolveProxyNodeId } from '../lifecycle/legacyNodeId.js';
+import { createClaimNudge, wrapHelloWithClaimNudge } from '../lifecycle/claimNudge.js';
 import { getCurrentVersion } from '../selfUpdate/version.js';
 import { resolveSelfUpdatePolicy } from '../selfUpdate/policy.js';
 import { atomicReplaceExecutable, downloadGithubReleaseArtifact, resolveGithubReleaseManifest, resolveSelfUpdateTarget, } from '../selfUpdate/releaseBinary.js';
@@ -153,7 +155,16 @@ export async function runProxyMain(options = {}) {
     proxySettingsState.url = `http://127.0.0.1:${port}`;
     publishLocalProxySettings();
     process.stdout.write(`[evolver-proxy] mode=${mode} hub=${hubUrl} ipc=127.0.0.1:${port} v=${evolverVersion} self-update=${selfUpdatePolicy}\n`);
-    await runProxyLoop(proxyDaemon, { logger: process.stderr });
+    const systemdNotifier = new SystemdNotifier({
+        env: process.env,
+        health: () => proxyDaemon.health(),
+    });
+    await runManagedProxyLoop({
+        daemon: proxyDaemon,
+        store: store,
+        notifier: systemdNotifier,
+        logger: process.stderr,
+    });
 }
 export async function recoverBoundDurableSelfUpdate(options) {
     return recoverDurableSelfUpdate({
@@ -455,6 +466,7 @@ export async function runProxyLoop(daemon, options = {}) {
     let consecutiveTickFailures = 0;
     try {
         for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+            daemon.setExpectedNextTick?.(undefined);
             let delayMs = errorDelayMs;
             let tickHealthy = false;
             let exitForResolvedFailure;
@@ -494,7 +506,9 @@ export async function runProxyLoop(daemon, options = {}) {
                 break;
             if (tickHealthy) {
                 // Healthy idle: wake-interruptible so new outbound/inbound work re-ticks promptly.
-                await sleepUntilDelayOrWake(Math.max(minDelayMs, delayMs), sleep, setWakeHandler);
+                const healthyDelayMs = Math.max(minDelayMs, delayMs);
+                daemon.setExpectedNextTick?.(healthyDelayMs);
+                await sleepUntilDelayOrWake(healthyDelayMs, sleep, setWakeHandler);
             }
             else {
                 // Error / fatal-candidate backoff: NON-interruptible. Otherwise wakeRunner()
@@ -506,13 +520,30 @@ export async function runProxyLoop(daemon, options = {}) {
         }
     }
     finally {
+        daemon.setExpectedNextTick?.(undefined);
         if (!useDaemonSleep)
             daemon.setWakeHandler?.(undefined);
     }
 }
+export async function runManagedProxyLoop(options) {
+    try {
+        await options.notifier.readyOrThrow();
+        await (options.runLoop ?? runProxyLoop)(options.daemon, options.logger ? { logger: options.logger } : {});
+    }
+    finally {
+        try {
+            options.notifier.stop();
+        }
+        finally {
+            await closeStartupResources({ store: options.store, daemon: options.daemon });
+        }
+    }
+}
 export function createProxyDaemonDeps(options) {
     const selfUpdate = createSelfUpdateDeps(options.selfUpdatePolicy, options.evolverVersion, options.env ?? process.env, options.selfUpdateOverrides);
-    const traceBackfill = resolveTraceBackfillConfig(options.env ?? process.env);
+    const env = options.env ?? process.env;
+    const traceBackfill = resolveTraceBackfillConfig(env);
+    const heartbeatIntervalMs = positiveIntegerEnv(env['HEARTBEAT_INTERVAL_MS']);
     return {
         hub: options.runtime.hub,
         ...(options.hubMode ? { hubMode: options.hubMode } : {}),
@@ -526,11 +557,19 @@ export function createProxyDaemonDeps(options) {
         evolverVersion: options.evolverVersion,
         hello: options.runtime.hello,
         heartbeat: options.runtime.heartbeat,
+        ...(heartbeatIntervalMs !== undefined ? { heartbeatIntervalMs } : {}),
         ...(options.runtime.helloMode ? { helloMode: options.runtime.helloMode } : {}),
         ...(selfUpdate ? { selfUpdate } : {}),
         ...(traceBackfill ? { traceBackfill } : {}),
     };
 }
+function positiveIntegerEnv(value) {
+    const trimmed = value?.trim();
+    if (!trimmed || !/^\d+$/.test(trimmed))
+        return undefined;
+    const parsed = Number(trimmed);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
 function resolveTraceBackfillConfig(env) {
     if (!traceCollectionEnabled(env))
         return undefined;
@@ -996,16 +1035,21 @@ export async function connectHubRuntime(deps) {
             clearDivergedPublicNodeSecret(deps.store, process.env);
         },
     });
+    const hello = wrapHelloWithClaimNudge(async (opts) => {
+        const result = await hub.hello(opts);
+        if (result.nodeId)
+            adoptVerifiedPublicNodeId(deps.store, selection, verifiedSender, result.nodeId);
+        return result;
+    }, createClaimNudge({
+        store: deps.store,
+        hubUrl: deps.hubUrl,
+        env: deps.env ?? process.env,
+        ...(deps.now ? { now: deps.now } : {}),
+    }));
     return {
         hub,
         atp: new AtpHubClient({ baseUrl: deps.hubUrl, auth, fetchFn: globalFetchLike, senderId }),
-        hello: async (opts) => {
-            const result = await hub.hello(opts);
-            if (result.nodeId) {
-                adoptVerifiedPublicNodeId(deps.store, selection, verifiedSender, result.nodeId);
-            }
-            return result;
-        },
+        hello,
         heartbeat: (opts) => hub.heartbeat(opts),
     };
 }

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,6 +3,7 @@ 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;
@@ -18,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 观测. */
@@ -60,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;
@@ -77,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: {
@@ -123,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;
@@ -134,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;
@@ -159,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
@@ -191,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;
 }