dsh-plugin-orchd 0.1.0 → 0.1.2

package/lib/detect.js

@@ -3,25 +3,26 @@
  *
  * 依据 docs/02-设计方案.md 第 5 节。判定顺序（每一步的 「reason」 都机器可读，FR-2.2）：
  *
- *   ① 安装痕迹            → not_installed
- *   ② 布局 / 布局一致性     → broken/layout-unresolved | broken/layout-marker-mismatch
- *   ③ Python              → broken/python-not-found
- *   ④ 定义层 缺失          → uninitialized（或 broken/definition-archived-unsupported）
- *   ④' 定义层 损坏         → broken/master-unparsable
- *   ⑤ 状态层（一次 CLI）    → broken/cli-timeout | broken/cli-failed      ← P1 起启用
- *   ⑥ 一致性交叉检查        → broken/definition-state-mismatch            ← P1 起启用
+ *   ① 布局发现（唯一真源）  → not_installed
+ *                          | broken/layout-unresolved | broken/layout-marker-mismatch
+ *      （痕迹判定与主工作树定位都收敛在 master.js::resolveLayout 的三种结论里）
+ *   ② Python              → broken/python-not-found
+ *   ③ 定义层 缺失          → uninitialized（或 broken/definition-archived-unsupported）
+ *   ③' 定义层 损坏         → broken/master-unparsable
+ *   ④ 状态层（一次 CLI）    → broken/cli-timeout | broken/cli-failed      ← P1 起启用
+ *   ⑤ 一致性交叉检查        → broken/definition-state-mismatch            ← P1 起启用
  *   → ready
  *
- * 与文档的唯一偏差：把「布局一致性」放到了 Python 探测之前。理由是文档把
- * «布局标记与真实主工作树不一致» 列进了 「broken」 的判定集合（FR-2 表格与 AC-2.5），
- * 而 python-not-found 会抢先返回、把 AC-2.5 永久遮蔽。两者都是 broken，
- * 只是谁先被报出来；先报更具体的那一个更利于排障。
+ * 与文档的偏差（已在根因治理时收敛）：布局发现（含「是否接入」的痕迹判定）排在 Python 探测之前。
+ * 理由：文档把 «布局标记与真实主工作树不一致» 列进 「broken」 判定集合（FR-2 表格与 AC-2.5），
+ * 而 python-not-found 会抢先返回、把 AC-2.5 永久遮蔽；布局发现放最前，not_installed 与 layout-*
+ * 都能先被报出。两者都是 broken，只是谁先报；先报更具体的那一个更利于排障。
  *
  * P0 范围（docs/05 第 3.2 节）：不含 CLI 状态层调用、不含一致性交叉检查，
  * 因此本模块的 「runCli」 允许缺省；P1 传入真实封装即可启用 ⑤⑥。
  */
 
-import { hasInstallationTrace, findArchiveCandidates, readMaster, resolveLayout } from './master.js'
+import { findArchiveCandidates, readMaster, resolveLayout } from './master.js'
 import { probePython } from './python.js'
 
 /** 机器可读的失败原因分类（FR-2.2）。 */
