evolclaw 3.1.4 → 3.1.5

package/dist/core/model/model-catalog.js

@@ -0,0 +1,215 @@
+/**
+ * model-catalog: 模型目录与单模型元数据。
+ *
+ * 目录来源（按序回退）：
+ *   {baseUrl}/v1/models  →  {baseUrl}/models  →  内置 mock catalog
+ *
+ * baseUrl/apiKey 复用 baseagent 凭据解析链（与发消息同源），命令不接收 url/key 参数。
+ * 单模型详情（info）现阶段全部为 mock，{baseUrl}/models 接口补全字段后自动接真实数据。
+ *
+ * 详见 docs/model-command-design.md。
+ */
+import { loadDefaults, loadAgent } from '../../config-store.js';
+import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/resolve.js';
+import { activeBaseagent } from './model-scope.js';
+/** 取指定 baseagent 的 baseUrl + apiKey（复用现有解析链）。 */
+function resolveCreds(self, ba) {
+    const baseagent = ba || activeBaseagent(self);
+    const agentCfg = self ? loadAgent(self) : null;
+    const defaults = loadDefaults();
+    const block = (agentCfg?.baseagents || defaults?.baseagents || {});
+    try {
+        if (baseagent === 'codex') {
+            const c = block.codex;
+            const r = resolveOpenaiConfig({ agents: { codex: c } }, c);
+            return { baseUrl: r.baseUrl, apiKey: r.apiKey };
+        }
+        const c = block.claude;
+        const r = resolveAnthropicConfig({ agents: { claude: c } }, c);
+        return { baseUrl: r.baseUrl, apiKey: r.apiKey };
+    }
+    catch {
+        return {};
+    }
+}
+/** 从对象/字符串条目里提取 id（兼容 id/name/model 字段）。 */
+function pickId(item) {
+    if (typeof item === 'string')
+        return item;
+    if (item && typeof item === 'object') {
+        const v = item.id ?? item.name ?? item.model;
+        return typeof v === 'string' ? v : undefined;
+    }
+    return undefined;
+}
+/** 从对象条目里提取厂商（兼容 owned_by/owner/provider）。 */
+function pickOwner(item) {
+    if (item && typeof item === 'object') {
+        const v = item.owned_by ?? item.owner ?? item.provider;
+        return typeof v === 'string' ? v : undefined;
+    }
+    return undefined;
+}
+/**
+ * 通用容错解析：
+ *   - 容器：json.data[] | json.models[] | json.data.models[] | 裸数组
+ *   - 条目：字符串 或 {id|name|model, owned_by|owner|provider, created}
+ */
+function genericParse(json) {
+    const arr = Array.isArray(json) ? json
+        : Array.isArray(json?.data) ? json.data
+            : Array.isArray(json?.models) ? json.models
+                : Array.isArray(json?.data?.models) ? json.data.models
+                    : [];
+    const out = [];
+    for (const item of arr) {
+        const id = pickId(item);
+        if (!id)
+            continue;
+        out.push({ id, owned_by: pickOwner(item), created: typeof item?.created === 'number' ? item.created : undefined });
+    }
+    return out;
+}
+/**
+ * 网关专用 parser 注册表（扩展点）。
+ * 当前为空：ModelGate 是标准 OpenAI list 风格，genericParse 已覆盖。
+ * 示例（接入异形网关时取消注释并按实际格式实现）：
+ *   {
+ *     name: 'some-gateway',
+ *     match: (url) => url.includes('some-gateway.example.com'),
+ *     parse: (json) => (json?.result?.modelList ?? []).map((m: any) => ({ id: m.code, owned_by: m.vendor })),
+ *   }
+ */
+const GATEWAY_PARSERS = [];
+/** 选择 parser 并解析（专用优先，否则通用容错）。 */
+export function parseModelList(json, url) {
+    for (const rule of GATEWAY_PARSERS) {
+        try {
+            if (rule.match(url, json))
+                return rule.parse(json);
+        }
+        catch { /* 专用 parser 失败则继续尝试通用解析 */ }
+    }
+    return genericParse(json);
+}
+async function fetchModelList(url, apiKey) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 5000);
+        const resp = await fetch(url, {
+            signal: controller.signal,
+            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+        });
+        clearTimeout(timer);
+        if (!resp.ok)
+            return null;
+        const json = await resp.json();
+        const entries = parseModelList(json, url);
+        return entries.length > 0 ? entries : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 内置 mock catalog（接口未就绪时的兜底；实测可用模型，见 docs 附录 A）。 */
+const MOCK_CATALOG = [
+    { id: 'claude-opus-4-7', owned_by: 'anthropic' },
+    { id: 'claude-opus-4-6', owned_by: 'anthropic' },
+    { id: 'claude-sonnet-4-6', owned_by: 'anthropic' },
+    { id: 'claude-haiku-4-5-20251001', owned_by: 'anthropic' },
+    { id: 'deepseek-v4-pro', owned_by: 'deepseek' },
+    { id: 'deepseek-v4-flash', owned_by: 'deepseek' },
+    { id: 'kimi-k2.6', owned_by: 'moonshot' },
+    { id: 'kimi-k2.5', owned_by: 'moonshot' },
+    { id: 'glm-5.1', owned_by: 'zhipu' },
+    { id: 'glm-5', owned_by: 'zhipu' },
+    { id: 'glm-4.7', owned_by: 'zhipu' },
+    { id: 'MiniMax-M2.7', owned_by: 'minimax' },
+];
+/**
+ * 远端模型目录接口（临时）。本地 baseUrl 的 /v1/models、/models 尚未实现，
+ * 自动降级到此接口拉取真实可用模型列表；待本地接口就绪后此级自然不再命中。
+ */
+const REMOTE_CATALOG_URL = 'https://mg-new.evolai.cn/claude-proxy/models';
+/**
+ * 各 baseagent 的稳定别名（cc/SDK 自动解析到最新版本）。
+ * 这些是一等公民——defaults.json 默认就存别名（如 "opus"），必须可选可校验。
+ */
+const KNOWN_ALIASES = {
+    claude: ['opus', 'sonnet', 'haiku'],
+    codex: [],
+    gemini: [],
+};
+/** 把别名作为虚拟条目并入目录头部（owned_by 标 alias，便于展示与校验）。 */
+function withAliases(models, ba) {
+    const aliases = KNOWN_ALIASES[ba] || [];
+    const existing = new Set(models.map(m => m.id));
+    const aliasEntries = aliases
+        .filter(a => !existing.has(a))
+        .map(a => ({ id: a, owned_by: 'alias' }));
+    return [...aliasEntries, ...models];
+}
+/** 拉取模型目录：v1/models → models → 远端接口 → mock，并并入别名。 */
+export async function getCatalog(self, ba) {
+    const baseagent = ba || activeBaseagent(self);
+    const { baseUrl, apiKey } = resolveCreds(self, baseagent);
+    if (baseUrl) {
+        const base = baseUrl.replace(/\/+$/, '');
+        const v1 = await fetchModelList(`${base}/v1/models`, apiKey);
+        if (v1)
+            return { models: withAliases(v1, baseagent), source: 'v1/models' };
+        const plain = await fetchModelList(`${base}/models`, apiKey);
+        if (plain)
+            return { models: withAliases(plain, baseagent), source: 'models' };
+    }
+    // 本地接口未实现 → 降级到远端目录接口（无需鉴权）
+    const remote = await fetchModelList(REMOTE_CATALOG_URL, apiKey);
+    if (remote)
+        return { models: withAliases(remote, baseagent), source: 'remote' };
+    return { models: withAliases(MOCK_CATALOG, baseagent), source: 'mock' };
+}
+/** claude 系判定：完整 ID 或别名（opus/sonnet/haiku）。 */
+function isClaudeFamily(id) {
+    return /^claude-/.test(id) || ['opus', 'sonnet', 'haiku'].includes(id);
+}
+/** 单模型详情（现阶段 mock）。 */
+export async function getModelInfo(modelId, self, ba) {
+    const cat = await getCatalog(self, ba);
+    const entry = cat.models.find(m => m.id === modelId);
+    const claudeFamily = isClaudeFamily(modelId);
+    // 远端目录把所有模型的 owned_by 标成网关名 'ModelGate'，别名标成 'alias'，
+    // 两者都不是真实厂商 → 回退到按 ID 推断。
+    const NON_VENDOR = new Set(['alias', 'ModelGate', '']);
+    const rawOwner = entry?.owned_by;
+    const owner = claudeFamily
+        ? 'anthropic'
+        : (rawOwner && !NON_VENDOR.has(rawOwner) ? rawOwner : inferOwner(modelId));
+    return {
+        id: modelId,
+        owned_by: owner,
+        context_window: claudeFamily ? 200000 : 128000,
+        max_output_tokens: 8192,
+        pricing: { input_per_mtok: null, output_per_mtok: null, currency: 'USD' },
+        modalities: ['text'],
+        supports_effort: claudeFamily,
+        status: entry ? 'available' : 'unknown',
+        mocked: true,
+    };
+}
+function inferOwner(id) {
+    if (/^claude-/.test(id))
+        return 'anthropic';
+    if (/^gpt-/.test(id))
+        return 'openai';
+    if (/^gemini-/.test(id))
+        return 'google';
+    if (/^deepseek-/.test(id))
+        return 'deepseek';
+    if (/^kimi-/.test(id))
+        return 'moonshot';
+    if (/^glm-/.test(id))
+        return 'zhipu';
+    if (/^MiniMax-/i.test(id))
+        return 'minimax';
+    return 'unknown';
+}

