@noob-stupid/dsh-plugin-console 0.5.16 → 0.5.18

package/lib/server/domain/install-job.js

@@ -2,74 +2,31 @@
 // 分层 Step 8c-2 从 lib/index.js 搬出；形参由 ctx 收窄为 ports（调用方注入的窄接口），只搬移未改逻辑。
 // 分组见 D:\dsh\dsh-plugin-hub-plan\architecture.zh.md 三
 
-import { readFileSync, existsSync, readdirSync } from 'node:fs'
+import { readFileSync, existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { basename, dirname, join, resolve } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
 import { aiRepair } from './ai-run.js'
 import { maybeAutoAdaptCompat } from './compat.js'
+import { getReposDir } from './repoland.js'
+import { aiConsentFailureText, cleanupAttemptedCandidates } from './install-cleanup.js'
+import { GIT_CHANNEL_BUDGET_MS, GIT_MIN_ATTEMPT_MS, GIT_SPEC_TIMEOUT_MS, gitChannelBudgetMs, noteChannel, formatBudgetMs, tryGitChannel } from './git-channel.js'
 import { DEFAULT_BUNDLES, AI_CONSENT_TIMEOUT_MS, PNPM_INSTALL_TIMEOUT_MS, addBundleToManifest, backfillMissingDeps, curlManualInstall, detectBundleOnly, ensureBundlePatchIntegrity, githubReleaseInstall, pnpmInstall, raceInstallChannels, readBundlePatchRefNames, readGithubAuth, syncAggregateSubpackageVersions } from './install.js'
 import { classifyInstallFailure, retryPnpmOnce } from './install-diagnose.js'
+import { jobLog } from './jobs.js'
 import { verifyInstalledEntry } from './install-verify.js'
-import { fetchRepoPackage, fetchRepoPackageEx, fetchSubpackageNames, packageProbeErrorText, subpackageCandidates } from './market.js'
+import { expandSubpackageCandidates, fetchRepoPackage, fetchRepoPackageEx, fetchSubpackageNames, npmNameHintForRepo, packageProbeErrorText, subpackageCandidates } from './market.js'
 import { declareProfileDependency } from './manifest.js'
 import { appendInsert, readPatchState, syncNameFromNote } from './patch.js'
 import { deriveEntryId, listEntries } from './runtime.js'
 import { detectSkillRepo, runSkillInstallJob } from './skills.js'
-import { gitCloneUrls, orderedRegistries, readSources } from './sources.js'
+import { orderedRegistries, readSources } from './sources.js'
 import { reconcileLockfile } from './selfupdate.js'
 import { probeGitmodules, resolveInstallKind, runSuiteInstallJob } from './suite.js'
 import { buildPnpmEnv, execFileAsync, runPnpmWithFallback } from '../infra/exec.js'
-import { cleanupStalePackageDir, removeDirVerified } from '../infra/fsx.js'
+import { cleanupStalePackageDir, startTrashCleanup, trashScanRoots } from '../infra/fsx.js'
 import { GITHUB_API, META_BUDGET_MS, curlJson, githubJson } from '../infra/http.js'
 import { findPatchPath, packageNameOf, resolvePackageJson } from '../infra/paths.js'
 
-/** 安装失败清场：把本次尝试过的候选包目录与 pnpm `_tmp_` 半成品一起清掉，并**如实汇报**清了什么、
- * 什么没清掉。为什么需要（2026-09-20 真装演练）：11 个子包的聚合仓库跑 19 分钟后失败，node_modules 里
- * 留着 `@captain1275/dsh-full-stats_tmp_56272_2` 这类半成品和一个真包，而面板只报"安装失败"——
- * 用户既不知道有东西被落盘，也不知道要不要手动清。删除一律走 removeDirVerified（本机 C 盘/`%TEMP%`
- * 下 rmSync 会静默落空，不核实就会谎报干净）。 */
-function cleanupAttemptedCandidates(profileDir, candidates) {
-  const cleaned = []
-  const failed = []
-  for (const name of candidates) {
-    const dir = join(profileDir, 'node_modules', ...String(name).split('/'))
-    const parent = dirname(dir)
-    const base = basename(dir)
-    let touched = 0
-    if (existsSync(dir)) {
-      const result = removeDirVerified(dir)
-      if (result.ok) touched += 1
-      else failed.push({ name, path: dir, error: result.error })
-    }
-    try {
-      for (const entry of readdirSync(parent)) {
-        if (!entry.startsWith(`${base}_tmp_`)) continue
-        const tmpPath = join(parent, entry)
-        const result = removeDirVerified(tmpPath)
-        if (result.ok) touched += 1
-        else failed.push({ name: `${name}（临时目录）`, path: tmpPath, error: result.error })
-      }
-    } catch {}
-    if (touched > 0) cleaned.push(name)
-  }
-  return { cleaned, failed }
-}
-
-/** 授权被拒/超时后的失败文案（纯函数，单测覆盖）：说清为什么失败、清理了什么、什么没清掉。
- * 时长取自 AI_CONSENT_TIMEOUT_MS —— 文案里的"10 分钟"不能与实际等待时间脱节。 */
-function aiConsentFailureText(decision, leftovers) {
-  const base = decision?.timeout === true
-    ? `等待授权超时（${Math.round(AI_CONSENT_TIMEOUT_MS / 60000)} 分钟），已取消本地 AI 兜底（该操作会调用模型 API 产生费用）`
-    : '用户取消本地 AI 兜底（该操作会调用模型 API 产生费用）'
-  const cleaned = leftovers?.cleaned ?? []
-  const failed = leftovers?.failed ?? []
-  const cleanedNote = cleaned.length > 0 ? `；已清理本次落盘残留：${cleaned.join('、')}` : ''
-  const failedNote = failed.length > 0
-    ? `；**有 ${failed.length} 项没能清理**（当前环境可能禁止删除，请手动删除）：${failed.map((f) => f.path).join('、')}`
-    : ''
-  return `${base}${cleanedNote}${failedNote}`
-}
-
 /** release 通道的候选预算（issue #3）：release 通道现在按包名反查发布仓库，**每个候选**至少一次
  * `releases?per_page=10` 调用（第一梯队仓库没命中还要多试几个候选仓库），而候选可能有十几个
  * （聚合仓库懒惰展开后最多 19 个）——不封顶会把 8 分钟的作业时间预算吃光。
@@ -83,7 +40,6 @@ const RELEASE_CHANNEL_BUDGET = 3
  * 否则替身与 cordis 语义不一致，这类缺陷还会再溜过去一次。 */
 function channelImpls(ports) {
   const real = { pnpmInstall, curlManualInstall, raceInstallChannels, githubReleaseInstall, backfillMissingDeps }
-  // 测试注入缝（2026-09-22 事故的修法，**别改回属性访问**）：
   //   生产路径上 ports 就是 cordis 的 ctx 代理，属性式读取未 inject 的名字会**同步抛**
   //   `cannot get property "installChannels" without inject` —— 0.3.59 因此每一次安装都在这里失败。
   //   正规写法是 ctx.get('installChannels')（Cordis 的可选读取，未声明也不抛，与本文件其它
@@ -112,7 +68,7 @@ function channelImpls(ports) {
  * ③ git 通道：**保留 repoChannelAllowed**（它只 clone `job.repo`，候选是子包时 clone 根仓库装不出子包，
  *    属无意义尝试）**并保留 !expanded**（同一作业里对同一个 job.repo 反复 clone 纯属浪费时间，
  *    级联顺序也不该被破坏）。 */
-async function tryCandidateChannels({ job, ch, name, profileDir, registries, repoChannelAllowed, budget, baseUrl = null, expanded = false }) {
+async function tryCandidateChannels({ job, ch, name, profileDir, registries, repoChannelAllowed, budget, baseUrl = null, expanded = false, deadline = null, expand = null }) {
   let installedName = null
   let lastError = null
   // 加法优化：包已在 node_modules 且名字匹配时，不再重复安装/触发 EPERM，直接进入启用流程
@@ -128,16 +84,27 @@ async function tryCandidateChannels({ job, ch, name, profileDir, registries, rep
   }
   // 通道 0：并行竞速（pnpm 与 curl 同时启动，先成功者生效；失败方 abort，不影响后续串行通道）——守卫①
   {
-    const raced = await ch.raceInstallChannels(profileDir, name, registries)
-    if (raced) {
-      installedName = name
-      if (raced.channel === 'curl') {
-        const racedInfo = raced.info
-        const stillMissing = await ch.backfillMissingDeps(profileDir, racedInfo.missingDeps, registries)
-        job.curlNote = `已通过并行 curl 通道安装 v${racedInfo.version}${stillMissing.length > 0 ? `（依赖仍未补齐：${stillMissing.join('、')}，网络恢复后建议重新安装）` : '（捆绑依赖已补齐）'}`
-        if (racedInfo.boxNote) job.curlNote += `（盒子验证：${racedInfo.boxNote}）`
-        job.integrity = racedInfo.integrity ?? null // ④ 下载物摘要校验结果（加法；见 install-verify.js）
+    try {
+      const raced = await ch.raceInstallChannels(profileDir, name, registries)
+      if (raced) {
+        installedName = name
+        if (raced.channel === 'curl') {
+          const racedInfo = raced.info
+          try {
+            const stillMissing = await ch.backfillMissingDeps(profileDir, racedInfo.missingDeps, registries)
+            job.curlNote = `已通过并行 curl 通道安装 v${racedInfo.version}${stillMissing.length > 0 ? `（依赖仍未补齐：${stillMissing.join('、')}，网络恢复后建议重新安装）` : '（捆绑依赖已补齐）'}`
+          } catch (backfillError) {
+            // 包已装好：补齐依赖失败只影响提示，绝不能因此把这次安装判成失败
+            job.curlNote = `已通过并行 curl 通道安装 v${racedInfo.version}（捆绑依赖补齐失败：${backfillError instanceof Error ? backfillError.message : String(backfillError)}；网络恢复后建议重新安装）`
+            noteChannel(job, `并行 curl 通道的依赖补齐失败（安装本身已成功）：${backfillError instanceof Error ? backfillError.message : String(backfillError)}`)
+          }
+          if (racedInfo.boxNote) job.curlNote += `（盒子验证：${racedInfo.boxNote}）`
+          job.integrity = racedInfo.integrity ?? null // ④ 下载物摘要校验结果（加法；见 install-verify.js）
+        }
       }
+    } catch (raceError) {
+      lastError = raceError
+      noteChannel(job, `并行竞速通道异常（已继续尝试后续串行通道）：${raceError instanceof Error ? raceError.message : String(raceError)}`)
     }
   }
   // 通道 1..n：配置的软件源依次尝试（每源 90 秒封顶）
@@ -180,31 +147,33 @@ async function tryCandidateChannels({ job, ch, name, profileDir, registries, rep
       } catch (ghError) {
         lastError = ghError
       }
-    } else if (lastError === null) {
-      // 预算用尽：不覆盖真实错误（面板/AI 兜底要看的是 curl·pnpm 的失败原因），只在无更具体错误时说明
-      lastError = new Error(`release 通道候选预算已用尽（本作业只对前 ${RELEASE_CHANNEL_BUDGET} 个候选做按包名反查+release 扫描）`)
+    } else {
+      // 预算用尽（批次 A-⑤）：原因**总是**记在 job 上供面板显示（旧代码只在 lastError === null 时写，用户看不出）
+      noteChannel(job, `release 通道因预算跳过（本作业只对前 ${RELEASE_CHANNEL_BUDGET} 个候选做按包名反查+release 扫描）`)
+      if (lastError === null) lastError = new Error(`release 通道候选预算已用尽（本作业只对前 ${RELEASE_CHANNEL_BUDGET} 个候选做按包名反查+release 扫描）`)
     }
   }
-  if (installedName === null) {
-    // 通道 n+2：git 通道（GitHub 走加速代理+直连；Gitee 走对应平台；各 60 秒封顶）——守卫③
-    if (repoChannelAllowed && !expanded) {
-      const gitSpecs = job.source === 'gitee'
-        ? [`git+https://gitee.com/${job.repo}.git`]
-        : [
-            ...gitCloneUrls(job.repo).map((u) => `git+${u}`),
-            `github:${job.repo}`,
-          ]
-      for (const spec of gitSpecs) {
-        try {
-          await ch.pnpmInstall(profileDir, spec, undefined, 60000)
-          installedName = name
-          break
-        } catch (gitError) {
-          lastError = gitError
-        }
-      }
+  // 懒惰展开（批次 A-③，2026-09-27 搬家）：**registry 类通道全部失败之后、git 通道之前**。
+  // 旧顺序是"所有通道（含 git）都失败 → 才展开子包"：对"根包 private、未发布到 npm"的仓库
+  // （真机 zhu1090093659/dsh-web）就是 registry 404 → 直接去 clone 那个 429 MB 的巨仓
+  // （ghproxy 上 git 协议 0 B/s，白等且注定失败），而真正能装的聚合子包 @linxin666/dsh-web-all
+  // （5.97 MB）连一次机会都没有。expand() 返回新增候选数；展开失败只记备注，绝不短路。
+  if (installedName === null && expanded === false && typeof expand === 'function') {
+    try {
+      const added = await expand()
+      if (added > 0) noteChannel(job, `registry 通道未命中，已自动展开仓库子包：新增 ${added} 个候选`)
+    } catch (error) {
+      noteChannel(job, `自动展开仓库子包失败（继续走后续通道）：${error instanceof Error ? error.message : String(error)}`)
     }
   }
+  if (installedName === null) {
+    // 通道 n+2：git 通道（GitHub 走加速代理+直连；Gitee 走对应平台）——守卫③
+    // 2026-09-27：实现搬进 domain/git-channel.js（独立预算 + 不得超过作业剩余预算；
+    // install-job.js 有 600 行硬顶，见 test-architecture-guard.mjs），此处只保留调用与错误归并。
+    const git = await tryGitChannel({ job, ch, name, profileDir, repoChannelAllowed, expanded, budget, deadline })
+    installedName = git.installedName
+    if (git.lastError !== null) lastError = git.lastError
+  }
   // ③ 失败分类 → 只对网络类超时用更长超时定向重试**一次**；其余分类只写 job.diagnosis 提示（见 install-diagnose.js）
   if (installedName === null && pnpmError !== null) {
     const retry = await retryPnpmOnce({ ch, profileDir, name, registries, pnpmError, job, baseTimeoutMs: PNPM_INSTALL_TIMEOUT_MS })
@@ -228,12 +197,28 @@ async function tryCandidateChannels({ job, ch, name, profileDir, registries, rep
   return { installedName, lastError }
 }
 
-async function runInstallJob(job, ports) {
+async function runInstallJob(job, ports, deps = {}) {
+  // 测试注入缝（2026-09-27，沿用 channelImpls 风格）：市场探测与两个时间预算可替换，只为离线断言
+  // 「候选顺序、展开时机、预算边界」；生产调用方不传第三个参数，默认值与旧行为一致。
+  const probes = {
+    fetchRepoPackage,
+    fetchRepoPackageEx,
+    fetchSubpackageNames,
+    subpackageCandidates,
+    npmNameHint: npmNameHintForRepo,
+    ...(deps.marketProbes ?? {}),
+  }
+  // 展开实现必须跟随**注入的** fetchSubpackageNames（否则注入的探测桩会被绕过、悄悄去打真网络 ——
+  // 2026-09-27 全量测试实测到的一次 30 秒空等就是这么来的）
+  if (deps.marketProbes?.expandSubpackages === undefined) {
+    probes.expandSubpackages = (opts = {}) => expandSubpackageCandidates({ ...opts, deps: { fetchSubpackageNames: probes.fetchSubpackageNames } })
+  }
+  const jobBudgetMs = Number.isFinite(deps.jobBudgetMs) && deps.jobBudgetMs > 0 ? deps.jobBudgetMs : 8 * 60 * 1000
+  const aiConsentTimeoutMs = Number.isFinite(deps.aiConsentTimeoutMs) && deps.aiConsentTimeoutMs > 0 ? deps.aiConsentTimeoutMs : AI_CONSENT_TIMEOUT_MS
   try {
     job.stage = 'preparing'
-    // 2026-09-06 事故（室友机器）：对 deepseek-ai/deepseek-harness（框架本体仓库）点「添加到本地/安装」
-    // 会按 bundle 规则注册其 patch，其中 deepseek-ai-dsh-root 等框架级行的包只存在于 npx 缓存/框架树，
-    // profile node_modules 不存在 → 整服务启动崩溃。直接拦截。
+    // 2026-09-06 事故（室友机器）：对 deepseek-ai/deepseek-harness（框架本体仓库）点安装会按 bundle 规则
+    // 注册其 patch，其中框架级行的包只存在于 npx 缓存/框架树 → profile 里不存在 → 整服务启动崩溃。直接拦截。
     const repoNorm = String(job.repo ?? '').toLowerCase().replace(/^git\+/u, '').replace(/\.git$/u, '')
     if (repoNorm === 'deepseek-ai/deepseek-harness') {
       job.status = 'failed'
@@ -242,9 +227,22 @@ async function runInstallJob(job, ports) {
     }
     let candidates = [job.packageName].filter((name) => typeof name === 'string' && name !== '')
     let subpackageMode = false
+    // ★ 市场索引的首选候选（批次 C-⑪）：索引带 npmName 时直接按包名走 registry，连"读根 package.json →
+    // 展开子包"这一轮都省掉（本机 api.github.com 不可达时那条路根本走不通）。老索引无该字段 → 行为不变。
+    if (candidates.length === 0 && job.repo) {
+      const npmHint = probes.npmNameHint(job.repo)
+      if (npmHint !== null) {
+        candidates = [npmHint]
+        job.npmNameHint = npmHint
+        job.packageName = npmHint
+        // git 通道只 clone 整个仓库（真机 dsh-web 429 MB / ghproxy 0 B/s），而且装不出这个子包 → 禁掉
+        job.gitChannelBlocked = true
+        noteChannel(job, `市场索引给出首选候选：${npmHint}（按包名直装，省掉"探测根包 + 展开子包"）`)
+        noteChannel(job, '已跳过 git 克隆通道：git 只 clone 整个仓库、装不出这个包（真机 dsh-web = 429 MB）')
+      }
+    }
     if (candidates.length === 0) {
-      // 套装兜底：submodule 聚合仓库（根 .gitmodules 内容校验通过）→ 自动转套装安装，
-      // 不依赖前端标记（搜索结果 enrich 是异步的、索引浏览条目无 enrich）。
+      // 套装兜底：submodule 聚合仓库（根 .gitmodules 内容校验通过）→ 自动转套装安装，不依赖前端标记。
       // 判据是**内容**（resolveInstallKind），不是"探测非 null"：后者会把代理/CDN 对不存在文件回的
       // 2xx 空 body、垃圾页当成套装（2026-09-19 用户反馈的「未找到 .gitmodules」事故根因）。
       if (resolveInstallKind(job.kind, await probeGitmodules(job.repo)) === 'suite') {
@@ -267,9 +265,8 @@ async function runInstallJob(job, ports) {
         job.kind = 'plugin'
         job.suiteNote = '探测到的 .gitmodules 与仓库实际内容不符（不是 submodule 套装仓库），已自动回落普通插件安装'
       }
-      // 兜底：宿主端自行拉取仓库元数据（githubJson 与 curl 竞速 + 8s 超时降级，黑洞期不卡 40s）。
-      // 8s 而非旧值 3s：IPv6 无路由的环境里单条通道就要 5.4s，3s 预算必输 → branch 恒为 main，
-      // 默认分支为 dev 的仓库会取错分支（2026-09-20 另一位用户实测）。
+      // 兜底：宿主端自行拉取仓库元数据（githubJson 与 curl 竞速 + 8s 超时降级）。8s 而非旧值 3s：
+      // IPv6 无路由时单条通道就要 5.4s，3s 预算必输 → branch 恒为 main（2026-09-20 另一位用户实测）。
       const meta = await Promise.race([
         Promise.any([
           githubJson(`${GITHUB_API}/repos/${job.repo}`),
@@ -278,7 +275,8 @@ async function runInstallJob(job, ports) {
         new Promise((resolve) => setTimeout(() => resolve(null), META_BUDGET_MS)),
       ]).catch(() => null)
       const branch = meta?.default_branch ?? 'main'
-      const { pkg, reason } = await fetchRepoPackageEx(job.repo, branch)
+      job.defaultBranch = branch // 批次 B-⑥：后续读子包一律以它打头（默认分支是 dev 的仓库不再读不到子包）
+      const { pkg, reason } = await probes.fetchRepoPackageEx(job.repo, branch)
       if (pkg === null) {
         // 无 package.json：先探测是否技能仓库（含 SKILL.md）→ 自动转技能安装；
         // 否则标记 hint=repo-land，前端给出「仓库落地」一键入口（克隆到本地目录）。
@@ -298,17 +296,23 @@ async function runInstallJob(job, ports) {
       if (pkg.private === true) {
         // 私有 monorepo 根：自动列出子包作为候选（把人工修复经验自动化），聚合包优先
         subpackageMode = true
+        // 批次 A-③（2026-09-27）：根包 private = **没发布到 npm** → registry 通道必然 404，
+        // 而 git 通道会去 clone 整个仓库（真机：dsh-web 429 MB、ghproxy 下 0 B/s）。
+        // 对该候选禁用 git，把时间让给"展开子包 → 按包名直装"这条真正能成功的路。
+        job.privateRoot = true
+        job.gitChannelBlocked = true
+        noteChannel(job, '根包未发布到 npm（private: true），已跳过 git 克隆通道（避免白拉整个仓库）')
         // 2026-09-20 事故（用户点装 zhu1090093659/dsh-web，报"未发现子包"）：该仓库根包确实
         // private: true，但 main/dev 各有 22 个子包目录。失败原因是当时市场索引源全挂、网络受限，
         // subpackageCandidates() 读不到列表 —— 旧代码只有"有没有子包"一个出口，把**没读到**
         // 报成了**不存在**，直接把用户带偏。教训：探测失败必须与确定性结论分开表达。
-        let subs = await subpackageCandidates(job.repo, branch)
+        let subs = await probes.subpackageCandidates(job.repo, branch)
         if (subs.length === 0) {
           // 读不到时先换一条分支重试：meta 探测失败时 branch 恒为 main，而默认分支为 dev 的仓库
           // （本例 dsh-web 就是 dev 为默认分支）main 上的子包布局可能不同/为空；
           // 换分支几乎零成本，却能把"分支取错"这一类假失败挡在报错之前。
           const altBranch = branch === 'main' ? 'dev' : 'main'
-          subs = await subpackageCandidates(job.repo, altBranch)
+          subs = await probes.subpackageCandidates(job.repo, altBranch)
           if (subs.length > 0) job.subpackageNote = `子包列表取自 ${altBranch} 分支（默认分支探测可能失败）`
         }
         if (subs.length === 0) {
@@ -330,12 +334,17 @@ async function runInstallJob(job, ports) {
       job.packageName = pkg.name
     }
     // 给了根包名但根包实际是 private 聚合仓库（如直接填 dsh-web-ui）：
-    // 与仓库模式同路径——直接展开子包（聚合包优先），跳过 git 装根包的无意义尝试
-    if (!subpackageMode && job.repo && job.packageName !== null) {
-      const rootPkg = await fetchRepoPackage(job.repo, 'main')
+    // 与仓库模式同路径——直接展开子包（聚合包优先），跳过 git 装根包的无意义尝试。
+    // 批次 C-⑪：候选来自索引 npmName 时跳过这一步（该装哪个包索引已给答案，再问 GitHub 就把"省掉探测"白省了）
+    if (!subpackageMode && job.repo && job.packageName !== null && job.npmNameHint === undefined) {
+      const rootPkg = await probes.fetchRepoPackage(job.repo, 'main')
       if (rootPkg !== null && rootPkg.private === true) {
         subpackageMode = true
-        const subs = await subpackageCandidates(job.repo, 'main', readGithubAuth().token)
+        // 同上游分支：根包未发布 → 禁用 git 通道（批次 A-③）
+        job.privateRoot = true
+        job.gitChannelBlocked = true
+        noteChannel(job, '根包未发布到 npm（private: true），已跳过 git 克隆通道（避免白拉整个仓库）')
+        const subs = await probes.subpackageCandidates(job.repo, 'main', readGithubAuth().token)
         if (subs.length > 0) {
           candidates = [...subs.filter((name) => !candidates.includes(name)), ...candidates]
           job.subpackages = subs
@@ -345,6 +354,8 @@ async function runInstallJob(job, ports) {
     job.stage = 'installing'
     const patchPath = findPatchPath(ports)
     const profileDir = dirname(patchPath)
+    // 每次安装开始前：后台清掉上次留下的 `.trash-*` 降级目录（2026-09-26 加法；即发即忘、最多 20 个 / 单个 ≤1s，绝不阻塞本次安装）
+    try { void startTrashCleanup({ roots: trashScanRoots({ profileDir, extra: [getReposDir()] }), log: (message) => jobLog(job, message) }) } catch {}
     const taken = new Set(listEntries(ports).map((entry) => entry.rowId))
     const patch = await readPatchState(patchPath)
     for (const id of [...patch.inserts, ...patch.disables, ...patch.forced]) taken.add(id)
@@ -353,7 +364,7 @@ async function runInstallJob(job, ports) {
     let expanded = false
     // 可配置软件源：主→备依次尝试（默认 npmmirror → npmjs，可增删自定义/内网源）
     const registries = orderedRegistries(readSources())
-    const deadline = Date.now() + 8 * 60 * 1000
+    const deadline = Date.now() + jobBudgetMs
     // 子包级进度（2026-09-20 真装实测：11 个子包的聚合仓库跑了 19 分钟，job.stage 一直停在
     // installing，面板只有一个不动的进度条）。candidateTotal/Index/Name 每轮开始时更新，
     // 由 installJobView 折算成 progress{index,total,name} 下发给面板。
@@ -372,33 +383,30 @@ async function runInstallJob(job, ports) {
       // ⚠️ 本行必须在 `const name` **之后**求值：旧代码把它写在 name 声明之前，`name === job.packageName`
       // 一被求值就命中 TDZ（ReferenceError: Cannot access 'name' before initialization）——
       // 私有聚合根（subpackageMode=true 且 packageName 非空）安装必失败，且报错文案完全指不到真正原因。
-      const repoChannelAllowed = !subpackageMode || job.packageName === null || name === job.packageName
-      const attempt = await tryCandidateChannels({ job, ch, name, profileDir, registries, repoChannelAllowed, budget, baseUrl: ports.baseUrl ?? null, expanded })
+      // 批次 A-③：再叠加 gitChannelBlocked —— 根包未发布（或首选候选来自索引）时不试 git（只 clone 整仓，纯白等）
+      const repoChannelAllowed = (!subpackageMode || job.packageName === null || name === job.packageName) && job.gitChannelBlocked !== true
+      // 懒惰展开的注入实现（只展开一次：expanded 由这里翻转，后续轮次传进去的就是 true）
+      const expandSubpackages = async () => {
+        if (expanded || !job.repo) return 0
+        expanded = true
+        // 批次 B-⑥：以**真实默认分支**打头（fetchSubpackageNames 内部再回退 main / master）
+        const extra = await probes.expandSubpackages({ repo: job.repo, branch: job.defaultBranch ?? 'main', auth: readGithubAuth().token, existing: candidates })
+        if (extra.length === 0) return 0
+        candidates = [...candidates, ...extra]
+        // 懒惰展开后候选变多：总数要跟着更新，否则面板会显示"第 9/1 个"
+        job.candidateTotal = candidates.length
+        if (!Array.isArray(job.subpackages)) job.subpackages = []
+        for (const e of extra) if (!job.subpackages.includes(e)) job.subpackages.push(e)
+        return extra.length
+      }
+      const attempt = await tryCandidateChannels({
+        job, ch, name, profileDir, registries, repoChannelAllowed, budget,
+        baseUrl: ports.baseUrl ?? null, expanded, deadline,
+        expand: (expanded || job.npmNameHint !== undefined) ? null : expandSubpackages,
+      })
       installedName = attempt.installedName
       lastError = attempt.lastError
       if (installedName !== null) break
-      // 懒惰展开：registry 与 git 通道都失败时，自动发现仓库子包继续尝试（聚合包优先），
-      // 覆盖"给了根包名但根包未发布"的场景——AI 兜底只处理真正无解的案例
-      if (!expanded && job.repo) {
-        expanded = true
-        let subs = await fetchSubpackageNames(job.repo, 'main', readGithubAuth().token)
-        if (subs.length === 0) subs = await fetchSubpackageNames(job.repo, 'master', readGithubAuth().token)
-        if (subs.length > 0) {
-          const extra = subs
-            .slice()
-            .sort((a, b) => Number(/(^|-)all$/u.test(b.name) || /-all-/u.test(b.name)) - Number(/(^|-)all$/u.test(a.name) || /-all-/u.test(a.name)))
-            .map((sub) => sub.name)
-            .filter((n) => !candidates.includes(n))
-            .slice(0, 8)
-          if (extra.length > 0) {
-            candidates = [...candidates, ...extra]
-            // 懒惰展开后候选变多：总数要跟着更新，否则面板会显示"第 9/1 个"
-            job.candidateTotal = candidates.length
-            if (!Array.isArray(job.subpackages)) job.subpackages = []
-            for (const e of extra) if (!job.subpackages.includes(e)) job.subpackages.push(e)
-          }
-        }
-      }
     }
     if (installedName === null) {
       if (job.diagnosis == null) job.diagnosis = classifyInstallFailure(lastError?.message) // 分类提示兜底（加法）
@@ -407,12 +415,12 @@ async function runInstallJob(job, ports) {
       job.aiPending = { lastError: lastError?.message ?? null }
       // 等授权期间要能展示"为什么卡住、还能等多久"：请求时间 + 超时上限 + 最后一个确定性错误
       job.aiPendingSince = Date.now()
-      job.aiConsentTimeoutMs = AI_CONSENT_TIMEOUT_MS
+      job.aiConsentTimeoutMs = aiConsentTimeoutMs
       job.lastError = lastError?.message ?? null
       job.aiWait = new Promise((resolve) => { job.aiPending.resolver = resolve })
       const decision = await Promise.race([
         job.aiWait,
-        new Promise((resolve) => setTimeout(() => resolve({ approved: false, timeout: true }), AI_CONSENT_TIMEOUT_MS)),
+        new Promise((resolve) => setTimeout(() => resolve({ approved: false, timeout: true }), aiConsentTimeoutMs)),
       ])
       job.aiPending = null
       job.aiWait = null
@@ -424,7 +432,7 @@ async function runInstallJob(job, ports) {
         // 不能让用户面对"面板说失败、磁盘上却留了半个包和 _tmp_ 残留"的糊涂账。
         const leftovers = cleanupAttemptedCandidates(profileDir, candidates)
         job.leftovers = leftovers
-        job.error = aiConsentFailureText(decision, leftovers)
+        job.error = aiConsentFailureText(decision, leftovers, aiConsentTimeoutMs)
       }
       return
     }
@@ -588,4 +596,4 @@ async function readExtraBundleRows(profileDir) {
   } catch {}
   return rows
 }
-export { runInstallJob, pnpmRemove, readExtraBundleRows, cleanupAttemptedCandidates, aiConsentFailureText, tryCandidateChannels, channelImpls, RELEASE_CHANNEL_BUDGET }
+export { runInstallJob, pnpmRemove, readExtraBundleRows, cleanupAttemptedCandidates, aiConsentFailureText, tryCandidateChannels, channelImpls, RELEASE_CHANNEL_BUDGET, GIT_CHANNEL_BUDGET_MS, GIT_SPEC_TIMEOUT_MS, GIT_MIN_ATTEMPT_MS, gitChannelBudgetMs, noteChannel, formatBudgetMs }

package/lib/server/domain/install.js

@@ -536,6 +536,8 @@ function installJobView(job) {
     lockVersion: job.lockVersion ?? null,
     lockNote: job.lockNote ?? null,
     depNote: job.depNote ?? null, // 依赖来源写回说明（缺陷②：release 专属包按 link: 记录时给出可见解释，绝不静默）
+    // 通道备注（2026-09-27 加法）：通道"为什么没试/为什么只试了一部分"如实下发（release/git 预算用尽、根包未发布禁 git…）
+    channelNotes: Array.isArray(job.channelNotes) && job.channelNotes.length > 0 ? job.channelNotes : null,
     compatNote: job.compatNote ?? null,
     kind: job.kind ?? 'plugin',
     skillName: job.skillName ?? null,

package/lib/server/domain/market.js

@@ -6,7 +6,7 @@ import { readFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { detectSkillRepo } from './skills.js'
 import { FETCH_OK, FETCH_UNREACHABLE, GITHUB_API, curlJson, curlText, fetchJsonUrl, githubJson, looksLikeGitmodules, rawTextFetch, rawTextWithFallback } from '../infra/http.js'
-import { ENRICH_CACHE_FILE, baseDirOf, resolvePackageJson } from '../infra/paths.js'
+import { ENRICH_CACHE_FILE, baseDirOf, marketIndexCacheFile, resolvePackageJson } from '../infra/paths.js'
 
 function readEnrichCache() {
   try {
@@ -368,16 +368,27 @@ async function readPluginDetails(moduleName, baseUrl, profileDir) {
   }
 }
 
-/** 服务端列出仓库子包（git trees 递归 + 并行读 package.json 的 name）。 */
-async function fetchSubpackageNames(repo, branch, auth) {
+/** 读子包时要按顺序试哪些分支（纯函数，单测覆盖 —— 批次 B-⑥，2026-09-27 改错）。
+ * 旧代码把分支**写死**成 'main'（读不到再手工换 'master'）：默认分支是 dev 的仓库
+ * （真机：zhu1090093659/dsh-web 的默认分支就是 dev）永远读不到子包列表，
+ * 于是「未发现子包」这类假失败又回来了。现在一律用**已经拿到的**默认分支打头，
+ * 再回退 main / master（去重、保序）。 */
+function subpackageBranchOrder(branch, defaults = ['main', 'master']) {
+  const list = Array.isArray(branch) ? branch : [branch]
+  const merged = [...list, ...defaults].filter((b) => typeof b === 'string' && b.trim() !== '')
+  return [...new Set(merged.map((b) => b.trim()))]
+}
+
+/** 单个分支上读子包列表（git trees 递归 + 并行读 package.json 的 name）。 */
+async function fetchSubpackageNamesOnBranch(repo, branch, auth, { ghJson, rawText }) {
   try {
-    const data = await githubJson(`${GITHUB_API}/repos/${repo}/git/trees/${encodeURIComponent(branch)}?recursive=1`, undefined, auth)
+    const data = await ghJson(`${GITHUB_API}/repos/${repo}/git/trees/${encodeURIComponent(branch)}?recursive=1`, undefined, auth)
     const paths = (data.tree ?? [])
       .filter((node) => node.type === 'blob' && /^(?!node_modules\/)[^/]+(?:\/[^/]+)?\/package\.json$/u.test(node.path))
       .map((node) => node.path)
     // 并行读取：黑洞期单条最坏 40s，24 条串行会拖到十几分钟
     const results = await Promise.all(paths.slice(0, 24).map(async (path) => {
-      const bodyText = await rawTextWithFallback(repo, branch, path)
+      const bodyText = await rawText(repo, branch, path)
       if (bodyText === null) return null
       try {
         const pkg = JSON.parse(bodyText)
@@ -391,6 +402,61 @@ async function fetchSubpackageNames(repo, branch, auth) {
   }
 }
 
+/** 从市场索引里查这个仓库的**首选 npm 包名**（批次 C-⑪，2026-09-27 加法）。
+ * 数据源与 /market-index 完全一致：routes/market.js 每次成功拉到索引都会写一份落盘缓存
+ * （infra/paths.marketIndexCacheFile），这里读它 —— 与内存缓存等价、且跨重启有效。
+ * 为什么值得这一步：真机 dsh-web 的根包 private（没发布），旧流程要先探测 package.json、
+ * 再展开子包才能找到 @linxin666/dsh-web-all；而本机 api.github.com 不可达时**这两步都做不了**。
+ * 兼容性：老索引没有 npmName 字段 → 返回 null → 行为与改动前完全一致。
+ * deps（readFile/cacheFile）只为单测注入，生产调用不传。 */
+function npmNameHintForRepo(repo, deps = {}) {
+  const full = String(repo ?? '').trim().replace(/\.git$/u, '')
+  if (full === '') return null
+  const read = deps.readFile ?? ((file) => readFileSync(file, 'utf8'))
+  const file = deps.cacheFile ?? marketIndexCacheFile()
+  try {
+    const parsed = JSON.parse(read(file))
+    const items = Array.isArray(parsed?.data?.items) ? parsed.data.items : (Array.isArray(parsed?.items) ? parsed.items : [])
+    const hit = items.find((it) => it !== null && typeof it.fullName === 'string' && it.fullName.toLowerCase() === full.toLowerCase())
+    if (hit === undefined) return null
+    const npmName = typeof hit.npmName === 'string' ? hit.npmName.trim() : ''
+    if (npmName === '') return null
+    // 只接受合法 npm 包名（索引是外部数据，不能拿它去拼命令）
+    return /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/u.test(npmName) ? npmName : null
+  } catch {
+    return null
+  }
+}
+
+/** 懒惰展开（批次 A-③ 的实现；2026-09-27 从 install-job.js 搬进 market.js —— 那边触到 600 行硬顶）：
+ * 读仓库子包列表 → **聚合包优先**（名字以 all 结尾/-all- 形式）→ 去掉已有候选 → 限量返回。
+ * 分支由调用方给（install-job 传 meta.default_branch），fetchSubpackageNames 自己会回退 main/master。 */
+async function expandSubpackageCandidates({ repo, branch = 'main', auth = null, existing = [], limit = 8, deps = {} } = {}) {
+  const fetchNames = deps.fetchSubpackageNames ?? fetchSubpackageNames
+  const subs = await fetchNames(repo, branch, auth, deps.fetchDeps ?? {})
+  if (subs.length === 0) return []
+  const isAll = (n) => /(^|-)all$/u.test(n) || /-all-/u.test(n)
+  return subs
+    .map((sub) => sub.name)
+    .filter((n) => !existing.includes(n))
+    .sort((a, b) => Number(isAll(b)) - Number(isAll(a)))
+    .slice(0, limit)
+}
+
+/** 服务端列出仓库子包（git trees 递归 + 并行读 package.json 的 name）。
+ * branch 可以是**单个分支名**（老调用点不变）或**分支数组**（按序试）；两种形态都会自动
+ * 追加 main / master 兜底（见 subpackageBranchOrder）。deps 只为单测注入，生产调用不传。 */
+async function fetchSubpackageNames(repo, branch, auth, deps = {}) {
+  const ghJson = deps.githubJson ?? githubJson
+  const rawText = deps.rawText ?? rawTextWithFallback
+  for (const b of subpackageBranchOrder(branch)) {
+    // eslint-disable-next-line no-await-in-loop
+    const subs = await fetchSubpackageNamesOnBranch(repo, b, auth, { ghJson, rawText })
+    if (subs.length > 0) return subs
+  }
+  return []
+}
+
 /** 子包候选：聚合包（名字带 all）优先，上限 8 个。
  * 2026-09-20 真装演练：`@dsh-suite/all` 这种 **scope 根形式**（`/all` 结尾）不被
  * `(^|-)all$` 命中，聚合包没能排到最前（那次纯属仓库目录顺序碰巧第一）。补上 `/all$`。 */
@@ -406,4 +472,4 @@ async function subpackageCandidates(repo, branch, auth) {
 
 const ENRICH_CACHE_TTL = 24 * 60 * 60 * 1000
 
-export { readEnrichCache, writeEnrichCache, enrichItemOne, enrichItems, normalizePlatformItems, githubRepoInfo, fetchRepoPackage, fetchRepoPackageEx, packageProbeErrorText, searchNpmPackages, searchSubpackageItems, parseRepoFromUrl, hasDirectNameHit, summarizeReadme, readPluginDetails, fetchSubpackageNames, subpackageCandidates, ENRICH_CACHE_TTL }
+export { readEnrichCache, writeEnrichCache, enrichItemOne, enrichItems, normalizePlatformItems, githubRepoInfo, fetchRepoPackage, fetchRepoPackageEx, packageProbeErrorText, searchNpmPackages, searchSubpackageItems, parseRepoFromUrl, hasDirectNameHit, summarizeReadme, readPluginDetails, fetchSubpackageNames, fetchSubpackageNamesOnBranch, subpackageBranchOrder, subpackageCandidates, expandSubpackageCandidates, npmNameHintForRepo, ENRICH_CACHE_TTL }