@@ -48,24 +49,23 @@ export const BROKEN_REASONS = Object.freeze([
  * @returns {Promise<object>} DetectedState（形状见 docs/02 第 7 节）
  */
 export async function detect({ root, config, runCli }) {
-  // ① 安装痕迹
-  if (!hasInstallationTrace(root)) {
-    return { state: 'not_installed', root }
-  }
-
-  // ② 布局（含一致性）
+  // ① 布局发现（唯一真源：痕迹判定 + 主工作树/定义文件定位，见 master.js::resolveLayout）
   const layout = resolveLayout(root)
   if (layout.ok !== true) {
+    // 「根与子工作树都没有痕迹」是唯一判 not_installed 的依据；其余都是 broken
+    if (layout.reason === 'no-installation') {
+      return { state: 'not_installed', root }
+    }
     return { state: 'broken', root, reason: layout.reason, detail: layout.detail }
   }
 
-  // ③ Python
+  // ② Python
   const python = await probePython(config)
   if (python.error !== undefined) {
     return { state: 'broken', root, reason: 'python-not-found', detail: python.error, layout }
   }
 
-  // ④ 定义层
+  // ③ 定义层
   const master = readMaster(layout.masterPath)
   if (master.ok !== true) {
     // 文件不存在 → 装了但没初始化。唯一例外：定义被归档到别处（R8），
@@ -96,7 +96,7 @@ export async function detect({ root, config, runCli }) {
     }
   }
 
-  // ⑤⑥ 状态层（P0 不做）
+  // ④⑤ 状态层（P0 不做）
   if (typeof runCli !== 'function') {
     return {
       state: 'ready',
@@ -113,7 +113,15 @@ export async function detect({ root, config, runCli }) {
   }
 
   // workDir = 主工作树：container 布局下引擎拒绝以容器根为 cwd（E036，见 orchd-cli.js 头注释）
-  const status = await runCli({ root, python, layout, workDir: layout.mainWorktree, command: ['status', '--all'] })
+  // containerRoot = 布局声明的容器根：引擎装在容器根、主工作树只有定义层时，启动器要从那里回退取
+  const status = await runCli({
+    root,
+    python,
+    layout,
+    workDir: layout.mainWorktree,
+    containerRoot: layout.containerRoot ?? null,
+    command: ['status', '--all']
+  })
   if (status.timedOut === true) {
     return { state: 'broken', root, reason: 'cli-timeout', detail: status, layout, python }
   }
@@ -143,7 +151,13 @@ export async function detect({ root, config, runCli }) {
     schemaVersion: master.schemaVersion,
     taskCount: master.taskCount,
     summary: status.json?.summary ?? null,
-    statusLayer: { checked: true }
+    statusLayer: {
+      checked: true,
+      // 用了哪一份启动器（`worktree` / `container-root-fallback`）：ready 时也留在诊断里，
+      // 免得「明明修好了」和「悄悄退回了另一侧」在面板上分不出来
+      launcher: status.launcher ?? null,
+      launcherSource: status.launcherSource ?? null
+    }
   }
 }
 

package/lib/git-times.js

@@ -0,0 +1,240 @@
+/**
+ * 只读 git 时间采集：给看板的默认排序提供「最近动作时间」与「合并时间」。
+ *
+ * 为什么需要它（FR-5.4 修订，2026-10-29）：默认排序改为——
+ *   · 活跃任务（pending / claimed / done / in_review）按「最近一次动作」由近到远；
+ *   · 终态任务（completed / cancelled）按「合并进 main 的时间」由近到远。
+ * 但引擎的 `status --all` 与 `status <id>` **都不返回时间字段**（只有 task_id / name /
+ * status / module / attempt_count / source / claimed_by，外加可选的 review_phase /
+ * revive_marker），唯一带精确时间戳的是账本事件流（`_ledger.sqlite3`），而插件按 A2
+ * 不直读账本。所以这里走 git 侧的两个**近似**来源：
+ *
+ *   ① 活跃任务 → `task/<id>` 分支的 tip 时间。任务还在推进时分支还在（终态回收才会删
+ *      分支与 worktree），tip 提交时间就是「最近一次动作」的最佳近似。
+ *   ② 终态任务 → 主分支上的合并提交时间（`Merge branch 'task/<id>'`）。分支已被回收，
+ *      合并提交是唯一留下的时间戳。
+ *
+ * 两处已知盲区（默认排序把它们兜底到本组最后，**不臆造时间**）：
+ *   · 尚未 claim 的 pending：还没有 `task/<id>` 分支；
+ *   · cancelled：多半从未合并，没有合并提交。squash / 直推进主分支的形态同样拿不到
+ *     合并提交（不猜）。
+ *
+ * 只读纪律（与引擎调用面同一口径，docs/03 第 8 节）：
+ *   · **只跑 `GIT_READONLY_INVOCATIONS` 里那两条固定只读命令**，参数里不含任务 id、
+ *     不含任何项目数据 —— 没有命令拼接面；
+ *   · 不写工作区、不动索引、不 fetch（纯本地查询）；
+ *   · 子进程 env 只保留运行必需项，不注入任何身份变量。
+ */
+
+import { spawn } from 'node:child_process'
+
+/** ① 活跃任务的 `task/*` 分支 tip 时间（`--sort=-committerdate`：第一份即最新）。 */
+const BRANCH_TIP_ARGS = Object.freeze([
+  'for-each-ref',
+  '--sort=-committerdate',
+  '--format=%(committerdate:iso-strict)%09%(refname:short)',
+  'refs/heads/task'
+])
+
+/** ② 主分支上的合并提交（`-n` 上限够覆盖几百个终态任务的合并历史）。 */
+const MERGE_COMMIT_ARGS = Object.freeze([
+  'log',
+  '--merges',
+  '--format=%cI%09%s',
+  '-n',
+  '4000'
+])
+
+/**
+ * 允许执行的 git 调用面（**唯一来源**：实现从它取参数，测试按它做静态断言）。
+ * 想加新调用必须先改这里 —— 与引擎白名单同一个 fail-closed 思路。
+ */
+export const GIT_READONLY_INVOCATIONS = Object.freeze([
+  Object.freeze({ name: 'branch-tips', args: BRANCH_TIP_ARGS }),
+  Object.freeze({ name: 'merge-commits', args: MERGE_COMMIT_ARGS })
+])
+
+/** 子进程 env 白名单：git 只读查询的最小集合（PATH 必需，Windows 还要 SystemRoot）。 */
+export const GIT_CHILD_ENV_KEYS = Object.freeze(['PATH', 'SystemRoot', 'SystemDrive', 'TEMP', 'TMP'])
+
+/** 采集结果的空形态（git 不可用 / 非 git 项目 / 超时都返回它，只是 `reason` 不同）。 */
+const EMPTY_TIMES = Object.freeze({ branchTimes: {}, mergeTimes: {} })
+
+/**
+ * 子进程 env：白名单式构造，绝不把宿主变量（尤其是身份类）带下去。
+ * @param {Record<string, string|undefined>} [source]
+ */
+export function buildGitChildEnv(source = process.env) {
+  const env = {}
+  for (const key of GIT_CHILD_ENV_KEYS) {
+    const value = source[key]
+    if (typeof value === 'string' && value !== '') env[key] = value
+  }
+  return env
+}
+
+/**
+ * `task/<id>` 或 `task/<line>/<id>` → 任务 id（多线取最后一段；id 自身不含 `/`）。
+ * 非任务分支（main / feature/... ）→ null。
+ * @param {string} refName
+ * @returns {string|null}
+ */
+export function parseTaskBranchRef(refName) {
+  if (typeof refName !== 'string') return null
+  const match = /^task\/(.+)$/.exec(refName.trim())
+  if (match === null) return null
+  const segments = match[1].split('/')
+  const id = segments[segments.length - 1].trim()
+  return id === '' ? null : id
+}
+
+/**
+ * 合并提交标题 → 任务 id。只认 `Merge branch 'task/<id>'`（可带 ` into <branch>` 尾巴）。
+ * @param {string} subject
+ * @returns {string|null}
+ */
+export function parseMergeSubject(subject) {
+  if (typeof subject !== 'string') return null
+  const match = /Merge branch 'task\/([^']+)'/.exec(subject)
+  if (match === null) return null
+  const segments = match[1].split('/')
+  const id = segments[segments.length - 1].trim()
+  return id === '' ? null : id
+}
+
+/** ISO 时间的最小形状校验（`iso-strict` / `%cI` 都是 `<date>T<time>` 开头）。 */
+function looksLikeIso(value) {
+  return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(value)
+}
+
+/** 按第一个制表符切开 `--format` 的两列（时间 + 后续列）。 */
+function splitColumns(line) {
+  // 双保险：`%x09` 这种写法在部分 git/环境上会被**原样带出**成字面量 `%09`
+  // （2026-10-29 实测踩到：GIT 2.56 + execFileSync 走 argv 时），先归一成真分隔符，
+  // 免得整个时间层静默变空。
+  const text = line.trim().replace(/%0?9/g, '\t')
+  if (text === '') return null
+  const index = text.indexOf('\t')
+  if (index < 0) return null
+  const when = text.slice(0, index).trim()
+  const rest = text.slice(index + 1).trim()
+  if (rest === '' || !looksLikeIso(when)) return null
+  return { when, rest }
+}
+
+/**
+ * 跑一条 git 只读命令。失败/超时都**不抛错**（排序降级即可，不能因为 git 坏了让面板挂）。
+ * @param {readonly string[]} args
+ * @param {{ cwd: string, timeoutMs: number, spawnImpl: Function }} options
+ */
+export function runGitReadonly(args, { cwd, timeoutMs = 8000, spawnImpl = spawn }) {
+  return new Promise((resolve) => {
+    let child
+    try {
+      child = spawnImpl('git', [...args], {
+        cwd,
+        windowsHide: true,
+        env: buildGitChildEnv(),
+        stdio: ['ignore', 'pipe', 'pipe']
+      })
+    } catch (error) {
+      resolve({ ok: false, reason: 'git-spawn-failed', stdout: '', stderr: String(error) })
+      return
+    }
+
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    let timedOut = false
+
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(value)
+    }
+
+    const timer = setTimeout(() => {
+      timedOut = true
+      try {
+        child.kill()
+      } catch {
+        /* 忽略：可能已退出 */
+      }
+    }, Math.max(1, timeoutMs))
+
+    // 刻意**不**设 setEncoding：按 Buffer 收集后统一 utf8 解码，
+    // 免得子进程（git）输出编码受宿主 locale 影响（中文提交信息会乱码）。
+    const chunks = []
+    const errChunks = []
+    child.stdout.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))))
+    child.stderr.on('data', (chunk) => errChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))))
+
+    child.on('error', (error) => {
+      finish({ ok: false, reason: 'git-spawn-failed', stdout: '', stderr: String(error) })
+    })
+
+    child.on('close', (code) => {
+      stdout = Buffer.concat(chunks).toString('utf8')
+      stderr = Buffer.concat(errChunks).toString('utf8')
+      if (timedOut) {
+        finish({ ok: false, reason: 'git-timeout', stdout, stderr })
+        return
+      }
+      if (code !== 0) {
+        // 非 git 仓库在这里表现得最典型（exit 128 + "not a git repository"）
+        finish({ ok: false, reason: 'git-failed', code, stdout, stderr })
+        return
+      }
+      finish({ ok: true, reason: null, code: 0, stdout, stderr })
+    })
+  })
+}
+
+/**
+ * 采集 git 时间层。
+ *
+ * @param {object} options
+ * @param {string} options.worktree 主工作树（git 仓库根）
+ * @param {number} [options.timeoutMs]
+ * @param {Function} [options.spawnImpl] 仅供测试注入
+ * @returns {Promise<{ available: boolean, reason: string|null, branchTimes: Record<string,string>, mergeTimes: Record<string,string> }>}
+ */
+export async function collectGitTimes({ worktree, timeoutMs = 8000, spawnImpl = spawn } = {}) {
+  if (typeof worktree !== 'string' || worktree === '') {
+    return { available: false, reason: 'no-worktree', ...EMPTY_TIMES }
+  }
+
+  const [branch, merge] = await Promise.all([
+    runGitReadonly(BRANCH_TIP_ARGS, { cwd: worktree, timeoutMs, spawnImpl }),
+    runGitReadonly(MERGE_COMMIT_ARGS, { cwd: worktree, timeoutMs, spawnImpl })
+  ])
+
+  if (branch.ok !== true && merge.ok !== true) {
+    return { available: false, reason: branch.reason ?? merge.reason ?? 'git-failed', ...EMPTY_TIMES }
+  }
+
+  const branchTimes = {}
+  if (branch.ok === true) {
+    for (const line of branch.stdout.split('\n')) {
+      const columns = splitColumns(line)
+      if (columns === null) continue
+      const id = parseTaskBranchRef(columns.rest)
+      // 已按 committerdate 倒序：同一任务分支只留第一次出现（= 最新）
+      if (id !== null && branchTimes[id] === undefined) branchTimes[id] = columns.when
+    }
+  }
+
+  const mergeTimes = {}
+  if (merge.ok === true) {
+    for (const line of merge.stdout.split('\n')) {
+      const columns = splitColumns(line)
+      if (columns === null) continue
+      const id = parseMergeSubject(columns.rest)
+      // `log` 也是新→旧：同一任务只留最近一次合并
+      if (id !== null && mergeTimes[id] === undefined) mergeTimes[id] = columns.when
+    }
+  }
+
+  return { available: true, reason: null, branchTimes, mergeTimes }
+}

