evolcore 0.0.20 → 0.0.22

package/dist/aun/outbox.js

@@ -1,12 +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;
+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 DEFAULT_TTL = 300_000; // 5 minutes
-function outboxFile(aid) {
-    return agentOutboxPath(aid);
+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();
@@ -17,7 +40,7 @@ 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)
+    if (entry.terminal || entry.deliveryResult)
         return false;
     if (entry.critical)
         return false;
@@ -26,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)
@@ -45,36 +68,45 @@ function readEntries(aid) {
         return [];
     }
 }
-function writeEntries(aid, entries) {
-    const file = outboxFile(aid);
-    const boundedEntries = trimTerminalEntries(entries);
+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 trimTerminalEntries(entries) {
-    const terminalEntries = entries.filter(entry => !!entry.terminal);
-    if (terminalEntries.length <= MAX_TERMINAL_ENTRIES_PER_AID)
+function trimFinalEntries(entries) {
+    const finalEntries = entries.filter(entry => !!entry.terminal || !!entry.deliveryResult);
+    if (finalEntries.length <= MAX_TERMINAL_ENTRIES_PER_AID)
         return entries;
-    const retainedTerminalIds = new Set(terminalEntries
-        .sort((left, right) => (left.terminal?.at ?? left.ts) - (right.terminal?.at ?? right.ts))
+    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 || retainedTerminalIds.has(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) {
         // 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 && !isExpired(entry));
+        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)
@@ -91,6 +123,7 @@ export function enqueue(aid, opts) {
         id: generateId(),
         ts: Date.now(),
         aid,
+        ...(queue === 'activity' ? { queue } : {}),
         channelId: opts.channelId,
         delivery,
         dedupeKey: opts.dedupeKey,
@@ -103,103 +136,145 @@ 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 the pending-entry cap without allowing historical terminal
-    // diagnostics to evict live messages. Terminal records are bounded
-    // separately so a permanently failing target cannot grow the file forever.
-    let entries = existingEntries;
-    if (entries.filter(candidate => !candidate.critical && !candidate.terminal).length >= MAX_ENTRIES_PER_AID) {
-        const dropIndex = entries.findIndex(candidate => !candidate.critical && !candidate.terminal);
-        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) {
-    const entries = readEntries(aid);
+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);
+    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) {
-    const entries = readEntries(aid);
+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);
+    writeEntries(aid, entries, queue);
     return 'replaced';
 }
 /** Update only the delivery receipt while preserving concurrent entry changes. */
-export function updateDeliveryReceiptIfRouteMatches(aid, submitted, receipt) {
-    const entries = readEntries(aid);
+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);
+    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 => !e.terminal && !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, opts = {}) {
+export function findByDedupeKey(aid, dedupeKey, opts = {}, queue = 'default') {
     const entries = opts.includeTerminal
-        ? readEntries(aid).filter(entry => !isExpired(entry))
-        : load(aid);
+        ? 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;
+/** Find all durable entries belonging to an operation family. */
+export function findByDedupePrefix(aid, dedupePrefix, opts = {}, queue = 'default') {
+    const entries = opts.includeTerminal
+        ? readEntries(aid, queue).filter(entry => !isExpired(entry))
+        : load(aid, queue);
+    return entries.filter(entry => typeof entry.dedupeKey === 'string' && entry.dedupeKey.startsWith(dedupePrefix));
+}
+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) {
-    const entries = readEntries(aid);
+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;
@@ -207,7 +282,20 @@ export function markTerminal(aid, id, failure, submitted) {
     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);
+    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
@@ -226,8 +314,8 @@ function hasSamePersistedRoute(left, right) {
         && isDeliveryTarget(right.delivery)
         && sameDeliveryTarget(left.delivery, right.delivery);
 }
-async function drainOnce(aid, sender) {
-    const entries = readEntries(aid).filter(entry => !entry.terminal);
+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));
@@ -240,6 +328,10 @@ async function drainOnce(aid, sender) {
     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)) {
@@ -265,7 +357,23 @@ async function drainOnce(aid, sender) {
                 ? { status: raw ? 'sent' : 'retry' }
                 : raw;
             if (result.status === 'sent') {
-                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++;
@@ -295,7 +403,7 @@ 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))
@@ -324,34 +432,35 @@ async function drainOnce(aid, sender) {
                 ...(failedEntry.terminal ? { terminal: failedEntry.terminal } : {}),
             }];
     });
-    writeEntries(aid, retained);
+    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 => !entry.terminal && !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}`);