gsd-pi 2.23.0 → 2.25.0

package/src/resources/extensions/gsd/session-status-io.ts

@@ -0,0 +1,197 @@
+/**
+ * GSD Session Status I/O
+ *
+ * File-based IPC protocol for coordinator-worker communication in
+ * parallel milestone orchestration. Each worker writes its status to a
+ * file; the coordinator reads all status files to monitor progress.
+ *
+ * Atomic writes (write to .tmp, then rename) prevent partial reads.
+ * Signal files let the coordinator send pause/resume/stop/rebase to workers.
+ * Stale detection combines PID liveness checks with heartbeat timeouts.
+ */
+
+import {
+  writeFileSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  readdirSync,
+  mkdirSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+
+// ─── Types ─────────────────────────────────────────────────────────────────
+
+export interface SessionStatus {
+  milestoneId: string;
+  pid: number;
+  state: "running" | "paused" | "stopped" | "error";
+  currentUnit: { type: string; id: string; startedAt: number } | null;
+  completedUnits: number;
+  cost: number;
+  lastHeartbeat: number;
+  startedAt: number;
+  worktreePath: string;
+}
+
+export type SessionSignal = "pause" | "resume" | "stop" | "rebase";
+
+export interface SignalMessage {
+  signal: SessionSignal;
+  sentAt: number;
+  from: "coordinator";
+}
+
+// ─── Constants ─────────────────────────────────────────────────────────────
+
+const PARALLEL_DIR = "parallel";
+const STATUS_SUFFIX = ".status.json";
+const SIGNAL_SUFFIX = ".signal.json";
+const TMP_SUFFIX = ".tmp";
+const DEFAULT_STALE_TIMEOUT_MS = 30_000;
+
+// ─── Helpers ───────────────────────────────────────────────────────────────
+
+function parallelDir(basePath: string): string {
+  return join(gsdRoot(basePath), PARALLEL_DIR);
+}
+
+function statusPath(basePath: string, milestoneId: string): string {
+  return join(parallelDir(basePath), `${milestoneId}${STATUS_SUFFIX}`);
+}
+
+function signalPath(basePath: string, milestoneId: string): string {
+  return join(parallelDir(basePath), `${milestoneId}${SIGNAL_SUFFIX}`);
+}
+
+function ensureParallelDir(basePath: string): void {
+  const dir = parallelDir(basePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Status I/O ────────────────────────────────────────────────────────────
+
+/** Write session status atomically (write to .tmp, then rename). */
+export function writeSessionStatus(basePath: string, status: SessionStatus): void {
+  try {
+    ensureParallelDir(basePath);
+    const dest = statusPath(basePath, status.milestoneId);
+    const tmp = dest + TMP_SUFFIX;
+    writeFileSync(tmp, JSON.stringify(status, null, 2), "utf-8");
+    renameSync(tmp, dest);
+  } catch { /* non-fatal */ }
+}
+
+/** Read a specific milestone's session status. */
+export function readSessionStatus(basePath: string, milestoneId: string): SessionStatus | null {
+  try {
+    const p = statusPath(basePath, milestoneId);
+    if (!existsSync(p)) return null;
+    const raw = readFileSync(p, "utf-8");
+    return JSON.parse(raw) as SessionStatus;
+  } catch {
+    return null;
+  }
+}
+
+/** Read all session status files from .gsd/parallel/. */
+export function readAllSessionStatuses(basePath: string): SessionStatus[] {
+  const dir = parallelDir(basePath);
+  if (!existsSync(dir)) return [];
+
+  const results: SessionStatus[] = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (!entry.endsWith(STATUS_SUFFIX)) continue;
+      try {
+        const raw = readFileSync(join(dir, entry), "utf-8");
+        results.push(JSON.parse(raw) as SessionStatus);
+      } catch { /* skip corrupt files */ }
+    }
+  } catch { /* non-fatal */ }
+  return results;
+}
+
+/** Remove a milestone's session status file. */
+export function removeSessionStatus(basePath: string, milestoneId: string): void {
+  try {
+    const p = statusPath(basePath, milestoneId);
+    if (existsSync(p)) unlinkSync(p);
+  } catch { /* non-fatal */ }
+}
+
+// ─── Signal I/O ────────────────────────────────────────────────────────────
+
+/** Write a signal file for a worker to consume. */
+export function sendSignal(basePath: string, milestoneId: string, signal: SessionSignal): void {
+  try {
+    ensureParallelDir(basePath);
+    const dest = signalPath(basePath, milestoneId);
+    const tmp = dest + TMP_SUFFIX;
+    const msg: SignalMessage = { signal, sentAt: Date.now(), from: "coordinator" };
+    writeFileSync(tmp, JSON.stringify(msg, null, 2), "utf-8");
+    renameSync(tmp, dest);
+  } catch { /* non-fatal */ }
+}
+
+/** Read and delete a signal file (atomic consume). Returns null if no signal pending. */
+export function consumeSignal(basePath: string, milestoneId: string): SignalMessage | null {
+  try {
+    const p = signalPath(basePath, milestoneId);
+    if (!existsSync(p)) return null;
+    const raw = readFileSync(p, "utf-8");
+    unlinkSync(p);
+    return JSON.parse(raw) as SignalMessage;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Stale Detection ───────────────────────────────────────────────────────
+
+/** Check whether a session is stale (PID dead or heartbeat timed out). */
+export function isSessionStale(
+  status: SessionStatus,
+  timeoutMs: number = DEFAULT_STALE_TIMEOUT_MS,
+): boolean {
+  if (!isPidAlive(status.pid)) return true;
+  const elapsed = Date.now() - status.lastHeartbeat;
+  return elapsed > timeoutMs;
+}
+
+/** Find and remove stale sessions. Returns the milestone IDs that were cleaned up. */
+export function cleanupStaleSessions(
+  basePath: string,
+  timeoutMs: number = DEFAULT_STALE_TIMEOUT_MS,
+): string[] {
+  const removed: string[] = [];
+  const statuses = readAllSessionStatuses(basePath);
+
+  for (const status of statuses) {
+    if (isSessionStale(status, timeoutMs)) {
+      removeSessionStatus(basePath, status.milestoneId);
+      // Also clean up any lingering signal file
+      try {
+        const sig = signalPath(basePath, status.milestoneId);
+        if (existsSync(sig)) unlinkSync(sig);
+      } catch { /* non-fatal */ }
+      removed.push(status.milestoneId);
+    }
+  }
+
+  return removed;
+}

package/src/resources/extensions/gsd/state.ts

@@ -32,7 +32,6 @@ import {
 
 import { milestoneIdSort, findMilestoneIds } from './guided-flow.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
-import { isDbAvailable, _getAdapter } from './gsd-db.js';
 
 import { join, resolve } from 'path';
 import { debugCount, debugTime } from './debug-logger.js';
@@ -53,6 +52,19 @@ export function isMilestoneComplete(roadmap: Roadmap): boolean {
   return roadmap.slices.length > 0 && roadmap.slices.every(s => s.done);
 }
 
+/**
+ * Check whether a VALIDATION file's verdict is terminal (pass or needs-attention).
+ * A non-terminal verdict (needs-remediation) means validation must re-run
+ * after remediation slices are executed.
+ */
+export function isValidationTerminal(validationContent: string): boolean {
+  const match = validationContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return false;
+  const verdict = match[1].match(/verdict:\s*(\S+)/);
+  if (!verdict) return false;
+  return verdict[1] === 'pass' || verdict[1] === 'needs-attention';
+}
+
 // ─── State Derivation ──────────────────────────────────────────────────────
 
 // ── deriveState memoization ─────────────────────────────────────────────────
@@ -82,6 +94,11 @@ export function invalidateStateCache(): void {
  */
 export async function getActiveMilestoneId(basePath: string): Promise<string | null> {
   const milestoneIds = findMilestoneIds(basePath);
+  // Parallel worker isolation
+  const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+  if (milestoneLock) {
+    return milestoneIds.includes(milestoneLock) ? milestoneLock : null;
+  }
   for (const mid of milestoneIds) {
     const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
     const content = roadmapFile ? await loadFile(roadmapFile) : null;
@@ -129,6 +146,18 @@ export async function deriveState(basePath: string): Promise<GSDState> {
 async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   const milestoneIds = findMilestoneIds(basePath);
 
+  // ── Parallel worker isolation ──────────────────────────────────────────
+  // When GSD_MILESTONE_LOCK is set, this process is a parallel worker
+  // scoped to a single milestone. Filter the milestone list so this worker
+  // only sees its assigned milestone (all others are treated as if they
+  // don't exist). This gives each worker complete isolation without
+  // modifying any other state derivation logic.
+  const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+  if (milestoneLock && milestoneIds.includes(milestoneLock)) {
+    milestoneIds.length = 0;
+    milestoneIds.push(milestoneLock);
+  }
+
   // ── Batch-parse file cache ──────────────────────────────────────────────
   // When the native Rust parser is available, read every .md file under .gsd/
   // in one call and build an in-memory content map keyed by absolute path.
@@ -136,30 +165,12 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   const fileContentCache = new Map<string, string>();
   const gsdDir = gsdRoot(basePath);
 
-  // ── DB-first content loading ──
-  // When the DB is available, load artifact content from the artifacts table
-  // (indexed SELECT instead of O(N) file I/O). Falls back to native Rust batch
-  // parser, which in turn falls back to sequential JS reads via cachedLoadFile.
-  let dbContentLoaded = false;
-  if (isDbAvailable()) {
-    const adapter = _getAdapter();
-    if (adapter) {
-      try {
-        const rows = adapter.prepare('SELECT path, full_content FROM artifacts').all();
-        for (const row of rows) {
-          const relPath = (row as Record<string, unknown>)['path'] as string;
-          const content = (row as Record<string, unknown>)['full_content'] as string;
-          const absPath = resolve(gsdDir, relPath);
-          fileContentCache.set(absPath, content);
-        }
-        dbContentLoaded = rows.length > 0;
-      } catch {
-        // DB query failed — fall through to native batch parse
-      }
-    }
-  }
-
-  if (!dbContentLoaded) {
+  // NOTE: We intentionally do NOT load from the SQLite DB here (#759).
+  // The DB's artifacts table is populated once during migrateFromMarkdown
+  // and is never updated when files change on disk (e.g. roadmap [x] updates,
+  // plan checkbox changes). Using stale DB content causes deriveState to
+  // return incorrect phase/slice state, leading to infinite skip loops.
+  // The native Rust batch parser is fast enough for state derivation.
   const batchFiles = nativeBatchParseGsdFiles(gsdDir);
   if (batchFiles) {
     for (const f of batchFiles) {
@@ -167,7 +178,6 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       fileContentCache.set(absPath, f.rawContent);
     }
   }
-  }
 
   /**
    * Load file content from batch cache first, falling back to disk read.
@@ -279,10 +289,20 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     const complete = isMilestoneComplete(roadmap);
 
     if (complete) {
-      // All slices done — check if milestone summary exists
+      // All slices done — check validation and summary state
+      const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
+      const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
+      const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (!summaryFile && !activeMilestoneFound) {
-        // All slices complete but no summary written yet → completing-milestone
+
+      if (!validationTerminal && !activeMilestoneFound) {
+        // No terminal validation yet → validating-milestone
+        activeMilestone = { id: mid, title };
+        activeRoadmap = roadmap;
+        activeMilestoneFound = true;
+        registry.push({ id: mid, title, status: 'active' });
+      } else if (!summaryFile && !activeMilestoneFound) {
+        // Validated but no summary written yet → completing-milestone
         activeMilestone = { id: mid, title };
         activeRoadmap = roadmap;
         activeMilestoneFound = true;
@@ -385,12 +405,34 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     };
   }
 
-  // Check if active milestone needs completion (all slices done, no summary)
+  // Check if active milestone needs validation or completion (all slices done)
   if (isMilestoneComplete(activeRoadmap)) {
+    const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
+    const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
+    const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
     const sliceProgress = {
       done: activeRoadmap.slices.length,
       total: activeRoadmap.slices.length,
     };
+
+    if (!validationTerminal) {
+      return {
+        activeMilestone,
+        activeSlice: null,
+        activeTask: null,
+        phase: 'validating-milestone',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: `Validate milestone ${activeMilestone.id} before completion.`,
+        registry,
+        requirements,
+        progress: {
+          milestones: milestoneProgress,
+          slices: sliceProgress,
+        },
+      };
+    }
+
     return {
       activeMilestone,
       activeSlice: null,

package/src/resources/extensions/gsd/tests/agent-end-provider-error.test.ts

@@ -27,3 +27,84 @@ test("pauseAutoForProviderError warns and pauses without requiring ctx.log", asy
     },
   ]);
 });
+
+test("pauseAutoForProviderError schedules auto-resume for rate limit errors", async () => {
+  const notifications: Array<{ message: string; level: string }> = [];
+  let pauseCalls = 0;
+  let resumeCalled = false;
+
+  // Use fake timer
+  const originalSetTimeout = globalThis.setTimeout;
+  const timers: Array<{ fn: () => void; delay: number }> = [];
+  globalThis.setTimeout = ((fn: () => void, delay: number) => {
+    timers.push({ fn, delay });
+    return 0 as unknown as ReturnType<typeof setTimeout>;
+  }) as typeof setTimeout;
+
+  try {
+    await pauseAutoForProviderError(
+      {
+        notify(message, level?) {
+          notifications.push({ message, level: level ?? "info" });
+        },
+      },
+      ": rate limit exceeded",
+      async () => {
+        pauseCalls += 1;
+      },
+      {
+        isRateLimit: true,
+        retryAfterMs: 90000,
+        resume: () => {
+          resumeCalled = true;
+        },
+      },
+    );
+
+    assert.equal(pauseCalls, 1, "should pause auto-mode");
+    assert.equal(timers.length, 1, "should schedule one timer");
+    assert.equal(timers[0].delay, 90000, "timer should match retryAfterMs");
+    assert.deepEqual(notifications[0], {
+      message: "Rate limited: rate limit exceeded. Auto-resuming in 90s...",
+      level: "warning",
+    });
+
+    // Fire the timer
+    timers[0].fn();
+    assert.equal(resumeCalled, true, "should call resume after timer fires");
+    assert.deepEqual(notifications[1], {
+      message: "Rate limit window elapsed. Resuming auto-mode.",
+      level: "info",
+    });
+  } finally {
+    globalThis.setTimeout = originalSetTimeout;
+  }
+});
+
+test("pauseAutoForProviderError falls back to indefinite pause when not rate limit", async () => {
+  const notifications: Array<{ message: string; level: string }> = [];
+  let pauseCalls = 0;
+
+  await pauseAutoForProviderError(
+    {
+      notify(message, level?) {
+        notifications.push({ message, level: level ?? "info" });
+      },
+    },
+    ": connection refused",
+    async () => {
+      pauseCalls += 1;
+    },
+    {
+      isRateLimit: false,
+    },
+  );
+
+  assert.equal(pauseCalls, 1);
+  assert.deepEqual(notifications, [
+    {
+      message: "Auto-mode paused due to provider error: connection refused",
+      level: "warning",
+    },
+  ]);
+});

package/src/resources/extensions/gsd/tests/auto-budget-alerts.test.ts

@@ -9,8 +9,12 @@ import {
 
 test("getBudgetAlertLevel returns the expected threshold bucket", () => {
   assert.equal(getBudgetAlertLevel(0.10), 0);
+  assert.equal(getBudgetAlertLevel(0.74), 0);
   assert.equal(getBudgetAlertLevel(0.75), 75);
-  assert.equal(getBudgetAlertLevel(0.89), 75);
+  assert.equal(getBudgetAlertLevel(0.79), 75);
+  assert.equal(getBudgetAlertLevel(0.80), 80);
+  assert.equal(getBudgetAlertLevel(0.85), 80);
+  assert.equal(getBudgetAlertLevel(0.89), 80);
   assert.equal(getBudgetAlertLevel(0.90), 90);
   assert.equal(getBudgetAlertLevel(1.00), 100);
 });
@@ -18,14 +22,27 @@ test("getBudgetAlertLevel returns the expected threshold bucket", () => {
 test("getNewBudgetAlertLevel only emits once per threshold", () => {
   assert.equal(getNewBudgetAlertLevel(0, 0.74), null);
   assert.equal(getNewBudgetAlertLevel(0, 0.75), 75);
-  assert.equal(getNewBudgetAlertLevel(75, 0.80), null);
-  assert.equal(getNewBudgetAlertLevel(75, 0.90), 90);
+  assert.equal(getNewBudgetAlertLevel(75, 0.79), null);
+  assert.equal(getNewBudgetAlertLevel(75, 0.80), 80);
+  assert.equal(getNewBudgetAlertLevel(80, 0.85), null);
+  assert.equal(getNewBudgetAlertLevel(80, 0.90), 90);
   assert.equal(getNewBudgetAlertLevel(90, 0.95), null);
   assert.equal(getNewBudgetAlertLevel(90, 1.0), 100);
   assert.equal(getNewBudgetAlertLevel(100, 1.2), null);
 });
 
+test("80% alert fires exactly once between 75% and 90%", () => {
+  // Transition from 75 → 80 emits 80
+  assert.equal(getNewBudgetAlertLevel(75, 0.80), 80);
+  // Already at 80 — no re-emission
+  assert.equal(getNewBudgetAlertLevel(80, 0.82), null);
+  assert.equal(getNewBudgetAlertLevel(80, 0.89), null);
+  // Transition from 80 → 90 emits 90
+  assert.equal(getNewBudgetAlertLevel(80, 0.90), 90);
+});
+
 test("getBudgetEnforcementAction maps the configured ceiling behavior", () => {
+  assert.equal(getBudgetEnforcementAction("warn", 0.80), "none");
   assert.equal(getBudgetEnforcementAction("warn", 0.99), "none");
   assert.equal(getBudgetEnforcementAction("warn", 1.0), "warn");
   assert.equal(getBudgetEnforcementAction("pause", 1.0), "pause");

package/src/resources/extensions/gsd/tests/auto-preflight.test.ts

@@ -17,6 +17,7 @@ writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-PLAN.md"), `
 writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), `---\nid: T01\nparent: S01\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# T01: Old Task\n\n**Done**\n\n## What Happened\nDone.\n\n## Diagnostics\n- log\n`);
 writeFileSync(join(gsd, "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), `---\nid: S01\nparent: M001\nmilestone: M001\nprovides: []\nrequires: []\naffects: []\nkey_files: []\nkey_decisions: []\npatterns_established: []\nobservability_surfaces: []\ndrill_down_paths: []\nduration: 5m\nverification_result: passed\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# S01: Old Slice\n\n**Done**\n\n## What Happened\nDone.\n\n## Verification\nDone.\n\n## Deviations\nNone\n\n## Known Limitations\nNone\n\n## Follow-ups\nNone\n\n## Files Created/Modified\n- \`x\` — x\n\n## Forward Intelligence\n\n### What the next slice should know\n- x\n\n### What's fragile\n- x\n\n### Authoritative diagnostics\n- x\n\n### What assumptions changed\n- x\n`);
 
+writeFileSync(join(gsd, "milestones", "M001", "M001-VALIDATION.md"), `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.\n`);
 writeFileSync(join(gsd, "milestones", "M001", "M001-SUMMARY.md"), `---\nid: M001\nstatus: complete\ncompleted_at: 2026-03-09T00:00:00Z\n---\n\n# M001: Historical\n\nComplete.\n`);
 
 writeFileSync(join(gsd, "milestones", "M009", "M009-ROADMAP.md"), `# M009: Active\n\n## Slices\n- [ ] **S01: Active Slice** \`risk:low\` \`depends:[]\`\n  > After this: active works\n`);