package/lib/ideas.js

@@ -15,6 +15,12 @@
  *   3. **归档不能当状态分布用**：`IDEAS-archive.md` 543 KB / 372 个 `## `，其中 311 条仍写着
  *      `pending`——归档保留原文，`status` 是**历史值**（AC-13.1/13.9）。
  *
+ * 状态词表（引擎 2026-10-23 调整后）：`study` / `questioning` / `pending` / `covered`。
+ *   · `taskified` 已正名为 `covered`（语义：被既有任务覆盖 / 撞车并入，待归档）；
+ *   · `dropped` 已从活跃台账下线（「放弃」改由 `idea close --reason` 一次离场归档）。
+ * 老引擎写下的 `taskified` / `dropped` 会按未知状态走降级路径（原文进 `extra`），
+ *   不静默改写、不猜测映射。
+ *
  * 只读：本模块只读文件，不写任何东西（FR-10 / FR-13.8）。
  */
 
@@ -23,47 +29,50 @@ import { createReadStream, statSync } from 'node:fs'
 const IDEAS_FILENAME = 'IDEAS.md'
 const ARCHIVE_FILENAME = 'IDEAS-archive.md'
 
-/** 引擎定义的 5 个状态（不得自造）。 */
-export const IDEA_STATUSES = Object.freeze(['study', 'questioning', 'pending', 'taskified', 'dropped'])
+/**
+ * 引擎定义的 4 个状态（不得自造）。
+ *
+ * `covered` 取代旧词 `taskified`：**只**表示「撞车并入已有任务，待归档」，
+ * **不是**「已注册 / 已立任务」的标记（引擎 `rules/intake.md` ①）。
+ * 旧的 `dropped` 已从活跃台账下线（引擎 `task-intake-exit-verb-close`）。
+ */
+export const IDEA_STATUSES = Object.freeze(['study', 'questioning', 'pending', 'covered'])
 
 /**
- * 「在等谁」由 status 派生，**不是引擎字段**（FR-13.4）。
+ * 派生桶（**不是引擎状态**）：任务定义层有 `source`/`additional_sources` 指向该想法。
+ *
+ * 为什么必须单列：`status` 只表达摄入/裁决态。被非终态任务引用的条目按 E025
+ * **必须保持 `pending`**，所以「已转任务」只能由定义层溯源推出（FR-13.3b）。
+ * 它不能复用 `covered`——`covered` 是「撞车并入已有任务」，两者语义不同。
+ */
+export const IDEA_CONVERTED_STATUS = 'converted'
+
+/** 统计条与行标签使用的展示桶：4 个引擎状态 + 1 个派生桶（顺序按生命周期）。 */
+export const IDEA_DISPLAY_STATUSES = Object.freeze([
+  'study', 'questioning', 'pending', IDEA_CONVERTED_STATUS, 'covered'
+])
+
+/**
+ * 「在等谁」由展示桶派生，**不是引擎字段**（FR-13.4）。
  * 徽章数 = 等用户的那两个状态之和，不是总条目数（FR-13.2）。
+ *
+ * `covered` / `converted` 都已有人接手（并入既有任务 / 已拆出新任务），故为 `none`。
  */
 export const IDEA_OWNER = Object.freeze({
   study: 'user',
   questioning: 'user',
   pending: 'agent',
-  taskified: 'none',
-  dropped: 'none'
+  [IDEA_CONVERTED_STATUS]: 'none',
+  covered: 'none'
 })
 
