dsh-plugin-orchd 0.1.0 → 0.1.2

package/lib/master.js

@@ -36,15 +36,17 @@ export function launcherOf(root) {
   return join(orchdDirOf(root), LAUNCHER_FILENAME)
 }
 
-/**
- * 安装痕迹判定（T6 的定稿）：项目根下存在 「.orchd」 目录即算「有痕迹」。
- * 不把 junction/符号链接排除在外——参考项目的 「.orchd」 正是指向真实目录的 junction。
- * @param {string} root
- * @returns {boolean}
- */
-export function hasInstallationTrace(root) {
-  return isDirectory(orchdDirOf(root))
-}
+// ── 安装痕迹不再是独立的判定步骤 ────────────────────────────────────────────
+//
+// 历史坑（根因治理前）：这里曾导出 `hasInstallationTrace(root)`（= 「根下有没有 `.orchd`」）
+// 作为 `detect` 的第 ① 步，而 `resolveLayout` 又自带一套容器主工作树自动探测。两条路径对
+// 「痕迹在哪」的口径不一致 → 每出现一种新布局形态就得在其中一条上补特例、另一条漏掉
+// （junction / 根空 `.orchd` / 根**无** `.orchd` / 子目录标记），于是来回打补丁：
+// 「3DViewer 空 `.orchd`」修过一次，「容器根连 `.orchd` 都没有」又漏一次。
+//
+// 现在把「是否接入 + 主工作树/定义文件在哪」**收敛为唯一真源**：`resolveLayout`。
+// 它返回的 `no-installation` 就是「根与子工作树都没有安装痕迹」这唯一一种结论，
+// `detect` 只消费它，不再有任何独立的痕迹判定。
 
 /**
  * 自动探测「容器布局的主工作树」（FR-2.2 补充，用户实测驱动）。
@@ -127,7 +129,17 @@ function findContainerWorktree(root) {
 }
 
 /**
- * 解析布局并推导三套路径。
+ * 布局发现 —— 「是否接入 orchd」与「主工作树/定义文件在哪」的**唯一真源**。
+ *
+ * 所有布局形态（junction / 根空 `.orchd` / 根**无** `.orchd` / 子目录标记 / 标记与实际工作树
+ * 不一致）都在**这一个函数**里收敛；`detect` 只消费它的结论，不再另判安装痕迹（历史坑见上方注释）。
+ *
+ * 三种结论：
+ *   · resolved         → `ok:true`，带 kind / mainWorktree / masterPath / storeHint
+ *   · broken           → `ok:false`，reason ∈ { layout-marker-mismatch, layout-unresolved }
+ *   · no-installation  → `ok:false`，reason = no-installation  ← detect 据此判 not_installed
+ *
+ * 三套路径：
  *
  * 「」「
  * container → mainWorktree = json.main_worktree
@@ -137,19 +149,28 @@ function findContainerWorktree(root) {
  *           → mainWorktree = root
  *             masterPath   = <root>/.orchd/_master.json
  *             storeHint    = <root>/.orchd
- * 探针兜底：masterPath 不存在则试另一分支候选；都失败 → layout-unresolved
+ * 探针兜底：主候选 masterPath 不存在则试另一分支候选
+*
+* 探针兜底后，扫一层非隐藏子目录找容器主工作树（见 findContainerWorktree）：
+*   找到（自述 container / 有 _master.json / 有 __main__.py）→ container
+*   找不到时再看根自己有没有 `.orchd`：
+*     有（哪怕空目录）→ flat（是否 uninitialized 交给 detect 的定义层判定）
+*     没有           → no-installation（根与子工作树都没有痕迹）
+* container 标记下两边 master 都不在 → layout-unresolved
  * 「」「
  *
  * @param {string} root 项目根（可能是容器根）
- * @param {{ probeFallback?: boolean }} [options] probeFallback=false 时跳过探针兜底（纯逻辑测试用）
- * @returns {{ ok: true, kind: 'container'|'flat', mainWorktree: string, masterPath: string, storeHint: string,
- *            markerPath: string, markerRead: boolean, markerError?: string, note?: string }
- *          | { ok: false, reason: 'layout-unresolved', detail: object }}
+* @param {{ probeFallback?: boolean }} [options] probeFallback=false 时跳过探针兜底与自动探测（纯逻辑测试用）
+* @returns {{ ok: true, kind: 'container'|'flat', mainWorktree: string, masterPath: string, storeHint: string,
+*            containerRoot: string|null, markerPath: string, markerRead: boolean, markerError?: string, note?: string }
+*          | { ok: false, reason: 'layout-marker-mismatch'|'layout-unresolved'|'no-installation', detail: object }}
  */
 export function resolveLayout(root, options = {}) {
   const probeFallback = options.probeFallback !== false
   const rootCanonical = canonicalPath(root)
   const markerPath = layoutFileOf(rootCanonical)
+  // 「根自己有没有 .orchd」是区分 flat 与 no-installation 的唯一依据（即原 hasInstallationTrace 的语义）。
+  const rootHasOrchd = isDirectory(orchdDirOf(rootCanonical))
 
   let marker
   let markerRead = false
@@ -167,6 +188,10 @@ export function resolveLayout(root, options = {}) {
       ok: true,
       kind,
       mainWorktree: worktree,
+      // 容器根 = 主工作树的父目录（仅 container 布局有意义，flat 下为 null）。
+      // 用途：引擎可能装在容器根的 `.orchd/`（主工作树只有定义层），启动器定位要能回退过去
+      // —— 见 `orchd-cli.js::resolveLauncherPath`。
+      containerRoot: kind === 'container' ? dirname(worktree) : null,
       masterPath: join(orchdDir, MASTER_FILENAME),
       storeHint: kind === 'container' ? join(dirname(worktree), '.orchd-runtime') : orchdDir,
       markerPath,
@@ -223,9 +248,9 @@ export function resolveLayout(root, options = {}) {
     }
   }
 
-  // ⚠ 根上**没有容器标记**（`alternate === null`）且根也没有定义文件时：
-  //   再扫一层子目录找容器主工作树——这正是「容器根的 .orchd/ 是空的、标记只在 main/ 下」
-  //   那种项目（用户实测识别不出来）。根上有标记时以标记为准，不在这里改判。
+  // ⚠ 根上**没有容器标记**（`alternate === null`）时：先扫一层子目录找容器主工作树
+  //   （「容器根的标记只在 main/ 下」这种项目——不论根自己有没有 `.orchd` 都要找）。
+  //   找不到时再看根自己有没有 `.orchd`，决定是 flat 还是「未接入」。
   if (alternate === null) {
     const auto = findContainerWorktree(rootCanonical)
     if (auto !== null) {
@@ -235,23 +260,36 @@ export function resolveLayout(root, options = {}) {
         markerRead: auto.markerRead
       }
     }
-  }
 
-  if (alternate !== null) {
+    // 探测不到主工作树：根有 `.orchd`（哪怕空目录）→ flat（装了没初始化，交给 detect 判）；
+    // 根连 `.orchd` 都没有 → 根与子工作树都没有痕迹 → 未接入。
+    if (rootHasOrchd) return primary
+
     return {
       ok: false,
-      reason: 'layout-unresolved',
+      reason: 'no-installation',
       detail: {
         root: rootCanonical,
         markerPath,
         markerRead,
         ...(markerError === undefined ? {} : { markerError }),
-        triedMasterPaths: [primary.masterPath, alternate.masterPath]
+        hint: 'no .orchd directory at the project root and no container main worktree found under it'
       }
     }
   }
 
-  return primary
+  // container 标记在，但两边候选都没有主工作树的定义文件 → 布局无法收敛
+  return {
+    ok: false,
+    reason: 'layout-unresolved',
+    detail: {
+      root: rootCanonical,
+      markerPath,
+      markerRead,
+      ...(markerError === undefined ? {} : { markerError }),
+      triedMasterPaths: [primary.masterPath, alternate.masterPath]
+    }
+  }
 }
 
 /**

package/lib/model.js

@@ -78,6 +78,8 @@ export function buildTaskRow(definition, state, extra = {}, weights = null) {
   // 状态层用 `task_id`（`status --all` 的 tasks[]），`pool --all` 用 `id`；两个都认。
   const stateId = state !== null && typeof state === 'object' ? (state.task_id ?? state.id) : undefined
   const id = definitionRow.id ?? (typeof stateId === 'string' ? stateId : undefined) ?? null
+  const times = extra.times ?? null
+  const timeOf = (map) => (typeof id === 'string' && typeof map?.[id] === 'string' ? map[id] : null)
 
   return {
     id,
@@ -99,6 +101,14 @@ export function buildTaskRow(definition, state, extra = {}, weights = null) {
     reviewPhase: stateRow.reviewPhase,
     reviewClaimedBy: stateRow.reviewClaimedBy,
     blockedDownstream: Number.isInteger(extra.blockedDownstream) ? extra.blockedDownstream : null,
+    /**
+     * 「最近动作时间」的 git 近似（FR-5.4 修订）：活跃任务取 `task/<id>` 分支的 tip 时间。
+     * 引擎不提供任何时间字段，来源与口径见 `git-times.js`；取不到就是 null（排序兜底，
+     * **不臆造时间**，UI 若显示则必须走占位符）。
+     */
+    lastActionAt: timeOf(times?.branchTimes ?? null),
+    /** 「合并进主分支时间」的 git 近似：终态任务取 `Merge branch 'task/<id>'` 提交时间。 */
+    mergedAt: timeOf(times?.mergeTimes ?? null),
     inDefinition: definition !== undefined && definition !== null,
     inState: state !== undefined && state !== null
   }
