prts-terrarchive 0.2.2 → 0.2.4

package/src/timeline.js

@@ -149,6 +149,63 @@ class TimelineFault extends Error {
  *  2. references/char_alias.txt 的分号分隔行（挂到同名 canonical 组，找不到则自建）。
  * @returns {Promise<Array<{canonical: string, aliases: string[], games: string[]}>>}
  */
+/** 别名字面归一：与识别器同源（NFKC + 小写 + 压缩空白），避免大小写或全角差异放过冲突。 */
+function aliasKey(value) {
+  return String(value || '').normalize('NFKC').replace(/\s+/gu, ' ').trim().toLocaleLowerCase()
+}
+
+/**
+ * 一个别名字面只能指向一个实体。资料里出现过把正文提及词当成别名的记录
+ * （如「玛利图斯」的 aliases 里塞进「预言家」「海嗣」），AC 自动机便会对同一字面
+ * 同时吐出两个 canonical，让无关实体混进本轮检索上下文。
+ * 裁决：字面等于某实体自身规范名时保留该实体（如「海嗣」保留给海嗣），
+ * 其余情况一律丢弃并登记冲突，交给数据侧修正别名表——不在代码里猜谁才是对的。
+ */
+function resolveAliasConflicts(groups, pinned = new Set()) {
+  const owners = new Map()
+  for (const group of groups.values()) for (const alias of group.aliases) {
+    const key = aliasKey(alias)
+    if (!key) continue
+    const list = owners.get(key) || []
+    list.push({ group, alias })
+    owners.set(key, list)
+  }
+  const conflicts = []
+  for (const [key, list] of owners) {
+    const canonicals = [...new Set(list.map((item) => item.group.canonical))]
+    if (canonicals.length < 2) continue
+    const keeper = list.find((item) => item.group.canonical === item.alias)
+    for (const item of list) {
+      if (item === keeper) continue
+      item.group.aliases.delete(item.alias)
+    }
+    if (!keeper && !pinned.has(key)) conflicts.push({ alias: list[0].alias, canonicals: canonicals.sort() })
+  }
+  return conflicts
+}
+
+/**
+ * 去掉"太泛"的短别名：两个字的词很容易是通用词（如某组织把「联合」当别名，
+ * 于是"联合解析"这种句子会把它整个拉进检索上下文）。
+ * 判据是它在多少条**其他**实体的规范名里当子串——只有人工别名表里裁决过的短别名豁免。
+ */
+function dropGenericShortAliases(groups, curated) {
+  const canonicals = [...groups.keys()]
+  const dropped = []
+  for (const group of groups.values()) {
+    for (const alias of [...group.aliases]) {
+      const key = aliasKey(alias)
+      if (key.length > 2 || key === aliasKey(group.canonical) || curated.has(key)) continue
+      const others = canonicals.filter((name) => name !== group.canonical
+        && aliasKey(name).includes(key)).length
+      if (others < 3) continue
+      group.aliases.delete(alias)
+      dropped.push({ alias, canonical: group.canonical, others })
+    }
+  }
+  return dropped
+}
+
 export async function buildAliasGroups(store) {
   const groups = new Map()
   const crossGameNames = relationEndfieldNames(await loadEntityRelationCatalog(store))
@@ -156,7 +213,11 @@ export async function buildAliasGroups(store) {
     const canonical = String(canonicalValue ?? '').trim()
     if (!canonical) return
     const group = groups.get(canonical) || { canonical, aliases: new Set([canonical]), games: new Set() }
-    for (const value of aliasValues) {
+    // 实体 JSON 点里 aliases 是分号分隔的字符串（个别用全角分号），资料包里是数组；
+    // 字符串直接迭代会被按字拆开，这里统一先切分。
+    const aliasList = typeof aliasValues === 'string' ? aliasValues.split(/[;；]/u)
+      : Array.isArray(aliasValues) ? aliasValues : []
+    for (const value of aliasList) {
       const alias = String(value ?? '').trim()
       // 旧 PRTS 数据曾把终末地再旅者名塞进泰拉人物 aliases 方便联搜。
       // 关系现在由独立附属字段承载；跨游戏名不再改变实体身份。
@@ -178,15 +239,38 @@ export async function buildAliasGroups(store) {
       entity.aliases || record.aliases, game)
   }
 
+  // 人工别名表（char_alias.txt）是裁决，不是补充：实体 JSON 里的 aliases 由当时的
+  // LLM 生成 json 点时顺手写出，会把正文提及词当成别名（「玛利图斯」曾带「预言家」
+  // 「海嗣」）。表里每一行声明的别名只归该行实体，其余组必须让出。
   const aliasReference = await store.getDocumentByPath('char_alias.txt')
+  const pinned = new Set()
   for (const line of aliasReference?.record?.lines || []) {
     const aliases = [...new Set(String(line.text || '').split(';').map((item) => item.trim()).filter(Boolean))]
     if (!aliases.length) continue
     const existing = [...groups.values()].find((group) =>
       group.canonical === aliases[0] || group.aliases.has(aliases[0]))
-    remember(existing?.canonical || aliases[0], aliases)
+    const canonical = existing?.canonical || aliases[0]
+    for (const alias of aliases) {
+      const key = aliasKey(alias)
+      if (!key) continue
+      for (const group of [...groups.values()]) {
+        if (group.canonical === canonical) continue
+        for (const owned of [...group.aliases]) {
+          if (aliasKey(owned) === key) group.aliases.delete(owned)
+        }
+      }
+      pinned.add(key)
+    }
+    remember(canonical, aliases)
   }
 
+  const conflicts = resolveAliasConflicts(groups, pinned)
+  const generic = dropGenericShortAliases(groups, pinned)
+  if (store && typeof store === 'object') {
+    store._aliasConflicts = conflicts
+    store._genericAliases = generic
+    store._curatedAliases = pinned
+  }
   return [...groups.values()].map((group) => ({ canonical: group.canonical,
     aliases: [...group.aliases], games: [...group.games] }))
 }

package/src/tool-args.js

@@ -0,0 +1,53 @@
+/**
+ * 模型参数的空占位归一化。
+ *
+ * DSH 工具 Schema 子集不支持 minLength/minItems/minimum，模型或第三方接口常把
+ * 可选字段整体填成 ""、[]、{}、null 或 0。这些值不表达任何意图，却会触发执行层
+ * 的严格校验并让 Agent 陷入循环。这里只删除“明确为空”的占位：
+ * - null / undefined
+ * - 去空白后为空的字符串
+ * - 删除空字符串项后为空的数组（非空项保持原样，交给执行层严格校验）
+ * - 递归清理后没有任何键（或只剩数字 0）的普通对象
+ * - 显式列入 zeroFields 的整数 0（仅用于从 1 开始计数的字段）
+ * 部分填写的对象、非空的非法值仍原样保留，由执行层报告具体错误。
+ */
+
+const isPlainObject = (value) => value !== null && typeof value === 'object'
+  && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype
+
+const isBlankString = (value) => typeof value === 'string' && value.trim() === ''
+
+function cleanValue(value) {
+  if (value === null || value === undefined) return undefined
+  if (isBlankString(value)) return undefined
+  if (Array.isArray(value)) {
+    const items = value.filter((item) => item !== null && item !== undefined && !isBlankString(item))
+    return items.length ? items : undefined
+  }
+  if (isPlainObject(value)) {
+    const cleaned = {}
+    for (const [key, item] of Object.entries(value)) {
+      const next = cleanValue(item)
+      if (next !== undefined) cleaned[key] = next
+    }
+    // {position: 0} 这类只剩数字 0 的对象同样是整体占位（如空的 after 分页凭据）。
+    return Object.values(cleaned).some((item) => item !== 0) ? cleaned : undefined
+  }
+  return value
+}
+
+/**
+ * @param {unknown} args 模型原始参数
+ * @param {{ zeroFields?: string[] }} [options]
+ * @returns {unknown} 删除空占位后的新对象；非对象原样返回，交给调用方报错
+ */
+export function dropEmptyPlaceholders(args, { zeroFields = [] } = {}) {
+  if (!isPlainObject(args)) return args
+  const result = {}
+  for (const [key, value] of Object.entries(args)) {
+    if (zeroFields.includes(key) && value === 0) continue
+    const next = cleanValue(value)
+    if (next !== undefined) result[key] = next
+  }
+  return result
+}

package/src/ui.js

@@ -641,13 +641,14 @@ const emptyDataset = (game) => ({
 })
 
 /** 把联合 release 中的 pack 汇总成用户可理解的两个游戏资料库。 */
-async function readReleaseDatasets(dir, manifest, packManifests = null) {
+async function readReleaseDatasets(dir, manifest, packManifests = null, installedPackIds = null) {
   const datasets = {
     arknights: emptyDataset('arknights'),
     endfield: emptyDataset('endfield'),
   }
   const sharedPacks = []
   for (const pack of Array.isArray(manifest?.packs) ? manifest.packs : []) {
+    if (installedPackIds && !installedPackIds.includes(pack.pack_id)) continue
     const manifestPath = String(pack?.manifest_path ?? '')
     if (!manifestPath || manifestPath.includes('..') || manifestPath.startsWith('/')) continue
     let detail = packManifests?.get(String(pack?.pack_id ?? ''))
@@ -657,8 +658,8 @@ async function readReleaseDatasets(dir, manifest, packManifests = null) {
     const packId = String(detail.pack_id ?? pack.pack_id ?? '')
     const game = detail.game === 'arknights' || detail.game === 'endfield'
       ? detail.game
-      : packId === 'official_game' ? 'arknights'
-        : packId.startsWith('endfield_') ? 'endfield' : null
+      : packId.startsWith('endfield_') ? 'endfield'
+        : ['official_game', 'reviewed_wiki', 'terra_journey', 'entities', 'references'].includes(packId) ? 'arknights' : null
     const summary = {
       packId,
       authority: detail.authority ?? pack.authority ?? null,
@@ -697,43 +698,57 @@ async function readReleaseDatasets(dir, manifest, packManifests = null) {
 async function readLocalReleases(shared, sizeCache = new Map()) {
   const releases = []
   let activeId = null
+  let previousId = null
   try {
-    activeId = (await readCurrentReleasePointer(shared.releasesDir)).release_id
+    const pointer = await readCurrentReleasePointer(shared.releasesDir)
+    activeId = pointer.release_id
+    previousId = pointer.previous_release_id ?? null
   } catch { /* 尚无激活版本 */ }
   let entries = []
   try {
     entries = await readdir(shared.releasesDir, { withFileTypes: true })
-  } catch { return { activeId, releases } }
+  } catch { return { activeId, previousId, releases } }
   for (const entry of entries) {
     if (!entry.isDirectory() || !RELEASE_ID_PATTERN.test(entry.name)) continue
     const dir = join(shared.releasesDir, entry.name)
     let manifest = null
     let packManifests = null
+    let installedPackIds = null
+    let installedGames = []
     try {
-      const validated = await validateLocalRelease(shared.releasesDir, entry.name, { details: true })
+      const validated = await validateLocalRelease(shared.releasesDir, entry.name, { details: true, allowPartial: true })
       manifest = validated.manifest
       packManifests = validated.packManifests
+      installedPackIds = validated.installedPackIds ?? manifest.packs.map((pack) => pack.pack_id)
+      installedGames = validated.installedGames ?? []
     } catch { /* 半成品/外来目录：仍列出，标记不完整 */ }
-    let sizeBytes = sizeCache.get(entry.name)
-    if (sizeBytes === undefined) {
-      sizeBytes = await releaseDirSize(dir).catch(() => 0)
-      if (manifest) sizeCache.set(entry.name, sizeBytes)
-    }
+    // 目录大小只对不完整的目录才有意义（用于提示半成品占用）；完整版本直接取
+    // 清单里的 compressed_size。此前对每个 release 都全量 stat 一遍，
+    // 设置页要等十几秒才出内容。
+    let sizeBytes = manifest
+      ? (manifest.compressed_size ?? 0)
+      : await releaseDirSize(dir).catch(() => 0)
     releases.push({
       releaseId: entry.name,
       active: entry.name === activeId,
       complete: Boolean(manifest),
+      installedGames, installedPackIds,
+      missingGames: manifest ? missingEnabledGamePacks(manifest, shared.effective().enabledGames, installedPackIds) : shared.effective().enabledGames,
       dataVersion: manifest?.data_version ?? null,
-      documentCount: manifest?.document_count ?? null,
-      compressedSize: manifest?.compressed_size ?? null,
+      documentCount: manifest ? manifest.packs.filter((pack) => installedPackIds.includes(pack.pack_id))
+        .reduce((sum, pack) => sum + pack.document_count, 0) : null,
+      compressedSize: manifest ? manifest.packs.filter((pack) => installedPackIds.includes(pack.pack_id))
+        .reduce((sum, pack) => sum + pack.compressed_size, 0) : null,
+      releaseDocumentCount: manifest?.document_count ?? null,
+      releaseCompressedSize: manifest?.compressed_size ?? null,
       createdAt: manifest?.created_at ?? null,
       sizeBytes,
       needsExtract: true, // 本地分片以 .jsonl.gz 存储，打开时需解压
-      datasets: manifest ? await readReleaseDatasets(dir, manifest, packManifests) : null,
+      datasets: manifest ? await readReleaseDatasets(dir, manifest, packManifests, installedPackIds) : null,
     })
   }
   releases.sort((left, right) => String(right.createdAt ?? '').localeCompare(String(left.createdAt ?? '')))
-  return { activeId, releases }
+  return { activeId, previousId, releases }
 }
 
 /**
@@ -752,6 +767,8 @@ async function checkForUpdate(shared, env = {}, sizeCache) {
     dataVersion: localRelease?.dataVersion ?? null,
     documentCount: localRelease?.documentCount ?? null,
     sizeBytes: localRelease?.sizeBytes ?? null,
+    installedGames: localRelease?.installedGames ?? [],
+    missingGames: localRelease?.missingGames ?? shared.effective().enabledGames,
   }
   try {
     const trusted = await resolveTrustedCurrentRelease({ fetchImpl,
@@ -765,7 +782,7 @@ async function checkForUpdate(shared, env = {}, sizeCache) {
       uncompressedSize: trusted.uncompressedSize,
       createdAt: null,
     }
-    const updateAvailable = local.activeId !== trusted.releaseId
+    const updateAvailable = localInfo.missingGames.length > 0 || local.activeId !== trusted.releaseId
       || (localInfo.dataVersion != null && localInfo.dataVersion !== trusted.dataVersion)
     return { source: 'site', local: localInfo, remote, updateAvailable }
   } catch (error) {
@@ -780,6 +797,8 @@ async function checkForUpdate(shared, env = {}, sizeCache) {
  * @param {{ logger?: object }} [env]
  */
 export function buildApi(shared, env = {}) {
+  // 保留最近几个版本：当前版本 + 回滚目标 + 余量。
+  const KEEP_RELEASES = 3
   const sizeCache = new Map()
   const fetchImpl = env.fetchImpl ?? fetch
   const manualCloudSearch = createManualCloudSearch(shared, { fetchImpl })
@@ -789,7 +808,51 @@ export function buildApi(shared, env = {}) {
     releaseMutation = running.catch(() => {})
     return running
   }
+  /**
+   * 自动清理旧资料版本：只保留最近 KEEP_RELEASES 个（当前版本与回滚目标必须保留），
+   * 否则每下载一次就在用户硬盘上多堆一份几百 MB 的旧包。
+   * 只删「能通过 Release 校验」的受管目录；半成品/外来目录一律不碰。
+   */
+  const pruneOldReleases = async ({ keep = KEEP_RELEASES } = {}) => {
+    let pointer = null
+    try { pointer = await readCurrentReleasePointer(shared.releasesDir) } catch { /* 无激活版本 */ }
+    const activeId = pointer?.release_id ?? null
+    const previousId = pointer?.previous_release_id ?? null
+    let entries = []
+    try { entries = await readdir(shared.releasesDir, { withFileTypes: true }) } catch { return [] }
+    const candidates = []
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !RELEASE_ID_PATTERN.test(entry.name)) continue
+      if (entry.name === activeId || entry.name === previousId) continue
+      if (shared.download?.active && shared.download.releaseId === entry.name) continue
+      try {
+        const validated = await validateLocalRelease(shared.releasesDir, entry.name, { allowPartial: true })
+        candidates.push({ releaseId: entry.name, createdAt: String(validated.manifest?.created_at ?? '') })
+      } catch { /* 不是受管版本，绝不自动删除 */ }
+    }
+    const reserved = (activeId ? 1 : 0) + (previousId ? 1 : 0)
+    const room = Math.max(0, keep - reserved)
+    candidates.sort((left, right) => right.createdAt.localeCompare(left.createdAt)
+      || right.releaseId.localeCompare(left.releaseId))
+    const removed = []
+    for (const item of candidates.slice(room)) {
+      try {
+        await rm(join(shared.releasesDir, item.releaseId), { recursive: true, force: true })
+        sizeCache.delete(item.releaseId)
+        removed.push(item.releaseId)
+      } catch (error) {
+        env.logger?.warn?.(`prts-corpus: 清理旧版本失败 ${item.releaseId}: ${error?.message ?? error}`)
+      }
+    }
+    if (removed.length) {
+      env.logger?.info?.(`prts-corpus: 自动清理 ${removed.length} 个旧版本（保留最近 ${keep} 个）：${removed.join('、')}`)
+    }
+    return removed
+  }
+
   const startDownload = async ({ releaseId }) => {
+    const config = shared.effective()
+    const enabledGames = [...config.enabledGames]
     const progress = shared.download
     if (progress.active) throw new ApiError(409, '已有下载任务在进行中')
     // 目标解析包含最长数十秒的网络请求；下载槽位必须在首个 await 之前同步
@@ -837,10 +900,10 @@ export function buildApi(shared, env = {}) {
     // 后台执行；结果写回 shared.download，界面轮询 status 跟踪
     void (async () => {
       try {
-        const config = shared.effective()
         const result = await ensureCorpusRelease({
           releasesDir: shared.releasesDir,
           releaseId: target,
+          enabledGames,
           ...(trustedCurrent ? { trustedCurrent } : {}),
           order: config.downloadOrder,
           siteBaseUrl: config.downloadSiteBaseUrl,
@@ -861,7 +924,8 @@ export function buildApi(shared, env = {}) {
         if (shared.store) {
           try {
             const pointer = await readCurrentReleasePointer(shared.releasesDir)
-            if (pointer.release_id !== shared.store.releaseId) {
+            if (pointer.release_id !== shared.store.releaseId
+                || (pointer.installation_id ?? null) !== shared.store.installationId) {
               shared.store.reset()
             }
           } catch { /* current.json 异常时保持现状 */ }
@@ -874,10 +938,15 @@ export function buildApi(shared, env = {}) {
         progress.active = false
         progress.finishedAt = new Date().toISOString()
         shared.notifyRuntime()
+        // 新包落位后立刻回收旧包；失败不影响下载结果。
+        await pruneOldReleases().catch((error) => {
+          env.logger?.warn?.(`prts-corpus: 自动清理旧版本失败：${error?.message ?? error}`)
+        })
       }
     })()
     return { started: true, releaseId: target }
   }
+  // 供启动清理调用（不进入路由，不暴露给 UI）。
 
   /** 原始路由分发：ApiError/配置校验错误转为响应，其余向上抛给 HTTP 层。 */
   const routeCall = async (method, pathname, body, { signal } = {}) => {
@@ -1025,11 +1094,17 @@ export function buildApi(shared, env = {}) {
       const config = shared.effective()
       let installed = false
       let installationIssue = null
+      let installedGames = []
+      let installedPackIds = []
+      let missingGames = []
       try {
         const pointer = await readCurrentReleasePointer(shared.releasesDir)
         const releaseId = String(pointer.release_id || '')
-        const manifest = await validateLocalRelease(shared.releasesDir, releaseId)
-        const missingGames = missingEnabledGamePacks(manifest, config.enabledGames)
+        const validated = await validateLocalRelease(shared.releasesDir, releaseId, { details: true, allowPartial: true })
+        const { manifest } = validated
+        installedGames = validated.installedGames ?? []
+        installedPackIds = validated.installedPackIds ?? manifest.packs.map((pack) => pack.pack_id)
+        missingGames = missingEnabledGamePacks(manifest, config.enabledGames, installedPackIds)
         installed = Boolean((!pointer.data_version || pointer.data_version === manifest.data_version)
           && missingGames.length === 0)
         if (missingGames.length) installationIssue = `当前版本缺少已启用模块：${missingGames.map((game) =>
@@ -1040,7 +1115,7 @@ export function buildApi(shared, env = {}) {
           ? '未找到本地语料；请下载资料或检查资料目录配置'
           : `无法读取本地语料配置：${error?.message ?? error}`
       }
-      let storeInfo = { loaded: ready, installed, installationIssue,
+      let storeInfo = { loaded: ready, installed, installationIssue, installedGames, installedPackIds, missingGames,
         releaseId: null, dataVersion: null, documentCount: null, packCount: null }
       if (store && ready && store.releaseId) {
         storeInfo = { ...storeInfo, loaded: true,
@@ -1050,8 +1125,8 @@ export function buildApi(shared, env = {}) {
       return { status: 200, json: { store: storeInfo, download: { ...shared.download }, config: redactConfig(config) } }
     }
     if (method === 'GET' && route === 'releases') {
-      const { activeId, releases } = await readLocalReleases(shared, sizeCache)
-      return { status: 200, json: { activeId, releases } }
+      const { activeId, previousId, releases } = await readLocalReleases(shared, sizeCache)
+      return { status: 200, json: { activeId, previousId, releases } }
     }
     if (method === 'GET' && route === 'check-update') {
       return { status: 200, json: await checkForUpdate(shared, env, sizeCache) }
@@ -1079,21 +1154,38 @@ export function buildApi(shared, env = {}) {
           return await withReleaseMutationLock(shared.releasesDir, async () => {
         let manifest
         try {
-          manifest = await validateLocalRelease(shared.releasesDir, releaseId, { verifyHashes: true })
+          const validated = await validateLocalRelease(shared.releasesDir, releaseId, { verifyHashes: true, details: true, allowPartial: true })
+          manifest = validated.manifest
+          const missing = missingEnabledGamePacks(manifest, shared.effective().enabledGames, validated.installedPackIds)
+          if (missing.length) throw new Error(`缺少已启用模块：${missing.join("、")}`)
         } catch (error) {
           throw new ApiError(400, `版本不完整，无法激活：${error?.message ?? error}`)
         }
+        // 记下上一版本，设置页才能提供「回滚」；否则切换一次就把退路弄丢了。
+        let previousId = null
+        let generation = 1
+        try {
+          const old = await readCurrentReleasePointer(shared.releasesDir)
+          previousId = old.release_id && old.release_id !== releaseId ? old.release_id
+            : (old.previous_release_id ?? null)
+          generation = Number(old.generation ?? 0) + 1
+        } catch { /* 首次激活 */ }
         const pointerTemp = join(shared.releasesDir, `current.json.${randomBytes(6).toString('hex')}.tmp`)
         await writeFile(pointerTemp, JSON.stringify({
           release_id: releaseId, data_version: manifest.data_version,
           channel: 'manual', public_download: true, schema_version: 1,
+          installation_id: randomBytes(16).toString('hex'),
           activated_at: new Date().toISOString(),
+          generation,
+          ...(previousId ? { previous_release_id: previousId } : {}),
+          rollback_available: Boolean(previousId),
         }))
         await rename(pointerTemp, join(shared.releasesDir, 'current.json'))
         shared.store?.reset()
         shared.notifyRuntime()
         env.logger?.info?.(`prts-corpus: 激活版本切换为 ${releaseId}`)
-        return { status: 200, json: { activated: releaseId } }
+        const pruned = await pruneOldReleases().catch(() => [])
+        return { status: 200, json: { activated: releaseId, pruned } }
           })
         } catch (error) {
           if (error?.code === 'DOWNLOAD_BUSY') throw new ApiError(409, error.message)
@@ -1101,6 +1193,18 @@ export function buildApi(shared, env = {}) {
         }
       })
     }
+    if (method === 'POST' && route === 'prune') {
+      return withReleaseMutation(async () => {
+        try {
+          return await withReleaseMutationLock(shared.releasesDir, async () => ({
+            status: 200, json: { removed: await pruneOldReleases() },
+          }))
+        } catch (error) {
+          if (error?.code === 'DOWNLOAD_BUSY') throw new ApiError(409, error.message)
+          throw error
+        }
+      })
+    }
     if (method === 'POST' && route === 'delete') {
       const releaseId = String(body?.releaseId ?? '')
       if (!RELEASE_ID_PATTERN.test(releaseId)) throw new ApiError(400, 'releaseId 非法')
@@ -1116,7 +1220,7 @@ export function buildApi(shared, env = {}) {
           throw new ApiError(409, '该版本正在下载')
         }
         try {
-          await validateLocalRelease(shared.releasesDir, releaseId)
+          await validateLocalRelease(shared.releasesDir, releaseId, { allowPartial: true })
         } catch (error) {
           throw new ApiError(400, `目录不是可确认的完整资料版本，拒绝递归删除：${error?.message ?? error}`)
         }
@@ -1134,6 +1238,7 @@ export function buildApi(shared, env = {}) {
   }
 
   return {
+    pruneOldReleases,
     async call(method, pathname, body, options = {}) {
       try {
         return await routeCall(method, pathname, body, options)
@@ -1160,6 +1265,12 @@ export function applyUi(ctx, shared) {
   const connection = ctx.get?.('connection') ?? ctx.connection
   if (!connection) return false
   const api = buildApi(shared, { logger: ctx.logger })
+  // 启动后再清一次：老用户机器上可能已经堆了十几个版本，不必等下一次下载。
+  setTimeout(() => {
+    void api.pruneOldReleases?.().catch?. ((error) => {
+      ctx.logger?.warn?.(`prts-corpus: 启动清理旧版本失败：${error?.message ?? error}`)
+    })
+  }, 15_000).unref?.()
   const endpoints = Object.freeze({
     status: ['GET', '/api/prts-corpus/status'],
     releases: ['GET', '/api/prts-corpus/releases'],
@@ -1169,6 +1280,7 @@ export function applyUi(ctx, shared) {
     download: ['POST', '/api/prts-corpus/download'],
     activate: ['POST', '/api/prts-corpus/activate'],
     delete: ['POST', '/api/prts-corpus/delete'],
+    prune: ['POST', '/api/prts-corpus/prune'],
     read: ['POST', '/api/prts-corpus/read'],
     'archive.search': ['POST', '/api/prts-corpus/archive/search'],
     'archive.cloud-search': ['POST', '/api/prts-corpus/archive/cloud-search'],
@@ -1299,8 +1411,20 @@ export function applyUi(ctx, shared) {
 
 function applyWebAssets(ctx, shared) {
   const webServer = ctx.webServer
+  const registerAsset = (route) => webServer.register({
+    ...route,
+    handler: (req, res) => {
+      // Match /api admission before serving legacy paths. Older Connection
+      // providers expose no admit helper and retain their static-asset behavior.
+      const admission = ctx.connection.admit?.(req)
+      if (admission && 'rejection' in admission) {
+        res.writeHead(admission.rejection); res.end(); return
+      }
+      return route.handler(req, res)
+    },
+  })
   ctx.effect(() => {
-    const disposeSkin = webServer.register({
+    const disposeSkin = registerAsset({
       kind: 'exact', path: '/prts-corpus/ui-skin.json',
       handler: (req, res) => {
         if (req.method !== 'GET' && req.method !== 'HEAD') {
@@ -1311,31 +1435,31 @@ function applyWebAssets(ctx, shared) {
         res.end(req.method === 'HEAD' ? undefined : body)
       },
     })
-    const disposeAgentSkin = webServer.register({
+    const disposeAgentSkin = registerAsset({
       kind: 'exact', path: '/prts-corpus/skins/prts-agent.css',
       handler: (req, res) => serveSkinStylesheet(req, res, 'prts-agent.css'),
     })
-    const disposeCommonSkin = webServer.register({
+    const disposeCommonSkin = registerAsset({
       kind: 'exact', path: '/prts-corpus/skins/common.css',
       handler: (req, res) => serveSkinStylesheet(req, res, 'common.css'),
     })
-    const disposeAicSkin = webServer.register({
+    const disposeAicSkin = registerAsset({
       kind: 'exact', path: '/prts-corpus/skins/endfield-aic.css',
       handler: (req, res) => serveSkinStylesheet(req, res, 'endfield-aic.css'),
     })
-    const disposeRhineSkin = webServer.register({
+    const disposeRhineSkin = registerAsset({
       kind: 'exact', path: '/prts-corpus/skins/rhine-lab.css',
       handler: (req, res) => serveSkinStylesheet(req, res, 'rhine-lab.css'),
     })
-    const disposeRhineAssets = Object.keys(RHINE_ASSETS).map((relative) => webServer.register({
+    const disposeRhineAssets = Object.keys(RHINE_ASSETS).map((relative) => registerAsset({
       kind: 'exact', path: `/prts-corpus/rhine/${relative}`,
       handler: (req, res) => serveRhineAsset(req, res, relative),
     }))
-    const disposeBundle = webServer.register({
+    const disposeBundle = registerAsset({
       kind: 'prefix', path: '/prts-corpus/endfield-map',
       handler: (req, res) => serveEndfieldMapAsset(req, res, '/prts-corpus/endfield-map'),
     })
-    const disposeResources = webServer.register({
+    const disposeResources = registerAsset({
       kind: 'prefix', path: '/webmap3d/resources',
       handler: (req, res) => serveEndfieldMapAsset(req, res, '/webmap3d'),
     })

package/src/web-guidance.js

@@ -1,15 +1,25 @@
 /** Observe the official web tools without replacing providers or handling their credentials. */
 const searchSetup = 'DSH 网页搜索的凭据独立于桌面账号登录。缺少 Key 时请告知用户在插件 → 网页搜索中配置搜索提供方的 API Key；旧版可在设置 → 模型配置对应凭据。不要索取聊天中的密钥，不要把登录 token 当 API Key，也不要自行更换端点。'
 const fetchSetup = 'web_fetch 不需要网页搜索的 API Key。单个站点连接失败不能推断整个网络不可用；可换用另一个已知的权威来源核验。若多个站点持续失败，提示用户检查 DSH 启动进程的网络/HTTPS_PROXY 配置并重启，不要猜测代理地址或关闭证书验证。'
+const fetchCredentialSetup = '当前联网抓取由 DeepSeek 官方接口提供，需要与聊天相同的 API Key：请提示用户在模型配置中补齐该凭据，或改回默认的匿名 HTTP 抓取。单个站点失败不能推断整个网络不可用；配置未改变前不要重复抓取同一个 URL。'
+
+// 0.2.x 有两套 DeepSeek 联网实现：聊天同源的 deepseek-official 报 "DeepSeek search has no
+// API key"，新版 Search/Fetch 接口报 "DeepSeek web access has no API key"。两者都带
+// WEB_PROVIDER_CREDENTIAL_MISSING，文案匹配保证旧宿主与新版开关都能命中。
+const credentialMissing = (code, text) => code === 'WEB_PROVIDER_CREDENTIAL_MISSING'
+  || /DeepSeek (?:search|web access) has no API key/.test(text)
 
 export function webFailureGuidance(name, result) {
   if (!['web_search', 'web_fetch'].includes(name) || !result.isError) return null
   const code = result.error?.info?.code || result.error?.code || ''
   const text = (result.content || []).filter(block => block.type === 'text').map(block => block.text).join('\n')
   if (/ABORT|CANCEL/.test(code) || /aborted|cancelled|已取消/i.test(text)) return null
-  if (name === 'web_search' && (code === 'WEB_PROVIDER_CREDENTIAL_MISSING' || /DeepSeek search has no API key/.test(text))) {
+  if (name === 'web_search' && credentialMissing(code, text)) {
     return { code: 'WEB_PROVIDER_CREDENTIAL_MISSING', guidance: searchSetup + '配置未改变前不要重复搜索；继续本地核验，并明确说明现实资料尚未完成联网查证。' }
   }
+  if (name === 'web_fetch' && credentialMissing(code, text)) {
+    return { code: 'WEB_PROVIDER_CREDENTIAL_MISSING', guidance: fetchCredentialSetup }
+  }
   if (name === 'web_fetch' && /web fetch failed/.test(text)) {
     return { code: 'WEB_FETCH_CONNECTION_FAILED', guidance: fetchSetup }
   }
@@ -34,7 +44,9 @@ export function mountWebGuidance(ctx) {
       states.set(exec.agent, state)
     } else if (!result.isError) state.delete(key)
   })
-  ctx.systemPrompt.context({ name: 'prts-terrarchive:web-access', order: 1006, text: ({ scope }) => {
+  // interpolate:false keeps literal text: DSH 0.2.1 resolves {{name}} in contexts
+  // and throws on unknown names, while this text is data/receipt prose.
+  ctx.systemPrompt.context({ name: 'prts-terrarchive:web-access', order: 1006, interpolate: false, text: ({ scope }) => {
     const issues = scope && states.get(scope)
     if (!issues?.size) return ''
     return '<prts:web-access>\n以下是本会话最近的联网工具故障及恢复指引。不得把未抓取到的网页或模型记忆说成已联网核实的来源。\n'