sillyspec 3.25.9 → 3.26.0

package/src/doctor-diagnostics.js

@@ -11,8 +11,8 @@
  *     - safe_actions：只描述建议动作与风险等级，绝不自动执行
  *
  * 安全约束（硬性）：
- *   - 所有检测只读。DB 以内存副本打开，不调用 export/writeFileSync，不跑建表/迁移，
- *     close 后丢弃——绝不写回原 db 文件。
+ *   - 所有检测只读。DB 以 better-sqlite3 只读连接打开（readonly + fileMustExist），不调用
+ *     export/writeFileSync，不跑建表/迁移，close 后丢弃——绝不写回原 db 文件。
  *   - 不删除/移动任何文件；orphan db 仅报告，处理交给后续 --dump-db / --confirm 流程。
  *   - execute-progress-plan-mismatch 维度同样只读：仅读 plan.md checkbox + 只读查 stages 表，
  *     绝不调用 ProgressManager 写方法（写操作是 progress.alignExecuteToPlan 的职责，D-001@v2 诊断/写分离）。
@@ -20,7 +20,7 @@
  * 风格对齐 scan-postcheck.js：checks 用 CHECK_SEVERITY，formatter 产出 schema_version JSON，
  * writer 落盘到 <authoritySpecDir>/.runtime/。
  */
