@bd7pil/reeve 0.1.3 → 0.1.5

package/default-chain.json

@@ -1,251 +0,0 @@
-{
-  "$schema": "https://www.getbifrost.ai/schema",
-  "//": "REEVE 代理层配置 —— 链的唯一维护处。改这个文件要重启 Bifrost；热改走 POST /api/routing/rules（需 setup token）。",
-  "//providers": "provider 全部写成 OpenAI 兼容自定义 provider（纯透传，不做任何格式翻译）。",
-  "//baseurls": "⚠️ 只写到「主机（+路径前缀）」，绝不要带 /v1 —— Bifrost 会自动在 base_url 之后追加 request_path_overrides.chat_completion（默认 /v1/chat/completions）。实测：base_url 带 /v1 会拼出 /v1/v1/chat/completions。",
-  "//path_overrides": "⚠️ 每个 provider 都要写 **两个** 键：chat_completion 与 chat_completion_stream。流式请求走后者，不设就用默认 /v1/chat/completions —— 而 opencode 永远走流式。实测踩到：只设 chat_completion 时，curl 非流式正常、引擎一跑就 405。值是「追加到 base_url 的路径」。",
-  "//keys": "API key 一律写 env.<VAR>（Bifrost 自己的语法，与 opencode 侧的 {env:VAR} 不同），由 ocrc 的实例启动行注入 —— 密钥不进仓库。",
-  "//modelids": "链上每个 model 都在 models.dev 目录里核对过存在（见 proxy/README.md 的核对清单）。",
-  "//name_collision": "⚠️ provider id 不能与 Bifrost 内置名撞车。实测：叫 deepseek 会回 'failed to get config for provider deepseek: not found'，改名 deepseek-api 后正常。这里一律加 -api 之类的后缀避开。",
-  "providers": {
-    "opencode": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/v1/chat/completions",
-          "chat_completion_stream": "/v1/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://opencode.ai/zen"
-      },
-      "keys": [
-        {
-          "name": "opencode-primary",
-          "value": "env.REEVE_KEY_OPENCODE",
-          "models": [
-            "*"
-          ],
-          "weight": 1
-        }
-      ]
-    },
-    "zhipuai-coding-plan": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/api/coding/paas/v4/chat/completions",
-          "chat_completion_stream": "/api/coding/paas/v4/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://open.bigmodel.cn"
-      },
-      "keys": [
-        {
-          "name": "zhipuai-primary",
-          "value": "env.REEVE_KEY_ZHIPUAI_CODING_PLAN",
-          "models": [
-            "*"
-          ],
-          "weight": 1
-        }
-      ]
-    },
-    "xxyapi-deepseek": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/v1/chat/completions",
-          "chat_completion_stream": "/v1/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://www.xxyapi.com"
-      },
-      "keys": [
-        {
-          "name": "xxyapi-primary",
-          "value": "env.REEVE_KEY_XXYAPI_DEEPSEEK",
-          "models": [
-            "*"
-          ],
-          "weight": 1
-        }
-      ]
-    },
-    "lmuai": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/v1/chat/completions",
-          "chat_completion_stream": "/v1/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://api.lmuai.com"
-      },
-      "keys": [
-        {
-          "name": "lmuai-primary",
-          "value": "env.REEVE_KEY_LMUAI",
-          "models": [
-            "*"
-          ],
-          "weight": 1
-        }
-      ]
-    },
-    "deepseek-api": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/v1/chat/completions",
-          "chat_completion_stream": "/v1/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://api.deepseek.com"
-      },
-      "keys": [
-        {
-          "name": "deepseek-primary",
-          "value": "env.REEVE_KEY_DEEPSEEK_API",
-          "models": [
-            "*"
-          ],
-          "weight": 1,
-          "fromAuth": "deepseek"
-        }
-      ]
-    },
-    "xiaomi": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/v1/chat/completions",
-          "chat_completion_stream": "/v1/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://api.xiaomimimo.com"
-      },
-      "keys": [
-        {
-          "name": "xiaomi-primary",
-          "value": "env.REEVE_KEY_XIAOMI",
-          "models": [
-            "*"
-          ],
-          "weight": 1
-        }
-      ]
-    },
-    "alibaba-cn": {
-      "custom_provider_config": {
-        "base_provider_type": "openai",
-        "request_path_overrides": {
-          "chat_completion": "/compatible-mode/v1/chat/completions",
-          "chat_completion_stream": "/compatible-mode/v1/chat/completions"
-        }
-      },
-      "network_config": {
-        "base_url": "https://dashscope.aliyuncs.com"
-      },
-      "keys": [
-        {
-          "name": "alibaba-primary",
-          "value": "env.REEVE_KEY_ALIBABA_CN",
-          "models": [
-            "*"
-          ],
-          "weight": 1
-        }
-      ]
-    }
-  },
-  "//governance": "三条 routing rule = 三个档位。CEL 变量是 model（字符串），不是 request.model —— 官方文档示例是错的。",
-  "//weight": "targets 的 weight 必须合计为 1（单 target 就是 1）。",
-  "//fallbacks": "fallbacks 用 \"provider/model\"；写 \"provider/\" 表示同模型换 provider。链尾要放「任何机器上都可服务」的那家，否则等于链是空的。",
-  "//ttft": "ttft_timeout_ms 放 target 上（changelog + Helm schema + DB migration 三处一致）。⚠️ 官方两份 MDX 把它写成 rule 级 —— 上机时两种都试，见 docs/PLAN.md §11 #2。",
-  "//ttft_verified": "✅ 2026-10-19 在 EL7 上实测：运行时执行的迁移叫 add_ttft_timeout_ms_column_to_routing_targets —— 列在 targets 表上，所以是 target 级。rule 级不报错只是因为未知字段被宽容忽略。",
-  "//setup_token": "⚠️ /api/routing/rules 与 /api/governance/* 需要 setup token，否则 401/403。写在 governance.setup_token，值用 env.BIFROST_SETUP_TOKEN —— 密钥不进仓库。请求头是 X-Bifrost-Setup-Token。",
-  "//virtual_key": "⚠️ Bifrost 默认 enforce_auth_on_inference=true：推理请求必须带 x-bf-vk（virtual key），否则 401 virtual_key_required。新建的 VK 默认不允许任何 provider，还要 PUT allow_all_providers=true。VK 是「引擎 → 代理」的凭据，provider 真 key 只留在本文件的 env.* 里。",
-  "governance": {
-    "setup_token": "env.BIFROST_SETUP_TOKEN",
-    "routing_rules": [
-      {
-        "id": "reeve-flash",
-        "name": "reeve/flash",
-        "description": "便宜、量大：探索 / 检索 / 照文档干活。链序承担'先试免费再付费'。",
-        "enabled": true,
-        "cel_expression": "model == \"reeve/flash\"",
-        "targets": [
-          {
-            "provider": "opencode",
-            "model": "mimo-v2.6-flash-free",
-            "weight": 1,
-            "ttft_timeout_ms": 30000
-          }
-        ],
-        "fallbacks": [
-          "zhipuai-coding-plan/glm-5.3-flash",
-          "xxyapi-deepseek/deepseek-v4.1-flash",
-          "lmuai/glm-5.3-flash",
-          "deepseek-api/deepseek-flash"
-        ],
-        "scope": "global",
-        "priority": 10
-      },
-      {
-        "id": "reeve-pro",
-        "name": "reeve/pro",
-        "description": "强推理：编排 / 规划 / 评审 / 审查。",
-        "enabled": true,
-        "cel_expression": "model == \"reeve/pro\"",
-        "targets": [
-          {
-            "provider": "zhipuai-coding-plan",
-            "model": "glm-5.3",
-            "weight": 1,
-            "ttft_timeout_ms": 30000
-          }
-        ],
-        "fallbacks": [
-          "deepseek-api/deepseek-flash",
-          "lmuai/glm-5.3",
-          "opencode/mimo-v2.6-flash-free"
-        ],
-        "scope": "global",
-        "priority": 20
-      },
-      {
-        "id": "reeve-multimodal",
-        "name": "reeve/multimodal",
-        "description": "多模态能力档：需要读图/读 PDF 的调用。",
-        "enabled": true,
-        "cel_expression": "model == \"reeve/multimodal\"",
-        "targets": [
-          {
-            "provider": "zhipuai-coding-plan",
-            "model": "glm-5.3-flash",
-            "weight": 1,
-            "ttft_timeout_ms": 30000
-          }
-        ],
-        "fallbacks": [
-          "xxyapi-deepseek/deepseek-v4.1-flash",
-          "lmuai/glm-5.3-flash",
-          "deepseek-api/deepseek-flash",
-          "opencode/mimo-v2.6-flash-free"
-        ],
-        "scope": "global",
-        "priority": 30
-      }
-    ]
-  },
-  "//client": "⚠️ 这个块的名字是 client，不是 client_config —— 实测 client_config 被静默忽略（DB 里仍是默认 365）。log_retention_days 默认 365 天，logs.db 只增不减。",
-  "client": {
-    "log_retention_days": 30
-  }
-}

