sillyspec 3.28.3 → 3.28.4

package/src/doctor-diagnostics.js

@@ -16,6 +16,8 @@
  *   - 不删除/移动任何文件；orphan db 仅报告，处理交给后续 --dump-db / --confirm 流程。
  *   - execute-progress-plan-mismatch 维度同样只读：仅读 plan.md checkbox + 只读查 stages 表，
  *     绝不调用 ProgressManager 写方法（写操作是 progress.alignExecuteToPlan 的职责，D-001@v2 诊断/写分离）。
+ *   - 写动作是独立 opt-in 导出（--cleanup-ghosts / --gc-unstamped-runs / --cleanup-remnant），
+ *     与 --json 诊断路径分离；默认 dry-run，--confirm 才落盘。
  *
  * 风格对齐 scan-postcheck.js：checks 用 CHECK_SEVERITY，formatter 产出 schema_version JSON，
  * writer 落盘到 <authoritySpecDir>/.runtime/。
@@ -23,8 +25,10 @@
 import { openDatabase, pluckGet, pluckAll } from './db-engine.js';
 import { safeGit } from './git-helper.js';
 import { existsSync, statSync, readFileSync, readdirSync, mkdirSync, writeFileSync, unlinkSync, rmSync } from 'fs';
-import { join } from 'path';
+import { join, relative, resolve, dirname } from 'path';
+import { gitQuiet } from './git-helper.js'
 import jsYaml from 'js-yaml';
+import { pruneTimestampedEntries } from './runtime-hygiene.js';
 import { CHECK_SEVERITY } from './constants.js';
 import { checkPlatformManaged, isSelfReferentialSpecRoot, PLATFORM_MANAGED_FILENAME, QUICK_SID_RE } from './run/shared.js';
 
