@evomap/evolver-proxy 2.0.0-beta.8 → 2.0.0

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { mailbox } from '@evomap/evolver-core';
+import { PrivateNodeCredentialStore } from '../private/nodeCredentialStore.js';
 import { loadEnvFileFromEnv } from './envFile.js';
 import { type SelfUpdatePolicy } from '../selfUpdate/policy.js';
 import { type ReleaseBinaryOptions } from '../selfUpdate/releaseBinary.js';
@@ -11,8 +12,9 @@ import type { AtpProxyClient, ProxyDaemonDeps, ProxyTickReport } from '../daemon
 import type { HelloLifecycleMode, HelloResult, HeartbeatOptions, HeartbeatResult } from '../lifecycle/manager.js';
 import type { InboundResult } from '../sync/engine.js';
 /** evolver-proxy 系统级 daemon 入口(M6-7). EVOMAP_HUB_MODE/URL/NODE_SECRET 选址. */
-interface RunProxyMainOptions {
+export interface RunProxyMainOptions {
     environmentPrepared?: boolean;
+    recoveryPrepared?: SelfUpdateRecoveryResult;
 }
 export declare function runProxyMain(options?: RunProxyMainOptions): Promise<void>;
 export declare function recoverBoundDurableSelfUpdate(options: Omit<SelfUpdateRecoveryOptions, 'beforeJournalMutation'>): Promise<SelfUpdateRecoveryResult>;
@@ -45,7 +47,8 @@ export interface RunProxyCliOptions {
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     processExecPath?: string;
-    runMain?: () => Promise<void>;
+    runMain?: (options?: RunProxyMainOptions) => Promise<void>;
+    recoverStartup?: typeof recoverBoundDurableSelfUpdate;
     runUnixRecoveryController?: typeof maybeRunUnixRecoveryController;
     runWindowsRecoveryController?: typeof maybeRunWindowsRecoveryController;
     runWindowsUpdaterWorker?: typeof maybeRunWindowsUpdaterWorkerFromArgv;
@@ -73,14 +76,22 @@ export interface RuntimeDeps {
     env?: Record<string, string | undefined>;
     now?: () => number;
     privateImporter?: PrivateAdapterImporter;
+    privateNodeCredentialStore?: Pick<PrivateNodeCredentialStore, 'read' | 'write'>;
 }
 export type PublicNodeSecretSource = 'env' | 'store' | 'hub_rotate' | 'legacy_file';
 export interface PublicNodeSecretSelection {
     nodeSecret: string | undefined;
+    nodeId?: string;
     nodeSecretVersion?: number;
     source: PublicNodeSecretSource;
     storeSecret?: string;
 }
+export interface VerifiedPublicSender {
+    senderId: () => string | undefined;
+    adopt: (nodeId: string) => void;
+}
+export declare function createVerifiedPublicSender(initialNodeId?: string): VerifiedPublicSender;
+export declare function adoptVerifiedPublicNodeId(store: mailbox.MailboxStore, selection: PublicNodeSecretSelection, sender: VerifiedPublicSender, nodeId: string): void;
 export interface HubRuntime {
     hub: ProxyDaemonDeps['hub'];
     hello: (opts: {
@@ -96,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;
@@ -110,9 +122,20 @@ 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;
+    hubMode?: 'public' | 'private';
     ipcToken: string;
     ipcPort?: number;
     evolverVersion: string;
@@ -139,6 +162,7 @@ export declare function resolvePublicNodeSecret(deps: RuntimeDeps): PublicNodeSe
  */
 export declare function clearDivergedPublicNodeSecret(store: mailbox.MailboxStore, env?: NodeJS.ProcessEnv): void;
 export declare function persistSelectedPublicNodeSecret(store: mailbox.MailboxStore, selection: PublicNodeSecretSelection): void;
+export declare function persistRotatedPublicNodeCredentials(store: mailbox.MailboxStore, selection: PublicNodeSecretSelection, secret: string, version: number | undefined): void;
 export declare function persistPublicNodeSecretVersion(store: mailbox.MailboxStore, selection: PublicNodeSecretSelection, version: number | undefined): void;
 export declare function connectHubRuntime(deps: RuntimeDeps): Promise<HubRuntime>;
 export declare function resolveLegacyNodeSecret(envNodeSecret: string | undefined, storedNodeSecret: string | undefined, storedSource: string | undefined): string | undefined;

package/dist/bin/evolver-proxy.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { readFileSync, realpathSync, rmSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve, win32 } from 'node:path';
@@ -10,14 +10,19 @@ import { ProxyDaemon } from '../daemon/proxyDaemon.js';
 import { resolveHubMode, resolveHubUrl } from '../daemon/selectHub.js';
 import { resolveIpcPort } from '../daemon/ipcConfig.js';
 import { traceCollectionEnabled } from '../llm/traceConfig.js';
-import { connectPrivateProxyHub } from '../private/adapterLoader.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 { resolveProxyNodeId } from '../lifecycle/legacyNodeId.js';
+import { readLegacyNodeId, resolveProxyNodeId } from '../lifecycle/legacyNodeId.js';
+import { createClaimNudge, wrapHelloWithClaimNudge } from '../lifecycle/claimNudge.js';
+import { bootstrapDegradedSelfUpdateStartup } from '../selfUpdate/bootstrap.js';
 import { getCurrentVersion } from '../selfUpdate/version.js';
-import { resolveSelfUpdatePolicy } from '../selfUpdate/policy.js';
+import { resolveEffectiveSelfUpdatePolicy, selfUpdateSupervisorAttested, } from '../selfUpdate/policy.js';
+import { resolveSelfUpdatePublicKey } from '../selfUpdate/builtinKey.js';
 import { atomicReplaceExecutable, downloadGithubReleaseArtifact, resolveGithubReleaseManifest, resolveSelfUpdateTarget, } from '../selfUpdate/releaseBinary.js';
 import { beginDurableSelfUpdate, confirmDurableSelfUpdate, recoverDurableSelfUpdate, rollbackDurableSelfUpdate, } from '../selfUpdate/transaction.js';
 import { SELF_UPDATE_FAILURE_CODES } from '../selfUpdate/failureCodes.js';
@@ -30,19 +35,23 @@ export async function runProxyMain(options = {}) {
         process.stdout.write(proxyUsage());
         return;
     }
-    if (!options.environmentPrepared) {
-        const envFile = loadProxyEnvFile(process.env);
-        if (envFile.error)
-            process.stderr.write(`[evolver-proxy] failed to load EVOLVER_ENV_FILE: ${safeLoopMessage(envFile.error)}\n`);
-    }
     // Recovery must run before any hub/store/runtime initialization. In particular,
-    // a broken store must not prevent a pending-health update from restoring the old binary.
-    const recovery = await recoverBoundDurableSelfUpdate({ env: process.env, processExecPath: process.execPath });
+    // a broken store or env-file pointer must not prevent a pending-health update from restoring the old binary.
+    const recovery = options.recoveryPrepared
+        ?? await recoverBoundDurableSelfUpdate({
+            env: proxyRecoveryEnvironment(process.env),
+            processExecPath: process.execPath,
+        });
     if (recovery.outcome === 'blocked') {
         throw new Error(`self_update_recovery_blocked:${recovery.failureCode ?? 'unknown'}`);
     }
     if (recovery.restartRequired)
         process.exit(78);
+    if (!options.environmentPrepared) {
+        const envFile = loadProxyEnvFile(process.env);
+        if (envFile.error)
+            throw new Error(`failed to load EVOLVER_ENV_FILE: ${safeLoopMessage(envFile.error)}`);
+    }
     let storePath;
     let store;
     let proxyDaemon;
@@ -76,7 +85,23 @@ export async function runProxyMain(options = {}) {
         // same owner. See lifecycle/legacyNodeId.ts for the duplicate-node rationale.
         const senderId = () => resolveProxyNodeId({ storedNodeId: store.getState('node_id'), configuredNodeId });
         evolverVersion = getCurrentVersion();
-        selfUpdatePolicy = resolveSelfUpdatePolicy(process.env);
+        // Default (unset) 'auto' without a durable supervisor attestation degrades to 'off' so
+        // unsupervised foreground runs keep starting; explicit 'auto' stays fail-closed at assembly below.
+        const effectiveSelfUpdate = resolveEffectiveSelfUpdatePolicy(process.env);
+        selfUpdatePolicy = effectiveSelfUpdate.policy;
+        if (effectiveSelfUpdate.degraded) {
+            // First-run bootstrap: try to register our own user-level durable launcher so a bare
+            // `npm install` run becomes permanently self-updating. Any failure/skip keeps the degraded
+            // 'off' startup; success hands restart ownership to the service manager.
+            const bootstrap = await bootstrapDegradedSelfUpdateStartup(process.env, process.platform);
+            if (bootstrap.handedOver) {
+                // Exit cleanly so the just-activated service instance can bind the IPC port; systemd
+                // RestartSec / launchd ThrottleInterval absorb the short hand-off window if we lose the race.
+                process.stdout.write(`${bootstrap.message}\n`);
+                process.exit(0);
+            }
+            process.stderr.write(`${bootstrap.message}\n`);
+        }
         const proxyStartedAt = new Date().toISOString();
         publishLocalProxySettings = () => {
             if (!proxySettingsState.url)
@@ -92,11 +117,21 @@ export async function runProxyMain(options = {}) {
                 },
             });
         };
-        const runtime = await connectHubRuntime({ mode, hubUrl, senderId, store });
+        const privateNodeCredentialStore = mode === 'private'
+            ? new PrivateNodeCredentialStore(storePath)
+            : undefined;
+        const runtime = await connectHubRuntime({
+            mode,
+            hubUrl,
+            senderId,
+            store,
+            ...(privateNodeCredentialStore ? { privateNodeCredentialStore } : {}),
+        });
         proxyDaemon = new ProxyDaemon({
             ...createProxyDaemonDeps({
                 runtime,
                 store,
+                hubMode: mode,
                 ipcToken,
                 ...(ipcPort !== undefined ? { ipcPort } : {}),
                 evolverVersion,
@@ -138,7 +173,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({
@@ -150,14 +194,27 @@ export async function recoverBoundDurableSelfUpdate(options) {
 }
 export function loadProxyEnvFile(env) {
     const supervisor = env['EVOLVER_SELF_UPDATE_SUPERVISOR'];
+    const lifecycleStateDir = env['EVOLVER_LIFECYCLE_STATE_DIR'];
     const stateDir = env['EVOLVER_SELF_UPDATE_STATE_DIR'];
     const targetPath = env['EVOLVER_SELF_UPDATE_TARGET_PATH'];
+    const systemRootBindings = Object.entries(env)
+        .filter(([key]) => key.toLowerCase() === 'systemroot');
     const result = loadEnvFileFromEnv(env);
+    for (const key of Object.keys(env)) {
+        if (key.toLowerCase() === 'systemroot')
+            delete env[key];
+    }
+    for (const [key, value] of systemRootBindings) {
+        if (value !== undefined)
+            env[key] = value;
+    }
     if (supervisor === undefined) {
         delete env['EVOLVER_SELF_UPDATE_SUPERVISOR'];
     }
     else {
         env['EVOLVER_SELF_UPDATE_SUPERVISOR'] = supervisor;
+        if (lifecycleStateDir !== undefined)
+            env['EVOLVER_LIFECYCLE_STATE_DIR'] = lifecycleStateDir;
         if (stateDir !== undefined)
             env['EVOLVER_SELF_UPDATE_STATE_DIR'] = stateDir;
         if (targetPath !== undefined)
@@ -165,6 +222,11 @@ export function loadProxyEnvFile(env) {
     }
     return result;
 }
+function proxyRecoveryEnvironment(env) {
+    const recoveryEnv = { ...env };
+    loadProxyEnvFile(recoveryEnv);
+    return recoveryEnv;
+}
 function finalizeRecoveryTelemetry(store, recovery) {
     try {
         finalizeSelfUpdateRecoveryLastUpdate(store, recovery);
@@ -302,6 +364,10 @@ export function prepareProxyCliEnvironment(argv, env) {
     if (options.envFile)
         env['EVOLVER_ENV_FILE'] = options.envFile;
     const envFile = loadProxyEnvFile(env);
+    applyProxyCliPathOptions(options, env);
+    return { options, envFile };
+}
+function applyProxyCliPathOptions(options, env) {
     if (options.home) {
         env['EVOMAP_DIR'] = options.home;
         env['EVOLVER_HOME'] = options.home;
@@ -320,7 +386,6 @@ export function prepareProxyCliEnvironment(argv, env) {
         env['EVOLVER_PROXY_STORE'] = options.store;
     if (options.settings)
         env['EVOLVER_PROXY_SETTINGS_FILE'] = options.settings;
-    return { options, envFile };
 }
 export async function runProxyCli(options = {}) {
     const argv = options.argv ?? process.argv.slice(2);
@@ -356,11 +421,28 @@ export async function runProxyCli(options = {}) {
             process.stdout.write(proxyUsage(argv[0] === 'proxy' ? 'evolver proxy' : 'evolver-proxy'));
             return 0;
         }
+        if (cliOptions.envFile)
+            env['EVOLVER_ENV_FILE'] = cliOptions.envFile;
+        applyProxyCliPathOptions(cliOptions, env);
+        const recovery = options.recoverStartup || !options.runMain
+            ? await (options.recoverStartup ?? recoverBoundDurableSelfUpdate)({
+                env: proxyRecoveryEnvironment(env),
+                processExecPath: options.processExecPath ?? process.execPath,
+            })
+            : undefined;
+        if (recovery?.outcome === 'blocked') {
+            throw new Error(`self_update_recovery_blocked:${recovery.failureCode ?? 'unknown'}`);
+        }
+        if (recovery?.restartRequired)
+            return 78;
         const prepared = prepareProxyCliEnvironment(argv, env);
         if (prepared.envFile.error) {
-            process.stderr.write(`[evolver-proxy] failed to load EVOLVER_ENV_FILE: ${safeLoopMessage(prepared.envFile.error)}\n`);
+            throw new Error(`failed to load EVOLVER_ENV_FILE: ${safeLoopMessage(prepared.envFile.error)}`);
         }
-        await (options.runMain ?? (() => runProxyMain({ environmentPrepared: true })))();
+        await (options.runMain ?? runProxyMain)({
+            environmentPrepared: true,
+            ...(recovery ? { recoveryPrepared: recovery } : {}),
+        });
         return 0;
     }
     catch (error) {
@@ -376,6 +458,20 @@ if (isDirectRun(import.meta.url, process.argv[1])) {
         process.exitCode = exitCode;
     });
 }
+export function createVerifiedPublicSender(initialNodeId) {
+    let verifiedNodeId = initialNodeId;
+    return {
+        senderId: () => verifiedNodeId,
+        adopt: (nodeId) => {
+            verifiedNodeId = nodeId;
+        },
+    };
+}
+export function adoptVerifiedPublicNodeId(store, selection, sender, nodeId) {
+    store.setState('node_id', nodeId);
+    selection.nodeId = nodeId;
+    sender.adopt(nodeId);
+}
 export async function runProxyLoop(daemon, options = {}) {
     const minDelayMs = options.minDelayMs ?? 1_000;
     const errorDelayMs = options.errorDelayMs ?? 5_000;
@@ -391,6 +487,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;
@@ -430,7 +527,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()
@@ -442,15 +541,33 @@ 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 } : {}),
         store: options.store,
         ipcToken: options.ipcToken,
         ...(options.ipcPort !== undefined ? { ipcPort: options.ipcPort } : {}),
@@ -461,11 +578,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;
@@ -594,7 +719,7 @@ export function createSelfUpdateDeps(policy, currentVersion, env = process.env,
     if (!supervisorAttested && !selfUpdateSupervisorAttested(env)) {
         throw new Error('self_update_supervisor_required');
     }
-    const publicKey = env['EVOLVER_SELF_UPDATE_PUBLIC_KEY']?.trim();
+    const publicKey = resolveSelfUpdatePublicKey(env);
     if (!publicKey)
         throw new Error('self_update_public_key_required');
     const releaseOpts = {
@@ -668,36 +793,81 @@ function canonicalExecutablePath(path) {
         .replace(/^\\\\\?\\/i, '');
     return win32.normalize(withoutNamespace).toLowerCase();
 }
-function selfUpdateSupervisorAttested(env) {
-    const supervisor = env['EVOLVER_SELF_UPDATE_SUPERVISOR']?.trim();
-    return supervisor === 'systemd'
-        || supervisor === 'launchd'
-        || supervisor === 'windows-scheduled-task';
-}
 export function resolvePublicNodeSecret(deps) {
-    const envNodeSecret = process.env['EVOMAP_NODE_SECRET'] ?? process.env['A2A_NODE_SECRET'];
-    // version env precedence MUST mirror the node_secret precedence above (EVOMAP-first) so an operator
-    // who sets both env pairs always resolves a matched (secret, version). v2 standardizes on EVOMAP_*-first
-    // for BOTH secret and version; v1 uses A2A_*-first but pairs the two identically. Do not flip one alone.
-    const envNodeSecretVersion = parseNodeSecretVersion(process.env['EVOMAP_NODE_SECRET_VERSION'] ?? process.env['A2A_NODE_SECRET_VERSION']);
+    const explicit = resolveExplicitPublicNodeCredentials(process.env);
     const storedNodeSecret = deps.store.getState('node_secret');
+    const storedNodeId = deps.store.getState('node_id')?.trim() || undefined;
     const storedSource = deps.store.getState('node_secret_source');
     const storedNodeSecretVersion = parseNodeSecretVersion(deps.store.getState('node_secret_version'));
-    const storeSecret = storedNodeSecret && isNodeSecret(storedNodeSecret) ? storedNodeSecret : undefined;
-    if (storedSource === 'hub_rotate' && storeSecret) {
-        return { nodeSecret: storeSecret, nodeSecretVersion: storedNodeSecretVersion, source: 'hub_rotate', storeSecret };
+    const storeSecret = storedSource?.startsWith('pending_')
+        ? undefined
+        : storedNodeSecret && isNodeSecret(storedNodeSecret) ? storedNodeSecret : undefined;
+    const legacy = readLegacyNodeSecret(process.env);
+    const pairedStoreNodeId = storedNodeId
+        ?? (explicit.nodeSecret === storeSecret ? explicit.nodeId : undefined)
+        ?? (legacy && legacy.nodeSecret === storeSecret ? legacy.nodeId : undefined);
+    const completeExplicitOverridesOrphan = Boolean(explicit.nodeId
+        && explicit.nodeSecret
+        && explicit.nodeSecret !== storeSecret
+        && pairedStoreNodeId !== explicit.nodeId);
+    if (storedSource === 'hub_rotate' && storeSecret && !completeExplicitOverridesOrphan) {
+        return {
+            nodeSecret: storeSecret,
+            ...(pairedStoreNodeId ? { nodeId: pairedStoreNodeId } : {}),
+            nodeSecretVersion: storedNodeSecretVersion,
+            source: 'hub_rotate',
+            storeSecret,
+        };
     }
-    if (envNodeSecret) {
-        const pairedStoreVersion = envNodeSecret === storeSecret ? storedNodeSecretVersion : undefined;
-        return { nodeSecret: envNodeSecret, nodeSecretVersion: envNodeSecretVersion ?? pairedStoreVersion, source: 'env', storeSecret };
+    if (explicit.nodeSecret) {
+        const pairedNodeId = explicit.nodeId
+            ?? (legacy?.nodeSecret === explicit.nodeSecret ? legacy.nodeId : undefined);
+        const pairedStoreVersion = explicit.nodeSecret === storeSecret ? storedNodeSecretVersion : undefined;
+        return {
+            nodeSecret: explicit.nodeSecret,
+            ...(pairedNodeId ? { nodeId: pairedNodeId } : {}),
+            nodeSecretVersion: explicit.nodeSecretVersion ?? pairedStoreVersion,
+            source: 'env',
+            storeSecret,
+        };
+    }
+    if (storeSecret) {
+        return {
+            nodeSecret: storeSecret,
+            ...(pairedStoreNodeId ? { nodeId: pairedStoreNodeId } : {}),
+            nodeSecretVersion: storedNodeSecretVersion,
+            source: 'store',
+            storeSecret,
+        };
     }
-    if (storeSecret)
-        return { nodeSecret: storeSecret, nodeSecretVersion: storedNodeSecretVersion, source: 'store', storeSecret };
-    const legacy = readLegacyNodeSecret(process.env);
     if (legacy)
         return { ...legacy, source: 'legacy_file' };
     return { nodeSecret: undefined, source: 'store' };
 }
+function resolveExplicitPublicNodeCredentials(env) {
+    const evomap = publicCredentialNamespace(env, 'EVOMAP');
+    const a2a = publicCredentialNamespace(env, 'A2A');
+    if (evomap.nodeId && evomap.nodeSecret)
+        return evomap;
+    if (a2a.nodeId && a2a.nodeSecret)
+        return a2a;
+    if (evomap.nodeId && a2a.nodeId && evomap.nodeId === a2a.nodeId) {
+        return evomap.nodeSecret ? evomap : a2a.nodeSecret ? a2a : {};
+    }
+    if (evomap.nodeId || a2a.nodeId)
+        return {};
+    return evomap.nodeSecret ? evomap : a2a.nodeSecret ? a2a : {};
+}
+function publicCredentialNamespace(env, prefix) {
+    const nodeId = env[`${prefix}_NODE_ID`]?.trim() || undefined;
+    const nodeSecret = env[`${prefix}_NODE_SECRET`]?.trim() || undefined;
+    const nodeSecretVersion = parseNodeSecretVersion(env[`${prefix}_NODE_SECRET_VERSION`]);
+    return {
+        ...(nodeId ? { nodeId } : {}),
+        ...(nodeSecret ? { nodeSecret } : {}),
+        ...(nodeSecretVersion !== undefined ? { nodeSecretVersion } : {}),
+    };
+}
 function setOptionalStoreState(store, key, value) {
     store.setState(key, value ?? '');
 }
@@ -732,8 +902,13 @@ function readLegacyNodeSecret(env = process.env) {
         const nodeSecret = readTrimmedFile(join(home, 'node_secret'));
         if (!nodeSecret || !isNodeSecret(nodeSecret))
             continue;
+        const nodeId = readLegacyNodeId({ candidates: [join(home, 'node_id')] });
         const nodeSecretVersion = parseNodeSecretVersion(readTrimmedFile(join(home, 'node_secret_version')));
-        return { nodeSecret, ...(nodeSecretVersion !== undefined ? { nodeSecretVersion } : {}) };
+        return {
+            ...(nodeId ? { nodeId } : {}),
+            nodeSecret,
+            ...(nodeSecretVersion !== undefined ? { nodeSecretVersion } : {}),
+        };
     }
     return undefined;
 }
@@ -768,9 +943,20 @@ export function clearDivergedPublicNodeSecret(store, env = process.env) {
 export function persistSelectedPublicNodeSecret(store, selection) {
     if (selection.source !== 'legacy_file' || !selection.nodeSecret)
         return;
+    store.setState('node_secret_source', 'pending_legacy');
+    if (selection.nodeId)
+        store.setState('node_id', selection.nodeId);
     store.setState('node_secret', selection.nodeSecret);
-    store.setState('node_secret_source', 'legacy_file');
     setOptionalStoreState(store, 'node_secret_version', selection.nodeSecretVersion !== undefined ? String(selection.nodeSecretVersion) : undefined);
+    store.setState('node_secret_source', 'legacy_file');
+}
+export function persistRotatedPublicNodeCredentials(store, selection, secret, version) {
+    store.setState('node_secret_source', 'pending_rotate');
+    if (selection.nodeId)
+        store.setState('node_id', selection.nodeId);
+    store.setState('node_secret', secret);
+    setOptionalStoreState(store, 'node_secret_version', version !== undefined ? String(version) : undefined);
+    store.setState('node_secret_source', 'hub_rotate');
 }
 export function persistPublicNodeSecretVersion(store, selection, version) {
     const currentStoreSecret = store.getState('node_secret');
@@ -801,31 +987,59 @@ function isDirectRun(metaUrl, argv1) {
 }
 export async function connectHubRuntime(deps) {
     if (deps.mode === 'private') {
-        const { hub } = await connectPrivateProxyHub({
+        const storedInvitationFingerprint = deps.store.getState('private_invitation_fingerprint')?.trim();
+        const runtimeEnv = deps.env ?? process.env;
+        let storedNodeSecret;
+        try {
+            storedNodeSecret = deps.privateNodeCredentialStore?.read();
+        }
+        catch (error) {
+            if (!(error instanceof PrivateNodeCredentialReadError)
+                || !hasPrivateEnrollmentFallback(runtimeEnv, storedInvitationFingerprint)) {
+                throw error;
+            }
+        }
+        const runtime = await connectPrivateProxyHub({
             hubUrl: deps.hubUrl,
             senderId: deps.senderId,
-            env: deps.env ?? process.env,
+            env: runtimeEnv,
+            ...(storedNodeSecret ? { storedNodeSecret } : {}),
+            ...(storedInvitationFingerprint ? { storedInvitationFingerprint } : {}),
+            ...(deps.privateNodeCredentialStore ? {
+                onNodeSecretAdopted: (nodeSecret) => {
+                    deps.privateNodeCredentialStore?.write(nodeSecret);
+                    deps.store.setState('private_node_secret_source', 'hub_enrollment');
+                },
+            } : {}),
+            onInvitationRedeemed: (fingerprint) => {
+                deps.store.setState('private_invitation_fingerprint', fingerprint);
+            },
             ...(deps.now ? { now: deps.now } : {}),
             ...(deps.privateImporter ? { importer: deps.privateImporter } : {}),
         });
-        return { hub, hello: (opts) => hub.hello(opts), heartbeat: (opts) => hub.heartbeat(opts), helloMode: 'enterprise_token' };
+        return {
+            hub: runtime.hub,
+            hello: runtime.hello,
+            heartbeat: (opts) => runtime.hub.heartbeat(opts),
+            helloMode: 'enterprise_token',
+        };
     }
     const selection = resolvePublicNodeSecret(deps);
     const { nodeSecret, nodeSecretVersion } = selection;
     if (!nodeSecret)
         throw new Error('public legacy 模式需 EVOMAP_NODE_SECRET');
     persistSelectedPublicNodeSecret(deps.store, selection);
+    const verifiedSender = createVerifiedPublicSender(selection.nodeId);
+    const senderId = verifiedSender.senderId;
     const { hub, auth } = connectPublicHub({
         hubUrl: deps.hubUrl,
         authMode: 'legacy',
         nodeSecret,
         ...(nodeSecretVersion !== undefined ? { nodeSecretVersion } : {}),
-        senderId: deps.senderId,
+        senderId,
         antiAbuse: { source: 'evolver-proxy', proxyPortConfigured: true },
         onNodeSecretRotated: (secret, version) => {
-            deps.store.setState('node_secret', secret);
-            deps.store.setState('node_secret_source', 'hub_rotate');
-            setOptionalStoreState(deps.store, 'node_secret_version', version !== undefined ? String(version) : undefined);
+            persistRotatedPublicNodeCredentials(deps.store, selection, secret, version);
         },
         onNodeSecretVersionUpdated: (version) => {
             persistPublicNodeSecretVersion(deps.store, selection, version);
@@ -836,13 +1050,32 @@ 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: deps.senderId }),
-        hello: (opts) => hub.hello(opts),
+        atp: new AtpHubClient({ baseUrl: deps.hubUrl, auth, fetchFn: globalFetchLike, senderId }),
+        hello,
         heartbeat: (opts) => hub.heartbeat(opts),
     };
 }
+function hasPrivateEnrollmentFallback(env, storedInvitationFingerprint) {
+    if (resolvePrivateNodeSecret(env) || resolvePrivateEnterpriseToken(env))
+        return true;
+    const invitationToken = resolvePrivateInvitationToken(env);
+    if (!invitationToken)
+        return false;
+    return createHash('sha256').update(invitationToken).digest('hex') !== storedInvitationFingerprint;
+}
 export function resolveLegacyNodeSecret(envNodeSecret, storedNodeSecret, storedSource) {
     if (envNodeSecret)
         return envNodeSecret;

package/dist/daemon/atpConsent.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { events } from '@evomap/evolver-core';
 export class AtpProxySpendConsentError extends Error {
     source;
     constructor(source) {
@@ -10,7 +10,10 @@ export class AtpProxySpendConsentError extends Error {
     }
 }
 function atpProxyConsentPath(env = process.env) {
-    const home = env['EVOMAP_DIR'] ?? env['EVOLVER_HOME'] ?? env['EVOMAP_HOME'] ?? events.evomapHome();
+    const home = [env['EVOMAP_DIR'], env['EVOLVER_HOME'], env['EVOMAP_HOME']]
+        .map((value) => value?.trim())
+        .find((value) => Boolean(value))
+        ?? join(homedir(), '.evomap');
     return join(home, 'evolution', 'atp-autobuy-ack.json');
 }
 export function getAtpProxyConsent(env = process.env, ackPath = atpProxyConsentPath(env)) {