evolcore 0.0.19 → 0.0.21

package/dist/aun/outbox.js

@@ -1,11 +1,35 @@
 import crypto from 'crypto';
-import { agentOutboxPath } from '../paths.js';
+import { agentActivityOutboxPath, agentOutboxPath } from '../paths.js';
 import { atomicRead, atomicWrite } from '../utils/atomic-write.js';
 import { isDeliveryTarget, isDeliveryTargetForChannel, sameDeliveryTarget } from '../core/message/message-utils.js';
-const MAX_ENTRIES_PER_AID = 20;
-const DEFAULT_TTL = 300_000; // 5 minutes
-function outboxFile(aid) {
-    return agentOutboxPath(aid);
+export const DEFAULT_OUTBOX_MAX_ENTRIES = 200;
+export const DEFAULT_OUTBOX_TTL_MS = 60 * 60 * 1000;
+export const ACTIVITY_OUTBOX_MAX_ENTRIES = 500;
+export const ACTIVITY_OUTBOX_TTL_MS = 30 * 60 * 1000;
+const MAX_TERMINAL_ENTRIES_PER_AID = 100;
+const QUEUE_CONFIG = {
+    default: {
+        file: agentOutboxPath,
+        maxEntries: DEFAULT_OUTBOX_MAX_ENTRIES,
+        defaultTtl: DEFAULT_OUTBOX_TTL_MS,
+    },
+    activity: {
+        file: agentActivityOutboxPath,
+        maxEntries: ACTIVITY_OUTBOX_MAX_ENTRIES,
+        defaultTtl: ACTIVITY_OUTBOX_TTL_MS,
+    },
+};
+function queueConfig(queue = 'default') {
+    return QUEUE_CONFIG[queue];
+}
+export function defaultTtl(queue = 'default') {
+    return queueConfig(queue).defaultTtl;
+}
+function outboxFile(aid, queue = 'default') {
+    return queueConfig(queue).file(aid);
+}
+function entryQueue(entry) {
+    return entry.queue ?? 'default';
 }
 function generateId() {
     const ts = Date.now();
@@ -13,6 +37,11 @@ function generateId() {
     return `out-${ts}-${rand}`;
 }
 function isExpired(entry) {
+    // Terminal failures are retained as durable diagnostics. They are excluded
+    // from `load()`/`hasPending()` and must not disappear merely because the
+    // original delivery TTL elapsed.
+    if (entry.terminal || entry.deliveryResult)
+        return false;
     if (entry.critical)
         return false;
     return Date.now() - entry.ts > entry.ttl;
@@ -20,8 +49,8 @@ function isExpired(entry) {
 export function isDeliveryForChannel(value, channelId) {
     return isDeliveryTargetForChannel(value, channelId);
 }
-function readEntries(aid) {
-    const file = outboxFile(aid);
+function readEntries(aid, queue = 'default') {
+    const file = outboxFile(aid, queue);
     try {
         const content = atomicRead(file)?.trim();
         if (!content)
@@ -39,22 +68,45 @@ function readEntries(aid) {
         return [];
     }
 }
-function writeEntries(aid, entries) {
-    const file = outboxFile(aid);
-    const content = entries.length > 0
-        ? entries.map(e => JSON.stringify(e)).join('\n') + '\n'
+function writeEntries(aid, entries, queue = 'default') {
+    const file = outboxFile(aid, queue);
+    const boundedEntries = trimFinalEntries(entries);
+    const content = boundedEntries.length > 0
+        ? boundedEntries.map(e => JSON.stringify(e)).join('\n') + '\n'
         : '';
     atomicWrite(file, content);
 }
+function trimFinalEntries(entries) {
+    const finalEntries = entries.filter(entry => !!entry.terminal || !!entry.deliveryResult);
+    if (finalEntries.length <= MAX_TERMINAL_ENTRIES_PER_AID)
+        return entries;
+    const retainedFinalIds = new Set(finalEntries
+        .sort((left, right) => (left.terminal?.at ?? left.deliveryResult?.at ?? left.ts) - (right.terminal?.at ?? right.deliveryResult?.at ?? right.ts))
+        .slice(-MAX_TERMINAL_ENTRIES_PER_AID)
+        .map(entry => entry.id));
+    return entries.filter(entry => (!entry.terminal && !entry.deliveryResult) || retainedFinalIds.has(entry.id));
+}
 export function enqueue(aid, opts) {
+    const queue = opts.queue ?? 'default';
+    const config = queueConfig(queue);
     const delivery = opts.delivery;
     if (!isDeliveryForChannel(delivery, opts.channelId)) {
         const code = isDeliveryTarget(delivery) ? 'AUN_OUTBOUND_ROUTE_MISMATCH' : 'AUN_OUTBOUND_ROUTE_REQUIRED';
         throw Object.assign(new Error(`invalid AUN outbox delivery route for channelId=${opts.channelId}`), { code });
     }
-    let existingEntries = readEntries(aid);
+    let existingEntries = readEntries(aid, queue);
+    for (const existing of existingEntries) {
+        if (isExpired(existing))
+            markExpired(existing);
+    }
     if (opts.dedupeKey) {
-        const existing = existingEntries.find(entry => entry.dedupeKey === opts.dedupeKey && !isExpired(entry));
+        // Terminal results are decisions for this logical operation. Reusing the
+        // same route must not silently turn a permanent rejection into a retry;
+        // an explicit route correction is the only case that replaces it.
+        const existing = existingEntries.find(entry => entry.dedupeKey === opts.dedupeKey
+            && !entry.terminal
+            && !entry.deliveryResult
+            && !isExpired(entry));
         if (existing
             && existing.channelId === opts.channelId
             && isDeliveryForChannel(existing.delivery, existing.channelId)
@@ -71,6 +123,7 @@ export function enqueue(aid, opts) {
         id: generateId(),
         ts: Date.now(),
         aid,
+        ...(queue === 'activity' ? { queue } : {}),
         channelId: opts.channelId,
         delivery,
         dedupeKey: opts.dedupeKey,
@@ -83,60 +136,160 @@ export function enqueue(aid, opts) {
         image: opts.image,
         logText: opts.logText,
         context: opts.context,
-        ttl: opts.ttl ?? DEFAULT_TTL,
+        ttl: opts.ttl ?? config.defaultTtl,
         postSend: opts.postSend,
     };
-    // Enforce cap: read existing, drop oldest if over limit
-    let entries = existingEntries;
-    if (entries.filter(candidate => !candidate.critical).length >= MAX_ENTRIES_PER_AID) {
-        const dropIndex = entries.findIndex(candidate => !candidate.critical);
-        if (dropIndex >= 0)
-            entries.splice(dropIndex, 1);
-        entries = [...entries, entry];
+    const pendingCount = existingEntries.filter(candidate => !candidate.critical && !candidate.terminal && !candidate.deliveryResult && !isExpired(candidate)).length;
+    if (!opts.critical && pendingCount >= config.maxEntries) {
+        throw Object.assign(new Error(`${queue} outbox is full for ${aid} (max ${config.maxEntries})`), { code: 'OUTBOX_FULL', queue, aid, maxEntries: config.maxEntries });
     }
-    else {
-        entries = [...entries, entry];
-    }
-    writeEntries(aid, entries);
+    const entries = [...existingEntries, entry];
+    writeEntries(aid, entries, queue);
     return entry;
 }
-export function remove(aid, id) {
-    const entries = readEntries(aid).filter(e => e.id !== id);
-    writeEntries(aid, entries);
+export function remove(aid, id, queue = 'default') {
+    const entries = readEntries(aid, queue).filter(e => e.id !== id);
+    writeEntries(aid, entries, queue);
+}
+/** Remove an entry only if it still points at the route that was submitted. */
+export function removeIfRouteMatches(aid, submitted, queue = entryQueue(submitted)) {
+    const entries = readEntries(aid, queue);
+    const index = entries.findIndex(entry => entry.id === submitted.id);
+    if (index < 0 || !hasSamePersistedRoute(entries[index], submitted))
+        return false;
+    entries.splice(index, 1);
+    writeEntries(aid, entries, queue);
+    return true;
 }
 /** Replace an existing entry without consuming another outbox slot. */
 export function replace(aid, entry) {
-    const entries = readEntries(aid);
+    const queue = entryQueue(entry);
+    const entries = readEntries(aid, queue);
     const index = entries.findIndex(candidate => candidate.id === entry.id);
     if (index < 0)
         return false;
     entries[index] = entry;
-    writeEntries(aid, entries);
+    writeEntries(aid, entries, queue);
     return true;
 }
+/** Replace an entry only while its submitted route is still current. */
+export function replaceIfRouteMatches(aid, submitted, replacement, queue = entryQueue(submitted)) {
+    const entries = readEntries(aid, queue);
+    const index = entries.findIndex(candidate => candidate.id === submitted.id);
+    if (index < 0)
+        return 'missing';
+    if (!hasSamePersistedRoute(entries[index], submitted))
+        return 'route-changed';
+    entries[index] = replacement;
+    writeEntries(aid, entries, queue);
+    return 'replaced';
+}
+/** Update only the delivery receipt while preserving concurrent entry changes. */
+export function updateDeliveryReceiptIfRouteMatches(aid, submitted, receipt, queue = entryQueue(submitted)) {
+    const entries = readEntries(aid, queue);
+    const index = entries.findIndex(candidate => candidate.id === submitted.id);
+    if (index < 0)
+        return 'missing';
+    if (!hasSamePersistedRoute(entries[index], submitted))
+        return 'route-changed';
+    entries[index].deliveryReceipt = receipt;
+    writeEntries(aid, entries, queue);
+    return 'replaced';
+}
 /** Remove durable interaction cards that were cancelled before delivery. */
-export function removeInteractionCards(aid, requestId) {
-    const entries = readEntries(aid);
+export function removeInteractionCards(aid, requestId, queue = 'default') {
+    const entries = readEntries(aid, queue);
     const retained = entries.filter(entry => !(entry.postSend?.type === 'register_interaction_card'
         && entry.postSend.requestId === requestId));
     const removed = entries.length - retained.length;
     if (removed > 0)
-        writeEntries(aid, retained);
+        writeEntries(aid, retained, queue);
     return removed;
 }
-export function load(aid) {
-    return readEntries(aid).filter(e => !isExpired(e));
+export function load(aid, queue = 'default') {
+    return readEntries(aid, queue).filter(e => !e.terminal && !e.deliveryResult && !isExpired(e));
 }
-export function findByDedupeKey(aid, dedupeKey) {
-    return load(aid).find(entry => entry.dedupeKey === dedupeKey);
+export function findByDedupeKey(aid, dedupeKey, opts = {}, queue = 'default') {
+    const entries = opts.includeTerminal
+        ? readEntries(aid, queue).filter(entry => !isExpired(entry))
+        : load(aid, queue);
+    return entries.find(entry => entry.dedupeKey === dedupeKey);
 }
-export function cleanup(aid) {
-    const all = readEntries(aid);
-    const valid = all.filter(e => !isExpired(e));
-    const removed = all.length - valid.length;
-    if (removed > 0)
-        writeEntries(aid, valid);
-    return removed;
+export function cleanup(aid, queue = 'default') {
+    const all = readEntries(aid, queue);
+    let expired = 0;
+    for (const entry of all) {
+        if (!isExpired(entry))
+            continue;
+        expired++;
+        markExpired(entry);
+    }
+    if (expired > 0)
+        writeEntries(aid, all, queue);
+    return expired;
+}
+/** Resolve a durable delivery without treating disappearance as success. */
+export function deliveryState(aid, id, queue = 'default') {
+    const entries = readEntries(aid, queue);
+    const entry = entries.find(candidate => candidate.id === id);
+    if (!entry)
+        return { status: 'missing' };
+    const deliveredMessageId = entry.deliveryResult?.messageId ?? entry.deliveryReceipt?.messageId;
+    if (deliveredMessageId) {
+        return { status: 'sent', messageId: deliveredMessageId };
+    }
+    if (entry.terminal) {
+        return {
+            status: 'failed',
+            error: entry.terminal.error,
+            ...(entry.terminal.code !== undefined ? { code: entry.terminal.code } : {}),
+        };
+    }
+    if (isExpired(entry)) {
+        markExpired(entry);
+        writeEntries(aid, entries, queue);
+        return {
+            status: 'failed',
+            error: entry.terminal.error,
+            code: entry.terminal.code,
+        };
+    }
+    return { status: 'queued' };
+}
+function markExpired(entry) {
+    entry.lastError = 'outbox delivery expired';
+    entry.lastErrorCode = 'OUTBOX_EXPIRED';
+    entry.terminal = {
+        at: Date.now(),
+        error: entry.lastError,
+        code: entry.lastErrorCode,
+    };
+}
+/** Mark a durable entry terminal while keeping its reason for diagnostics. */
+export function markTerminal(aid, id, failure, submitted, queue = submitted ? entryQueue(submitted) : 'default') {
+    const entries = readEntries(aid, queue);
+    const entry = entries.find(candidate => candidate.id === id);
+    if (!entry || (submitted && !hasSamePersistedRoute(entry, submitted)))
+        return false;
+    entry.lastError = failure.error ?? 'permanent send failure';
+    if (failure.code !== undefined)
+        entry.lastErrorCode = failure.code;
+    entry.terminal = { at: Date.now(), error: entry.lastError, ...(failure.code !== undefined ? { code: failure.code } : {}) };
+    writeEntries(aid, entries, queue);
+    return true;
+}
+/** Retain a bounded success receipt for queued Trigger history reconciliation. */
+export function markDelivered(aid, id, messageId, submitted, queue = submitted ? entryQueue(submitted) : 'default') {
+    const entries = readEntries(aid, queue);
+    const entry = entries.find(candidate => candidate.id === id);
+    if (!entry || (submitted && !hasSamePersistedRoute(entry, submitted)))
+        return false;
+    entry.deliveryResult = { status: 'sent', at: Date.now(), messageId };
+    delete entry.lastError;
+    delete entry.lastErrorCode;
+    delete entry.terminal;
+    writeEntries(aid, entries, queue);
+    return true;
 }
 // Each caller gets its own pass over the current disk state. This prevents
 // duplicate sends while allowing a later drain trigger to pick up entries
@@ -145,36 +298,95 @@ const activeDrainTails = new Map();
 function hasRouteForChannel(entry) {
     return isDeliveryForChannel(entry.delivery, entry.channelId);
 }
-async function drainOnce(aid, sender) {
-    const entries = readEntries(aid);
+function hasSamePersistedRoute(left, right) {
+    if (left.channelId !== right.channelId)
+        return false;
+    if (left.delivery === undefined && right.delivery === undefined)
+        return true;
+    return isDeliveryTarget(left.delivery)
+        && isDeliveryTarget(right.delivery)
+        && sameDeliveryTarget(left.delivery, right.delivery);
+}
+async function drainOnce(aid, sender, queue) {
+    const entries = readEntries(aid, queue).filter(entry => !entry.terminal && !entry.deliveryResult);
     if (entries.length === 0)
         return { sent: 0, expired: 0, failed: 0 };
     const drainedIds = new Set(entries.map(e => e.id));
+    const drainedById = new Map(entries.map(entry => [entry.id, entry]));
     let sent = 0;
     let expired = 0;
     let failed = 0;
+    let permanent = 0;
     const remaining = [];
     for (const entry of entries) {
         if (isExpired(entry)) {
             expired++;
+            markExpired(entry);
+            // Keep the terminal record so Trigger history can distinguish an
+            // operation that expired from one that was actually sent.
+            remaining.push(entry);
             continue;
         }
         if (!hasRouteForChannel(entry)) {
             // A route is security-sensitive metadata. An entry whose groupId does
-            // not match its address cannot be repaired from channelId, so remove it
-            // instead of retrying the same malformed send forever.
-            expired++;
+            // not match its address cannot be repaired from channelId. Keep a
+            // terminal diagnostic record instead of retrying the same malformed
+            // send forever or silently deleting evidence of the failure.
+            permanent++;
+            entry.lastError = 'outbox entry has no valid delivery route';
+            entry.lastErrorCode = 'AUN_OUTBOUND_ROUTE_REQUIRED';
+            entry.terminal = {
+                at: Date.now(),
+                error: entry.lastError,
+                code: entry.lastErrorCode,
+            };
+            remaining.push(entry);
             continue;
         }
         try {
             entry.attempts = (entry.attempts ?? 0) + 1;
-            const ok = await sender(entry);
-            if (ok) {
-                sent++;
+            const raw = await sender(entry);
+            const result = typeof raw === 'boolean'
+                ? { status: raw ? 'sent' : 'retry' }
+                : raw;
+            if (result.status === 'sent') {
+                const messageId = result.messageId ?? entry.deliveryReceipt?.messageId;
+                if (messageId) {
+                    sent++;
+                    entry.deliveryResult = { status: 'sent', at: Date.now(), messageId };
+                    remaining.push(entry);
+                }
+                else {
+                    permanent++;
+                    entry.lastError = 'outbox sender returned sent without a remote message_id';
+                    entry.lastErrorCode = 'MISSING_MESSAGE_ID';
+                    entry.terminal = {
+                        at: Date.now(),
+                        error: entry.lastError,
+                        code: entry.lastErrorCode,
+                    };
+                    remaining.push(entry);
+                }
+            }
+            else if (result.status === 'permanent') {
+                permanent++;
+                entry.lastError = result.error ?? 'permanent send failure';
+                if (result.code !== undefined)
+                    entry.lastErrorCode = result.code;
+                entry.terminal = {
+                    at: Date.now(),
+                    error: entry.lastError,
+                    ...(result.code !== undefined ? { code: result.code } : {}),
+                };
+                // Keep a terminal record for diagnostics, but exclude it from all
+                // pending-send views so the timer cannot submit it again.
+                remaining.push(entry);
             }
             else {
                 failed++;
-                entry.lastError = 'sender returned false';
+                entry.lastError = result.error ?? 'sender returned false';
+                if (result.code !== undefined)
+                    entry.lastErrorCode = result.code;
                 remaining.push(entry);
             }
         }
@@ -184,49 +396,64 @@ async function drainOnce(aid, sender) {
             remaining.push(entry);
         }
     }
-    const current = readEntries(aid);
+    const current = readEntries(aid, queue);
     const failedById = new Map(remaining.map(entry => [entry.id, entry]));
     const retained = current.flatMap(entry => {
         if (!drainedIds.has(entry.id))
             return [entry];
         const failedEntry = failedById.get(entry.id);
-        if (!failedEntry)
-            return [];
+        if (!failedEntry) {
+            const submittedEntry = drainedById.get(entry.id);
+            return submittedEntry && !hasSamePersistedRoute(entry, submittedEntry)
+                ? [entry]
+                : [];
+        }
+        // A failure belongs to the route that was actually submitted. If another
+        // writer corrected that route while the RPC was in flight, preserve the
+        // corrected entry as pending instead of terminating it with a stale
+        // target's permanent error.
+        if (!hasSamePersistedRoute(entry, failedEntry))
+            return [entry];
+        if (entry.terminal && !failedEntry.terminal)
+            return [entry];
         return [{
                 ...failedEntry,
                 ...entry,
                 attempts: failedEntry.attempts,
                 lastError: failedEntry.lastError,
+                lastErrorCode: failedEntry.lastErrorCode,
+                ...(failedEntry.terminal ? { terminal: failedEntry.terminal } : {}),
             }];
     });
-    writeEntries(aid, retained);
-    return { sent, expired, failed };
+    writeEntries(aid, retained, queue);
+    return { sent, expired, failed, ...(permanent > 0 ? { permanent } : {}) };
 }
-export async function drain(aid, sender) {
-    const previous = activeDrainTails.get(aid);
+export async function drain(aid, sender, queue = 'default') {
+    const drainKey = `${queue}:${aid}`;
+    const previous = activeDrainTails.get(drainKey);
     let releaseTurn;
     const turn = new Promise(resolve => { releaseTurn = resolve; });
     const tail = (previous ?? Promise.resolve()).then(() => turn);
-    activeDrainTails.set(aid, tail);
+    activeDrainTails.set(drainKey, tail);
     if (previous)
         await previous;
     try {
-        return await drainOnce(aid, sender);
+        return await drainOnce(aid, sender, queue);
     }
     finally {
         releaseTurn();
-        if (activeDrainTails.get(aid) === tail)
-            activeDrainTails.delete(aid);
+        if (activeDrainTails.get(drainKey) === tail)
+            activeDrainTails.delete(drainKey);
     }
 }
-export function hasPending(aid) {
-    return readEntries(aid).some(entry => !isExpired(entry));
+export function hasPending(aid, queue = 'default') {
+    return readEntries(aid, queue).some(entry => !entry.terminal && !entry.deliveryResult && !isExpired(entry));
 }
 /**
  * 当前 outbox 中待发送条目数。用于诊断发送管线堵塞：depth 持续增长说明
  * message.send 出队速度跟不上入队速度（网关慢 / 链路抖动 / 卡片洪泛），
  * 是命令「回复慢/无回复」的先行指标。
  */
-export function pendingCount(aid) {
-    return load(aid).length;
+export function pendingCount(aid, queue = 'default') {
+    return load(aid, queue).length;
 }

package/dist/aun/service-proxy.js

@@ -11,7 +11,7 @@
  *   所以不能把 client 引用直接交给 ServiceProxyClient；传一个动态解引用的
  *   facade，每次 .call()/.authenticate()/._tokenStore 都读 channel 当前 client。
  *   serveForever(persistent) 的指数退避会在 client 缺失时自动等待恢复。
- * - endpoint 发现：source='ecweb' 时读 data/instance/ecweb-*.json 的 port。
+ * - endpoint 发现：source='instance' 时读服务实例登记文件的 port；source='static' 时使用显式 endpoint。
  * - 失败降级：任何异常只 warn，绝不影响 daemon 主流程。
  */
 import fs from 'fs';
@@ -20,16 +20,16 @@ import { ServiceProxyClient, EndpointPolicy } from '@agentunion/fastaun';
 import { resolvePaths } from '../paths.js';
 import { logger } from '../utils/logger.js';
 const LOG = '[ServiceProxy]';
-const ECWEB_DISCOVERY_TIMEOUT_MS = 10_000;
-const ECWEB_DISCOVERY_INTERVAL_MS = 250;
+const INSTANCE_DISCOVERY_TIMEOUT_MS = 10_000;
+const INSTANCE_DISCOVERY_INTERVAL_MS = 250;
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 /**
- * 读 data/instance/ 下存活的 ecweb 实例端口。
+ * 读 data/instance/ 下指定服务的存活实例端口。
  * 取 startedAt 最新的一条（多实例保护下通常只有一条存活）。
  */
-function discoverEcwebPort() {
+function discoverInstancePort(serviceName) {
     const dir = resolvePaths().instanceDir;
     let files;
     try {
@@ -40,11 +40,25 @@ function discoverEcwebPort() {
     }
     const records = [];
     for (const file of files) {
-        if (!/^(ecweb|watch-web)-\d+\.json$/.test(file))
+        const match = serviceName === 'ecweb'
+            ? file.match(/^(?:ecweb|watch-web)-(\d+)\.json$/)
+            : file.match(new RegExp(`^${serviceName.replace(/[^a-z0-9_-]/gi, '')}-(\\d+)\\.json$`));
+        if (!match)
             continue;
+        const filePid = Number(match[1]);
         try {
             const rec = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf-8'));
-            if (rec && typeof rec.pid === 'number' && isProcessAlive(rec.pid) && typeof rec.port === 'number') {
+            if (rec
+                && Number.isInteger(rec.pid)
+                && rec.pid > 0
+                && rec.pid === filePid
+                && isProcessAlive(rec.pid)
+                && typeof rec.startedAt === 'number'
+                && Number.isFinite(rec.startedAt)
+                && rec.startedAt >= 0
+                && Number.isInteger(rec.port)
+                && rec.port >= 1
+                && rec.port <= 65535) {
                 records.push(rec);
             }
         }
@@ -67,18 +81,18 @@ function isProcessAlive(pid) {
         return e?.code === 'EPERM';
     }
 }
-async function waitForEcwebPort(serviceName) {
-    const deadline = Date.now() + ECWEB_DISCOVERY_TIMEOUT_MS;
+async function waitForInstancePort(serviceName) {
+    const deadline = Date.now() + INSTANCE_DISCOVERY_TIMEOUT_MS;
     let loggedWait = false;
     while (Date.now() <= deadline) {
-        const port = discoverEcwebPort();
+        const port = discoverInstancePort(serviceName);
         if (port)
             return port;
         if (!loggedWait) {
-            logger.info(`${LOG} 服务 "${serviceName}" source=ecweb，等待 ecweb 实例就绪`);
+            logger.info(`${LOG} 服务 "${serviceName}" source=instance，等待实例就绪`);
             loggedWait = true;
         }
-        await sleep(ECWEB_DISCOVERY_INTERVAL_MS);
+        await sleep(INSTANCE_DISCOVERY_INTERVAL_MS);
     }
     return null;
 }
@@ -86,18 +100,22 @@ async function waitForEcwebPort(serviceName) {
  * 把单个服务配置解析为本地回连 endpoint。无法解析返回 null。
  */
 async function resolveEndpoint(svc) {
-    if (svc.source === 'ecweb') {
-        const port = await waitForEcwebPort(svc.name);
+    if (svc.proxy?.source === 'instance') {
+        const port = await waitForInstancePort(svc.name);
         if (!port) {
-            logger.warn(`${LOG} 服务 "${svc.name}" source=ecweb 等待 ${ECWEB_DISCOVERY_TIMEOUT_MS}ms 后仍未发现存活的 ecweb 实例，跳过`);
+            logger.warn(`${LOG} 服务 "${svc.name}" source=instance 等待 ${INSTANCE_DISCOVERY_TIMEOUT_MS}ms 后仍未发现存活实例，跳过`);
             return null;
         }
         return `http://127.0.0.1:${port}`;
     }
-    // static
-    if (svc.endpoint && svc.endpoint.trim())
-        return svc.endpoint.trim();
-    logger.warn(`${LOG} 服务 "${svc.name}" source=static 但未配置 endpoint，跳过`);
+    if (svc.proxy?.source === 'static') {
+        const endpoint = svc.proxy.endpoint?.trim();
+        if (endpoint)
+            return endpoint;
+        logger.warn(`${LOG} 服务 "${svc.name}" source=static 但未配置 endpoint，跳过`);
+        return null;
+    }
+    logger.warn(`${LOG} 服务 "${svc.name}" 未配置有效 proxy.source，跳过`);
     return null;
 }
 /**
@@ -105,8 +123,8 @@ async function resolveEndpoint(svc) {
  * 返回 handle 供关停；没有启用服务时返回 null。endpoint 发现和隧道启动在后台执行，
  * 失败只 warn，不抛异常，不阻塞 daemon 主流程。
  */
-export function startServiceProxy(controlChannel, providerAid, config) {
-    const services = (config.services ?? []).filter((s) => s.enabled !== false);
+export function startServiceProxy(controlChannel, providerAid, configuredServices) {
+    const services = configuredServices.filter((s) => s.enabled === true && s.proxy?.enabled === true);
     if (services.length === 0) {
         logger.info(`${LOG} 无启用的服务，跳过`);
         return null;
@@ -177,12 +195,12 @@ export function startServiceProxy(controlChannel, providerAid, config) {
                     continue;
                 try {
                     proxyClient.registerService(svc.name, endpoint, {
-                        serviceType: svc.serviceType ?? 'http',
-                        visibility: svc.visibility ?? 'private',
-                        metadata: svc.metadata ?? {},
+                        serviceType: svc.proxy?.serviceType ?? 'http',
+                        visibility: svc.proxy?.visibility ?? 'private',
+                        metadata: svc.proxy?.metadata ?? {},
                     });
                     registered += 1;
-                    logger.info(`${LOG} 注册服务 "${svc.name}" → ${endpoint} (visibility=${svc.visibility ?? 'private'})`);
+                    logger.info(`${LOG} 注册服务 "${svc.name}" → ${endpoint} (type=${svc.proxy?.serviceType ?? 'http'}, visibility=${svc.proxy?.visibility ?? 'private'})`);
                 }
                 catch (e) {
                     logger.warn(`${LOG} 注册服务 "${svc.name}" 失败: ${e?.message || e}`);