package/dist/core/model/model-scope.js

@@ -0,0 +1,250 @@
+/**
+ * model-scope: 模型/推理强度的三级作用域读写与解析。
+ *
+ * 作用域（越具体越优先）：
+ *   关系级  >  agent级  >  全局
+ *
+ * 存储位置：
+ *   全局   agents/defaults.json          → baseagents.<ba>.{model,effort}
+ *   agent  agents/<self>/config.json     → baseagents.<ba>.{model,effort}
+ *   关系   agents/<self>/relations/<peerKey>/preferences.json → {model,effort}
+ *
+ * 改关系级/agent级/全局后，对应范围所有会话的下一条消息即时生效
+ * （运行时每条消息按 关系>agent>全局 解析，不缓存、不绑会话）。
+ *
+ * 详见 docs/model-command-design.md。
+ */
+import fs from 'fs';
+import path from 'path';
+import { agentRelationsDir } from '../../paths.js';
+import { loadDefaults, saveDefaultsSafe, loadAgent, saveAgent } from '../../config-store.js';
+import { formatPeerKey, parsePeerKey } from '../relation/peer-key.js';
+export class ModelScopeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ModelScopeError';
+    }
+}
+// ── peer 归一化 ────────────────────────────────────────────────────────
+/**
+ * 把 `--peer` 入参归一为规范 peerKey。
+ * 接受两种形态：
+ *   - `channelType#channelId`（channelId 可能已 urlEncode，统一 round-trip 重编码）
+ *   - 裸 aid（无 '#'）→ 视为 `aun#<aid>`
+ */
+export function normalizePeer(input) {
+    const raw = (input || '').trim();
+    if (!raw)
+        throw new ModelScopeError('INVALID_PEER', '--peer 不能为空');
+    if (raw.includes('#')) {
+        let parsed;
+        try {
+            parsed = parsePeerKey(raw);
+        }
+        catch {
+            throw new ModelScopeError('INVALID_PEER', `无法解析 --peer: ${raw}`);
+        }
+        if (!parsed.channelType || !parsed.channelId) {
+            throw new ModelScopeError('INVALID_PEER', `无法解析 --peer: ${raw}`);
+        }
+        return formatPeerKey(parsed.channelType, parsed.channelId);
+    }
+    // 裸 aid → AUN 原生对端
+    return formatPeerKey('aun', raw);
+}
+// ── 作用域判定 ────────────────────────────────────────────────────────
+/**
+ * 由选择器判定作用域，并校验参数依赖关系。
+ * 依赖：peerKey 须配 self。
+ */
+export function determineScope(sel) {
+    const hasSelf = !!sel.self;
+    const hasPeer = !!sel.peerKey;
+    if (hasPeer && !hasSelf) {
+        throw new ModelScopeError('PEER_WITHOUT_SELF', '--peer 必须配合 --self 使用');
+    }
+    if (hasPeer)
+        return 'relation';
+    if (hasSelf)
+        return 'agent';
+    return 'global';
+}
+// ── baseagent 解析（global/agent 级模型挂在 baseagents.<ba> 下）──────────
+/** 取本端的活跃 baseagent；无 self 时取全局默认。 */
+export function activeBaseagent(self) {
+    try {
+        if (self) {
+            const cfg = loadAgent(self);
+            if (cfg?.active_baseagent)
+                return cfg.active_baseagent;
+        }
+        const d = loadDefaults();
+        if (d?.active_baseagent)
+            return d.active_baseagent;
+    }
+    catch { /* fall through */ }
+    return 'claude';
+}
+/** codex 的推理强度字段名是 reasoning，其余是 effort。 */
+function effortField(ba) {
+    return ba === 'codex' ? 'reasoning' : 'effort';
+}
+// ── 关系级文件路径 ─────────────────────────────────────────────────────
+function relationPrefsPath(self, peerKey) {
+    return path.join(agentRelationsDir(self), peerKey, 'preferences.json');
+}
+function readJsonSafe(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonAtomic(file, data) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tmp, file);
+}
+// ── 读：单作用域 ──────────────────────────────────────────────────────
+/** 读取指定作用域当前存的 {model,effort}（未设为空对象）。 */
+export function readScope(scope, sel, ba) {
+    switch (scope) {
+        case 'global': {
+            const block = (loadDefaults()?.baseagents || {});
+            const c = block[ba] || {};
+            return { model: c.model, effort: c[effortField(ba)] };
+        }
+        case 'agent': {
+            const cfg = sel.self ? loadAgent(sel.self) : null;
+            const c = (cfg?.baseagents || {})[ba] || {};
+            return { model: c.model, effort: c[effortField(ba)] };
+        }
+        case 'relation': {
+            const p = readJsonSafe(relationPrefsPath(sel.self, sel.peerKey));
+            return { model: p?.model, effort: p?.effort };
+        }
+    }
+}
+// ── 写：单作用域 ──────────────────────────────────────────────────────
+/**
+ * 写入指定作用域。patch 中 undefined 的字段不动；显式 null 删除该字段。
+ */
+export function writeScope(scope, sel, ba, patch) {
+    switch (scope) {
+        case 'global':
+            writeConfigBlock(scope, sel, ba, patch);
+            return;
+        case 'agent':
+            writeConfigBlock(scope, sel, ba, patch);
+            return;
+        case 'relation':
+            writeFlatFile(relationPrefsPath(sel.self, sel.peerKey), patch);
+            return;
+    }
+}
+function writeConfigBlock(scope, sel, ba, patch) {
+    const ef = effortField(ba);
+    if (scope === 'global') {
+        const block = {};
+        const sub = {};
+        if (patch.model !== undefined)
+            sub.model = patch.model === null ? undefined : patch.model;
+        if (patch.effort !== undefined)
+            sub[ef] = patch.effort === null ? undefined : patch.effort;
+        block[ba] = sub;
+        // saveDefaultsSafe 做深合并；删除字段需读改写
+        if (patch.model === null || patch.effort === null) {
+            const d = loadDefaults() || { $schema_version: 1 };
+            d.baseagents = d.baseagents || {};
+            d.baseagents[ba] = d.baseagents[ba] || {};
+            if (patch.model === null)
+                delete d.baseagents[ba].model;
+            else if (patch.model !== undefined)
+                d.baseagents[ba].model = patch.model;
+            if (patch.effort === null)
+                delete d.baseagents[ba][ef];
+            else if (patch.effort !== undefined)
+                d.baseagents[ba][ef] = patch.effort;
+            saveDefaultsSafe({ baseagents: d.baseagents });
+        }
+        else {
+            saveDefaultsSafe({ baseagents: block });
+        }
+        return;
+    }
+    // agent 级
+    const cfg = loadAgent(sel.self);
+    if (!cfg)
+        throw new ModelScopeError('AGENT_NOT_FOUND', `agent 不存在: ${sel.self}`);
+    cfg.baseagents = cfg.baseagents || {};
+    cfg.baseagents[ba] = cfg.baseagents[ba] || {};
+    const sub = cfg.baseagents[ba];
+    if (patch.model === null)
+        delete sub.model;
+    else if (patch.model !== undefined)
+        sub.model = patch.model;
+    if (patch.effort === null)
+        delete sub[ef];
+    else if (patch.effort !== undefined)
+        sub[ef] = patch.effort;
+    saveAgent(cfg);
+}
+function writeFlatFile(file, patch) {
+    const cur = readJsonSafe(file) || {};
+    if (patch.model === null)
+        delete cur.model;
+    else if (patch.model !== undefined)
+        cur.model = patch.model;
+    if (patch.effort === null)
+        delete cur.effort;
+    else if (patch.effort !== undefined)
+        cur.effort = patch.effort;
+    cur.updatedAt = Date.now();
+    writeJsonAtomic(file, cur);
+}
+// ── 清除：单作用域 ────────────────────────────────────────────────────
+/** 清除指定作用域的 model+effort（关系级直接删文件）。 */
+export function clearScope(scope, sel, ba) {
+    if (scope === 'relation') {
+        try {
+            fs.unlinkSync(relationPrefsPath(sel.self, sel.peerKey));
+        }
+        catch { /* already gone */ }
+        return;
+    }
+    writeScope(scope, sel, ba, { model: null, effort: null });
+}
+/**
+ * 按 关系>agent>全局 解析实际生效的 model（首个有 model 的作用域命中）。
+ * 仅就给定选择器可达的作用域参与：无 peer 不读关系级，无 self 只读全局。
+ * 不读 ~/.claude/settings.json，不使用硬编码默认。
+ *
+ * 运行时（message-processor）每条消息调用本函数，结果直接传入 runQuery，
+ * 不缓存、不绑会话——故改关系级/agent级后该范围所有会话下条消息即时生效。
+ */
+export function resolveEffectiveModel(sel, ba) {
+    const baseagent = ba || activeBaseagent(sel.self);
+    const order = [];
+    if (sel.peerKey && sel.self)
+        order.push('relation');
+    if (sel.self)
+        order.push('agent');
+    order.push('global');
+    const chain = [];
+    let resolved = { chain };
+    for (const scope of order) {
+        const prefs = readScope(scope, sel, baseagent);
+        const hit = !!prefs.model && resolved.source === undefined;
+        chain.push({ scope, model: prefs.model, effort: prefs.effort, hit });
+        if (hit) {
+            resolved.model = prefs.model;
+            resolved.effort = prefs.effort;
+            resolved.source = scope;
+        }
+    }
+    return resolved;
+}