package/src/chain.js

@@ -1,358 +0,0 @@
-// 链文件（`~/.reeve/chain.json`）↔ Bifrost 的 `governance.routing_rules` 的**唯一映射处**。
-//
-// 为什么需要这一层：链原本写死在链基座里（仓库 `proxy/config.json` / 插件自带的
-// `default-chain.json`），改一次要重启 Bifrost。使用者要的是"面板里调顺序、加回退"——
-// 那就得有一份**只属于 REEVE 的小配置**，由插件读、由面板写，派生出的规则用
-// `/api/routing/rules` 热更（实测：热改能持久、不用重启）。
-//
-// 分工（别越界）：
-//   · chain.json 只说三件事：每档位「先打谁」（targets）、「打不通再打谁」（fallbacks）。
-//   · provider 的 base_url / key / 路径覆盖仍然只在链基座里（那属部署，要重启）。
-//   · 派生出的规则 id 固定 `reeve-<tier>`，CEL 固定 `model == "reeve/<tier>"`。
-//
-// 纯函数 + 注入式 IO：全部可在单测里跑（`plugin/test/chain.mjs`）。
-
-import { readFile, stat } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-/** 三个档位（顺序即面板里的展示顺序，也是 priority 10/20/30 的由来）。 */
-export const TIER_ORDER = Object.freeze(['flash', 'pro', 'multimodal'])
-
-export const TIER_PRIORITY = Object.freeze({ flash: 10, pro: 20, multimodal: 30 })
-
-/** target 的 TTFT 上限（实测列在 targets 上，不是 rule 上）。 */
-export const DEFAULT_TTFT_MS = 30_000
-
-export const CHAIN_VERSION = 1
-
-/** 与运行时规则做"是否有差异"比对时要看的字段（服务端字段如 config_hash 不算）。 */
-export const RULE_FIELDS = Object.freeze([
-  'name',
-  'cel_expression',
-  'enabled',
-  'targets',
-  'fallbacks',
-  'priority',
-  'scope',
-  'description',
-])
-
-export const TIER_DESC = Object.freeze({
-  flash: '便宜、量大：探索 / 检索 / 照文档干活。',
-  pro: '强推理：编排 / 规划 / 评审 / 审查。',
-  multimodal: '多模态能力档：需要读图 / 读 PDF 的调用。',
-})
-
-export function defaultChainPath({ home = homedir() } = {}) {
-  return join(home, '.reeve', 'chain.json')
-}
-
-export function tierRuleId(tier) {
-  return `reeve-${tier}`
-}
-
-/** 去掉整行 `//` 注释（链文件与仓库里的 proxy/config.json 同风格：注释只可能是整行）。 */
-export function stripLineComments(text) {
-  return String(text)
-    .split('\n')
-    .filter((l) => !l.trim().startsWith('//'))
-    .join('\n')
-}
-
-export function parseChainText(text) {
-  return JSON.parse(stripLineComments(text))
-}
-
-/**
- * `"provider/model"` → `{provider, model}`；`"provider/"`→ `{provider, model:null}`
- * （链基座的约定：同模型换 provider）。认不出就返回 null（由调用方记问题）。
- */
-export function parseTierRef(ref) {
-  if (ref && typeof ref === 'object') {
-    const provider = typeof ref.provider === 'string' ? ref.provider.trim() : ''
-    const model = typeof ref.model === 'string' ? ref.model.trim() : ''
-    return provider ? { provider, model: model || null } : null
-  }
-  if (typeof ref !== 'string') return null
-  const s = ref.trim()
-  const i = s.indexOf('/')
-  if (i <= 0) return null
-  const provider = s.slice(0, i).trim()
-  const model = s.slice(i + 1).trim()
-  return provider ? { provider, model: model || null } : null
-}
-
-export function formatTierRef({ provider, model }) {
-  return `${provider}/${model ?? ''}`
-}
-
-/**
- * 把链文件里的 `tiers` 收拾成规范形（面板写来的、人手写的都过这一关）。
- * 返回 `{ tiers, problems }` —— problems 非空时**也**返回能用的部分（如实报，不静默丢）。
- */
-export function normalizeTiers(raw) {
-  const problems = []
-  const tiers = {}
-  if (raw == null || typeof raw !== 'object') return { tiers, problems }
-  for (const tier of TIER_ORDER) {
-    const spec = raw?.[tier]
-    if (spec == null) continue
-    if (typeof spec !== 'object') {
-      problems.push(`${tier}: 不是对象`)
-      continue
-    }
-    const targets = []
-    for (const t of Array.isArray(spec.targets) ? spec.targets : []) {
-      const parsed = parseTierRef(t)
-      if (!parsed || !parsed.model) problems.push(`${tier}: 认不出的 target ${JSON.stringify(t)}`)
-      else targets.push(parsed)
-    }
-    const fallbacks = []
-    for (const f of Array.isArray(spec.fallbacks) ? spec.fallbacks : []) {
-      const parsed = parseTierRef(f)
-      if (!parsed) problems.push(`${tier}: 认不出的 fallback ${JSON.stringify(f)}`)
-      else fallbacks.push(parsed.model ? formatTierRef(parsed) : `${parsed.provider}/`)
-    }
-    if (targets.length === 0 && fallbacks.length > 0) {
-      // 只有回退、没有首选 —— 等于把第一个回退提到首选（比"整档消失"更接近人的意图）
-      const first = parseTierRef(fallbacks.shift())
-      if (first) targets.push(first)
-      problems.push(`${tier}: 没写 targets，把第一个 fallback 提为首选`)
-    }
-    if (targets.length === 0) {
-      problems.push(`${tier}: 既没有 targets 也没有 fallbacks，跳过`)
-      continue
-    }
-    tiers[tier] = {
-      targets,
-      fallbacks,
-      ...(typeof spec.description === 'string' ? { description: spec.description } : {}),
-      ...(Number.isFinite(spec.ttftMs) ? { ttftMs: Number(spec.ttftMs) } : {}),
-    }
-  }
-  return { tiers, problems }
-}
-
-/**
- * 一个档位 → 一条 routing rule。
- * `base` 是链基座里同 id 的规则：链文件没写 description / ttftMs 时从它继承
- * （免得每次热更都把人工写好的中文说明冲掉）。
- */
-export function tierToRule(tier, spec, { base = null, priority = null } = {}) {
-  const targets = (spec?.targets ?? []).map((t) => ({
-    provider: t.provider,
-    model: t.model,
-    weight: 1,
-    ttft_timeout_ms: Number(spec?.ttftMs ?? base?.targets?.[0]?.ttft_timeout_ms ?? DEFAULT_TTFT_MS),
-  }))
-  // weight 必须合计为 1（多 target 时均分）
-  if (targets.length > 1) for (const t of targets) t.weight = 1 / targets.length
-  return {
-    id: tierRuleId(tier),
-    name: `reeve/${tier}`,
-    description: spec?.description ?? base?.description ?? TIER_DESC[tier] ?? '',
-    enabled: spec?.enabled ?? base?.enabled ?? true,
-    cel_expression: `model == "reeve/${tier}"`,
-    targets,
-    fallbacks: [...(spec?.fallbacks ?? [])],
-    scope: spec?.scope ?? base?.scope ?? 'global',
-    priority: Number(priority ?? spec?.priority ?? TIER_PRIORITY[tier] ?? base?.priority ?? 100),
-  }
-}
-
-/** 三个档位 → 规则数组（按 priority 升序）。 */
-export function tiersToRoutingRules(tiers) {
-  const out = []
-  for (const tier of TIER_ORDER) {
-    if (!tiers?.[tier]) continue
-    out.push(tierToRule(tier, tiers[tier]))
-  }
-  return out.sort((a, b) => a.priority - b.priority)
-}
-
-/**
- * 把档位合到链基座上：**providers 等一切照旧，只替换 `reeve-*` 那几条规则**。
- * tiers 为空（链文件缺失/坏掉）时原样返回 —— 这就是"回落到现状"。
- */
-export function applyTiers(chain, tiers) {
-  const baseRules = chain?.governance?.routing_rules ?? []
-  const derived = []
-  for (const tier of TIER_ORDER) {
-    if (!tiers?.[tier]) continue
-    const id = tierRuleId(tier)
-    derived.push(tierToRule(tier, tiers[tier], { base: baseRules.find((r) => r?.id === id) ?? null }))
-  }
-  if (derived.length === 0) return chain ?? {}
-  const ids = new Set(derived.map((r) => r.id))
-  const kept = baseRules.filter((r) => r?.id && !ids.has(r.id))
-  const governance = { ...(chain?.governance ?? {}) }
-  governance.routing_rules = [...kept, ...derived].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0))
-  return { ...(chain ?? {}), governance }
-}
-
-/**
- * 反向：从链基座（或运行时规则）反推档位 —— 用在"链文件还没建"时给面板/快照一个起点。
- * @param {Array<{id?:string,name?:string,targets?:any[],fallbacks?:any[]}>} rules
- */
-export function tiersFromRules(rules) {
-  const tiers = {}
-  for (const tier of TIER_ORDER) {
-    const id = tierRuleId(tier)
-    const rule = (rules ?? []).find((r) => r?.id === id || r?.name === `reeve/${tier}`)
-    if (!rule) continue
-    const targets = (rule.targets ?? [])
-      .map((t) => parseTierRef(t))
-      .filter((t) => t && t.model)
-    if (targets.length === 0) continue
-    const fallbacks = (rule.fallbacks ?? [])
-      .map((f) => parseTierRef(f))
-      .filter(Boolean)
-      .map((f) => (f.model ? formatTierRef(f) : `${f.provider}/`))
-    tiers[tier] = {
-      targets,
-      fallbacks,
-      ...(rule.description ? { description: rule.description } : {}),
-      ...(rule.targets?.[0]?.ttft_timeout_ms ? { ttftMs: Number(rule.targets[0].ttft_timeout_ms) } : {}),
-    }
-  }
-  return tiers
-}
-
-export function tiersFromChainDoc(chain) {
-  return tiersFromRules(chain?.governance?.routing_rules)
-}
-
-/** 排序后的规范 JSON —— 用于"有没有差异"的比对（键序不同不算差异）。 */
-export function canonicalJson(value) {
-  const walk = (v) => {
-    if (Array.isArray(v)) return v.map(walk)
-    if (v && typeof v === 'object') {
-      const out = {}
-      for (const k of Object.keys(v).sort()) out[k] = walk(v[k])
-      return out
-    }
-    return v
-  }
-  return JSON.stringify(walk(value))
-}
-
-/** 两条规则在关心字段上是否一致（键序无关）。 */
-export function rulesSame(a, b) {
-  return RULE_FIELDS.every((k) => canonicalJson(a?.[k]) === canonicalJson(b?.[k]))
-}
-
-/**
- * 期望规则 vs 运行时规则 → 差异（收敛与快照共用一份判断）。
- * @returns {{drifted: boolean, missing: string[], changed: string[], extra: string[]}}
- */
-export function rulesDrift(desired, runtime) {
-  const want = new Map((desired ?? []).filter((r) => r?.id).map((r) => [r.id, r]))
-  const have = new Map((runtime ?? []).filter((r) => r?.id).map((r) => [r.id, r]))
-  const missing = []
-  const changed = []
-  const extra = []
-  for (const [id, rule] of want) {
-    const got = have.get(id)
-    if (!got) missing.push(id)
-    else if (!rulesSame(got, rule)) changed.push(id)
-  }
-  for (const id of have.keys()) if (!want.has(id)) extra.push(id)
-  return { drifted: missing.length + changed.length + extra.length > 0, missing, changed, extra }
-}
-
-/**
- * 读链文件。三种结果都要能区分（面板会显示"没有链文件=用基座"）：
- *   · 不存在        → { exists:false, doc:null, tiers:null }
- *   · 存在但读不动/坏 → { exists:true,  doc:null, error:'…' }（视为"未变更"，不炸）
- *   · 存在且能读     → { exists:true,  doc, tiers, problems, marker }
- * `marker` 是变更检测的记号（mtime+size）。**先 stat 再读**：万一读的这一刻文件正在被换
- * （面板写是 temp+rename），记号会偏旧 → 下一个 tick 再收敛一遍（幂等，无害）；
- * 反过来（记号偏新）就会漏掉一次变更，那才是真 bug。
- */
-export async function readChainFile({ path, readFileImpl = readFile, statImpl = stat } = {}) {
-  let st = null
-  try {
-    st = await statImpl(path)
-  } catch {
-    return { exists: false, path, doc: null, tiers: null, problems: [], marker: null, mtimeMs: null, error: null }
-  }
-  const marker = `${Number(st.mtimeMs)}:${Number(st.size)}`
-  const base = { exists: true, path, marker, mtimeMs: Number(st.mtimeMs) }
-  try {
-    const text = await readFileImpl(path, 'utf8')
-    const doc = parseChainText(text)
-    const { tiers, problems } = normalizeTiers(doc?.tiers)
-    return { ...base, doc, tiers, problems, error: null }
-  } catch (err) {
-    return { ...base, doc: null, tiers: null, problems: [], error: String(err?.message ?? err).slice(0, 160) }
-  }
-}
-
-/** 面板要写的形状（插件侧只用来生成"初始链文件"的建议内容，不自动写）。 */
-export function buildChainDoc(tiers, { now = Date.now(), version = CHAIN_VERSION } = {}) {
-  const out = {}
-  for (const tier of TIER_ORDER) {
-    const spec = tiers?.[tier]
-    if (!spec) continue
-    out[tier] = {
-      targets: (spec.targets ?? []).map((t) => ({ provider: t.provider, model: t.model })),
-      fallbacks: [...(spec.fallbacks ?? [])],
-      ...(spec.description ? { description: spec.description } : {}),
-      ...(Number.isFinite(spec.ttftMs) ? { ttftMs: Number(spec.ttftMs) } : {}),
-    }
-  }
-  return { version, updatedAt: now, tiers: out }
-}
-
-/**
- * 链文件 + 链基座 → **实际该用哪份规则**。四种情形，一个有意的区分：
- *
- *   ① 没有链文件                   → 用链基座（首次安装的常态，也是"回落现状"）
- *   ② 链文件好且有三档             → 用它派生（只换 `reeve-*` 三条，providers 来自基座）
- *   ③ 链文件坏（JSON 解析不了 /    → **当作"未变更"**：留上一份好的（previous），
- *      声明了档位但一条都没活下来）    不要因为一次手滑把线上路由翻回基座
- *   ④ 链文件好但没有档位            → 用链基座（`tiers: {}` 是"恢复默认"的合法写法）
- *
- * `effective === null` 只在 ③ 出现 —— 调用方必须"什么都不改"，而不是拿 null 当"用基座"。
- *
- * @param {{base: object, from: string, file: object, previous?: object|null}} args
- * @returns {{effective: object|null, tiers: object, source: string, derived: boolean, stale: boolean, problems: string[], error: string|null}}
- */
-export function resolveChain({ base, from, file, previous = null }) {
-  const problems = [...(file?.problems ?? [])]
-  const error = file?.error ?? null
-  const exists = file?.exists === true
-  const parsed = exists && file?.doc != null
-  const usable = parsed && Object.keys(file?.tiers ?? {}).length > 0
-  const declaredTiers = parsed ? Object.keys(file?.doc?.tiers ?? {}).length : 0
-
-  if (!exists) {
-    return { effective: base, tiers: tiersFromChainDoc(base), source: from, derived: false, stale: false, problems, error: null }
-  }
-  if (usable) {
-    return {
-      effective: applyTiers(base, file.tiers),
-      tiers: file.tiers,
-      source: file.path,
-      derived: true,
-      stale: false,
-      problems,
-      error: null,
-    }
-  }
-  if (!parsed || declaredTiers > 0) {
-    // 坏文件 → 当作未变更
-    return {
-      effective: null,
-      tiers: previous?.tiers ?? tiersFromChainDoc(base),
-      source: previous?.source ?? from,
-      derived: previous?.derived === true,
-      stale: true,
-      problems,
-      error: error ?? '链文件里的档位一条都没解析出来',
-    }
-  }
-  // 好文件、明确没有档位 → 回落到链基座
-  return { effective: base, tiers: tiersFromChainDoc(base), source: from, derived: false, stale: false, problems, error: null }
-}