sillyspec 3.26.15 → 3.27.2

package/src/worktree-deps.js

@@ -8,8 +8,8 @@
  * 见 change 2026-06-28-worktree-deps-provision / D-005@v1, D-007@v1。
  */
 
-import { existsSync, readFileSync, realpathSync } from 'fs';
-import { join, isAbsolute, resolve as resolvePath, sep as pathSep } from 'path';
+import { existsSync, readFileSync, realpathSync, lstatSync } from 'fs';
+import { join, isAbsolute, relative, resolve as resolvePath, sep as pathSep } from 'path';
 import { execFileSync } from 'child_process';
 import { createHash } from 'crypto';
 
@@ -137,10 +137,22 @@ function tryLink(mainNodeModules, linkPath) {
       // execFileSync 数组形式不经 shell：POSIX 双引号内 `/$() 会执行、cmd.exe 双引号内 %VAR% 仍展开，
       // linkPath 含 local.yaml 模块 path，属项目内可配置值（安全收敛，与 git-helper 同范式）
       execFileSync('cmd.exe', ['/c', 'mklink', '/J', linkPath, mainNodeModules], { stdio: ['pipe', 'pipe', 'pipe'] });
-      return { ok: true, method: 'junction' };
+    } else {
+      execFileSync('ln', ['-s', mainNodeModules, linkPath], { stdio: ['pipe', 'pipe', 'pipe'] });
     }
-    execFileSync('ln', ['-s', mainNodeModules, linkPath], { stdio: ['pipe', 'pipe', 'pipe'] });
-    return { ok: true, method: 'symlink' };
+    // 创建后实物复核（坑 provision-silent-fake-installed 第②层，2026-08-21 实证：doctor 报
+    // re-provisioned 成功但 junction 实际没建）——mklink/ln 退出码 0 不等于链接落盘（cmd.exe
+    // 垫片链存在静默失败面），lstat+existsSync 复核不存在即判失败，交由调用方走 install 兜底
+    //（junction（reparse point）与 symlink 的 lstat 均报 isSymbolicLink=true）
+    try {
+      const st = lstatSync(linkPath);
+      if (!st.isSymbolicLink() || !existsSync(linkPath)) {
+        return { ok: false, error: 'link 创建后复核失败：lstat 非 link 或路径不可达' };
+      }
+    } catch (e) {
+      return { ok: false, error: `link 创建后复核失败（lstat ${e.message}）` };
+    }
+    return { ok: true, method: process.platform === 'win32' ? 'junction' : 'symlink' };
   } catch (e) {
     return { ok: false, error: e.message };
   }
@@ -344,6 +356,48 @@ export function provisionDeps(worktreePath, mainCwd, opts = {}) {
         ? { depsStatus: 'installed', depsMethod: 'install', depsSource: 'install', depsLockHash: wtHash }
         : { depsStatus: 'failed', depsMethod: null, depsSource: null, depsLockHash: wtHash, depsError: installResult.error };
     }
+    // ── 结果后验证（坑 provision-silent-fake-installed，2026-08-21 Windows 实证；
+    //    坑 provision-monorepo-subpackage-fake-installed，2026-08-22 复发：pnpm monorepo
+    //    workspace 根 package.json 的 dependencies 常为空（依赖在 frontend/daemon 子包），
+    //    只查根会把 installed 状态整体跳过——doctor 标 installed 但子包 node_modules 全缺，
+    //    Wave 1 测试才挂）。分层校验：
+    //   linked：根 junction 实存硬校验（link 声称成功必留痕）；
+    //   installed：校验目标集 = 根 + local.yaml modules 块声明的含 package.json 子模块，
+    //     其中【声明了依赖】的目录逐一要求 node_modules 存在（pnpm/npm/yarn workspace
+    //     安装都会给子包建 node_modules；无依赖声明的空壳目录合法地不建，不校验）。
+    //   python/.venv、jvm 本地仓库本就不适用（整体仅 nodejs）。
+    if (projectType === 'nodejs') {
+      const pkgHasDeps = (dir) => {
+        try {
+          const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
+          return ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']
+            .some(k => pkg[k] && Object.keys(pkg[k]).length > 0)
+        } catch { return false }
+      }
+      // 目标集：根 + modules 块内含 package.json 的安全子模块（monorepo 子包）
+      const verifyDirs = [worktreePath]
+      for (const mp of extractModulePaths(yamlText)) {
+        if (!isSafeModulePath(mp)) continue
+        const sub = join(worktreePath, mp)
+        if (existsSync(join(sub, 'package.json'))) verifyDirs.push(sub)
+      }
+      const depsDeclaredDirs = verifyDirs.filter(pkgHasDeps)
+      const needVerify = result.depsStatus === 'linked'
+        || (result.depsStatus === 'installed' && depsDeclaredDirs.length > 0)
+      if (needVerify) {
+        // linked 只验根（junction 语义）；installed 验全部声明依赖的目标目录
+        const targets = result.depsStatus === 'linked' ? [worktreePath] : depsDeclaredDirs
+        const missing = targets.filter(dir => !existsSync(join(dir, 'node_modules')))
+        if (missing.length > 0) {
+          const missingRel = missing.map(dir => relative(worktreePath, dir) || '(根)')
+          result = {
+            depsStatus: 'failed', depsMethod: null, depsSource: null, depsLockHash: wtHash,
+            depsError: `${result.depsStatus} 后验证失败：${missingRel.join('、')} 的 node_modules 不存在（报成功但实际未落盘——Windows 静默失败面：cmd.exe 垫片解析/杀毒拦截/frozen-lockfile 快退）。` +
+              `手动兜底：进 worktree 手动跑 ${installCmd}（子包随 workspace 一起装），或对 lockfile 一致的目录用 junction：New-Item -ItemType Junction -Path "<目标>/node_modules" -Target "<主仓对应目录>/node_modules"，然后重试 doctor --fix`,
+          }
+        }
+      }
+    }
   }
   result.depsCheckedAt = depsCheckedAt;
 