package/dist/core/relation/peer-identity.js

@@ -6,7 +6,7 @@
  * 2. 仅在 agent.md 内容变化时重写 peer-identity.json
  * 3. 支持入站和出站消息的身份查询
  *
- * 信源：对端的 agent.md（通过 AUN SDK checkAgentMd + fetchAgentMd）
+ * 信源：对端的 agent.md（通过 AIDStore.checkAgentMd + downloadAgentMd，由 agentmdSync 封装）
  * 判定规则：type !== 'human' → agent
  * 缓存位置：$AGENT_DIR/relations/<channel>#<urlEncode(peerId)>/peer-identity.json
  */
@@ -15,6 +15,7 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
 import { agentMdPath } from '../../paths.js';
+import { formatPeerKey } from './peer-key.js';
 /**
  * 对端身份缓存管理器
  */
@@ -24,16 +25,16 @@ export class PeerIdentityCache {
     /**
      * 获取 peer-identity.json 文件路径
      */
-    static getFilePath(channel, peerId, agentDir) {
-        const peerKey = `${channel}#${encodeURIComponent(peerId)}`;
+    static getFilePath(channelType, peerId, agentDir) {
+        const peerKey = formatPeerKey(channelType, peerId);
         return path.join(agentDir, 'relations', peerKey, 'peer-identity.json');
     }
     /**
      * 从文件读取缓存
      * @returns PeerIdentity | null（缓存不存在）
      */
-    static get(channel, peerId, agentDir) {
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+    static get(channelType, peerId, agentDir) {
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             const content = fs.readFileSync(filePath, 'utf-8');
             return JSON.parse(content);
@@ -47,8 +48,8 @@ export class PeerIdentityCache {
      * @param maxAgeMs 最大缓存时间（默认 30 天）
      * @returns true=需要刷新
      */
-    static needsRefresh(channel, peerId, agentDir, maxAgeMs = this.CACHE_MAX_AGE_MS) {
-        const cached = this.get(channel, peerId, agentDir);
+    static needsRefresh(channelType, peerId, agentDir, maxAgeMs = this.CACHE_MAX_AGE_MS) {
+        const cached = this.get(channelType, peerId, agentDir);
         if (!cached)
             return true;
         return Date.now() - cached.lastCheckedAt > maxAgeMs;
@@ -56,8 +57,8 @@ export class PeerIdentityCache {
     /**
      * 从 agent.md 更新身份信息
      */
-    static updateFromAgentMd(channel, peerId, agentDir, agentMd, verifiedAt) {
-        const typeMatch = agentMd.match(/^type:\s*["']?(\w+)["']?/m);
+    static updateFromAgentMd(channelType, peerId, agentDir, agentMd, verifiedAt) {
+        const typeMatch = agentMd.match(/^type:\s*["']?([^"'\n]+?)["']?\s*$/m);
         const nameMatch = agentMd.match(/^name:\s*["']?(.+?)["']?\s*$/m);
         const type = typeMatch?.[1] || 'unknown';
         const isAgent = type !== 'human';
@@ -75,11 +76,11 @@ export class PeerIdentityCache {
             lastCheckedAt: now,
             source: 'agentmd',
         };
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
-            logger.debug(`[PeerIdentityCache] Updated: ${channel}#${peerId} type=${type} isAgent=${isAgent}`);
+            logger.debug(`[PeerIdentityCache] Updated: ${channelType}#${peerId} type=${type} isAgent=${isAgent}`);
         }
         catch (err) {
             logger.warn(`[PeerIdentityCache] Failed to write cache: ${filePath} err=${err}`);
@@ -89,9 +90,9 @@ export class PeerIdentityCache {
     /**
      * 仅更新 lastCheckedAt（内容未变时的轻量操作）
      */
-    static touchLastChecked(channel, peerId, agentDir, cached) {
+    static touchLastChecked(channelType, peerId, agentDir, cached) {
         const updated = { ...cached, lastCheckedAt: Date.now() };
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.writeFileSync(filePath, JSON.stringify(updated, null, 2), 'utf-8');
         }
@@ -101,7 +102,7 @@ export class PeerIdentityCache {
     /**
      * 标记为 unknown（验签失败或无 agent.md）
      */
-    static markUnknown(channel, peerId, agentDir) {
+    static markUnknown(channelType, peerId, agentDir) {
         const identity = {
             aid: peerId,
             type: 'unknown',
@@ -112,11 +113,11 @@ export class PeerIdentityCache {
             lastCheckedAt: Date.now(),
             source: 'unknown',
         };
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
-            logger.debug(`[PeerIdentityCache] Marked unknown: ${channel}#${peerId}`);
+            logger.debug(`[PeerIdentityCache] Marked unknown: ${channelType}#${peerId}`);
         }
         catch (err) {
             logger.warn(`[PeerIdentityCache] Failed to write unknown cache: ${filePath} err=${err}`);
@@ -126,47 +127,37 @@ export class PeerIdentityCache {
     /**
      * 完整流程：缓存检查 → agentmdSync（check+fetch）→ 按 changed 决定是否重写
      *
-     * @param channel 渠道类型（如 'aun'）
+     * @param channelType 渠道类型（如 'aun'）
      * @param peerId 对端 ID（AUN 是 AID）
      * @param agentDir agent 数据根目录
-     * @param aunClient AUN SDK client（需要有 checkAgentMd / fetchAgentMd 方法）
+     * @param store AIDStore 实例（由调用方提供，负责 checkAgentMd + downloadAgentMd）
      * @param forceRefresh 强制刷新（忽略缓存时效）
-     * @returns PeerIdentity
      */
-    static async resolve(channel, peerId, agentDir, aunClient, forceRefresh = false) {
+    static async resolve(channelType, peerId, agentDir, store, forceRefresh = false) {
         // 1. 缓存检查
-        if (!forceRefresh && !this.needsRefresh(channel, peerId, agentDir)) {
-            const cached = this.get(channel, peerId, agentDir);
+        if (!forceRefresh && !this.needsRefresh(channelType, peerId, agentDir)) {
+            const cached = this.get(channelType, peerId, agentDir);
             if (cached) {
-                logger.debug(`[PeerIdentityCache] Cache hit: ${channel}#${peerId} type=${cached.type} age=${Math.floor((Date.now() - cached.lastCheckedAt) / 1000 / 60 / 60 / 24)}d`);
+                logger.debug(`[PeerIdentityCache] Cache hit: ${channelType}#${peerId} type=${cached.type} age=${Math.floor((Date.now() - cached.lastCheckedAt) / 1000 / 60 / 60 / 24)}d`);
                 return cached;
             }
         }
-        // 2. 标准流程：checkAgentMd → fetchAgentMd（如果有变化）
+        // 2. 通过 agentmdSync 拉取（内部走 store.checkAgentMd → store.downloadAgentMd）
         try {
-            logger.debug(`[PeerIdentityCache] Syncing agent.md: ${channel}#${peerId}`);
-            const state = await aunClient.checkAgentMd(peerId, 30);
-            let content;
-            if (state.in_sync && state.local_found) {
-                // 本地已是最新，读本地文件
-                const localPath = agentMdPath(peerId);
-                try {
-                    content = fs.readFileSync(localPath, 'utf-8');
-                }
-                catch { /* ignore */ }
-            }
+            logger.debug(`[PeerIdentityCache] Syncing agent.md: ${channelType}#${peerId}`);
+            const { agentmdSync } = await import('../../aun/aid/agentmd.js');
+            const result = await agentmdSync(peerId, { store });
+            const content = result.content;
             if (!content) {
-                // 需要下载（不同步或本地不存在）
-                const info = await aunClient.fetchAgentMd(peerId);
-                content = info.content;
+                throw new Error('agent.md content unavailable');
             }
             // 3. 比较 hash，仅在变化时重写 peer-identity.json
             const newHash = 'sha256:' + crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
-            const cached = this.get(channel, peerId, agentDir);
+            const cached = this.get(channelType, peerId, agentDir);
             if (cached && cached.agentMdHash === newHash && cached.source === 'agentmd') {
-                return this.touchLastChecked(channel, peerId, agentDir, cached);
+                return this.touchLastChecked(channelType, peerId, agentDir, cached);
             }
-            return this.updateFromAgentMd(channel, peerId, agentDir, content, Date.now());
+            return this.updateFromAgentMd(channelType, peerId, agentDir, content, Date.now());
         }
         catch (err) {
             // 4. 网络失败，fallback 本地文件
@@ -176,26 +167,26 @@ export class PeerIdentityCache {
                     const localContent = fs.readFileSync(localPath, 'utf-8');
                     logger.info(`[PeerIdentityCache] Network failed, using local agent.md for ${peerId}`);
                     const localHash = 'sha256:' + crypto.createHash('sha256').update(localContent, 'utf-8').digest('hex');
-                    const cached = this.get(channel, peerId, agentDir);
+                    const cached = this.get(channelType, peerId, agentDir);
                     if (cached && cached.agentMdHash === localHash && cached.source === 'agentmd') {
-                        return this.touchLastChecked(channel, peerId, agentDir, cached);
+                        return this.touchLastChecked(channelType, peerId, agentDir, cached);
                     }
-                    return this.updateFromAgentMd(channel, peerId, agentDir, localContent, cached?.verifiedAt ?? 0);
+                    return this.updateFromAgentMd(channelType, peerId, agentDir, localContent, cached?.verifiedAt ?? 0);
                 }
             }
             catch { /* ignore fs errors */ }
-            logger.warn(`[PeerIdentityCache] Failed to resolve: ${channel}#${peerId} err=${err instanceof Error ? err.message : String(err)}`);
-            return this.markUnknown(channel, peerId, agentDir);
+            logger.warn(`[PeerIdentityCache] Failed to resolve: ${channelType}#${peerId} err=${err instanceof Error ? err.message : String(err)}`);
+            return this.markUnknown(channelType, peerId, agentDir);
         }
     }
     /**
      * 清除指定对端的缓存
      */
-    static clear(channel, peerId, agentDir) {
-        const filePath = this.getFilePath(channel, peerId, agentDir);
+    static clear(channelType, peerId, agentDir) {
+        const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.unlinkSync(filePath);
-            logger.debug(`[PeerIdentityCache] Cleared: ${channel}#${peerId}`);
+            logger.debug(`[PeerIdentityCache] Cleared: ${channelType}#${peerId}`);
         }
         catch {
             // 文件不存在，忽略