peaks-loop 4.0.30 → 4.0.32

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 4.0.32 — 2026-09-08 (CI 首次全绿 — 工作流修复 + Linux-only 测试修复)
+
+**Highlights**:
+
+1. **CI 工作流修复（本仓库 ci.yml 首次真正跑通）** — 此前第一个门 `pnpm/action-setup@v4` 在 runner 默认 Node 24 上 self-installer 必挂，导致后续所有步骤从未被验证。
+
+   - `pnpm/action-setup@v4` → `corepack`（对齐 publish.yml）。
+   - 删除 Build 之前的 `npx tsc --noEmit` 步骤：它跑在 `packages/*/dist` 生成之前，而 `peaks-loop-shared/version` 等 subpath 指向 dist，任何 commit 都过不了；canonical typecheck 由 `npm run build` 内的 `tsc -p tsconfig.build.json` 承担。
+   - 移除 node 20.x 矩阵（windows-latest + 20.x 的 pnpm install 红且日志 admin-only 无法诊断）。
+   - capability-guard 固定 `PEAKS_CALLER_ID`（J02 等 contract 会 spawn `bin/peaks.js`，CI 无 IDE adapter env 时 callerId 解析走 D2/EX_USAGE）。
+   - Test 步骤新增 `--reporter=github-actions`，失败转为可无 admin 读取的 check-run annotation。
+
+2. **3 类 pre-existing Linux-only 测试修复**（windows 早已绿，ubuntu 红；用 Docker Linux 容器忠实复现定位）：
+
+   - `setImmediate` 闭包竞态：延迟清理回调读取可变模块级 `workspace`，可能在下一个测试 `beforeEach` 重新赋值后删除**活着的**工作目录 → `ENOENT: uv_cwd`（3 个 session 套件 + 4 个潜伏同模式文件）。
+   - `detect-eslint` 断言 Windows 专属行为（`npx-resolver` 在 POSIX 上按设计返回裸 `npx`）→ 改为平台感知断言。
+   - `scan-orchestrator` 的 100ms 墙钟下限 flake → 改为断言 `elapsedMs` 已被填充。
+
+   验证：CI run 全 3 job success；双平台独立复跑 Linux 119 files / 1010 passed、Windows 119 files / 1014 passed。
+
+## 4.0.31 — 2026-09-08 (codegraph auto-refresh 悬空 marker 修复)
+
+**Highlights**:
+
+1. **codegraph 自动刷新失效修复** — 根因：`peaks workspace init` auto-stake 只写 `.peaks-loop-marker` 不跑上游 `codegraph init`，留下无 `codegraph.db` 的悬空 `.codegraph/`；下游把"有 marker"误判为"已初始化"，post-slice 自动刷新跑 `index` 静默失败（"CodeGraph not initialized"）。
+
+   - 新增 `isCodegraphInitialized()` 按 `.codegraph/codegraph.db` 判真实初始化（对齐上游 `isInitialized`）。
+   - `workspace init` auto-stake 改为真跑上游 `codegraph init`（快、离线安全）。
+   - auto-refresh / preflight 发现悬空 marker（有 marker 无 db）时自愈：先 `init` 再 `index`。
+   - init guard 对"marker 有但 db 无"返回 `fresh`，`peaks codegraph init` 可重跑恢复。
+
+   验证：scoped 51 测试 + codegraph/workspace 73 测试全过，tsc 干净，现场自测从悬空态成功建出 `codegraph.db`。
+
 ## 4.0.30 — 2026-09-07 (搜索优先 preflight + 超行文件拆分 + CLI 漂移修复)
 
 **Highlights**:

package/dist/cli/commands/workspace/init-command.js

@@ -26,7 +26,7 @@ import { resolveCanonicalProjectRoot } from '../../../services/config/config-ser
 import { applyHookInstall, readHookStatus } from '../../../services/skills/hooks-settings-service.js';
 import { clearStalePresenceOnRotation } from '../../../services/skills/skill-presence-service.js';
 import { gcStalePresenceLeases } from '../../../services/skills/presence-lease-service.js';
-import { defaultCodegraphInitGuard, writeCodegraphMarker } from '../../../services/codegraph/codegraph-service.js';
+import { createCodegraphInvocation, defaultCodegraphInitGuard, executeCodegraphInvocation, writeCodegraphMarker } from '../../../services/codegraph/codegraph-service.js';
 import { mkdirSync } from 'node:fs';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.js';