-/**
- * 活跃层可能出现的状态。
- *
- * ⚠ 为什么不是全部 5 个：`taskified` / `dropped` 的条目已被引擎**移入归档文件**
- * （`IDEAS-archive.md`），而归档按 FR-13.12 不进默认加载路径（参考项目实测 543 KB / 373 条）。
- * 因此这两个筛选在活跃列表上必然恒为 0——把恒 0 的筛选摆出来只会让人以为坏了
- * （用户实测反馈：「已经立任务的条目，为什么没有出现在已转任务中？」）。
- * 它们的数量由归档分类计数回答（见 `scanArchiveFile` 的 `byStatus`，FR-13.7）。
- *
- * 另外注意：**归档件里的 `- status:` 是入档历史值**，引擎明确「不改写 status」
- * （`rules/intake.md`：归档面的语义是「已消费」而非某个状态值）。
- */
-export const IDEA_ACTIVE_STATUSES = Object.freeze(['study', 'questioning', 'pending'])
-
-/** 活跃层里的「终态」：已转任务 / 已丢弃（不再算活跃）。 */
-export const IDEA_TERMINAL_STATUSES = Object.freeze(['taskified', 'dropped'])
-
-/** 归档里值得单独露出来的两个终态（FR-13.7 的分类计数）。 */
-export const IDEA_ARCHIVE_TERMINAL_STATUSES = Object.freeze(['taskified', 'dropped'])
 
 /**
  * 从任务定义层建「想法 id → 任务 id[]」的溯源索引（FR-13.3b / docs/03 E025）。
  *
  * 为什么必须靠定义层：**`status` 不是「是否已立任务」的标记**。引擎 `rules/intake.md` 明确：
  *   · `source: idea:<id>` 的条目在任务非终态期间**必须保持 `pending`**（E025 硬约束）；
- *   · `taskified` **并非「已注册」语义**，只服务「撞车并入已有任务」。
+ *   · `covered` **并非「已注册」语义**，只服务「撞车并入已有任务」。
  * 实测 `phase-workflow-engineering` 在 `IDEAS.md` 里写着 `pending`（这是**正确**的，
  * 它的 3 个任务都未终态），但定义层已有 3 个 `source: idea:phase-workflow-engineering`。
  * 只看 status 的话，这条已经立成任务的想法会被算进「活跃 / 待拆解」（用户实测发现）。
@@ -100,23 +109,27 @@ export function buildIdeaTaskIndex(tasks) {
 }
 
 /**
- * 把「定义层溯源」叠加到条目上，得到**有效状态**：
- * 只要这个想法 id 在任务定义层出现过，就算已转任务（覆盖字面上的 `pending`）。
+ * 把「定义层溯源」叠加到条目上，得到**展示桶**（不改写引擎的 `status`）。
+ *
+ * 只要这个想法 id 在任务定义层出现过，就额外标记 `converted: true` 并把
+ * `displayStatus` 置为派生桶 `converted`；`status` / `rawStatus` 仍是文件里的字面值
+ * （被非终态任务引用的条目按 E025 必须保持 `pending`，这不是滞后）。
  *
  * @param {object[]} entries `mergeIdeasList` 的结果
  * @param {Map<string, string[]>} ideaTaskIndex `buildIdeaTaskIndex` 的结果
  */