@@ -155,7 +165,7 @@ export function buildTaskDetail(definition, state, index, extra = {}) {
  * @param {object} args.index 定义层索引
  * @param {string} [args.masterPath]
  */
-export function buildBoard({ statusJson, poolJson, index, masterPath }) {
+export function buildBoard({ statusJson, poolJson, index, masterPath, gitTimes }) {
   const stateRows = new Map()
   for (const task of Array.isArray(statusJson?.tasks) ? statusJson.tasks : []) {
     if (task !== null && typeof task === 'object' && typeof task.task_id === 'string') stateRows.set(task.task_id, task)
@@ -175,7 +185,7 @@ export function buildBoard({ statusJson, poolJson, index, masterPath }) {
   for (const id of ids) {
     const definition = index?.tasks?.get(id)
     const state = stateRows.get(id)
-    rows.push(buildTaskRow(definition, state, { blockedDownstream: blockedByTask.get(id) }, weights))
+    rows.push(buildTaskRow(definition, state, { blockedDownstream: blockedByTask.get(id), times: gitTimes }, weights))
   }
 
   sortRows(rows, 'default', weights)
@@ -196,7 +206,14 @@ export function buildBoard({ statusJson, poolJson, index, masterPath }) {
       hasDag: (index?.tasks?.size ?? 0) > 0,
       hasBlockedCount: blockedByTask.size > 0,
       hasDefinitionLayer: (index?.tasks?.size ?? 0) > 0,
-      hasStateLayer: stateRows.size > 0
+      hasStateLayer: stateRows.size > 0,
+      /** 排序用的 git 时间层（FR-5.4 修订）：活跃=分支 tip 时间、终态=合并提交时间。 */
+      hasActionTimes: Object.keys(gitTimes?.branchTimes ?? {}).length > 0,
+      hasMergeTimes: Object.keys(gitTimes?.mergeTimes ?? {}).length > 0,
+      /** git 时间层不可用时的原因（非 git 项目 / git 缺失 / 超时）；可用时为 null。 */
+      gitTimesReason: gitTimes !== undefined && gitTimes !== null && gitTimes.available === false
+        ? (gitTimes.reason ?? 'unavailable')
+        : null
     },
     /** 两层不一致时显式报告（不静默丢数据）。 */
     orphans: { onlyInState, onlyInDefinition }
@@ -226,16 +243,45 @@ export function summarize(engineSummary, rows) {
 }
 
 /**
- * 排序。默认按「活跃优先，其次重要度」（FR-5.4）。
+ * 排序。默认档 = 「活跃优先 → 组内按时间」（FR-5.4 修订，2026-10-29）：
+ *   · 组：活跃（claimed / done / in_review）→ 待办（pending）→ 终态（completed / cancelled）；
+ *   · 活跃组内按 `lastActionAt` 由近到远（git 近似：`task/<id>` 分支 tip 时间）；
+ *   · 终态组内按 `mergedAt` 由近到远（git 近似：合并进主分支的提交时间）；
+ *   · 取不到时间的（未 claim 的 pending、cancelled、非 git 项目）留在本组最后，退回
+ *     「重要度 → id」——**不臆造时间**。
+ * 其它档位（importance / difficulty / module / status）行为不变。
+ *
  * @param {object[]} rows 原地排序
  * @param {'default'|'importance'|'difficulty'|'module'|'status'} by
+ * @param {object|null} weights 引擎的重要度权重
  */
 export function sortRows(rows, by = 'default', weights = null) {
   const statusRank = (status) => (ACTIVE_STATUSES.has(status) ? 0 : TERMINAL_STATUSES.has(status) ? 2 : 1)
+  // 时间戳只算一次（比较器会被调用 O(n log n) 次）；非法值一律折叠成 null
+  const timeCache = new Map()
+  const timeValue = (row) => {
+    if (timeCache.has(row)) return timeCache.get(row)
+    const raw = TERMINAL_STATUSES.has(row.status) ? row.mergedAt : row.lastActionAt
+    const parsed = typeof raw === 'string' && raw !== '' ? Date.parse(raw) : Number.NaN
+    const value = Number.isFinite(parsed) ? parsed : null
+    timeCache.set(row, value)
+    return value
+  }
+  const byTime = (a, b) => {
+    const ta = timeValue(a)
+    const tb = timeValue(b)
+    if (ta === null && tb === null) return 0
+    if (ta === null) return 1
+    if (tb === null) return -1
+    return tb - ta
+  }
+  const byImportance = (a, b) =>
+    importanceRank(b.importance ?? b.importanceDerived, weights) - importanceRank(a.importance ?? a.importanceDerived, weights)
   const comparators = {
     default: (a, b) =>
       statusRank(a.status) - statusRank(b.status) ||
-      importanceRank(b.importance ?? b.importanceDerived, weights) - importanceRank(a.importance ?? a.importanceDerived, weights) ||
+      byTime(a, b) ||
+      byImportance(a, b) ||
       (a.id ?? '').localeCompare(b.id ?? ''),
     importance: (a, b) => importanceRank(b.importance ?? b.importanceDerived, weights) - importanceRank(a.importance ?? a.importanceDerived, weights) || (a.id ?? '').localeCompare(b.id ?? ''),
     difficulty: (a, b) => difficultyRank(b.difficulty) - difficultyRank(a.difficulty) || (a.id ?? '').localeCompare(b.id ?? ''),

package/lib/orchd-cli.js

@@ -14,6 +14,7 @@
 
 import { spawn } from 'node:child_process'
 import { launcherOf } from './master.js'
+import { isFile, keyOf } from './paths.js'
 
 /** 子进程环境：逐项登记（docs/03 第 6.3 节）。 */
 export const CHILD_ENV = Object.freeze({
@@ -118,6 +119,55 @@ function parseJson(text) {
   }
 }
 
+/**
+ * 启动器定位：按「同一工作树 → 会话根 → 布局声明的容器根」的顺序取第一个**真实存在**的
+ * `.orchd/__main__.py`。
+ *
+ * 背景（用户实测，WallDetect 形态）：引擎的安装落点与主工作树**可以分离**——有的项目在
+ * 容器根跑安装器，引擎落在 `<容器根>/.orchd/`（含 `orchd/` 包与入口），而主工作树
+ * `<容器根>/main/.orchd/` 只有定义层（`_master.json` / `.layout.json` / `shared/` /
+ * `snapshots/`），**没有**引擎入口。此时按「启动器取主工作树」的旧逻辑会
+ * `can't open file ... __main__.py`（exit 2）→ 四态检测恒为 `broken/cli-failed`
+ * （面板显示「状态异常」，所有读命令连带失败）。
+ *
+ * 实测：`cwd = 主工作树` + `启动器 = 容器根 .orchd/__main__.py` → `exit=0`（正常返回 JSON）。
+ * 原因是启动器用 `Path(__file__).resolve()` 定位引擎包，**不依赖 cwd**；而 E036 约束只针对
+ * cwd，与启动器在哪一侧无关。所以 cwd 仍然必须是主工作树（见 `runOrchdCli` 头注释）。
+ *
+ * 三个候选的顺序与去重（按启动器路径去重，Windows 大小写不敏感）：
+ *   ① `cwd`（主工作树）—— 正常形态，也是历史行为；
+ *   ② `root`（会话根）—— 会话根就是容器根时命中；
+ *   ③ `containerRoot`（由 `resolveLayout` 给出，= 主工作树的父目录）—— 会话根是主工作树时命中。
+ *
+ * 三个都不存在时返回 ①：让解释器自己报错，stderr 里那条路径正好用于诊断。
+ *
+ * @param {string} cwd 工作目录（主工作树；flat 布局下等于项目根）
+ * @param {string} root 会话根（容器根或 flat 根或主工作树）
+ * @param {string|null} [containerRoot] 布局声明的容器根（flat 布局下为 null）
+ * @returns {{ path: string, source: 'worktree'|'container-root-fallback' }}
+ */
+export function resolveLauncherPath(cwd, root, containerRoot) {
+  const seen = new Set()
+  const candidates = []
+  const add = (dir, source) => {
+    if (typeof dir !== 'string' || dir === '') return
+    const path = launcherOf(dir)
+    const key = keyOf(path)
+    if (seen.has(key)) return
+    seen.add(key)
+    candidates.push({ path, source })
+  }
+
+  add(cwd, 'worktree')
+  add(root, 'container-root-fallback')
+  add(containerRoot ?? null, 'container-root-fallback')
+
+  for (const candidate of candidates) {
+    if (isFile(candidate.path)) return candidate
+  }
+  return candidates[0]
+}
+
 /**
  * 调用项目自带的引擎（唯一入口）。
  *
@@ -128,12 +178,14 @@ function parseJson(text) {
  * 所以 `workDir` 由调用方从 `layout.mainWorktree` 传进来；布局解析不出来时它等于项目根，
  * 这正好就是 flat 布局的情形，行为与 P0 一致。
  *
- * 启动器取同一个目录下的 `.orchd/__main__.py`。实测「主工作树 cwd + 容器根启动器（junction）」
- * 也能跑通，但那是靠 junction 的等价性，所以不采用。
+ * 启动器优先取**同一个工作树**下的 `.orchd/__main__.py`；该文件不存在时回退到项目根
+ * （容器根）的 `.orchd/__main__.py`——见 `resolveLauncherPath`：引擎的安装落点与主工作树
+ * 可以分离（用户实测的项目正是这种形态），该组合实测 `exit=0`。
  *
  * @param {object} args
  * @param {string} args.root 项目根（容器根或 flat 根）——仅用于诊断信息
  * @param {string} [args.workDir] 引擎工作目录（**必须是主工作树**）
+ * @param {string|null} [args.containerRoot] 布局声明的容器根（`resolveLayout` 给出；启动器回退候选之一）
  * @param {{path: string, args: string[]}} args.python 已探测到的解释器
  * @param {string[]} args.argv 例如 `['status', '--all']`
  * @param {number} [args.timeoutMs]
@@ -141,7 +193,7 @@ function parseJson(text) {
  * @param {Function} [args.spawnImpl] 仅测试用：替换 `child_process.spawn`
  * @returns {Promise<object>} 见下方各 return 分支
  */
-export async function runOrchdCli({ root, workDir, python, argv, timeoutMs = 20_000, signal, spawnImpl = spawn }) {
+export async function runOrchdCli({ root, workDir, containerRoot, python, argv, timeoutMs = 20_000, signal, spawnImpl = spawn }) {
   const allowed = checkWhitelist(argv)
   if (allowed.ok !== true) {
     return {
@@ -159,7 +211,8 @@ export async function runOrchdCli({ root, workDir, python, argv, timeoutMs = 20_
   }
 
   const cwd = typeof workDir === 'string' && workDir !== '' ? workDir : root
-  const launcher = launcherOf(cwd)
+  const chosenLauncher = resolveLauncherPath(cwd, root, containerRoot ?? null)
+  const launcher = chosenLauncher.path
   const command = python.path
   const commandArgs = [...(python.args ?? []), launcher, ...argv]
 
@@ -169,7 +222,8 @@ export async function runOrchdCli({ root, workDir, python, argv, timeoutMs = 20_
     const finish = (value) => {
       if (settled) return
       settled = true
-      resolve({ ...value, elapsedMs: Date.now() - startedAt, argv })
+      // launcher / launcherSource 一并带出：回退发生时诊断区能直接看出用的是哪一份入口
+      resolve({ ...value, elapsedMs: Date.now() - startedAt, argv, launcher, launcherSource: chosenLauncher.source })
     }
 
     let child

package/lib/routes.js

@@ -21,9 +21,10 @@ import { detect, summarizeLayout } from './detect.js'
 import { cachedDefinition } from './cache.js'
 import { readMasterIndexed } from './master.js'
 import { buildBoard, buildGraph, buildReviewTimeline, buildTaskDetail } from './model.js'
+import { collectGitTimes } from './git-times.js'
 import { isTaskId, isUnsupportedCommand } from './cli-invoke.js'
 import { INSTALL_COMMAND, buildInstallPrompt, injectInstallPrompt, probeInjectSupport } from './install-entry.js'
-import { IDEA_OWNER, IDEA_STATUSES, applyConvertedStatus, buildIdeaTaskIndex, classifyArchive, ideaStripStatuses, ideasArchiveOf, ideasFileOf, parseIdeasMarkdown, scanArchiveFile, summarizeIdeas } from './ideas.js'
+import { IDEA_OWNER, IDEA_STATUSES, attachConvertedTasks, buildIdeaTaskIndex, classifyArchive, ideaStripStatuses, ideasArchiveOf, ideasFileOf, parseIdeasMarkdown, scanArchiveFile, summarizeIdeas } from './ideas.js'
 import { ORCHD_OFFICIAL_REPO, ORCHD_MIRROR_REPO, resolveRepo } from './config.js'
 import { keyOf } from './paths.js'
 
@@ -138,11 +139,26 @@ async function loadDefinition(deps, detected) {
   return read?.ok === true ? read.index : undefined
 }
 
+/**
+ * 引擎调用上下文：**每个调用点都走这里**，保证两个位置信息都带上——
+ *   · `workDir` = 主工作树（E036 约束：container 布局下引擎拒绝以容器根为 cwd）；
+ *   · `containerRoot` = 布局声明的容器根（引擎装在容器根、主工作树只有定义层时，
+ *     启动器要从那里回退取，见 `orchd-cli.js::resolveLauncherPath`）。
+ */
+function cliTarget(detected) {
+  return {
+    root: detected.root,
+    workDir: detected.layout?.mainWorktree,
+    containerRoot: detected.layout?.containerRoot ?? null,
+    python: detected.python
+  }
+}
+
 /** 状态层 `status --all`（5 s TTL；失败不污染缓存由 cache 保证）。 */
 async function loadStatusLayer(deps, detected, refresh) {
   const root = detected.root
   return deps.caches.status.get(keyOf(root), refresh, () =>
-    deps.cli.statusAll({ root, workDir: detected.layout?.mainWorktree, python: detected.python })
+    deps.cli.statusAll(cliTarget(detected))
   )
 }
 
@@ -150,10 +166,24 @@ async function loadStatusLayer(deps, detected, refresh) {
 async function loadPoolLayer(deps, detected, refresh) {
   const root = detected.root
   return deps.caches.pool.get(keyOf(root), refresh, () =>
-    deps.cli.poolAll({ root, workDir: detected.layout?.mainWorktree, python: detected.python })
+    deps.cli.poolAll(cliTarget(detected))
   )
 }
 
+/**
+ * git 时间层（FR-5.4 修订）：默认排序要的「最近动作时间 / 合并时间」。
+ *
+ * 为什么走 git 而不是引擎：`status --all` 不返回任何时间字段，唯一带时间戳的账本
+ * 插件不直读（A2）。口径与只读纪律见 `git-times.js` 头注释。
+ * 失败/非 git 项目返回 `available:false`（带原因），排序退回「重要度」——不臆造、不挂面板。
+ */
+async function loadGitTimes(deps, detected, refresh) {
+  // 采集器可注入（测试用假实现，避免测试去真跑 git）
+  const collect = deps.collectGitTimes ?? collectGitTimes
+  const worktree = detected.layout?.mainWorktree ?? detected.root
+  return deps.caches.gitTimes.get(keyOf(worktree), refresh, () => collect({ worktree }))
+}
+
 /** GET /orchd/api/context */
 async function handleContext(deps, req, res, url) {
   const startedAt = Date.now()
@@ -280,17 +310,20 @@ async function handleBoard(deps, req, res, url) {
     }
 
     const pool = await loadPoolLayer(deps, detected, refresh)
+    const gitTimes = await loadGitTimes(deps, detected, refresh)
 
     const board = buildBoard({
       statusJson: status.json,
       poolJson: pool?.ok === true ? pool.json : undefined,
       index,
-      masterPath: detected.layout?.masterPath
+      masterPath: detected.layout?.masterPath,
+      gitTimes
     })
     board.layers = {
       definition: index === undefined ? 'missing' : 'ok',
       state: 'ok',
-      pool: pool?.ok === true ? 'ok' : (pool?.reason ?? 'not-loaded')
+      pool: pool?.ok === true ? 'ok' : (pool?.reason ?? 'not-loaded'),
+      gitTimes: gitTimes?.available === true ? 'ok' : (gitTimes?.reason ?? 'not-loaded')
     }
     sendJson(res, 200, envelope({ ok: true, startedAt, data: board }))
   } catch (error) {
@@ -333,7 +366,7 @@ async function handleTask(deps, req, res, url) {
     const definition = index?.tasks?.get(taskId)
 
     const detail = await deps.caches.detail.get(`${keyOf(detected.root)}|${taskId}`, refresh, async () =>
-      deps.cli.statusOne({ root: detected.root, workDir: detected.layout?.mainWorktree, python: detected.python }, taskId)
+      deps.cli.statusOne(cliTarget(detected), taskId)
     )
 
     // 单任务失败**不得**让整个面板进入 broken（docs/02 第 12 节末）：这里返回 ok:false，
@@ -364,7 +397,7 @@ async function handleTask(deps, req, res, url) {
     let reviewHistory
     if (url.searchParams.get('review') === '1') {
       const review = await deps.caches.review.get(`${keyOf(detected.root)}|${taskId}`, refresh, () =>
-        deps.cli.reviewShow({ root: detected.root, workDir: detected.layout?.mainWorktree, python: detected.python }, taskId)
+        deps.cli.reviewShow(cliTarget(detected), taskId)
       )
       reviewHistory = review?.ok === true ? review.json : { unavailable: true, reason: review?.reason ?? 'not-loaded' }
     }
@@ -427,7 +460,7 @@ async function handleHistory(deps, req, res, url) {
       return
     }
 
-    const target = { root: detected.root, workDir: detected.layout?.mainWorktree, python: detected.python }
+    const target = cliTarget(detected)
     const review = await deps.caches.review.get(`${keyOf(detected.root)}|${taskId}`, refresh, () =>
       deps.cli.reviewShow(target, taskId)
     )
@@ -529,16 +562,19 @@ async function handleGraph(deps, req, res, url) {
     }
 
     const pool = await loadPoolLayer(deps, detected, refresh)
+    const gitTimes = await loadGitTimes(deps, detected, refresh)
     const board = buildBoard({
       statusJson: status.json,
       poolJson: pool?.ok === true ? pool.json : undefined,
       index,
-      masterPath: detected.layout?.masterPath
+      masterPath: detected.layout?.masterPath,
+      gitTimes
     })
     board.layers = {
       definition: index === undefined ? 'missing' : 'ok',
       state: 'ok',
-      pool: pool?.ok === true ? 'ok' : (pool?.reason ?? 'not-loaded')
+      pool: pool?.ok === true ? 'ok' : (pool?.reason ?? 'not-loaded'),
+      gitTimes: gitTimes?.available === true ? 'ok' : (gitTimes?.reason ?? 'not-loaded')
     }
 
     if (focus !== null && !board.tasks.some((row) => row.id === focus)) {
@@ -603,7 +639,7 @@ async function handleIdeas(deps, req, res, url) {
 
     // 清单：引擎只给 title / id / status
     const list = await deps.caches.ideas.get(keyOf(detected.root), refresh, () =>
-      deps.cli.ideasList({ root: detected.root, workDir: detected.layout?.mainWorktree, python: detected.python })
+      deps.cli.ideasList(cliTarget(detected))
     )
     // 引擎**没有 `ideas` 子命令**（旧版本，实测 v1.5.0：argparse `invalid choice: 'ideas'`，
     // exit=2，E007）⇒ 这不是项目坏了，而是**能力缺失**：优雅降级成「只读 IDEAS.md + 归档」，
@@ -640,20 +676,20 @@ async function handleIdeas(deps, req, res, url) {
 
     const parsed = parseIdeasMarkdown(files.markdown.text ?? '')
     // ⚠ `status` 不是「是否已立任务」的标记（引擎 rules/intake.md：在途条目按 E025
-    // 必须保持 pending，`taskified` 只服务撞车并入）。所以用定义层做「已转任务」判定，
-    // 覆盖字面上的 pending（FR-13.3b / docs/03 E025 溯源）。
+    // 必须保持 pending，`covered` 只服务撞车并入）。所以用定义层做「已转任务」判定，
+    // 但**不改写 status**——派生桶单独放在 `displayStatus`（FR-13.3b / docs/03 E025 溯源）。
     const definition = await loadDefinition(deps, detected)
     // 引用判据 = `source` ∪ `additional_sources`（引擎 rules ④ 同判据）
     const ideaTaskIndex = buildIdeaTaskIndex(definition?.tasks)
     // 引擎不支持 `ideas` 时没有清单可合并，只读 Markdown（`mergeIdeasList(null, …)` 就是这条路，
     // 条目会带上「仅存在于 IDEAS.md」的标记，界面本来就会这么显示）
     const engineList = ideasUnsupported ? null : list.json
-    const entries = applyConvertedStatus(mergeIdeasList(engineList, parsed.entries), ideaTaskIndex)
+    const entries = attachConvertedTasks(mergeIdeasList(engineList, parsed.entries), ideaTaskIndex)
     const summary = summarizeIdeas(entries)
     // 归档分组：**与任务池对照**（用户口径 / FR-13.7）。
     // 不按归档件里的字面 status 分组——引擎明确归档不改写 status（语义是「已消费」），
     // 实测 312/373 条仍写着 pending，其中 287 条在任务池里有引用。
-    // 「已丢弃」用扫描时收下的归档件自身 status（`statusById`），不能用 IDEAS.md 的状态表。
+    // 「历史已放弃」用扫描时收下的归档件自身 status（`statusById`），不能用 IDEAS.md 的状态表。
     const archived = classifyArchive(files.archive, ideaTaskIndex)
     // ⚠ 两个集合必须各自取「本层」的 id：曾误用合并后的 entries 当作引擎清单，
     // 导致只存在于 Markdown 的条目也被算成「引擎也有」，mismatches 恒为空。
@@ -679,25 +715,26 @@ async function handleIdeas(deps, req, res, url) {
         unsupportedHint: ideasUnsupported ? 'engine-ideas-command-missing' : null,
         /**
          * 活跃层的**三分区**（用户口径）：
-         *   `total = active + converted + dropped`
-         * 其中 `active = 论证中 + 待补充 + 待拆解`，converted/dropped 都算离队。
+         *   `total = active + converted + covered`
+         * 其中 `active = 论证中 + 待补充 + 待拆解`；
+         * `converted`（定义层有任务引用）与 `covered`（撞车并入既有任务）都不计入活跃。
          */
         active: summary.active,
         /** 活跃层内已转任务的条数（由任务池引用推出，不是归档计数） */
         converted: summary.converted,
-        /** 活跃层内已丢弃（离队） */
-        dropped: summary.dropped,
+        /** 活跃层内已覆盖（撞车并入既有任务，待 close 归档） */
+        covered: summary.covered,
         archivedCount: files.archive.count,
         /**
          * 归档分组（FR-13.7）：**与任务池对照**判定「已转任务」，不按归档件里的字面 status。
-         *   taskified  任务池（source ∪ additional_sources）引用了该 id
-         *   dropped    未被引用且字面 status = dropped
-         *   untasked   未被引用（人工裁决「已消费」离场）
-         *   noId       小节缺 `- id:`，无从对照（存量数据问题，显式计数不静默丢）
+         *   converted      任务池（source ∪ additional_sources）引用了该 id
+         *   legacyDropped  未被引用且字面 status = dropped（旧词表遗留历史值）
+         *   untasked       未被引用（人工裁决离场，含 close 归档的 covered/pending/study）
+         *   noId           小节缺 `- id:`，无从对照（存量数据问题，显式计数不静默丢）
          * `byLiteralStatus` 仅作诊断：引擎明确归档不改写 status，不是分组依据。
          */
         archived: { ...archived, byLiteralStatus: files.archive.byStatus ?? {} },
-        // 统计条要渲染的芯片状态集合：固定 5 个想法状态，保证三分区在界面上闭合（FR-13.6）
+        // 统计条要渲染的芯片集合：4 个引擎状态 + 派生桶 converted，保证三分区在界面上闭合（FR-13.6）
         activeStatuses: ideaStripStatuses(),
         layers: {
           list: ideasUnsupported ? 'unsupported' : 'ok',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-orchd",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Read-only orchd panel for the DSH right sidebar: task board, dependency graph, ideas and review timeline for the project of the current session. · 把 orchd 项目状态带进 DSH 右侧栏的只读面板。",
   "license": "MIT",
   "repository": {