@@ -372,6 +426,18 @@ export function provisionDeps(worktreePath, mainCwd, opts = {}) {
       result.depsMethod = linkedModules[0].method;
       result.depsSource = 'main-checkout';
     }
+    // 子模块 link 后验证（坑 modules-submodule-link-verify，2026-08-23 实证：Windows 下漏链
+    // frontend node_modules——linkOneDir 报 linked 但 junction 实际未建或 main 侧本就没有）。
+    // linked 状态的子模块逐一核验 wt/<mp>/node_modules 实存：缺失降 failed 并给兜底指引
+    //（不静默放行——跑测试时才发现就晚了）。
+    for (const m of moduleResults) {
+      if (m.status !== 'linked') continue
+      const nmPath = join(worktreePath, m.path, 'node_modules')
+      if (!existsSync(nmPath)) {
+        m.status = 'failed'
+        m.error = `linked 后验证失败：${m.path}/node_modules 不存在（报成功但实际未落盘）。兜底：New-Item -ItemType Junction -Path "<wt>/${m.path}/node_modules" -Target "<主仓>/${m.path}/node_modules"`
+      }
+    }
     const failedModules = moduleResults.filter(m => m.status === 'failed');
     if (failedModules.length > 0) {
       const fmsg = failedModules.map(m => `${m.path}: ${m.error}`).join('; ');

package/src/worktree.js

@@ -1003,7 +1003,7 @@ export class WorktreeManager {
    * @param {string} wtPath - worktree 根目录（meta.worktreePath）
    * @returns {{ ok: boolean, msg: string }}
    */
-  _doctorReprovision(name, wtPath) {
+  _doctorReprovision(name, wtPath, opts = {}) {
     try {
       const meta = this.getMeta(name) || {};
       const isInPlace = meta.mode === 'in-place-fallback';
@@ -1033,9 +1033,14 @@ export class WorktreeManager {
           }
         }
       }
+      // 触发分流（坑 doctor-reprovision-junction-missing，2026-08-22 实证：junction 未建的
+      // missing/failed 场景被 force install 强制重装——install 静默失败面大且慢；lockfile 一致时
+      // 重建 junction 才是对症动作。opts.relinkFirst（missing/failed 触发）→ 非 force 跑：解链后
+      // node_modules 不存在，tryLink 直接重建；lockfile 漂移自动落 install。stale/main-drift 维持
+      // force 重装（依赖确实变了）。
       const deps = provisionDeps(wtPath, this.cwd, {
         specBase: join(this.cwd, '.sillyspec'),
-        force: true,
+        force: !opts.relinkFirst,
       }) || {};
       const metaPath = join(this.getWorktreePath(name), META_FILE);
       // 成功重供时清掉旧 depsError（provisionDeps 成功结果不含该键，{...meta,...deps} 会残留旧值）
@@ -1153,7 +1158,29 @@ export class WorktreeManager {
         // 放宽原 909 in-place-fallback 守卫：in-place 也跑（main-drift/stale/failed 对它同样有意义，
         // 真 in-place 的 wtPath===主仓→wtHash===mainHash→不会误报 main-drift，仅 failed/stale 有意义）。
         // fix 时 _doctorReprovision 自行判断是否解链（in-place 不解链，仅 install）。
+        // 归档态前置闸（坑 doctor-reprovision-archived-change，2026-08-21 实证：已归档变更的
+        // worktree 被 doctor 当活跃任务 re-provision——给死目录装依赖）。归档判定（changes/archive/
+        // 实体 或 进度库 status='archived'）命中 → 跳过供给，fix 时走 cleanup（其内建
+        // hasUnappliedChanges 护栏仍在，未落仓内容照样拒删）。
         if (meta && meta.worktreePath && existsSync(meta.worktreePath)) {
+          const isArchivedChange = existsSync(join(this.cwd, '.sillyspec', 'changes', 'archive', name))
+            || this._isChangeArchivedInDb(name);
+          if (isArchivedChange) {
+            issues.push({ type: 'worktree-archived-change', name, fixable: meta.mode !== 'native-worktree',
+              detail: `变更 ${name} 已归档但 worktree 残留——不供给依赖（死目录），建议清理（cleanup 内建未落仓护栏）` });
+            if (fix && meta.mode !== 'native-worktree') {
+              try {
+                const r = this.cleanup(name);
+                if (r.result === 'cleaned' || r.result === 'force-cleaned') {
+                  fixed.push(`cleaned archived-change worktree: ${name}`);
+                } else if (r.result === 'blocked') {
+                  unfixable.push(`cleanup blocked (archived change 有未落仓内容): ${name} — 先 apply/commit 再清`);
+                } else {
+                  unfixable.push(`cleanup skipped (archived change): ${name}`);
+                }
+              } catch { unfixable.push(`cleanup failed (archived change): ${name}`); }
+            }
+          } else {
           const wtPath = meta.worktreePath;
           const fresh = checkDepsFreshness(meta, wtPath, this.cwd);
           const issueTypeByStatus = {
@@ -1166,10 +1193,13 @@ export class WorktreeManager {
           if (issueType) {
             issues.push({ type: issueType, name, detail: fresh.detail, fixable: true });
             if (fix) {
-              const r = this._doctorReprovision(name, wtPath);
+              // relinkFirst：missing/failed 多为 junction 丢失/上次供给失败——link 优先重建；
+              // stale/main-drift 是依赖真变了——force 重装
+              const r = this._doctorReprovision(name, wtPath, { relinkFirst: issueType === 'deps-missing' || issueType === 'deps-failed' });
               (r.ok ? fixed : unfixable).push(r.msg);
             }
           }
+          }
         }
 
         // meta 存在但 worktree 目录不存在
@@ -1311,10 +1341,24 @@ export class WorktreeManager {
 
       // 2) 候选集中尚未落到主工作区 HEAD 的子集
       const pending = this._changesAlreadyOnMain(worktreePath, tracked, untracked);
-      if (pending.length === 0) {
-        return { hasChanges: false, changedFiles: [], reason: 'all changes already on main HEAD' };
+      // 3) main 工作区副本降噪层（坑 unapplied-false-positive-workspace-copy，2026-08-21 实证：
+      // apply 后 main 工作区有逐字节一致副本但未 commit → HEAD-only 判定报「未落仓」虚警拦
+      // doctor）。原注释「不查 main 工作区未提交副本（防误删）」的保护意图是内容未落地——
+      // 逐字节一致时内容确已落地（删 worktree 无损），仅逐字节不同的才保守保留。
+      const pendingAfterWs = pending.filter(f => {
+        try {
+          const mainCopy = join(this.cwd, f);
+          if (!existsSync(mainCopy)) return true; // main 工作区无副本 → 仍算未落仓
+          const wtCopy = join(worktreePath, f);
+          if (!existsSync(wtCopy)) return true; // worktree 侧是删除态、main 侧却在 → 内容分叉，保留
+          const a = readFileSync(wtCopy); const b = readFileSync(mainCopy);
+          return !(a.length === b.length && a.equals(b)); // 逐字节一致 → 已落地（剔除）
+        } catch { return true }
+      })
+      if (pendingAfterWs.length === 0) {
+        return { hasChanges: false, changedFiles: [], reason: 'all changes already on main (HEAD or identical workspace copy)' };
       }
-      return { hasChanges: true, changedFiles: pending };
+      return { hasChanges: true, changedFiles: pendingAfterWs };
     } catch (e) {
       // 检测失败时保守处理：视为有变更，保留 worktree
       return { hasChanges: true, changedFiles: [], reason: `check failed: ${e.message}` };
@@ -1385,6 +1429,26 @@ export class WorktreeManager {
     return map;
   }
 
+  /**
+   * DB 归档态探测（坑 doctor-reprovision-archived-change）：changes 表 status='archived'。
+   * 只读直查（node:sqlite）——doctor 是同步方法，惰性动态 import 不可用；DB 不存在/无行/
+   * 读失败 → false（保守退回普通 deps 供给路径）。
+   * @param {string} name
+   * @returns {boolean}
+   */
+  _isChangeArchivedInDb(name) {
+    try {
+      const dbPath = join(this.cwd, '.sillyspec', '.runtime', 'sillyspec.db');
+      if (!existsSync(dbPath)) return false;
+      const { openDatabase } = require('./db-engine.js');
+      const db = openDatabase(dbPath, { readOnly: true });
+      try {
+        const row = db.prepare('SELECT status FROM changes WHERE name = ?').get(name);
+        return row?.status === 'archived';
+      } finally { try { db.close() } catch {} }
+    } catch { return false }
+  }
+
   /**
    * 从 worktree 路径反推 changeName
    * @private