-export function applyConvertedStatus(entries, ideaTaskIndex) {
+export function attachConvertedTasks(entries, ideaTaskIndex) {
   return entries.map((entry) => {
     const convertedTasks = typeof entry.id === 'string' ? (ideaTaskIndex.get(entry.id) ?? []) : []
     const converted = convertedTasks.length > 0
+    const displayStatus = converted ? IDEA_CONVERTED_STATUS : entry.status
     return {
       ...entry,
-      rawStatus: entry.status,
+      rawStatus: entry.rawStatus ?? entry.status,
       convertedTasks,
-      // 有效状态：定义层说已经立成任务，就不再算「待拆解」
-      // （status 按引擎语义只表达摄入/裁决态，不表达「已立任务」）
-      status: converted ? 'taskified' : entry.status
+      converted,
+      displayStatus,
+      owner: displayStatus === null ? 'none' : (IDEA_OWNER[displayStatus] ?? 'none')
     }
   })
 }
@@ -278,39 +291,48 @@ function finalizeEntry(raw) {
   }
 }
 
-/** 汇总计数 + 徽章数（FR-13.2）。 */
+/**
+ * 汇总计数 + 徽章数（FR-13.2）。
+ *
+ * `byStatus` 按**展示桶**计数：4 个引擎状态 + 派生桶 `converted`（已转任务）。
+ * 已转任务的条目不会同时计入 `pending`，因此三分区闭合：
+ *   `全部 = 活跃 + 已转任务 + 已覆盖`（未知状态另计，不进分区）
+ *   `活跃 = 论证中 + 待补充 + 待拆解`
+ * `covered` 不计入活跃：它表示「已并入既有任务，待用户 close 归档」。
+ */
 export function summarizeIdeas(entries) {
   const byStatus = {}
-  for (const status of IDEA_STATUSES) byStatus[status] = 0
+  for (const status of IDEA_DISPLAY_STATUSES) byStatus[status] = 0
   let unknown = 0
   for (const entry of entries) {
-    if (entry.status === null) unknown += 1
-    else byStatus[entry.status] += 1
+    const display = entry.displayStatus ?? (entry.converted === true ? IDEA_CONVERTED_STATUS : entry.status)
+    if (display === null || display === undefined || byStatus[display] === undefined) unknown += 1
+    else byStatus[display] += 1
   }
   return {
     byStatus,
     unknown,
     needsUser: byStatus.study + byStatus.questioning,
     total: entries.length,
-    /** 活跃 = 活跃层里**尚未转成任务**的条目（FR-13.6b；已扣除定义层已立任务的） */
-    active: entries.filter((entry) => !IDEA_TERMINAL_STATUSES.includes(entry.status)).length,
+    /** 活跃 = 尚未转成任务、也未被覆盖的条目（FR-13.6b） */
+    active: byStatus.study + byStatus.questioning + byStatus.pending,
     /** 已转任务（活跃层内）—— 由定义层溯源推出，不是归档计数 */
-    converted: entries.filter((entry) => entry.status === 'taskified').length,
-    /** 已丢弃（活跃层内）—— 与 converted 同属「离队」 */
-    dropped: entries.filter((entry) => entry.status === 'dropped').length
+    converted: byStatus[IDEA_CONVERTED_STATUS],
+    /** 已覆盖（活跃层内）—— 撞车并入既有任务，待 close 归档 */
+    covered: byStatus.covered
   }
 }
 
 /**
  * 统计条要渲染的芯片状态集合（FR-13.6）。
  *
- * 固定为**全部 5 个想法状态**（0 值可点，FR-5.9），因为统计条必须能完整表达三分区：
- *   `全部 = 活跃 + 已转任务 + 已丢弃`，其中 `活跃 = 论证中 + 待补充 + 待拆解`。
+ * 固定为**全部展示桶**（0 值可点，FR-5.9），因为统计条必须能完整表达三分区：
+ *   `全部 = 活跃 + 已转任务 + 已覆盖`，其中 `活跃 = 论证中 + 待补充 + 待拆解`。
  * 早先试过「只显示实际出现过的状态」以避免恒 0 芯片，但那会让分区在界面上不闭合
- * （例如 已丢弃 缺失时看不出 0 是「没有」还是「没显示」）——用户要求分区自洽，故固定。
+ * （例如 已覆盖 缺失时看不出 0 是「没有」还是「没显示」）——用户要求分区自洽，故固定。
  */
 export function ideaStripStatuses() {
-  return [...IDEA_STATUSES]
+  return [...IDEA_DISPLAY_STATUSES]
 }
 
 /**
@@ -338,7 +360,7 @@ export function scanArchiveFile(filePath, onError) {
     const ids = []
     /** @type {Record<string, number>} */
     const byStatus = {}
