@opengsd/gsd-pi 1.1.1-dev.154fd443 → 1.1.1-dev.1854a79a

package/src/resources/extensions/gsd/doctor-proactive.ts

@@ -267,12 +267,18 @@ export async function preDispatchHealthGate(basePath: string): Promise<PreDispat
     // Non-fatal — dispatch continues without STATE.md if rebuild fails
   }
 
+  // #442 Phase 1.7: resolve repo-ness once per gate. ensureWorkspaceGitReady
+  // has already run, and nothing below initializes/deinitializes the repo, so
+  // the two downstream blocks (integration-branch check, stale-changes
+  // snapshot) can share one nativeIsRepo result instead of querying twice.
+  const isRepo = nativeIsRepo(basePath);
+
   // ── Integration branch existence check ──
   // If the active milestone's recorded integration branch no longer exists in
   // git, the merge-back at the end of the milestone will fail. Block dispatch
   // now to surface this before work is lost.
   try {
-    if (nativeIsRepo(basePath)) {
+    if (isRepo) {
       const state = await deriveState(basePath);
       if (state.activeMilestone) {
         const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
@@ -296,7 +302,7 @@ export async function preDispatchHealthGate(basePath: string): Promise<PreDispat
   // If the working tree is dirty and no commit has happened recently,
   // create a safety snapshot so work isn't lost if the next unit crashes.
   try {
-    if (nativeIsRepo(basePath)) {
+    if (isRepo) {
       const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
       // `git.snapshots: false` is the canonical toggle that disables WIP
       // snapshot commits — honour it before touching the threshold path (#4420).

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -9,11 +9,10 @@
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
 
-import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, statSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
-import { createRequire } from "node:module";
 import {
   getAllMilestones,
   getMilestone,
@@ -38,7 +37,8 @@ import {
   buildTaskFileName,
   buildSliceFileName,
 } from "./paths.js";
-import { saveFile, clearParseCache } from "./files.js";
+import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
+import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
 import type { RiskLevel } from "./types.js";
@@ -738,20 +738,41 @@ export interface StaleEntry {
  * Returns a list of stale entries with file path and reason.
  * Logs to stderr when stale files are detected.
  */
-export function detectStaleRenders(basePath: string): StaleEntry[] {
-  // Lazy-load parsers — intentional disk-vs-DB comparison requires parsers
-  const _require = createRequire(import.meta.url);
-  let parseRoadmap: Function, parsePlan: Function;
-  try {
-    // Prefer compiled JS for packaged/runtime installs; TS exists only in source/dev contexts.
-    const m = _require("./parsers-legacy.js");
-    parseRoadmap = m.parseRoadmap; parsePlan = m.parsePlan;
-  } catch (e) {
-    logWarning("renderer", `parsers-legacy.js require failed, falling back to .ts: ${(e as Error).message}`);
-    const m = _require("./parsers-legacy.ts");
-    parseRoadmap = m.parseRoadmap; parsePlan = m.parsePlan;
+// #442 Phase 1.5: cache parsed ROADMAP/PLAN projections by file identity
+// (path + mtimeMs + size) so an unchanged projection skips readFileSync AND
+// the parse entirely on repeated dispatches. The DB-vs-disk comparison below
+// still runs every call against fresh DB rows — only the disk-parse half is
+// memoized, and parsed output depends solely on file bytes, so this is
+// behavior-preserving. Invalidation rides the existing clearParseCache()
+// callback chain (fired by invalidateCaches() after every projection write and
+// by reconcileBeforeDispatch repairs), so a changed file always re-parses.
+interface CachedProjection { mtimeMs: number; size: number; parsed: unknown }
+const _projectionParseCache = new Map<string, CachedProjection>();
+registerCacheClearCallback(() => _projectionParseCache.clear());
+
+function parseProjectionByIdentity(path: string, parse: (content: string) => unknown): unknown {
+  let st: ReturnType<typeof statSync> | null = null;
+  try { st = statSync(path); } catch { st = null; }
+  if (st) {
+    const hit = _projectionParseCache.get(path);
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+      return hit.parsed;
+    }
+    const parsed = parse(readFileSync(path, "utf-8"));
+    _projectionParseCache.set(path, { mtimeMs: st.mtimeMs, size: st.size, parsed });
+    return parsed;
   }
+  // stat failed (e.g. file vanished between existsSync and here) — fall back to
+  // the original plain read+parse so error handling is unchanged.
+  return parse(readFileSync(path, "utf-8"));
+}
 
+export function detectStaleRenders(basePath: string): StaleEntry[] {
+  // parseRoadmap/parsePlan are statically imported (#442 Phase 1.4): the
+  // per-call createRequire("./parsers-legacy") that used to live here ran on
+  // every dispatch. The static `./parsers-legacy.js` specifier resolves in
+  // both packaged (.js) and source (.ts via the strip-types loader) contexts —
+  // the same form a dozen other modules already use.
   const stale: StaleEntry[] = [];
   const milestones = getAllMilestones();
 
@@ -762,8 +783,7 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
     const roadmapPath = resolveRoadmapProjectionPath(basePath, milestone.id);
     if (existsSync(roadmapPath)) {
       try {
-        const content = readFileSync(roadmapPath, "utf-8");
-        const parsed = parseRoadmap(content);
+        const parsed = parseProjectionByIdentity(roadmapPath, parseRoadmap) as ReturnType<typeof parseRoadmap>;
 
         for (const slice of slices) {
           const isCompleteInDb = isClosedStatus(slice.status);
@@ -795,8 +815,7 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
       const planPath = resolveSliceFile(basePath, milestone.id, slice.id, "PLAN");
       if (planPath && existsSync(planPath)) {
         try {
-          const content = readFileSync(planPath, "utf-8");
-          const parsed = parsePlan(content);
+          const parsed = parseProjectionByIdentity(planPath, parsePlan) as ReturnType<typeof parsePlan>;
 
           for (const task of tasks) {
             const isDoneInDb = isClosedStatus(task.status);

package/src/resources/extensions/gsd/mcp-filter.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 
 import type { ClaudeCodeMcpConfig } from "./preferences-types.js";
@@ -115,6 +116,12 @@ export function discoverMcpServerNames(projectDir: string): string[] {
   return discoverMcpServers(projectDir).map((server) => server.name);
 }
 
+export function discoverUserMcpServerNames(): string[] {
+  const userSettingsPath = resolve(homedir(), ".claude", "settings.json");
+  const userSettings = readJsonFile(userSettingsPath, true) as ClaudeSettingsFile | undefined;
+  return collectServerEntries(userSettings?.mcpServers).map((s) => s.name);
+}
+
 export function computeMcpDisallowedTools(
   modelId: string,
   mcpConfig: ClaudeCodeMcpConfig | undefined,

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -13,6 +13,7 @@ import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { getErrorMessage } from "./error-utils.js";
 import { isInfrastructureError } from "./auto/infra-errors.js";
+import { debugCount } from "./debug-logger.js";
 
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
@@ -140,6 +141,8 @@ function loadNative(): typeof nativeModule {
 
 /** Run a git command via execFileSync. Returns trimmed stdout. */
 function gitExec(basePath: string, args: string[], allowFailure = false): string {
+  // Counts git CLI shell-outs only (native libgit2 paths bypass this helper).
+  debugCount("gitInvocations");
   try {
     return execFileSync("git", args, {
       cwd: basePath,
@@ -169,6 +172,8 @@ function execGitFileSyncWithRetry(
   args: string[],
   options: Partial<ExecFileSyncOptionsWithStringEncoding>,
 ): string {
+  // Counts git CLI shell-outs only (native libgit2 paths bypass this helper).
+  debugCount("gitInvocations");
   try {
     return execFileSync("git", args, {
       cwd: basePath,
@@ -180,6 +185,8 @@ function execGitFileSyncWithRetry(
   } catch (err) {
     if (!isRetryableGitError(err)) throw err;
     sleepSync(GIT_RETRY_DELAY_MS);
+    // Retry is a second physical shell-out — count it too.
+    debugCount("gitInvocations");
     return execFileSync("git", args, {
       cwd: basePath,
       stdio: ["ignore", "pipe", "pipe"],
@@ -192,6 +199,8 @@ function execGitFileSyncWithRetry(
 
 /** Run a git command via execFileSync. Returns trimmed stdout. */
 function gitFileExec(basePath: string, args: string[], allowFailure = false): string {
+  // Counts git CLI shell-outs only (native libgit2 paths bypass this helper).
+  debugCount("gitInvocations");
   try {
     return execFileSync("git", args, {
       cwd: basePath,

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -38,7 +38,7 @@ If slice research is inlined, trust its architectural findings, but verify every
 
 1. If requirements are preloaded, identify owned and supporting Active requirements.
 2. Call `memory_query` with keywords from the slice title and source files.
-3. Read `{{planTemplatePath}}` and `{{taskPlanTemplatePath}}`.
+3. Use the inlined Output Template sections already present in this prompt. Do not read template files from disk.
 4. {{skillActivation}} Record expected executor skills in each task plan's `skills_used` frontmatter.
 5. Define slice verification before tasks. Non-trivial slices need real tests or executable assertions; boundary contracts need contract-exercising checks. Tests must not read .gitignore/gitignored paths such as `.gsd/`, `.planning/`, or `.audits/`.
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.

package/src/resources/extensions/gsd/schemas/parsers.ts

@@ -67,7 +67,12 @@ export interface ParsedRoadmap {
 const TEMPLATE_TOKEN_RE = /\{\{[^}]+\}\}/;
 const H2_RE = /^##\s+(.+)$/gm;
 const H3_RE = /^###\s+(.+)$/gm;
-const MILESTONE_LINE_RE = /^-\s+\[([ x])\]\s+(M\d{3}):\s+(.+?)\s+(?:—|--|-)\s+(.+)$/gm;
+// A milestone line is single-line by construction. Every inter-token gap uses
+// horizontal-whitespace classes (`[^\S\n]`) rather than `\s`, because `\s`
+// matches newlines: a line missing a valid separator would otherwise let the
+// `\s+(?:—|--|-)\s+` clause "bridge" onto the NEXT bullet's `- `, consuming it
+// as the separator and silently swallowing the following well-formed milestone.
+const MILESTONE_LINE_RE = /^-[^\S\n]+\[([ x])\][^\S\n]+(M\d{3}):[^\S\n]+(.+?)[^\S\n]+(?:—|--|-)[^\S\n]+(.+)$/gm;
 const SLICE_HEADER_RE = /^###\s+(S\d{2})\s*(?:—|--|-)\s+(.+)$/m;
 const REQUIREMENT_HEADER_RE = /^###\s+(R\d{3})\s*(?:—|--|-)\s+(.+)$/m;
 

package/src/resources/extensions/gsd/state-reconciliation/drift/artifact-db.ts

@@ -335,21 +335,42 @@ function detectDiskSliceIdDivergenceForMilestone(
   return drifts;
 }
 
+type ArtifactDbDrift =
+  | DiskSliceIdDivergenceDrift
+  | ArtifactDbStatusDivergenceDrift
+  | CompletedMilestoneReopenedDrift;
+
+// #442 Phase 1.6: the three artifact/DB drift handlers (disk-slice-id,
+// artifact-db-status, completed-milestone-reopened) each call
+// detectArtifactDbDrift and then filter for their own kind — so the full
+// milestone→slice→task walk + artifact SQL + disk scan would run THREE times
+// per detection pass and discard 2/3 of the work. Memoize the result per
+// DriftContext so the three handlers share one computation. The key is the
+// ctx object, which detectAllDrift rebuilds for every pass (and which is
+// unreferenced once the pass ends, so the WeakMap entry is GC'd) — DB/disk
+// state is immutable within a single pass (repairs run only after detection),
+// so this is behavior-preserving. A fresh ctx (e.g. the maintenance command's
+// inline { basePath, state }) always recomputes.
+const _artifactDbDriftMemo = new WeakMap<DriftContext, ArtifactDbDrift[]>();
+
 export function detectArtifactDbDrift(
+  state: GSDState,
+  ctx: DriftContext,
+): ArtifactDbDrift[] {
+  const cached = _artifactDbDriftMemo.get(ctx);
+  if (cached) return cached;
+  const computed = computeArtifactDbDrift(state, ctx);
+  _artifactDbDriftMemo.set(ctx, computed);
+  return computed;
+}
+
+function computeArtifactDbDrift(
   _state: GSDState,
   ctx: DriftContext,
-): Array<
-  | DiskSliceIdDivergenceDrift
-  | ArtifactDbStatusDivergenceDrift
-  | CompletedMilestoneReopenedDrift
-> {
+): ArtifactDbDrift[] {
   if (!isDbAvailable()) return [];
 
-  const drifts: Array<
-    | DiskSliceIdDivergenceDrift
-    | ArtifactDbStatusDivergenceDrift
-    | CompletedMilestoneReopenedDrift
-  > = [];
+  const drifts: ArtifactDbDrift[] = [];
 
   for (const milestone of getAllMilestones()) {
     if (isClosedStatus(milestone.status)) continue;

package/src/resources/extensions/gsd/tests/artifact-db-drift-memo.test.ts

@@ -0,0 +1,66 @@
+// Project/App: gsd-pi
+// File Purpose: #442 Phase 1.6 — detectArtifactDbDrift is memoized per
+// DriftContext so the three artifact/DB drift handlers share one
+// milestone→slice→task walk per detection pass instead of recomputing it
+// three times. Asserts external behavior: same ctx returns the same result
+// (shared within a pass); a fresh ctx recomputes identical content (no
+// cross-pass leakage).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
+import { detectArtifactDbDrift } from "../state-reconciliation/drift/artifact-db.ts";
+import type { DriftContext } from "../state-reconciliation/types.ts";
+import type { GSDState } from "../types.ts";
+
+function stubState(): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "M" },
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+    progress: { milestones: { done: 0, total: 1 } },
+  };
+}
+
+test("#442: detectArtifactDbDrift is memoized per DriftContext", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-artifact-memo-"));
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "M", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  // A SUMMARY on disk while the slice is still pending = artifact/DB divergence.
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# S01 Summary\n");
+
+  const state = stubState();
+
+  const ctx1: DriftContext = { basePath: base, state };
+  const first = detectArtifactDbDrift(state, ctx1);
+  const firstAgain = detectArtifactDbDrift(state, ctx1);
+
+  // Same ctx → cache hit → identical array reference (the 3 handlers in one
+  // pass share this exact result).
+  assert.strictEqual(firstAgain, first, "same ctx must return the memoized result");
+  assert.ok(first.length > 0, "fixture should produce at least one drift record");
+
+  // Fresh ctx → recomputed (distinct instance) but identical content.
+  const ctx2: DriftContext = { basePath: base, state };
+  const second = detectArtifactDbDrift(state, ctx2);
+  assert.notStrictEqual(second, first, "a fresh ctx must recompute, not reuse the prior pass");
+  assert.deepEqual(second, first, "recomputed result must be identical content");
+});

package/src/resources/extensions/gsd/tests/auto-dispatch-baseline-harness.test.ts

@@ -0,0 +1,53 @@
+// Project/App: gsd-pi
+// File Purpose: Cover the getDebugCounters() snapshot getter added for the
+// per-dispatch benchmark harness (issue #442, Phase 0.3). The harness itself
+// (scripts/auto-dispatch-baseline.mjs) reads counters via this getter without
+// disabling debug (which is what writeDebugSummary does).
+
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { mkdtempSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  enableDebug,
+  disableDebug,
+  debugCount,
+  getDebugCounters,
+} from '../debug-logger.ts';
+
+function tmpGsd(): string {
+  const tmp = mkdtempSync(join(tmpdir(), 'gsd-baseline-harness-'));
+  mkdirSync(join(tmp, '.gsd'), { recursive: true });
+  return tmp;
+}
+
+test('getDebugCounters returns a live snapshot of the hot-path counters', () => {
+  enableDebug(tmpGsd());
+
+  debugCount('deriveStateCalls', 3);
+  debugCount('parseRoadmapCalls');
+  debugCount('parsePlanCalls', 2);
+  debugCount('gitInvocations', 7);
+
+  const snap = getDebugCounters();
+  assert.strictEqual(snap.deriveStateCalls, 3);
+  assert.strictEqual(snap.parseRoadmapCalls, 1);
+  assert.strictEqual(snap.parsePlanCalls, 2);
+  assert.strictEqual(snap.gitInvocations, 7);
+
+  disableDebug();
+});
+
+test('getDebugCounters returns a copy — callers cannot mutate internal state', () => {
+  enableDebug(tmpGsd());
+  debugCount('gitInvocations', 5);
+
+  const snap = getDebugCounters() as Record<string, number>;
+  snap.gitInvocations = 999;
+
+  assert.strictEqual(getDebugCounters().gitInvocations, 5, 'internal counter must be unaffected by mutating the snapshot');
+
+  disableDebug();
+});