-import initSqlJs from 'sql.js';
+import Database from 'better-sqlite3';
 import { existsSync, statSync, readFileSync, readdirSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { CHECK_SEVERITY } from './constants.js';
@@ -59,7 +59,7 @@ function resolvePointer(cwd) {
  * 只读打开一个 db 文件，提取诊断信号。绝不写回。
  * 返回 null 表示文件不存在。
  */
-async function probeDb(dbPath, SQL) {
+function probeDb(dbPath) {
   if (!existsSync(dbPath)) return null;
   const st = statSync(dbPath);
   const base = { path: dbPath, exists: true, size: st.size, mtime: st.mtime.toISOString() };
@@ -68,18 +68,16 @@ async function probeDb(dbPath, SQL) {
   }
   let db = null;
   try {
-    const buf = readFileSync(dbPath);
-    db = new SQL.Database(buf); // 内存副本
+    db = new Database(dbPath, { readonly: true, fileMustExist: true });
     const pick = (sql, fallback = null) => {
       try {
-        const r = db.exec(sql);
-        return r.length ? r[0].values[0][0] : fallback;
+        const r = db.prepare(sql).pluck().get();
+        return r === undefined ? fallback : r;
       } catch { return fallback; }
     };
     const pickCol = (sql) => {
       try {
-        const r = db.exec(sql);
-        return r.length ? r[0].values.map((row) => row[0]) : [];
+        return db.prepare(sql).pluck().all();
       } catch { return []; }
     };
     // 每个 active change 的 execute stage status（只读查询；stages 表的 status 列）。
@@ -87,14 +85,12 @@ async function probeDb(dbPath, SQL) {
     // change_name → execute stage status（无 execute 行则 absent）。
     const pickExecuteStatusByChange = () => {
       try {
-        const r = db.exec(
+        const rows = db.prepare(
           `SELECT c.name, s.status FROM changes c
            LEFT JOIN stages s ON s.change_id = c.id AND s.stage = 'execute'`
-        );
+        ).all();
         const out = {};
-        if (r.length) {
-          for (const [name, status] of r[0].values) out[name] = status || null;
-        }
+        for (const row of rows) out[row.name] = row.status || null;
         return out;
       } catch { return {}; }
     };
@@ -123,7 +119,7 @@ function summarizeActive(changes) {
 
 // ── D1 多 db 探测与权威判定 ────────────────────────────────────────────
 
-async function detectMultiDb(cwd, pointer, SQL) {
+function detectMultiDb(cwd, pointer) {
   const localSpec = join(cwd, '.sillyspec');
   const candidates = [
     { path: join(localSpec, 'sillyspec.db'), kind: 'local_root' },
@@ -136,7 +132,7 @@ async function detectMultiDb(cwd, pointer, SQL) {
 
   const dbs = [];
   for (const c of candidates) {
-    const probed = await probeDb(c.path, SQL);
+    const probed = probeDb(c.path);
     if (!probed) continue;
     dbs.push({ kind: c.kind, ...probed });
   }
@@ -492,8 +488,7 @@ function detectExecuteProgressPlanMismatch(authoritySpecRoot, authDb) {
 
 export async function runDoctorDiagnostics({ cwd }) {
   const pointer = resolvePointer(cwd);
-  const SQL = await initSqlJs(); // 复用单个 WASM 实例，避免每个 db 重新初始化遗留 handle
-  const multiDb = await detectMultiDb(cwd, pointer, SQL);
+  const multiDb = detectMultiDb(cwd, pointer);
   const pointerHealth = detectPointerHealth(pointer);
   const changesSplit = detectChangesSplit(cwd, pointer);
   const changeDb = detectChangeDbConsistency(cwd, pointer, multiDb);
@@ -662,17 +657,16 @@ export async function dumpDb({ dbPath, cwd }) {
   }
   let db = null;
   try {
-    const SQL = await initSqlJs();
-    db = new SQL.Database(readFileSync(dbPath));
+    db = new Database(dbPath, { readonly: true, fileMustExist: true });
     const rows = (sql) => {
-      try { const r = db.exec(sql); return r.length ? r[0].values : []; } catch { return []; }
+      try { return db.prepare(sql).all(); } catch { return []; }
     };
     const sv = rows('SELECT schema_version FROM project LIMIT 1');
-    const schemaVersion = sv.length ? sv[0][0] : null;
+    const schemaVersion = sv.length ? sv[0].schema_version : null;
     const changes = rows('SELECT name, current_stage, status, created_at, last_active FROM changes ORDER BY last_active DESC')
-      .map((r) => ({ name: r[0], current_stage: r[1], status: r[2], created_at: r[3], last_active: r[4] }));
+      .map((r) => ({ name: r.name, current_stage: r.current_stage, status: r.status, created_at: r.created_at, last_active: r.last_active }));
     const stages = rows('SELECT c.name, s.stage, s.status, s.started_at, s.completed_at FROM stages s JOIN changes c ON s.change_id = c.id ORDER BY c.name, s.stage')
-      .map((r) => ({ change: r[0], stage: r[1], status: r[2], started_at: r[3], completed_at: r[4] }));
+      .map((r) => ({ change: r.name, stage: r.stage, status: r.status, started_at: r.started_at, completed_at: r.completed_at }));
     return writeDump({ ok: true, meta, schema_version: schemaVersion, changes, stages }, authoritySpecDir);
   } catch (e) {
     return writeDump({ ok: false, meta, error: `读取失败: ${e.message}` }, authoritySpecDir);

package/src/fs-atomic.js

@@ -1,69 +1,69 @@
-/**
- * fs-atomic.js — 原子文件写 + Windows 友好的 rename 重试
- *
- * 用于 .runtime/*.json、pointer、guard.json 等「会被其他进程 / hook 读取」的配置文件。
- * 保证读者要么看到旧完整内容、要么看到新完整内容，不会读到半截 JSON。
- *
- * 注意：db.js 有自己的 _atomicWriteSync（含 .bak 备份），那是 DB 专属持久化逻辑，
- * 已经过稳定性验证，此处不复用、不替换——保持 db.js 零改动。
- */
-import { writeFileSync, renameSync, unlinkSync } from 'fs';
-import { dirname, basename, join } from 'path';
-
-// Windows 上杀毒 / 索引 / IDE 占用文件时，rename 偶发这些错误，短退避重试即可
-const RENAME_RETRY_CODES = ['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY'];
-
-/** 同步退避：优先 Atomics.wait，不可用时退化忙等（仅在 rename 冲突的极端情况触发）。 */
-function sleepSync(ms) {
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-  } catch {
-    const end = Date.now() + ms;
-    while (Date.now() < end) { /* busy wait */ }
-  }
-}
-
-/**
- * rename 带退避重试，覆盖 Windows 偶发的 EPERM/EBUSY/EACCES/ENOTEMPTY。
- * 目录 rename 同样适用（归档移动目录时可复用）。
- * @param {string} from
- * @param {string} to
- * @param {number} [retries=5]
- */
-export function renameSyncRetry(from, to, retries = 5) {
-  let lastErr;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      renameSync(from, to);
-      return;
-    } catch (err) {
-      lastErr = err;
-      const code = err && err.code;
-      // 非可重试错误码立即抛出，不浪费时间
-      if (!code || !RENAME_RETRY_CODES.includes(code)) throw err;
-      if (attempt < retries) sleepSync(15 * (attempt + 1));
-    }
-  }
-  throw lastErr;
-}
-
-/**
- * 原子写文本文件：同目录 tmp 写入 → rename 覆盖目标（带 Windows 退避重试）。
- * - tmp 名含 pid，避免多进程并发写同一目标时 tmp 名碰撞（如多会话写 gate-status.json）。
- * - rename 失败时清理 tmp，避免留下孤儿 .tmp 文件。
- * - Node 的 rename 在 Windows 上用 MoveFileEx(REPLACE_EXISTING)，可覆盖已存在目标；
- *   EPERM 仅在文件被其他进程锁定时出现，由 renameSyncRetry 退避重试。
- * @param {string} filePath - 目标文件绝对路径
- * @param {string} content - 文件内容
- */
-export function writeAtomicSync(filePath, content) {
-  const dir = dirname(filePath);
-  const tmpPath = join(dir, `.${basename(filePath)}.${process.pid}.tmp`);
-  writeFileSync(tmpPath, content);
-  try {
-    renameSyncRetry(tmpPath, filePath);
-  } catch (err) {
-    try { unlinkSync(tmpPath); } catch { /* tmp 可能已被 rename 走，忽略 */ }
-    throw err;
-  }
-}
+/**
+ * fs-atomic.js — 原子文件写 + Windows 友好的 rename 重试
+ *
+ * 用于 .runtime/*.json、pointer、guard.json 等「会被其他进程 / hook 读取」的配置文件。
+ * 保证读者要么看到旧完整内容、要么看到新完整内容，不会读到半截 JSON。
+ *
+ * 注意：db.js 有自己的 _atomicWriteSync（含 .bak 备份），那是 DB 专属持久化逻辑，
+ * 已经过稳定性验证，此处不复用、不替换——保持 db.js 零改动。
+ */
+import { writeFileSync, renameSync, unlinkSync } from 'fs';
+import { dirname, basename, join } from 'path';
+
+// Windows 上杀毒 / 索引 / IDE 占用文件时，rename 偶发这些错误，短退避重试即可
+const RENAME_RETRY_CODES = ['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY'];
+
+/** 同步退避：优先 Atomics.wait，不可用时退化忙等（仅在 rename 冲突的极端情况触发）。 */
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* busy wait */ }
+  }
+}
+
+/**
+ * rename 带退避重试，覆盖 Windows 偶发的 EPERM/EBUSY/EACCES/ENOTEMPTY。
+ * 目录 rename 同样适用（归档移动目录时可复用）。
+ * @param {string} from
+ * @param {string} to
+ * @param {number} [retries=5]
+ */
+export function renameSyncRetry(from, to, retries = 5) {
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err && err.code;
+      // 非可重试错误码立即抛出，不浪费时间
+      if (!code || !RENAME_RETRY_CODES.includes(code)) throw err;
+      if (attempt < retries) sleepSync(15 * (attempt + 1));
+    }
+  }
+  throw lastErr;
+}
+
+/**
+ * 原子写文本文件：同目录 tmp 写入 → rename 覆盖目标（带 Windows 退避重试）。
+ * - tmp 名含 pid，避免多进程并发写同一目标时 tmp 名碰撞（如多会话写 local.yaml）。
+ * - rename 失败时清理 tmp，避免留下孤儿 .tmp 文件。
+ * - Node 的 rename 在 Windows 上用 MoveFileEx(REPLACE_EXISTING)，可覆盖已存在目标；
+ *   EPERM 仅在文件被其他进程锁定时出现，由 renameSyncRetry 退避重试。
+ * @param {string} filePath - 目标文件绝对路径
+ * @param {string} content - 文件内容
+ */
+export function writeAtomicSync(filePath, content) {
+  const dir = dirname(filePath);
+  const tmpPath = join(dir, `.${basename(filePath)}.${process.pid}.tmp`);
+  writeFileSync(tmpPath, content);
+  try {
+    renameSyncRetry(tmpPath, filePath);
+  } catch (err) {
+    try { unlinkSync(tmpPath); } catch { /* tmp 可能已被 rename 走，忽略 */ }
+    throw err;
+  }
+}

package/src/git-helper.js

@@ -0,0 +1,66 @@
+/**
+ * 统一公共 git 调用入口（数组形式 execFileSync，不经 shell）。
+ *
+ * 背景：worktree 链路原用 `execSync(\`git ${args}\`)` 字符串拼接（经 shell），
+ * 文件名/路径/用户输入插值进 shell 存在空格拆词 + 命令注入面；
+ * run/shared.js 的 safeGit 已用 execFileSync 数组形式（注释明示避免拆词）。
+ * 本模块把 safeGit 收口为单一实现，并补抛错版 git / 静默版 gitQuiet，
+ * 供 worktree 链与 run 层共用，消除口径分裂。
+ *
+ * 三者统一带 `-c safe.directory=<cwd>` per-command（不污染全局 config）+ `-C cwd` 前缀；
+ * 默认 timeout 5000ms（opts.timeout 可覆盖），默认 trim（opts.trim:false 保留原样输出）。
+ * 数组形式天然规避 shell 拆词，路径含空格 / 元字符安全。
+ */
+import { execFileSync } from 'node:child_process'
+
+/**
+ * 安全执行 git：失败不抛，返回 { value, error } 结构。
+ * @param {string} cwd
+ * @param {string[]} args
+ * @param {{ trim?: boolean, timeout?: number }} [opts]
+ *   - trim:false 保留原样输出（git status --porcelain 首行前导空格
+ *     是状态码的一部分，trim 会削掉致 parsePorcelainPath 丢首字符，坑见 auditQuickCompletion 注释）
+ *   - timeout 默认 5000ms，长操作（大 diff / worktree list）可传更大值
+ * @returns {{ value: string|null, error: string|null }}
+ */
+export function safeGit(cwd, args, opts = {}) {
+  const { trim = true, timeout = 5000 } = opts
+  const fullArgs = ['-c', `safe.directory=${cwd}`, '-C', cwd, ...args]
+  try {
+    let value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout })
+    if (trim) value = value.trim()
+    return { value, error: null }
+  } catch (e) {
+    return { value: null, error: e.message.split('\n')[0] }
+  }
+}
+
+/**
+ * 抛错版 git：失败抛异常，成功返回 trim 后 string（对齐 worktree 本地 git() 语义）。
+ * 调用方自行 catch；不经 shell，参数以数组元素传递。
+ * @param {string} cwd
+ * @param {string[]} args
+ * @param {{ trim?: boolean, timeout?: number }} [opts]
+ * @returns {string}
+ */
+export function git(cwd, args, opts = {}) {
+  const { trim = true, timeout = 5000 } = opts
+  const fullArgs = ['-c', `safe.directory=${cwd}`, '-C', cwd, ...args]
+  const value = execFileSync('git', fullArgs, { encoding: 'utf8', timeout })
+  return trim ? value.trim() : value
+}
+
+/**
+ * 静默版 git：内部调 git，失败 catch 返回 null（对齐 worktree 本地 gitQuiet() 语义）。
+ * @param {string} cwd
+ * @param {string[]} args
+ * @param {{ trim?: boolean, timeout?: number }} [opts]
+ * @returns {string|null}
+ */
+export function gitQuiet(cwd, args, opts = {}) {
+  try {
+    return git(cwd, args, opts)
+  } catch {
+    return null
+  }
+}

package/src/hooks/worktree-guard.js

@@ -5,7 +5,7 @@
  * 纯判断模块，不做实际的 hook 注入。
  *
  * P0 优化：
- * - 阶段检测 fallback：gate-status.json → sillyspec.db currentStage
+ * - 阶段检测：直读 sillyspec.db currentStage（task-10 废 gate-status.json 缓存双源）
  * - 拦截提示针对每个阶段给出具体修复建议
  */
 
@@ -13,7 +13,6 @@ import { existsSync, readFileSync, readdirSync } from 'fs'
 import path from 'path'
 import { execFileSync } from 'child_process'
 import { createRequire } from 'module'
-import { pathToFileURL } from 'url'
 
 // ── 常量 ──
 
@@ -89,7 +88,6 @@ function findProjectRoot(cwd) {
   let dir = path.resolve(cwd || process.cwd())
   while (true) {
     if (
-      existsSync(path.join(dir, '.sillyspec', '.runtime', 'gate-status.json')) ||
       existsSync(path.join(dir, '.sillyspec', '.runtime', 'sillyspec.db')) ||
       existsSync(path.join(dir, '.sillyspec', 'local.yaml')) ||
       existsSync(path.join(dir, '.sillyspec', 'local.yml')) ||
@@ -224,47 +222,55 @@ function isInsideWorktreeStorage(filePath, cwd) {
   return isPathInside(absPath, resolveWorktreeDir(cwd || process.cwd()))
 }
 
-/**
- * 读取 gate-status.json
- * @param {string} cwd
- * @returns {{ stage: string, changes?: string[], updatedAt?: string } | null}
- */
-function readGateStatus(cwd) {
-  const p = path.join(cwd, '.sillyspec', '.runtime', 'gate-status.json')
-  if (!existsSync(p)) return null
-  try {
-    return JSON.parse(readFileSync(p, 'utf8'))
-  } catch {
-    return null
-  }
-}
-
 /**
  * 同步只读查询 sillyspec.db 第一行第一列（不依赖外部 sqlite3 CLI）。
- * sql.js 的 init 是 async，故用子进程跑（execFileSync 等待）；sql.js 模块经 hook 进程的
- * require.resolve 解析出绝对路径传入，避免子进程 cwd（项目目录）找不到 sql.js。
- * 全平台一致（node 是 SillySpec 自身运行时）。返回字符串值或 null。
+ *
+ * 用子进程跑 better-sqlite3 同步原生绑定（execFileSync 等待）：
+ * - 原生绑定经 hook 进程的 createRequire(import.meta.url).resolve('better-sqlite3') 解析出绝对路径，
+ *   JSON.stringify 嵌入子进程脚本——子进程 cwd 是项目目录，裸 require('better-sqlite3') 找不到包
+ *   （用户项目未必直接装了它）；绝对路径 Windows/Linux/macOS 均 require 直接可用，无需 file:// URL。
+ * - readonly + fileMustExist 双 true 打开只读连接：绝不写库；WAL 并发读不阻塞主进程写，
+ *   且原生绑定可看到已 commit 但未 checkpoint 的过渡态（修复旧 WASM 内存库裸读 .db
+ *   看不见 WAL 的过渡态可见性窗口）。
+ *
+ * 环境假设（R-09）：WAL 模式下只读连接仍需在 .runtime/ 目录建/更新 -shm 索引文件，故 .runtime
+ * 必须可写（与主进程一致）——“只读”指不改 DB 数据，不等于不对 -shm 加索引。
+ *
+ * fail-closed：better-sqlite3 resolve 失败 / db 文件不存在 / fileMustExist 打开失败 / 查询异常 /
+ * 子进程超时或崩溃——一律 console.warn（含 e.stderr 详情）并返回 null，调用方
+ *（readCurrentStage/isNoWorktreeMode）对 null 走 fail-closed，禁止 fail-open。
  */
 function queryDbFirstCell(cwd, sql) {
   const dbPath = path.join(cwd, '.sillyspec', '.runtime', 'sillyspec.db')
-  if (!existsSync(dbPath)) return null
-  let sqlJsPath
-  try { sqlJsPath = createRequire(import.meta.url).resolve('sql.js') } catch { return null }
-  // Windows 上 dynamic import 不接受裸 "C:\..." 路径，必须转 file:// URL（全平台合法）
-  const libUrl = pathToFileURL(sqlJsPath).href
+  if (!existsSync(dbPath)) {
+    // db 文件不存在（findProjectRoot 命中 local.yaml/projects 但无 DB，或 DB 被删）：fail-closed。
+    // warn 让异常（如 DB 误删）可见；正常空态在 findProjectRoot 未命中时根本不会进到这里。
+    console.warn('⚠️ sillyspec.db 不存在，hook 降级 fail-closed: ' + dbPath)
+    return null
+  }
+  let libPath
+  try {
+    libPath = createRequire(import.meta.url).resolve('better-sqlite3')
+  } catch (e) {
+    console.warn('⚠️ sillyspec.db 查询失败（better-sqlite3 未解析），hook 降级 fail-closed: ' + ((e && e.message) || e))
+    return null
+  }
+  // 子进程同步 require 绝对路径（better-sqlite3 是同步原生 API，无 async/import().then 包装）。
+  // pluck().get() 取第一行第一列原值，无行返回 undefined（写空 stdout → 父侧 trim 后 null）。
   const script =
-    "const fs=require('fs');" +
-    "const dbPath=" + JSON.stringify(dbPath) + ",sql=" + JSON.stringify(sql) + ",lib=" + JSON.stringify(libUrl) + ";" +
-    "if(!fs.existsSync(dbPath))process.exit(0);" +
-    "import(lib).then(async m=>{const SQL=await m.default();" +
-    "const db=new SQL.Database(fs.readFileSync(dbPath));const r=db.exec(sql);" +
-    "if(r.length&&r[0].values.length)process.stdout.write(String(r[0].values[0][0]??''));db.close()}).catch(e=>{process.stderr.write('hook db query failed: '+String(e&&e.message||e));process.exit(1)});"
+    "const D=require(" + JSON.stringify(libPath) + ")," +
+    "dbPath=" + JSON.stringify(dbPath) + ",sql=" + JSON.stringify(sql) + ";" +
+    "let db;" +
+    "try{db=new D(dbPath,{readonly:true,fileMustExist:true});" +
+    "const v=db.prepare(sql).pluck().get();" +
+    "if(v!==undefined)process.stdout.write(String(v??''));db.close()}" +
+    "catch(e){process.stderr.write('hook db query failed: '+String(e&&e.message||e));process.exit(1)};"
   try {
     return execFileSync(process.execPath, ['-e', script], {
       encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'],
     }).trim() || null
   } catch (e) {
-    // DB 查询失败（db 损坏 / sql.js resolve 失败 / 子进程超时）：降级返回 null，调用方
+    // DB 查询失败（db 损坏 / fileMustExist 打开失败 / 子进程超时或崩溃）：降级返回 null，调用方
     //（readCurrentStage 等）对 null 走 fail-closed。补 warn 让 doctor/agent 能看到根因，
     // 而非完全静默（子进程把诊断写到了 stderr，execFileSync 抛错时挂在 e.stderr 上）。
     const detail = (e && e.stderr ? String(e.stderr).trim() : '') || (e && e.message) || 'timeout/crash'
@@ -280,47 +286,48 @@ export {
   isSingleCommandReadonly as _isSingleCommandReadonlyForTest,
 };
 /**
- * 从 sillyspec.db 读取 currentStage
- * 优先级：gate-status.json > sillyspec.db
+ * 从 sillyspec.db 读取 currentStage（直读 DB，task-10 废 gate-status.json 后为唯一来源）
  * @param {string} cwd
  * @returns {string|null} 阶段名，null 表示无法确定
  */
 function readCurrentStage(cwd) {
-  // 1. gate-status.json（高速缓存，权威来源）
-  const gateStatus = readGateStatus(cwd)
-  if (gateStatus && gateStatus.stage) return gateStatus.stage
-
-  // 2. 从 sillyspec.db 读取（node + sql.js 子进程，不依赖外部 sqlite3 CLI——Windows 默认没有）
+  // 直读 sillyspec.db（node + better-sqlite3 只读子进程，不依赖外部 sqlite3 CLI——Windows 默认没有）
   const v = queryDbFirstCell(cwd, "SELECT current_stage FROM changes WHERE status='active' AND current_stage IN ('execute','quick') ORDER BY last_active DESC LIMIT 1")
   return v || null
 }
 
 /**
- * 检查当前变更是否处于 noWorktree 模式
+ * 检查当前变更是否处于 noWorktree 模式（直读 sillyspec.db）
  * @param {string} cwd
  * @returns {boolean}
  */
 function isNoWorktreeMode(cwd) {
-  // 1. 检查 gate-status.json
-  const gateStatus = readGateStatus(cwd)
-  if (gateStatus && gateStatus.noWorktree) return true
-
-  // 2. 从 sillyspec.db 读取（node + sql.js，同 readCurrentStage）
+  // 直读 sillyspec.db（node + better-sqlite3，同 readCurrentStage）
   return queryDbFirstCell(cwd, "SELECT no_worktree FROM changes WHERE status='active' AND current_stage IN ('execute','quick') LIMIT 1") === '1'
 }
 
 /**
- * 判断路径是否在 worktree 内
+ * 判断路径是否在某已注册 worktree 内
  * @param {string} filePath - 绝对路径
  * @returns {boolean}
  */
 function isInsideRegisteredWorktree(filePath, cwd) {
   const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd || process.cwd(), filePath)
   const effectiveCwd = cwd || process.cwd()
-  const gateStatus = readGateStatus(effectiveCwd)
-  const changes = Array.isArray(gateStatus?.changes) ? gateStatus.changes : []
 
-  for (const changeName of changes) {
+  // 已注册 worktree 名单来源：扫描 .runtime/worktrees/ 子目录（task-10 废 gate-status.json 后的权威来源）。
+  // queryDbFirstCell 是单行单列，读不了多行 change 名单；目录扫描天然支持多 change 并发，
+  // 且 worktree 目录存在性 == 注册态，比 DB changes 表更贴合“已注册 worktree”语义
+  // （changes 表可能含 no_worktree 变更，它们没有 worktree 目录）。
+  // 跨平台：isPathInside 用 path.sep 判定包含关系，Windows backslash / POSIX slash 均正确。
+  const worktreeDir = resolveWorktreeDir(effectiveCwd)
+  let changeNames = []
+  try {
+    const entries = readdirSync(worktreeDir, { withFileTypes: true })
+    changeNames = entries.filter(e => e.isDirectory()).map(e => e.name)
+  } catch { /* 目录不存在或不可读 → 无注册 worktree */ }
+
+  for (const changeName of changeNames) {
     const meta = readWorktreeMeta(effectiveCwd, changeName)
     if (meta?.worktreePath && isPathInside(absPath, meta.worktreePath)) return true
   }
@@ -661,7 +668,7 @@ function readAllQuickGuards(projectRoot) {
  * - 除非同时设置 SILLYSPEC_DISABLE_HOOKS=1
  *
  * P0 优化：
- * - 使用 readCurrentStage() fallback 读取阶段（gate-status → progress）
+ * - 使用 readCurrentStage() 直读 sillyspec.db 获取阶段
  * - 拦截提示按阶段给出具体修复建议
  *
  * @param {string} filePath - 目标文件绝对路径
@@ -675,7 +682,7 @@ export function shouldBlockWrite(filePath, cwd) {
   const projectRoot = findProjectRoot(callerCwd)
   const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(callerCwd, filePath)
 
-  // 1. 阶段门禁（使用 fallback 读取）
+  // 1. 阶段门禁（直读 sillyspec.db）
   const stage = readCurrentStage(projectRoot) || '(none)'
 
   const scanGuardResult = shouldBlockScanDocOverwrite(absPath, projectRoot)
@@ -694,9 +701,11 @@ export function shouldBlockWrite(filePath, cwd) {
   // quick 阶段：检查 baselineFiles（合并所有活跃 session guard 并集，D-002@v1）
   if (stage === 'quick') {
     const { baselineFiles } = readAllQuickGuards(projectRoot)
-    const relTarget = path.relative(projectRoot, absPath)
+    // 归一为 forward-slash：baselineFiles 取自 guard.json（经 parsePorcelainPath 已是 /），
+    // Windows 下 path.relative 产 backslash 会与 baseline 不匹配，导致实时防护被静默绕过
+    const relTarget = path.relative(projectRoot, absPath).split(path.sep).join('/')
     // 如果目标是 baseline protected file，阻止写入（并集 = 保护所有 session 的 baseline）
-    if (baselineFiles.some(f => relTarget === f || relTarget.startsWith(f + path.sep))) {
+    if (baselineFiles.some(f => relTarget === f || relTarget.startsWith(f + '/'))) {
       return {
         blocked: true,
         reason: [
@@ -755,7 +764,7 @@ export function shouldBlockBash(command, cwd) {
   // cwd 在 worktree 内 → 全部放行
   if (isInsideRegisteredWorktree(callerCwd, projectRoot)) return { blocked: false }
 
-  // 阶段门禁（使用 fallback 读取）
+  // 阶段门禁（直读 sillyspec.db）
   const stage = readCurrentStage(projectRoot) || '(none)'
 
   if (!['execute', 'quick'].includes(stage)) {