sillyspec 3.28.0 → 3.28.3

package/src/modules.js

@@ -212,21 +212,42 @@ export function splitChangelog(cwd, { force = false } = {}) {
     for (const f of cards) {
       const cardPath = join(modulesDir, f);
       const content = readFileSync(cardPath, 'utf8');
-      // 提取「## 变更索引」节（CRLF 归一后行级匹配，与 modules.js 其余解析同防线）
+      // 提取「## 变更索引」节（CRLF 归一后行级匹配，与 modules.js 其余解析同防线）。
+      // 标题正则允许后缀（如「（表格，初始为空）」——2026-09-07 实证 core-engine 形态漏迁）；
+      // miss 时再试 MANUAL_NOTES 区（stages/runtime 形态：<!-- MANUAL_NOTES_END --> 前的尾部
+      // 行块——全或无：块内行须全部为「- <变更名> | 摘要」形态才整体迁出，防误迁散文）
       const lines = content.replace(/\r\n/g, '\n').split('\n');
-      const startIdx = lines.findIndex(l => /^##\s*变更索引\s*$/.test(l));
-      if (startIdx < 0) { skipped++; continue; }
-      let endIdx = lines.length;
-      for (let i = startIdx + 1; i < lines.length; i++) {
-        if (/^##\s/.test(lines[i])) { endIdx = i; break; }
+      const startIdx = lines.findIndex(l => /^##\s*变更索引/.test(l));
+      let kind = 'index';
+      let segStart = -1, segEnd = -1, body = '';
+      if (startIdx >= 0) {
+        let endIdx = lines.length;
+        for (let i = startIdx + 1; i < lines.length; i++) {
+          if (/^##\s/.test(lines[i])) { endIdx = i; break; }
+        }
+        const b = lines.slice(startIdx + 1, endIdx).join('\n').trim();
+        // 已迁出（只剩指针行）或本就为空 → 跳过
+        if (!b || /^见\s/.test(b) || b.includes('.changelog.md')) { skipped++; continue; }
+        kind = 'index'; segStart = startIdx + 1; segEnd = endIdx; body = b;
+      } else {
+        const endMark = lines.findIndex(l => l.includes('<!-- MANUAL_NOTES_END -->'));
+        if (endMark < 0) { skipped++; continue; }
+        // 块首 = END 标记向上、以空行为界的连续内容块起点
+        let bs = endMark - 1;
+        while (bs >= 0 && lines[bs].trim() !== '') bs--;
+        // 块内剔除 HTML 注释行（区开标记 <!-- MANUAL_NOTES ... --> 等）后须全为变更行形态
+        const block = lines.slice(bs + 1, endMark).filter(l => {
+          const t = l.trim()
+          return t !== '' && !/^<!--.*-->$/.test(t)
+        });
+        const CHG_LINE = /^- [A-Za-z0-9][\w\-./]* \| /;
+        if (block.length === 0 || !block.every(l => CHG_LINE.test(l))) { skipped++; continue; }
+        kind = 'manual-notes'; segStart = bs + 1; segEnd = endMark; body = block.join('\n');
       }
-      const body = lines.slice(startIdx + 1, endIdx).join('\n').trim();
-      // 已迁出（只剩指针行）或本就为空 → 跳过
-      if (!body || /^见\s/.test(body) || body.includes('.changelog.md')) { skipped++; continue; }
       const bytesMoved = Buffer.byteLength(body, 'utf8');
       const stem = f.replace(/\.md$/, '');
       const sidecarPath = join(modulesDir, `${stem}.changelog.md`);
-      results.push({ card: cardPath, sidecar: sidecarPath, bytesMoved, _lines: lines, _startIdx: startIdx, _endIdx: endIdx, _body: body });
+      results.push({ card: cardPath, sidecar: sidecarPath, bytesMoved, kind, _lines: lines, _segStart: segStart, _segEnd: segEnd, _body: body });
     }
   }
 
@@ -253,9 +274,17 @@ export function splitChangelog(cwd, { force = false } = {}) {
       sidecarContent = header + '\n' + r._body + '\n';
     }
     writeFileSync(r.sidecar, sidecarContent, 'utf8');
-    // 卡内节体替换为指针行（只动该节，其余逐字保留；_lines 已是 LF 归一）
+    // 卡内替换（只动该段，其余逐字保留；_lines 已是 LF 归一）：
+    // index → 节体换指针行；manual-notes → 尾部块清空 + END 标记前留迁移指针注释
     const stem = r.card.split(/[\\/]/).pop().replace(/\.md$/, '');
-    const newLines = [...r._lines.slice(0, r._startIdx + 1), '', `见 \`${stem}.changelog.md\`——历史条目已迁出；新条目直接追加 sidecar，勿写回本卡。`, '', ...r._lines.slice(r._endIdx)];
+    let newLines;
+    if (r.kind === 'manual-notes') {
+      newLines = [...r._lines.slice(0, r._segStart),
+        `<!-- MANUAL_NOTES 区变更条目已迁出至 ${stem}.changelog.md（split-changelog）；新条目追加 sidecar，勿写回本卡 -->`,
+        ...r._lines.slice(r._segEnd)];
+    } else {
+      newLines = [...r._lines.slice(0, r._segStart), '', `见 \`${stem}.changelog.md\`——历史条目已迁出；新条目直接追加 sidecar，勿写回本卡。`, '', ...r._lines.slice(r._segEnd)];
+    }
     writeFileSync(r.card, newLines.join('\n'), 'utf8');
     console.log(`✅ ${r.card} → ${r.sidecar}（迁出 ${(r.bytesMoved / 1024).toFixed(1)}KB，卡内留指针）`);
   }

package/src/progress/change-registry.js

@@ -19,6 +19,25 @@ export class ChangeRegistry {
     return rows.map(r => r.name);
   }
 
+  /**
+   * 读变更创建时间（IR 严格模式闸门判别源，change: 2026-09-07-ir-hardening D-001@v1）。
+   * 只读不抛（与 listChanges 同款 DB 访问）：变更不存在 / db 异常 → null——调用方
+   * （isStrictChange）按 fail-open 落存量豁免，不误伤。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @returns {string|null} ISO 时间字符串或 null
+   */
+  getChangeCreatedAt(cwd, changeName) {
+    if (!changeName || typeof changeName !== 'string') return null;
+    try {
+      const db = this.pm._ensureDB(cwd);
+      const row = db.getDb().prepare('SELECT created_at FROM changes WHERE name = ?').get(changeName);
+      return row && typeof row.created_at === 'string' ? row.created_at : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * 查询单个变更的流程阶段与状态（quick 轻量归档阶段闸用）。
    * 与 readChangeIsolation 不同（展示读，catch → null 宽容）：本方法服务权限判定，读失败
@@ -126,6 +145,26 @@ export class ChangeRegistry {
     }
   }
 
+  /**
+   * 读取变更回填的 quicklog_id（quick 启动时 stage.js 写入的分配 ql-ID）。
+   * quick --done 兜底路径复用启动 ql-ID 用（坑 platform-takeover-phantom-progress-db
+   * 同日变体：guard 缺失时补分配新号制造引用劈叉——落码注释/模块文档的 ql-ID 是启动
+   * 时就给出的，兜底换号必然劈叉；启动 ID 进度库里可查）。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @returns {string|null} 行缺失/未回填/读取失败返回 null
+   */
+  getQuicklogId(cwd, changeName) {
+    if (!changeName) return null;
+    try {
+      const db = this.pm._ensureDB(cwd);
+      const row = db.getDb().prepare('SELECT quicklog_id FROM changes WHERE name = ?').get(changeName);
+      return (row && typeof row.quicklog_id === 'string' && row.quicklog_id) || null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * 读取变更的隔离状态
    * @param {string} cwd - 项目根目录

package/src/progress/consistency-doctor.js

@@ -1,8 +1,9 @@
 // W6 Step9a: Revision v1 状态一致性检查 + 修复 + --force 审计日志。
 // 从 src/progress.js 单体 ProgressManager 抽出。持有 pm 引用（构造注入），调 pm.read / pm._write /
 // pm._ensureRuntimeDir / pm._runtimePath（persistence-core 留 facade 本体）。
-import { appendFileSync, existsSync, readdirSync } from 'fs';
-import { join } from 'path';
+import { appendFileSync, existsSync, readFileSync, readdirSync } from 'fs';
+import { join, resolve } from 'path';
+import { DB } from '../db.js';
 import { summarizeTaskCompletion } from '../task-review.js';
 import { STAGE_ORDER, MAIN_FLOW_ORDER } from './shared.js';
 
@@ -11,6 +12,104 @@ export class ConsistencyDoctor {
     this.pm = pm;
   }
 
+  /**
+   * 双进度库分裂探测（坑 progress-repair-dual-library-blind，2026-09-04 用户实证②：
+   * 接管指针切换库后 progress repair 只看当前库，旧库残留的活跃变更进度完全不可见，
+   * 报告「未发现问题，无需修复」的假阴性）。
+   *
+   * 判据：cwd 存在平台接管指针（.sillyspec-platform.json 指向库 A = 当前修复目标），
+   * 同时 cwd/.sillyspec/.runtime/sillyspec.db（库 B = 切库前旧库）也存在且 ≠ 库 A
+   * → 双库并存。自指指针（specRoot 解析回本地 .sillyspec）不算。
+   *
+   * 只读探测：另一库仅在 sillyspec.db 已存在时直读（DB 类 + 存在性前置检查，绝不新建库文件）；
+   * 读失败 fail-open 返回库存在但活跃清单不可读，不阻断 check/repair 主流程。
+   *
+   * @param {string} cwd - 进度库锚定 cwd（index.js 传入 progDir）
+   * @param {string|null} [changeName] - check/repair 的 --change 目标（判「操作错了库」用）
+   * @returns {{ split: boolean, dualDb: boolean, bothActive: boolean, targetInOther: boolean, lines: string[] }}
+   */
+  detectLibrarySplit(cwd, changeName = null) {
+    const out = { split: false, dualDb: false, bothActive: false, targetInOther: false, lines: [] };
+    const pointerPath = join(cwd, '.sillyspec-platform.json');
+    if (!existsSync(pointerPath)) return out;
+    let ptr = null;
+    try {
+      ptr = JSON.parse(readFileSync(pointerPath, 'utf8'));
+    } catch {
+      return out; // 指针损坏由 resolvePlatformSpecDir fail-closed 负责，此处不重复报
+    }
+    if (!ptr.specRoot) return out;
+
+    const localRoot = join(cwd, '.sillyspec');
+    const localDbPath = join(localRoot, '.runtime', 'sillyspec.db');
+    if (resolve(ptr.specRoot) === resolve(localRoot)) return out; // 自指/同库
+    if (!existsSync(localDbPath)) return out; // 旧库无 DB → 无分裂
+
+    out.dualDb = true;
+    const currentSpecDir = this.pm._getSpecDir(cwd);
+    // 当前库：DB 已存在才读（readGlobal 走 pm 连接池，不新开连接；不存在时 readGlobal 会
+    // 隐式建库，须前置 existsSync 挡住——探测绝不产生写副作用）
+    let current = null;
+    if (existsSync(join(currentSpecDir, '.runtime', 'sillyspec.db'))) {
+      try {
+        const g = this.pm.readGlobal(cwd);
+        current = { activeChanges: (g && g.activeChanges) || [] };
+      } catch (e) {
+        current = { activeChanges: [], unreadable: true, error: e.message };
+      }
+    }
+    const other = this._readActiveQuiet(localRoot, cwd);
+    const currentActive = current?.activeChanges || [];
+    const otherActive = other?.activeChanges || [];
+
+    out.lines.push(
+      `双进度库并存（接管指针 ${pointerPath} → ${currentSpecDir}；切库前旧库残留 ${localRoot}）` +
+      `——本次 check/repair 只作用于当前库，旧库状态不可见`
+    );
+    out.lines.push(
+      `  当前库活跃变更: ${currentActive.length > 0 ? currentActive.join('、') : '(无)'}${current?.unreadable ? '（读取失败：' + current.error + '）' : ''}`
+    );
+    out.lines.push(
+      `  旧库活跃变更: ${otherActive.length > 0 ? otherActive.join('、') : '(无)'}${other?.unreadable ? '（读取失败：' + other.error + '）' : ''}`
+    );
+    out.lines.push(
+      `  处理：确认权威库后收尾/归档弃用库的活跃变更；或 sillyspec platform pointer --cleanup 删指针后重跑平台 scan 指向正确库；临时读旧库用 --spec-dir ${localRoot}`
+    );
+
+    if (currentActive.length > 0 && otherActive.length > 0) {
+      out.bothActive = true;
+      out.split = true;
+    }
+    // 目标变更只在旧库活跃（当前库查无）→ 本次操作几乎必然找错了库，最强信号
+    if (changeName && otherActive.includes(changeName) && !currentActive.includes(changeName)) {
+      out.targetInOther = true;
+      out.split = true;
+      out.lines.push(
+        `  ⚠️ 目标变更 "${changeName}" 不在当前库，但旧库有同名活跃变更——本次操作错了库，修复应带上 --spec-dir ${localRoot}（或修正指针）`
+      );
+    }
+    return out;
+  }
+
+  /**
+   * 只读读一个库的活跃变更清单（detectLibrarySplit 专用）。
+   * sillyspec.db 不存在返回 null（绝不新建库）；打开/读取失败返回 { unreadable, error }
+   * 不上抛——分裂探测 fail-open，不阻断主流程。
+   */
+  _readActiveQuiet(specDir, cwd) {
+    const dbPath = join(specDir, '.runtime', 'sillyspec.db');
+    if (!existsSync(dbPath)) return null;
+    let db = null;
+    try {
+      db = new DB(dbPath);
+      db.init();
+      const rows = db.getDb().prepare("SELECT name FROM changes WHERE status = 'active' ORDER BY name").all();
+      return { activeChanges: rows.map(r => r.name) };
+    } catch (e) {
+      return { activeChanges: [], unreadable: true, error: e.message };
+    }
+  }
+
   /**
    * 强制状态变更的审计记录（--force 逃生口专用）。
    * 追加到 .runtime/audit.log，供人工/doctor 追溯"谁在什么时候绕过了校验"。
@@ -36,12 +135,26 @@ export class ConsistencyDoctor {
   checkConsistency(cwd, changeName = null) {
     const data = this.pm.read(cwd, changeName);
     if (!data) {
-      return { ok: false, issues: ['无法读取进度数据'], warnings: [] };
+      // 双库分裂探测不依赖单变更 progress 可读（read 失败时更要看见另一库，坑
+      // progress-repair-dual-library-blind）：无 progress 也要报分裂，不能只报「无法读取」
+      const splitNoData = this.detectLibrarySplit(cwd, changeName);
+      const issuesNoData = ['无法读取进度数据'];
+      if (splitNoData.targetInOther || splitNoData.bothActive) issuesNoData.push(...splitNoData.lines);
+      return { ok: false, issues: issuesNoData, warnings: splitNoData.dualDb && !splitNoData.split ? splitNoData.lines : [] };
     }
 
     const issues = [];
     const warnings = [];
 
+    // 双库分裂（2026-09-04 ②）：目标变更只在旧库 / 两库皆有活跃 → issue；
+    // 仅双库并存（单侧活跃）→ warning（平台模式本地库保留真实资产是容忍态，避免常态误报）
+    const libSplit = this.detectLibrarySplit(cwd, changeName);
+    if (libSplit.targetInOther || libSplit.bothActive) {
+      issues.push(...libSplit.lines);
+    } else if (libSplit.dualDb) {
+      warnings.push(...libSplit.lines);
+    }
+
     for (const stageName of STAGE_ORDER) {
       const sd = data.stages[stageName];
       if (!sd) continue;
@@ -186,14 +299,20 @@ export class ConsistencyDoctor {
   repairConsistency(cwd, opts = {}) {
     const { apply = false, changeName = null } = opts;
 
+    // 双库分裂（2026-09-04 ②）：repair 修不了「哪边是权威库」，只能把另一库的存在与活跃
+    // 变更亮出来进 manual 清单。放 read 之前——多活跃/读不了库时 read 早退，探测不能跟着瞎。
+    const libSplit = this.detectLibrarySplit(cwd, changeName);
+    const splitManual = libSplit.dualDb ? [...libSplit.lines] : [];
+
     const data = this.pm.read(cwd, changeName);
     if (!data) {
       console.log('❌ 无法读取进度数据');
-      return { fixable: [], manual: ['无法读取进度数据'], applied: [] };
+      for (const m of splitManual) console.log(`   - ${m}`);
+      return { fixable: [], manual: ['无法读取进度数据', ...splitManual], applied: [] };
     }
 
     const fixable = []; // { stage, action, description, apply: (data) => void }
-    const manual = [];  // string
+    const manual = [...splitManual];  // string
 
     const now = new Date().toLocaleString('zh-CN', { hour12: false });
 

package/src/progress/stage-machine.js

@@ -7,8 +7,19 @@ import { mkdirSync, existsSync, readdirSync, readFileSync } from 'fs';
 import { join, resolve, basename } from 'path';
 import { writeAtomicSync } from '../fs-atomic.js';
 import { runValidators } from '../stage-contract.js';
+import { QUICK_SID_RE } from '../run/shared.js';
 import { VALID_STAGES, STAGE_LABELS, STAGE_ORDER, MAIN_FLOW_ORDER, SPEC_DIR_NAME, CURRENT_VERSION, STALL_WARN_DAYS, emptyStage } from './shared.js';
 
+// quick 会话行（quick-<8hex>）按设计无实体 changes/ 目录（progress.js initChange 跳过建目录），
+// 「DB active + changes/ 无同名目录」的 ghost 判定对它是类别错误——进行中的 quick 从写库那
+// 一刻起即命中误报（2026-09-07 quick-inflight-ghost-misjudge，面板「一键清理」清了又长：
+// 每次清理都成功，新 ghost 是清理后才启动的 quick）。show 与 overview 统一经此判定排除。
+// 注意：排除的只是「判定」，doctor --cleanup-ghosts 仍保留 quick 行归档能力（QUICKLOG 已
+// 完成但 DB 行未注销的收尾中断形态，那是兜底出口，不在此排除）。
+function _isGhostChange(changesRoot, cn) {
+  return !QUICK_SID_RE.test(cn) && !existsSync(join(changesRoot, cn));
+}
+
 /**
  * 归一化步骤的已记录等待回答（show 渲染用，跨会话恢复数据源）。
  * waitAnswers 走 pm.read 时已 JSON.parse，但容错字符串/损坏；单值列 wait_answer（旧路径）并入第 1 轮。
@@ -209,7 +220,7 @@ export class StageMachine {
     const pendingConflicts = this._listPendingConflicts(this.pm._getSpecDir(cwd));
     for (const cn of changes) {
       const data = this.pm.read(cwd, cn);
-      const dirMissing = !existsSync(join(changesRoot, cn));
+      const dirMissing = _isGhostChange(changesRoot, cn);
       if (!data) {
         console.log(`  📂 ${cn} — (无法读取)${dirMissing ? ' ⚠️ 目录缺失（残留记录，sillyspec doctor --cleanup-ghosts --confirm 可归档清理）' : ''}`);
         continue;
@@ -272,7 +283,7 @@ export class StageMachine {
     const list = [];
     for (const cn of changes) {
       const data = this.pm.read(cwd, cn);
-      const dirMissing = !existsSync(join(changesRoot, cn));
+      const dirMissing = _isGhostChange(changesRoot, cn);
       const entry = {
         name: cn,
         readable: !!data,

package/src/progress.js

@@ -833,6 +833,8 @@ export class ProgressManager {
   // ── 变更管理 ──
 
   listChanges(cwd) { return this._changeRegistry.listChanges(cwd); }
+  /** 读变更创建时间（IR 严格模式闸门判别源，2026-09-07-ir-hardening D-001）——只读不抛，缺行/异常 → null */
+  getChangeCreatedAt(cwd, changeName) { return this._changeRegistry.getChangeCreatedAt(cwd, changeName); }
 
   // 单变更阶段查询（quick 轻量归档阶段闸）：无行 null，读失败抛（调用方 fail-closed）
   getChangeStage(cwd, changeName) { return this._changeRegistry.getChangeStage(cwd, changeName); }
@@ -868,6 +870,9 @@ export class ProgressManager {
 
   updateChangeMeta(cwd, changeName, meta) { return this._changeRegistry.updateChangeMeta(cwd, changeName, meta); }
 
+  // quick --done 兜底复用启动 ql-ID（坑 platform-takeover-phantom-progress-db 同日变体）
+  getQuicklogId(cwd, changeName) { return this._changeRegistry.getQuicklogId(cwd, changeName); }
+
   // ── CLI 命令 ──
 
   init(cwd) {

package/src/quicklog.js

@@ -713,6 +713,57 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
   })
 }
 
+/**
+ * 以**给定 ql-ID** 追加一条「进行中」骨架条目（不分配新 ID）。
+ *
+ * 坑 platform-takeover-phantom-progress-db 同日变体：quick --done 兜底复用启动分配的
+ * ql-ID（进度库 changes.quicklog_id 可查）时，该 ID 的条目可能不在当前 specBase 的
+ * QUICKLOG 文件里（启动与 --done 落到不同库/文件的分裂形态）——用原 ID 补建骨架再走
+ * 完成翻态，保证「同一次会话只有一个 ql-ID」。条目已存在则幂等跳过（不重复追加）。
+ * 与 allocateQuicklogEntry 同锁同格式同平台推送，仅跳过 ID 分配段。
+ */
+export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { description = '(guard 缺失补建)', linkedChanges = [], allowedFiles = [] } = {}) {
+  if (!qlId || typeof qlId !== 'string') throw new Error('appendQuicklogEntryWithId: qlId 必填')
+  if (findQuicklogEntry(specBase, gitUser, qlId)) return { qlId, existed: true }
+  const quicklogDir = join(specBase, 'quicklog')
+  mkdirSync(quicklogDir, { recursive: true })
+  const user = sanitizeQuicklogUser(gitUser) || 'unknown'
+  const userFile = join(quicklogDir, `QUICKLOG-${user}.md`)
+  const lockPath = join(quicklogDir, `.QUICKLOG-${user}.md.lock`)
+  const desc = sanitizeDesc(description)
+  const linked = Array.isArray(linkedChanges) ? linkedChanges : []
+  const files = Array.isArray(allowedFiles) ? allowedFiles : []
+
+  return await withFileLock(lockPath, async () => {
+    // 双检（锁内）：并发兜底同 ID 只落一条
+    if (findQuicklogEntry(specBase, gitUser, qlId)) return { qlId, existed: true }
+    await rotateIfNeeded(userFile, user)
+    const entry = [
+      '',
+      `## ${qlId} | ${nowDatetime()} | ${desc}`,
+      '状态：进行中',
+      `关联变更：${linked.length > 0 ? linked.join(', ') : '（无）'}`,
+      `文件：${files.length > 0 ? files.join(', ') : '（见实际改动）'}`,
+      '',
+    ].join('\n')
+    appendFileSync(userFile, entry)
+    for (const c of linked) await appendTaskCheckbox(specBase, c, qlId, desc)
+    await pushQuicklogEntryToPlatform(specBase, {
+      ql_id: qlId,
+      timestamp: nowDatetime(),
+      title: desc,
+      status: 'in_progress',
+      status_note: null,
+      author_raw: user,
+      linked_changes: linked.filter(c => /^\d{4}-\d{2}-\d{2}-/.test(c)),
+      files: files.map(f => ({ path: f, note: null })),
+      body_sections: {},
+      raw_block: entry,
+    }).catch(() => {})
+    return { qlId, existed: false }
+  })
+}
+
 /**
  * 翻某 qlId 条目为「已完成」+ 追加结果 + 勾选关联 tasks.md。持锁。
  */