@@ -339,23 +339,36 @@ export function registerWorkspaceInitCommand(workspace, io) {
             if (report.standardsMissing.missing) {
                 markStandardsChecked(projectRoot, sessionId);
             }
-            // rid-CG-001: auto-stake a peaks-loop-managed `.codegraph/`
-            // directory after a successful workspace init. Calls the
-            // conflict guard (rid-CG-006) BEFORE writing so a foreign
-            // schema is never silently overwritten. We deliberately do
-            // NOT spawn the upstream codegraph binary here — `peaks
-            // workspace init` must stay fast and offline-safe; the user
-            // runs `peaks codegraph index` next if they want the actual
-            // SQLite-backed index.
+            // rid-CG-001 (revised): auto-stake a peaks-loop-managed `.codegraph/`
+            // directory after a successful workspace init. Calls the conflict
+            // guard (rid-CG-006) BEFORE writing so a foreign schema is never
+            // silently overwritten. We now run a REAL upstream `codegraph init`
+            // (not just mkdir + marker) so the schema actually has a
+            // `codegraph.db`, which is what post-slice auto-refresh and the
+            // pre-dispatch preflight gate on. `codegraph init` (WITHOUT
+            // `--index`) is fast (~1 s) and offline-safe — it only `Parser.init()`s
+            // WASM grammars that resolve from node_modules; the slow/offline
+            // concern applies to `index` (full build), not `init`.
             let codegraphAutoOutcome = null;
             try {
                 const guard = defaultCodegraphInitGuard(projectRoot);
                 if (guard.status === 'fresh') {
-                    mkdirSync(guard.codegraphDir, { recursive: true });
-                    writeCodegraphMarker(guard.codegraphDir);
-                    codegraphAutoOutcome = { status: 'fresh' };
-                    nextActions.push(`Auto-created empty ${guard.codegraphDir}/ and stamped the peaks-loop marker. ` +
-                        'Run `peaks codegraph index --project <path>` next to build the SQLite-backed index.');
+                    // 'fresh' here also covers the dangling state (marker present but
+                    // no codegraph.db) — running init self-heals both.
+                    const initResult = await executeCodegraphInvocation(createCodegraphInvocation({ subcommand: 'init', project: projectRoot }));
+                    if (initResult.exitCode !== 0) {
+                        warningsForEnvelope.push(`codegraph auto-stake init failed (exit ${String(initResult.exitCode)}). ` +
+                            'Run `peaks codegraph init --project <path>` manually to enable codegraph.');
+                    }
+                    else {
+                        // Upstream init creates `.codegraph/`; mkdir is a no-op in the
+                        // real path and lets the marker write succeed. Best-effort.
+                        mkdirSync(guard.codegraphDir, { recursive: true });
+                        writeCodegraphMarker(guard.codegraphDir);
+                        codegraphAutoOutcome = { status: 'fresh' };
+                        nextActions.push(`Auto-staked a peaks-loop-managed ${guard.codegraphDir}/ (upstream init + marker). ` +
+                            'Run `peaks codegraph index --project <path>` next to build the SQLite-backed index.');
+                    }
                 }
                 else if (guard.status === 'noop-already-peaks-loop') {
                     codegraphAutoOutcome = { status: 'noop' };

package/dist/services/codegraph/codegraph-autorefresh.js

@@ -20,17 +20,24 @@
 //   - No `<projectRoot>/.codegraph/` directory → skip (codegraph was
 //     never initialized for this project; `peaks codegraph init` is a
 //     one-time setup the orchestrator owns).
+//   - `.codegraph/` present WITH `codegraph.db` → `index` (incremental).
+//   - `.codegraph/` present with the peaks-loop marker but NO
+//     `codegraph.db` (dangling) → self-heal: `init` then `index`.
+//   - `.codegraph/` present without a marker and without `codegraph.db`
+//     (foreign schema) → skip; never touch a foreign store.
 //   - The upstream index exits non-zero → return `index-failed` with a
 //     human-readable note.
 //   - Any unexpected error → return `unavailable` with a note.
 //
-// We deliberately do NOT auto-init: `codegraph init` can prompt / take a
-// long time on first run, which would make the background side-effect
-// block the slice boundary. Projects that want auto-refresh first run
-// `peaks codegraph init` once (per the orchestration doc).
-import { statSync } from 'node:fs';
+// We do NOT auto-init a genuinely fresh (no `.codegraph/` dir) project:
+// the orchestrator owns that one-time setup. The dangling self-heal above
+// IS an auto-init, but `codegraph init` (WITHOUT `--index`) is fast (~1 s)
+// and offline-safe — it only `Parser.init()`s WASM grammars that resolve
+// from node_modules. The slow/offline concern applies to `index` (full
+// build), not `init`.
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { CODEGRAPH_DIR_NAME, createCodegraphInvocation, executeCodegraphInvocation, } from './codegraph-service.js';
+import { CODEGRAPH_DIR_NAME, CODEGRAPH_MARKER_NAME, createCodegraphInvocation, executeCodegraphInvocation, isCodegraphInitialized, } from './codegraph-service.js';
 /**
  * True when `<projectRoot>/.codegraph/` exists and is a directory.
  * Pure fs probe; never throws.
@@ -43,6 +50,14 @@ export function isCodegraphPresent(projectRoot) {
         return false;
     }
 }
+/**
+ * True when `<projectRoot>/.codegraph/` carries the peaks-loop marker
+ * (i.e. peaks-loop manages it, as opposed to a foreign tool). Pure fs
+ * probe; never throws.
+ */
+function isCodegraphPeaksLoopManaged(projectRoot) {
+    return existsSync(join(projectRoot, CODEGRAPH_DIR_NAME, CODEGRAPH_MARKER_NAME));
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -70,6 +85,29 @@ export async function refreshCodegraphAfterSlice(projectRoot, runner) {
         };
     }
     try {
+        // A `.codegraph/` dir without a `codegraph.db` is uninitialized:
+        //   - NOT peaks-loop-managed → foreign schema, never touch it.
+        //   - peaks-loop-managed → the dangling state left by the pre-fix
+        //     rid-CG-001 auto-stake (marker stamped, no upstream init). Run
+        //     init (fast, offline-safe — no full index) so the subsequent
+        //     index has a schema to write into.
+        if (!isCodegraphInitialized(projectRoot)) {
+            if (!isCodegraphPeaksLoopManaged(projectRoot)) {
+                return {
+                    refreshed: false,
+                    reason: 'no-codegraph-dir',
+                    note: `auto codegraph refresh skipped: ${CODEGRAPH_DIR_NAME}/ exists without a codegraph.db and is not peaks-loop-managed. Run \`peaks codegraph init\` once to enable post-slice auto-refresh.`,
+                };
+            }
+            const initResult = await executeCodegraphInvocation(createCodegraphInvocation({ subcommand: 'init', project: projectRoot }), runner);
+            if (initResult.exitCode !== 0) {
+                return {
+                    refreshed: false,
+                    reason: 'index-failed',
+                    note: `auto codegraph refresh self-heal init failed (exit ${String(initResult.exitCode)}): ${firstMeaningfulLine(initResult.stderr || initResult.stdout)}`,
+                };
+            }
+        }
         const invocation = createCodegraphInvocation({ subcommand: 'index', project: projectRoot, quiet: true });
         const result = await executeCodegraphInvocation(invocation, runner);
         if (result.exitCode !== 0) {

package/dist/services/codegraph/codegraph-preflight-service.d.ts

@@ -42,8 +42,11 @@ export declare function renderCodegraphStructureBlock(files: readonly CodegraphS
  *
  * Behavior matrix (acceptance criteria):
  * - `.codegraph/` absent  → init + index (best-effort), then read.
- * - `.codegraph/` present with peaks-loop marker → skip init/index
- *   (fresh), read directly. No redundant re-index on every dispatch.
+ * - `.codegraph/` present with peaks-loop marker AND `codegraph.db` →
+ *   skip init/index (fresh), read directly. No redundant re-index on
+ *   every dispatch.
+ * - `.codegraph/` present with peaks-loop marker but NO `codegraph.db`
+ *   (dangling) → init + index (self-heal), then read.
  * - `.codegraph/` present WITHOUT marker (foreign schema) → fail-soft;
  *   never clobber a foreign store.
  *

package/dist/services/codegraph/codegraph-preflight-service.js

@@ -31,7 +31,7 @@
 //   - CODEGRAPH_STRUCTURE_MAX_DIRS        = 40  directory rows
 //   - CODEGRAPH_STRUCTURE_MAX_ROOT_FILES  = 12  bare root files
 import { mkdirSync } from 'node:fs';
-import { CODEGRAPH_DIR_NAME, createCodegraphInvocation, defaultCodegraphInitGuard, executeCodegraphInvocation, writeCodegraphMarker, } from './codegraph-service.js';
+import { CODEGRAPH_DIR_NAME, createCodegraphInvocation, defaultCodegraphInitGuard, executeCodegraphInvocation, isCodegraphInitialized, writeCodegraphMarker, } from './codegraph-service.js';
 import { defaultCodegraphProcessRunner } from './codegraph-process-runner.js';
 /** Cap for the directory histogram in the rendered structure block. */
 export const CODEGRAPH_STRUCTURE_MAX_DIRS = 40;
@@ -163,8 +163,11 @@ async function readStructure(projectRoot, runner) {
  *
  * Behavior matrix (acceptance criteria):
  * - `.codegraph/` absent  → init + index (best-effort), then read.
- * - `.codegraph/` present with peaks-loop marker → skip init/index
- *   (fresh), read directly. No redundant re-index on every dispatch.
+ * - `.codegraph/` present with peaks-loop marker AND `codegraph.db` →
+ *   skip init/index (fresh), read directly. No redundant re-index on
+ *   every dispatch.
+ * - `.codegraph/` present with peaks-loop marker but NO `codegraph.db`
+ *   (dangling) → init + index (self-heal), then read.
  * - `.codegraph/` present WITHOUT marker (foreign schema) → fail-soft;
  *   never clobber a foreign store.
  *
@@ -180,7 +183,10 @@ export async function buildCodegraphPreflightBlock(projectRoot, runner) {
             note: `codegraph unavailable: ${CODEGRAPH_DIR_NAME}/ exists with a non-peaks-loop schema and was not touched. Move or rename the foreign directory, then re-run \`peaks codegraph init\` to enable pre-dispatch structure reads.`,
         };
     }
-    if (guard.status === 'fresh') {
+    // 'fresh' (no dir) OR a dangling peaks-loop dir (marker present, no
+    // codegraph.db) → run init + index. An initialized peaks-loop dir
+    // (`noop-already-peaks-loop` with codegraph.db) skips straight to read.
+    if (guard.status === 'fresh' || !isCodegraphInitialized(projectRoot)) {
         // 1. init (best-effort). Upstream creates the `.codegraph/` dir; we
         //    stamp the peaks-loop marker afterwards so the NEXT dispatch hits
         //    the noop (skip-when-fresh) branch.
@@ -220,7 +226,8 @@ export async function buildCodegraphPreflightBlock(projectRoot, runner) {
             return { available: false, note: `codegraph index unavailable: ${errorMessage(error)}` };
         }
     }
-    // guard.status === 'noop-already-peaks-loop' (or we just initialized):
-    // the schema exists — do NOT re-index, go straight to the bounded read.
+    // guard.status === 'noop-already-peaks-loop' with codegraph.db (or we
+    // just initialized): the schema exists — do NOT re-index, go straight
+    // to the bounded read.
     return readStructure(projectRoot, processRunner);
 }

package/dist/services/codegraph/codegraph-service.d.ts

@@ -55,6 +55,12 @@ export declare const CODEGRAPH_DIR_NAME = ".codegraph";
  * etc. all happily use the same directory name).
  */
 export declare const CODEGRAPH_MARKER_NAME = ".peaks-loop-marker";
+/**
+ * Upstream SQLite schema filename. `isCodegraphInitialized` mirrors
+ * `@colbymchenry/codegraph`'s `isInitialized`, which requires this file
+ * (not just the `.codegraph/` directory) to exist.
+ */
+export declare const CODEGRAPH_DB_NAME = "codegraph.db";
 export declare const CODEGRAPH_INIT_CONFLICT_EXIT_CODE = 73;
 export type ResolvedCodegraphLocation = {
     readonly source: 'root';
@@ -88,10 +94,19 @@ export declare class CodegraphInitConflictError extends Error {
     constructor(message: string, codegraphDir: string);
 }
 export type CodegraphInitGuard = (projectRoot: string) => CodegraphInitGuardResult;
+/**
+ * True when `<projectRoot>/.codegraph/codegraph.db` exists. Mirrors
+ * upstream `@colbymchenry/codegraph` `isInitialized`: the `.codegraph/`
+ * directory alone (or with only the peaks-loop marker) is NOT initialized.
+ * Pure fs probe; never throws.
+ */
+export declare function isCodegraphInitialized(projectRoot: string): boolean;
 /**
  * Root-only init guard: probes `<projectRoot>/.codegraph/`. 'fresh'
- * is returned when the directory does not exist yet, so the next
- * `peaks codegraph init` creates the root `.codegraph/` directory.
+ * is returned when the directory does not exist yet OR when it exists
+ * with the peaks-loop marker but no `codegraph.db` (dangling), so the
+ * next `peaks codegraph init` creates the root `.codegraph/` directory
+ * and its SQLite schema.
  */
 export declare function defaultCodegraphInitGuard(projectRoot: string): CodegraphInitGuardResult;
 /**

package/dist/services/codegraph/codegraph-service.js

@@ -180,6 +180,12 @@ export const CODEGRAPH_DIR_NAME = '.codegraph';
  * etc. all happily use the same directory name).
  */
 export const CODEGRAPH_MARKER_NAME = '.peaks-loop-marker';
+/**
+ * Upstream SQLite schema filename. `isCodegraphInitialized` mirrors
+ * `@colbymchenry/codegraph`'s `isInitialized`, which requires this file
+ * (not just the `.codegraph/` directory) to exist.
+ */
+export const CODEGRAPH_DB_NAME = 'codegraph.db';
 export const CODEGRAPH_INIT_CONFLICT_EXIT_CODE = 73;
 /**
  * Root-only resolver: peaks-loop always manages
@@ -205,6 +211,15 @@ export class CodegraphInitConflictError extends Error {
         this.name = 'CodegraphInitConflictError';
     }
 }
+/**
+ * True when `<projectRoot>/.codegraph/codegraph.db` exists. Mirrors
+ * upstream `@colbymchenry/codegraph` `isInitialized`: the `.codegraph/`
+ * directory alone (or with only the peaks-loop marker) is NOT initialized.
+ * Pure fs probe; never throws.
+ */
+export function isCodegraphInitialized(projectRoot) {
+    return existsSync(join(projectRoot, CODEGRAPH_DIR_NAME, CODEGRAPH_DB_NAME));
+}
 /**
  * Inspect a candidate codegraph directory and return its guard
  * status. A file (or symlink-to-file) at the path counts as a
@@ -223,14 +238,24 @@ function inspectCandidateCodegraphDir(codegraphDir) {
     }
     const markerPath = join(codegraphDir, CODEGRAPH_MARKER_NAME);
     if (existsSync(markerPath)) {
+        // Marker present but no codegraph.db → the dangling state left by the
+        // pre-fix rid-CG-001 auto-stake (marker stamped without running
+        // upstream init). Report 'fresh' so consumers re-run upstream init
+        // (idempotent, creates the db) instead of treating the schema as
+        // fully initialized.
+        if (!existsSync(join(codegraphDir, CODEGRAPH_DB_NAME))) {
+            return { status: 'fresh', codegraphDir };
+        }
         return { status: 'noop-already-peaks-loop', codegraphDir };
     }
     return { status: 'conflict-foreign-schema', codegraphDir };
 }
 /**
  * Root-only init guard: probes `<projectRoot>/.codegraph/`. 'fresh'
- * is returned when the directory does not exist yet, so the next
- * `peaks codegraph init` creates the root `.codegraph/` directory.
+ * is returned when the directory does not exist yet OR when it exists
+ * with the peaks-loop marker but no `codegraph.db` (dangling), so the
+ * next `peaks codegraph init` creates the root `.codegraph/` directory
+ * and its SQLite schema.
  */
 export function defaultCodegraphInitGuard(projectRoot) {
     const codegraphDir = join(projectRoot, CODEGRAPH_DIR_NAME);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.30",
+  "version": "4.0.32",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -101,10 +101,10 @@
     "fzf": "^0.5.2",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "peaks-loop-internal-runtime": "0.0.15",
-    "peaks-loop-mut": "0.1.28",
-    "peaks-loop-shared": "0.0.64",
-    "peaks-loop-shared-channel": "0.0.32"
+    "peaks-loop-internal-runtime": "0.0.17",
+    "peaks-loop-shared-channel": "0.0.34",
+    "peaks-loop-mut": "0.1.30",
+    "peaks-loop-shared": "0.0.66"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",