-    /** @type {Record<string, string>} 小节 id → 该小节字面 status（判定「已丢弃」要用） */
+    /** @type {Record<string, string>} 小节 id → 该小节字面 status（判定「历史已放弃」要用） */
     const statusById = {}
     /** 当前小节的 id / 首个 status（小节只有第一个 `- id:` / `- status:` 算数） */
     let sectionId = null
@@ -428,34 +450,37 @@ export function scanArchiveFile(filePath, onError) {
  * `pending`——按字面分组会把它们全算成「没立任务」，而其中 287 条在任务池里有引用。
  *
  * 分组（互斥，合计 = `count`）：
- *   已转任务   任务池（`source` ∪ `additional_sources`）引用了该 id
- *   已丢弃     未被引用，且字面 status = dropped
- *   未立任务   未被引用，也不是 dropped（人工裁决「已消费」离场）
- *   无法对照   小节缺 `- id:`，无从判断（实测存量 20 条）
+ *   已转任务   converted       任务池（`source` ∪ `additional_sources`）引用了该 id
+ *   历史已放弃 legacyDropped   未被引用，且字面 status = dropped（**旧词表遗留数据**）
+ *   未立任务   untasked        未被引用（人工 `idea close` 裁决离场，含 covered/pending/study）
+ *   无法对照   noId            小节缺 `- id:`，无从判断（实测存量 20 条）
+ *
+ * ⚠ `dropped` 已从引擎词表下线，分组里的 `legacyDropped` 只统计**入档历史值**，
+ * 不代表当前状态机还有这个状态。
  *
  * @param {{count: number, ids: string[], noIdCount: number, statusById?: Record<string, string>}} scan `scanArchiveFile` 的结果
  * @param {Map<string, string[]>} ideaTaskIndex `buildIdeaTaskIndex` 的结果
  * @param {Record<string, string>} [statusByIdOverride] 覆盖 scan 里的 id → 字面 status（测试用）
  */
 export function classifyArchive(scan, ideaTaskIndex, statusByIdOverride) {
-  // 「已丢弃」要按**归档件自己的**字面 status 判（不能拿 IDEAS.md 的状态表来查，那是活跃层文件）
+  // 「历史已放弃」要按**归档件自己的**字面 status 判（不能拿 IDEAS.md 的状态表来查，那是活跃层文件）
   const statusById = statusByIdOverride ?? scan.statusById ?? {}
-  let taskified = 0
-  let dropped = 0
+  let converted = 0
+  let legacyDropped = 0
   let untasked = 0
   for (const id of scan.ids ?? []) {
     if (ideaTaskIndex instanceof Map && ideaTaskIndex.has(id)) {
-      taskified += 1
+      converted += 1
       continue
     }
-    if (statusById[id] === 'dropped') dropped += 1
+    if (statusById[id] === 'dropped') legacyDropped += 1
     else untasked += 1
   }
   const noId = Math.max(0, scan.count - (scan.ids?.length ?? 0))
   return {
     total: scan.count,
-    taskified,
-    dropped,
+    converted,
+    legacyDropped,
     untasked,
     noId: Math.max(noId, scan.noIdCount ?? 0)
   }