@@ -239,15 +243,18 @@ function detectPointerHealth(pointer, cwd = null) {
     if (cwd) {
       const decl = checkPlatformManaged(cwd);
       if (decl) {
+        // 悬空声明检测（2026-09-09 §7-2，会话实证：.sillyspec-platform-managed 指向已删除的
+        // tmp 目录会挡住一切 CLI 命令）：声明 specRoot 不存在 = 平台会话已死/测试残留——
+        // disconnect 是唯一正解，点名前置（防用户对着死路径反复重建指针）。
+        const declDead = !!decl.specRoot && !existsSync(decl.specRoot)
         return {
           name: 'pointer_health',
           label: '平台指针健康',
           pass: false,
           severity: CHECK_SEVERITY.WARNING,
           findings: [
-            `pointer_missing_but_managed: 平台接管声明存在但恢复指针缺失（原 specRoot: ${decl.specRoot || '(未记录)'}）——` +
-            `裸调命令将 fail-closed 拒绝静默落本地。恢复：① 重跑平台 scan/init（带 --spec-root）重建指针；` +
-            `② sillyspec platform disconnect（删除接管声明，彻底脱离平台）；③ 显式 --spec-dir <路径> 临时指定。`,
+            `pointer_missing_but_managed: 平台接管声明存在但恢复指针缺失（原 specRoot: ${decl.specRoot || '(未记录)'}${declDead ? '——⚠️ 该路径已不存在（平台会话已死/测试残留），重建指针无意义' : ''}）——` +
+            `裸调命令将 fail-closed 拒绝静默落本地。恢复：${declDead ? '建议直接 sillyspec platform disconnect（删除接管声明，脱离平台后走本地库）；' : '① 重跑平台 scan/init（带 --spec-root）重建指针；② sillyspec platform disconnect（删除接管声明，彻底脱离平台）；'}③ 显式 --spec-dir <路径> 临时指定。`,
           ],
           safe_actions: [{ dimension: 'pointer_health', action: 'recreate_pointer', risk: 'confirm_required', rationale: '接管声明存在但指针缺失，需重建指针或显式脱离平台', next_step: '重跑平台 scan（带 --spec-root）或 sillyspec platform disconnect' }],
         };
@@ -738,6 +745,191 @@ export function detectDocBloat(specRoot) {
     ? { ...dim, findings: ['模块卡与知识库体量在软限内'], pass: true, severity: CHECK_SEVERITY.PASSED }
     : { ...dim, pass: false, severity: CHECK_SEVERITY.WARNING };
 }
+// ══ 2026-09-09-doctor-noai：净增三类探测器（只读 fail-soft，skipped 带内降级）══
+
+/**
+ * worktree 健康（FR-02）：复用 WorktreeManager.doctor()（薄适配不重复探测——设计审查附加
+ * gap 修正）+ sillyspec/* 残留分支对账（vs changes/ 活跃目录）。锚定主仓根
+ * .sillyspec/.runtime/worktrees（worktree.js:24——勿用 runtimeRoot，平台模式分离只影响
+ * execute-runs 族）。
+ */
+export function detectWorktreeHealth(cwd) {
+  const base = { name: 'worktree_health', label: 'worktree 隔离健康', safe_actions: [] }
+  try {
+    const { WorktreeManager } = require_wtm()
+    const wm = new WorktreeManager(cwd)
+    const r = wm.doctor(cwd)
+    const findings = []
+    for (const iss of r.issues || []) findings.push(`worktree: ${typeof iss === 'string' ? iss : JSON.stringify(iss)}`)
+    // 残留分支对账（sillyspec/* vs 活跃变更目录）
+    try {
+      const branches = gitQuiet(cwd, ['branch', '--list', 'sillyspec/*']) || ''
+      const activeDirs = new Set()
+      // 活跃变更目录锚定主仓根（审查 B-01：worktree 内 cwd/.sillyspec/changes 只含 archive——
+      // 活跃变更不入 git；git common-dir 反推主仓根，失败回退 cwd）
+      let mainRoot = cwd
+      try {
+        const commonDir = gitQuiet(cwd, ['rev-parse', '--git-common-dir'])
+        if (commonDir) mainRoot = resolve(dirname(resolve(cwd, String(commonDir).trim())))
+      } catch { /* 回退 cwd */ }
+      const changesDir = join(mainRoot, '.sillyspec', 'changes')
+      if (existsSync(changesDir)) {
+        for (const d of readdirSync(changesDir)) {
+          if (!d.startsWith('archive')) activeDirs.add(d)
+        }
+      }
+      for (const line of branches.split('\n')) {
+        // 剥 */+ 两前缀（审查 B-01：+ 是 worktree checkout 中标记，未剥致分支名与删除命令双重语法坏）
+        const b = line.trim().replace(/^[*+][ ]*/, '').replace(/^sillyspec\//, '')
+        if (b && !activeDirs.has(b)) findings.push(`残留分支 sillyspec/${b}（变更已归档/删除）——git branch -d sillyspec/${b} 或 sillyspec worktree cleanup`)
+      }
+    } catch { /* 分支读失败跳过该子项 */ }
+    return findings.length === 0
+      ? { ...base, findings: ['worktree 与会话目录健康'], pass: true, severity: CHECK_SEVERITY.PASSED }
+      : { ...base, findings, pass: false, severity: CHECK_SEVERITY.WARNING }
+  } catch (e) {
+    return { ...base, findings: [`探测降级（git 不可用或非仓库：${e?.message || e}）——skipped`], pass: true, severity: null, skipped: true }
+  }
+}
+
+/**
+ * 构建环境（FR-02）：node 版本 vs package.json engines.node（^/>=/= 前缀简化比较，
+ * 复杂区间 unknown 不判红）+ 包管理器存在性。无 package.json → skipped 注记。
+ */
+export function detectBuildEnv(cwd) {
+  const base = { name: 'build_env', label: '构建环境', safe_actions: [] }
+  try {
+    const pkgPath = join(cwd, 'package.json')
+    if (!existsSync(pkgPath)) return { ...base, findings: ['无 package.json（非 Node 项目）——skipped'], pass: true, severity: null, skipped: true }
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+    const findings = []
+    const want = pkg.engines && pkg.engines.node
+    if (want) {
+      const cur = process.version.replace(/^v/, '')
+      const m = String(want).match(/^(\^|>=|=)?\s*(\d+)\.?(\d+)?\.?(\d+)?/)
+      if (m) {
+        const [_, op, a, b, c] = m
+        const w = [Number(a), Number(b || 0), Number(c || 0)]
+        const cu = cur.split('.').map(Number)
+        const ge = cu[0] > w[0] || (cu[0] === w[0] && (cu[1] > w[1] || (cu[1] === w[1] && cu[2] >= w[2])))
+        const ok = op === '^' ? (cu[0] === w[0] && ge) : ge
+        if (!ok) findings.push(`node ${process.version} 不满足 engines.node ${want}`)
+      } else {
+        findings.push(`engines.node 区间复杂（${want}）——unknown 不判红`)
+      }
+    }
+    // 包管理器
+    const pm = (pkg.packageManager || '').split('@')[0]
+      || (existsSync(join(cwd, 'pnpm-lock.yaml')) ? 'pnpm' : existsSync(join(cwd, 'yarn.lock')) ? 'yarn' : 'npm')
+    findings.push(`node ${process.version} / 包管理器 ${pm}${pkg.packageManager ? `（packageManager 锁定）` : '（lockfile 推断）'}`)
+    return findings.some(f => f.includes('不满足'))
+      ? { ...base, findings, pass: false, severity: CHECK_SEVERITY.WARNING }
+      : { ...base, findings, pass: true, severity: CHECK_SEVERITY.PASSED }
+  } catch (e) {
+    return { ...base, findings: [`探测降级（${e?.message || e}）——skipped`], pass: true, severity: null, skipped: true }
+  }
+}
+
+/**
+ * MCP 端点配置在场性（FR-02）：项目级 .mcp.json / .cursor/mcp.json 查 Context7/grep.app
+ * 键——零网络请求。无配置 → skipped 注记（不判红——MCP 是可选增强）。
+ */
+export function detectMcpEndpoints(cwd) {
+  const base = { name: 'mcp_endpoints', label: 'MCP 端点配置', safe_actions: [] }
+  try {
+    const candidates = [join(cwd, '.mcp.json'), join(cwd, '.cursor', 'mcp.json')]
+    const found = candidates.find(p => existsSync(p))
+    if (!found) return { ...base, findings: ['无项目级 MCP 配置（.mcp.json/.cursor/mcp.json）——可选增强，skipped'], pass: true, severity: null, skipped: true }
+    const text = readFileSync(found, 'utf8')
+    const findings = [`配置文件：${relative(cwd, found)}`]
+    for (const key of ['context7', 'grep.app', 'grepapp']) {
+      if (text.toLowerCase().includes(key)) findings.push(`${key} 端点已配置 ✅`)
+    }
+    return { ...base, findings, pass: true, severity: CHECK_SEVERITY.PASSED }
+  } catch (e) {
+    return { ...base, findings: [`探测降级（${e?.message || e}）——skipped`], pass: true, severity: null, skipped: true }
+  }
+}
+
+/**
+ * 模块文档健康（2026-09-09-doctor-noai 审查 B-02 补维，FR-01 step1 承诺）：
+ * _module-map.yaml 的 needs_review=true 清单（卡缺失/精确校验归 modules rebuild/status）。
+ * 只读 fail-soft。
+ */
+function detectModuleDocHealth(cwd) {
+  const base = { name: 'module_doc_health', label: '模块文档健康', safe_actions: [] }
+  try {
+    let mapText = null
+    const docsDir = join(cwd, '.sillyspec', 'docs')
+    if (existsSync(docsDir)) {
+      for (const d of readdirSync(docsDir)) {
+        const cand = join(docsDir, d, 'modules', '_module-map.yaml')
+        if (existsSync(cand)) { mapText = readFileSync(cand, 'utf8'); break }
+      }
+    }
+    if (!mapText) return { ...base, findings: ['无 _module-map.yaml（未 scan）——skipped'], pass: true, severity: null, skipped: true }
+    const findings = []
+    // needs_review 清单（模块块内 needs_review: true）
+    const blocks = mapText.split(/\n(?=  \\w)/)
+    for (const blk of blocks) {
+      const idM = blk.match(/^  ([\w.-]+):/)
+      if (idM && /needs_review:\s*true/.test(blk)) {
+        const reasons = (blk.match(/review_reasons:\s*\[([^\]]*)\]/) || [])[1] || ''
+        findings.push(`${idM[1]} needs_review=true${reasons ? `（${reasons.trim()}）` : ''}——按卡指引复核`)
+      }
+    }
+    return findings.length === 0
+      ? { ...base, findings: ['模块卡 needs_review 清零'], pass: true, severity: CHECK_SEVERITY.PASSED }
+      : { ...base, findings, pass: false, severity: CHECK_SEVERITY.WARNING }
+  } catch (e) {
+    return { ...base, findings: [`探测降级（${e?.message || e}）——skipped`], pass: true, severity: null, skipped: true }
+  }
+}
+
+/**
+ * 决策版本漂移（审查 B-02 补维）：knowledge/decisions/ 条目计数 + 提示精确复核链归属
+ * （behind 精确计算归 verify evidence-auto / docs-check 决策规则族——此处只做在场概览）。
+ * 只读 fail-soft。
+ */
+function detectDecisionDrift(cwd) {
+  const base = { name: 'decision_drift', label: '决策版本漂移', safe_actions: [] }
+  try {
+    const decDir = join(cwd, '.sillyspec', 'knowledge', 'decisions')
+    if (!existsSync(decDir)) return { ...base, findings: ['无 knowledge/decisions/——skipped'], pass: true, severity: null, skipped: true }
+    let count = 0
+    for (const f of readdirSync(decDir)) {
+      if (!f.endsWith('.md')) continue
+      count += (readFileSync(join(decDir, f), 'utf8').match(/^## D-\d+@\d+/gm) || []).length
+    }
+    return { ...base, findings: [`decisions 库 ${count} 条（behind 精确复核在 verify evidence-auto 与 docs-check 决策规则族）`], pass: true, severity: CHECK_SEVERITY.PASSED }
+  } catch (e) {
+    return { ...base, findings: [`探测降级（${e?.message || e}）——skipped`], pass: true, severity: null, skipped: true }
+  }
+}
+
+/**
+ * renderDoctorSummary（FR-01，全新输出契约——2026-09-09-doctor-noai）：逐维
+ * ✅/⚠️/❌ + label + findings 首行 + safe_actions 提示行。顶层非 --json 命令与
+ * _cliAction 步共用。
+ */
+export function renderDoctorSummary(diagnostics) {
+  const L = ['🩺 SillySpec 项目自检诊断', '']
+  for (const d of (diagnostics.dimensions || [])) {
+    if (!d || !d.name) continue
+    const icon = d.pass === false && d.severity === CHECK_SEVERITY.FAILED ? '❌' : d.pass === false ? '⚠️' : '✅'
+    L.push(`${icon} ${d.label || d.name}`)
+    for (const f of (d.findings || []).slice(0, 3)) L.push(`   · ${f}`)
+    if ((d.findings || []).length > 3) L.push(`   · …还有 ${d.findings.length - 3} 条`)
+    for (const a of (d.safe_actions || []).slice(0, 2)) L.push(`   🔧 ${a.action}：${a.next_step || a.rationale || ''}`)
+  }
+  L.push('')
+  return L.join('\n')
+}
+
+// worktree.js 延迟引用（防环：worktree 不 import doctor-diagnostics）
+import * as _wtm from './worktree.js'
+function require_wtm() { return _wtm }
+
 export async function runDoctorDiagnostics({ cwd }) {
   const pointer = resolvePointer(cwd);
   const multiDb = detectMultiDb(cwd, pointer);
@@ -759,7 +951,10 @@ export async function runDoctorDiagnostics({ cwd }) {
   // P2-2-②：file-lifecycle 文档欠账（git behind 事实计算，治「改了生命周期代码忘同步文档」）
   const lifecycleDoc = detectLifecycleDocStaleness(cwd);
 
-  const dimensions = [multiDb, pointerHealth, changesSplit, changeDb, executeMismatch, docBloat, repoNativeChain, lifecycleDoc];
+  const worktreeHealth = detectWorktreeHealth(cwd)
+  const buildEnv = detectBuildEnv(cwd)
+  const mcpEndpoints = detectMcpEndpoints(cwd)
+  const dimensions = [multiDb, pointerHealth, changesSplit, changeDb, executeMismatch, docBloat, repoNativeChain, lifecycleDoc, worktreeHealth, buildEnv, mcpEndpoints];
 
   return {
     dimensions,
@@ -1169,3 +1364,244 @@ export async function cleanupGhostChanges({ cwd, specDir = null, confirm = false
     if (db) { try { db.close(); } catch { /* 忽略关闭失败 */ } }
   }
 }
+
+// ── 存量无戳 execute-runs 清扫（doctor --gc-unstamped-runs）────────────────
+
+const TASK_ID_RE = /\btask-(\d+)\b/gi
+const CHANGE_PATH_RE = /(?:^|\/)changes\/([^/]+)\//
+const TASK_DIR_RE = /^task-(\d+)$/i
+
+function normTaskId(digits) {
+  return `task-${String(digits).padStart(2, '0')}`
+}
+
+function parseTaskIdsFromText(text) {
+  const ids = new Set()
+  if (!text) return ids
+  const re = new RegExp(TASK_ID_RE.source, TASK_ID_RE.flags)
+  for (const m of String(text).matchAll(re)) ids.add(normTaskId(m[1]))
+  return ids
+}
+
+function setEq(a, b) {
+  if (a.size !== b.size) return false
+  for (const x of a) if (!b.has(x)) return false
+  return true
+}
+
+function isSubset(small, big) {
+  for (const x of small) if (!big.has(x)) return false
+  return true
+}
+
+function listDirNames(dir) {
+  if (!dir || !existsSync(dir)) return []
+  try {
+    return readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+  } catch {
+    return []
+  }
+}
+
+function loadTasksMd(changeDir) {
+  const p = join(changeDir, 'tasks.md')
+  if (!existsSync(p)) return new Set()
+  try {
+    return parseTaskIdsFromText(readFileSync(p, 'utf8'))
+  } catch {
+    return new Set()
+  }
+}
+
+/**
+ * 扫一个 execute-run 目录：戳 / reviewedFiles 路径首段 / task-NN 目录名。
+ * reviewedFiles 取全部条目（不只 [0]），路径段精确相等——login 不命中 2026-08-01-login。
+ */
+function inspectExecuteRun(runDir) {
+  const stampFile = join(runDir, 'change')
+  let stamp = ''
+  if (existsSync(stampFile)) {
+    try { stamp = readFileSync(stampFile, 'utf8').trim() } catch { /* 读失败当无戳 */ }
+  }
+  const pathOwners = new Set()
+  const taskIds = new Set()
+  const tasksDir = join(runDir, 'tasks')
+  if (existsSync(tasksDir)) {
+    let entries = []
+    try { entries = readdirSync(tasksDir, { withFileTypes: true }) } catch { entries = [] }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue
+      const tm = e.name.match(TASK_DIR_RE)
+      if (tm) taskIds.add(normTaskId(tm[1]))
+      const rjPath = join(tasksDir, e.name, 'review.json')
+      if (!existsSync(rjPath)) continue
+      try {
+        const rj = JSON.parse(readFileSync(rjPath, 'utf8'))
+        const files = Array.isArray(rj.reviewedFiles) ? rj.reviewedFiles : []
+        for (const f of files) {
+          const m = String(f || '').replace(/\\/g, '/').match(CHANGE_PATH_RE)
+          if (m) pathOwners.add(m[1])
+        }
+      } catch { /* 坏 JSON 不据此猜归属 */ }
+    }
+  }
+  return { hasStamp: stamp.length > 0, stamp, pathOwners, taskIds }
+}
+
+/**
+ * 无戳 run 的归属判定。禁 mtime。命中活跃变更一律 skip。
+ *
+ * 1. reviewedFiles 路径 `changes/<name>/` 首段精确命中：
+ *    - ∩ active → matches_active
+ *    - ∩ archive 多个 → ambiguous_archive
+ *    - ∩ archive 恰好 1：若 tasks.md 有任务且 run 有多余 task-NN → tasks_md_mismatch；否则 via path
+ * 2. 无路径（或路径名既不在 active 也不在 archive）：
+ *    - taskIds 空 → no_attribution
+ *    - 与恰好一个归档 tasks.md **集合全等**且无 active 全等 → via tasks_md
+ *      （子集太弱：task-01 几乎每个变更都有）
+ */
+function classifyUnstampedRun(inspected, { active, archive, archiveTasks, activeTasks }) {
+  const pathActive = [...inspected.pathOwners].filter((n) => active.has(n))
+  if (pathActive.length) {
+    return { skip: true, reason: 'matches_active' }
+  }
+  const pathArchived = [...inspected.pathOwners].filter((n) => archive.has(n))
+  if (pathArchived.length > 1) {
+    return { skip: true, reason: 'ambiguous_archive' }
+  }
+  if (pathArchived.length === 1) {
+    const owner = pathArchived[0]
+    const mdTasks = archiveTasks.get(owner) || new Set()
+    if (mdTasks.size > 0 && inspected.taskIds.size > 0 && !isSubset(inspected.taskIds, mdTasks)) {
+      return { skip: true, reason: 'tasks_md_mismatch', owner }
+    }
+    return { delete: true, owner, via: 'path' }
+  }
+
+  if (inspected.taskIds.size === 0) {
+    return { skip: true, reason: 'no_attribution' }
+  }
+  const activeEquals = [...active].filter((n) => setEq(inspected.taskIds, activeTasks.get(n) || new Set()))
+  if (activeEquals.length) {
+    return { skip: true, reason: 'matches_active' }
+  }
+  const archivedEquals = [...archive].filter((n) => setEq(inspected.taskIds, archiveTasks.get(n) || new Set()))
+  if (archivedEquals.length === 1) {
+    return { delete: true, owner: archivedEquals[0], via: 'tasks_md' }
+  }
+  if (archivedEquals.length > 1) {
+    return { skip: true, reason: 'ambiguous_archive' }
+  }
+  return { skip: true, reason: 'no_attribution' }
+}
+
+/**
+ * 存量无戳 execute-runs 一次性清扫（ql-20260908-006-5f04）。
+ *
+ * 不进 archive 热路径：pruneArchivedChangeRuntime 故意不猜无戳 run（禁 mtime）。
+ * 本函数是 doctor 旁路，对齐 --cleanup-ghosts：默认 dry-run，--confirm 才 rmSync。
+ * 只处理 execute-runs/<runId>/（有 change 戳的留给归档精确回收；stage-reviews / verify-runs 本轮不动）。
+ *
+ * @param {{ cwd: string, specDir?: string|null, confirm?: boolean }} opts
+ */
+export async function gcUnstampedExecuteRuns({ cwd, specDir = null, confirm = false }) {
+  const pointer = resolvePointer(cwd)
+  const localSpec = specDir && existsSync(specDir) ? specDir : join(cwd, '.sillyspec')
+  const authoritySpecRoot = (pointer.present && pointer.specRoot && existsSync(pointer.specRoot))
+    ? pointer.specRoot
+    : localSpec
+  const runtimeRoot = (pointer.runtimeRoot && existsSync(pointer.runtimeRoot))
+    ? pointer.runtimeRoot
+    : join(authoritySpecRoot, '.runtime')
+  const execDir = join(runtimeRoot, 'execute-runs')
+  if (!existsSync(execDir)) {
+    return {
+      action: 'skipped',
+      reason: '未找到 execute-runs 目录',
+      runtime_root: runtimeRoot,
+      candidates: [],
+      skipped: [],
+      errors: [],
+      count: 0,
+    }
+  }
+
+  const activeNames = listChanges(authoritySpecRoot)
+  const archiveNames = listDirNames(join(authoritySpecRoot, 'changes', 'archive'))
+    .filter((n) => n !== 'archive')
+  const active = new Set(activeNames)
+  const archive = new Set(archiveNames)
+  const archiveTasks = new Map()
+  for (const n of archiveNames) {
+    archiveTasks.set(n, loadTasksMd(join(authoritySpecRoot, 'changes', 'archive', n)))
+  }
+  const activeTasks = new Map()
+  for (const n of activeNames) {
+    activeTasks.set(n, loadTasksMd(join(authoritySpecRoot, 'changes', n)))
+  }
+
+  const candidates = []
+  const skipped = []
+  const errors = []
+  let entries = []
+  try {
+    entries = readdirSync(execDir, { withFileTypes: true })
+  } catch (e) {
+    return {
+      action: 'error',
+      reason: e.message,
+      runtime_root: runtimeRoot,
+      candidates: [],
+      skipped: [],
+      errors: [{ error: e.message }],
+      count: 0,
+    }
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const runId = entry.name
+    const runDir = join(execDir, runId)
+    let inspected
+    try {
+      inspected = inspectExecuteRun(runDir)
+    } catch (e) {
+      errors.push({ runId, error: e.message })
+      continue
+    }
+    if (inspected.hasStamp) {
+      skipped.push({ runId, reason: 'has_stamp' })
+      continue
+    }
+    const verdict = classifyUnstampedRun(inspected, { active, archive, archiveTasks, activeTasks })
+    if (verdict.skip) {
+      skipped.push({ runId, reason: verdict.reason, owner: verdict.owner || null })
+      continue
+    }
+    candidates.push({ runId, owner: verdict.owner, via: verdict.via })
+  }
+
+  const removed = []
+  if (confirm) {
+    for (const c of candidates) {
+      try {
+        rmSync(join(execDir, c.runId), { recursive: true, force: true })
+        removed.push(c.runId)
+      } catch (e) {
+        errors.push({ runId: c.runId, error: e.message })
+      }
+    }
+  }
+
+  return {
+    action: confirm ? 'deleted' : 'dry_run',
+    runtime_root: runtimeRoot,
+    candidates,
+    skipped,
+    errors,
+    removed: confirm ? removed : [],
+    count: candidates.length,
+  }
+}

package/src/foreign-declared.js

@@ -14,6 +14,7 @@ import { existsSync, readFileSync, readdirSync } from 'fs'
 import { join } from 'path'
 import { parseFileChangeListDetailed } from './change-list.js'
 import { safeGit, unquoteGitPath } from './git-helper.js'
+import { parseAllowedPaths, parseTargetFiles } from './stages/plan-postcheck.js'
 
 /**
  * 主仓未提交文件集（staged + unstaged + untracked，rename 取新路径）。
@@ -138,8 +139,53 @@ export function collectForeignDeclaredFiles(cwd, currentChangeName, opts = {}) {
   return foreign
 }
 
+/**
+ * 本变更（currentChangeName）的 own 声明集——own 优先判据（坑
+ * verify-reconcile-own-file-foreign-false-positive，2026-09-09 实证）：
+ * quick 会话 = guard.allowedFiles；变更 = design §6 清单 ∪ task 卡 allowed_paths/target_files。
+ * 文件被本变更与他者**双方声明**时归 own：foreign 排除的职责是「他者的工作不混进我的
+ * 判定」，不是「我声明并真实修改的文件因他者（尤其未归档旧变更的陈旧 design 声明）也
+ * 声明过就被剔出我的对账」。读不出来（无 design/无 task 卡/quick guard 损坏）→ 空集
+ * （退回旧 foreign-first 行为，fail-closed 不放大放行面）。
+ * @returns {Set<string>} 正斜杠归一后的声明路径集
+ */
+function loadOwnDeclaredSet(specBase, runtimeRoot, currentChangeName) {
+  const set = new Set()
+  if (!currentChangeName) return set
+  const norm = (p) => String(p || '').replace(/\\/g, '/')
+  const addAll = (paths) => { for (const p of paths) { const n = norm(p); if (n) set.add(n) } }
+  try {
+    if (/^quick-[0-9a-f]{8}$/.test(currentChangeName)) {
+      try {
+        const guard = JSON.parse(readFileSync(join(runtimeRoot, 'quick-sessions', currentChangeName, 'guard.json'), 'utf8'))
+        addAll(Array.isArray(guard?.allowedFiles) ? guard.allowedFiles : [])
+      } catch { /* guard 缺失/损坏 → 空集退回旧行为 */ }
+      return set
+    }
+    const changeDir = join(specBase, 'changes', currentChangeName)
+    try { addAll(parseFileChangeListDetailed(join(changeDir, 'design.md')).map(e => e.path)) } catch {}
+    let taskFiles = []
+    try { taskFiles = readdirSync(join(changeDir, 'tasks')).filter(f => /^task-\d+\.md$/.test(f)) } catch {}
+    for (const tf of taskFiles) {
+      try {
+        const content = readFileSync(join(changeDir, 'tasks', tf), 'utf8')
+        addAll(parseAllowedPaths(content))
+        addAll(parseTargetFiles(content).entries.map(e => e.path))
+      } catch { /* 单卡损坏跳过 */ }
+    }
+  } catch { /* 整体异常 → 空集 */ }
+  return set
+}
+
 /**
  * 按他者声明集切分 diff 文件（collectForeignDeclaredFiles 的消费端快捷封装）。
+ *
+ * own 优先（2026-09-09 坑 verify-reconcile-own-file-foreign-false-positive 修复）：文件在
+ * 本变更 own 声明集（design §6 / task allowed_paths / target_files / quick guard）内时
+ * 永不判 foreign——哪怕他者变更（含未归档旧变更的陈旧声明，其活性被本变更自己的 dirty
+ * 反向喂活）也声明过。双方都声明 = 归属歧义按「自己声明优先」收敛：本变更的 dirty 是
+ * 自己工作的一部分，剔除它只会制造「声明未做」假红。
+ *
  * @param {string} cwd 项目根
  * @param {string|null} currentChangeName 本变更名
  * @param {string[]|null} diffFiles 待切分文件列表（null 透传，保持调用方 null 语义）
@@ -148,12 +194,17 @@ export function collectForeignDeclaredFiles(cwd, currentChangeName, opts = {}) {
  */
 export function splitOwnVsForeignDiffFiles(cwd, currentChangeName, diffFiles, opts = {}) {
   if (!Array.isArray(diffFiles)) return { own: diffFiles, foreign: [] }
-  const foreignMap = collectForeignDeclaredFiles(cwd, currentChangeName, opts)
+  const specBase = opts.specBase || join(cwd, '.sillyspec')
+  const runtimeRoot = opts.runtimeRoot || join(specBase, '.runtime')
+  const foreignMap = collectForeignDeclaredFiles(cwd, currentChangeName, { specBase, runtimeRoot })
   if (foreignMap.size === 0) return { own: diffFiles, foreign: [] }
+  const ownDeclared = loadOwnDeclaredSet(specBase, runtimeRoot, currentChangeName)
   const own = []
   const foreign = []
   for (const f of diffFiles) {
-    const owners = foreignMap.get(String(f).replace(/\\/g, '/'))
+    const n = String(f).replace(/\\/g, '/')
+    if (ownDeclared.size > 0 && ownDeclared.has(n)) { own.push(f); continue } // own 优先
+    const owners = foreignMap.get(n)
     if (owners) foreign.push({ file: f, owners })
     else own.push(f)
   }