gsd-pi 2.23.0 → 2.24.0

package/dist/resources/extensions/gsd/prompts/research-slice.md

@@ -46,7 +46,7 @@ Research what this slice needs. Narrate key findings and surprises as you go —
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
 3. Explore relevant code for this slice's scope. For targeted exploration, use `rg`, `find`, and reads. For broad or unfamiliar subsystems, use `scout` to map the relevant area first.
 4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase
-5. Use the **Research** output template from the inlined context above — include only sections that have real content
+5. Use the **Research** output template from the inlined context above — include only sections that have real content. The template is already inlined above; do NOT attempt to read any template file from disk (there is no `templates/SLICE-RESEARCH.md` — the correct template is already present in this prompt).
 6. Write `{{outputPath}}`
 
 The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir — just write the file.

package/dist/resources/extensions/gsd/prompts/validate-milestone.md

@@ -1,6 +1,6 @@
 You are executing GSD auto-mode.
 
-## UNIT: Validate Milestone {{milestoneId}} ("{{milestoneTitle}}") — Remediation Round {{remediationRound}}
+## UNIT: Validate Milestone {{milestoneId}} ("{{milestoneTitle}}")
 
 ## Working Directory
 
@@ -8,84 +8,63 @@ Your working directory is `{{workingDirectory}}`. All file reads, writes, and sh
 
 ## Your Role in the Pipeline
 
-All slices are done. Before the **complete-milestone agent** closes this milestone, you reconcile planned work against what was actually delivered. You audit success criteria against evidence, inventory deferred work across all slice summaries and UAT results, and classify gaps. If auto-remediable gaps exist on the first pass, you append remediation slices to the roadmap so the pipeline can execute them before completion. After remediation slices run, you re-validate. The milestone only proceeds to completion once validation passes.
+All slices are done. Before the milestone can be completed, you must validate that the planned work was delivered as specified. Compare the roadmap's success criteria and slice definitions against the actual slice summaries and UAT results. This is a reconciliation gate — catch gaps, regressions, or missing deliverables before the milestone is sealed.
 
-This is a gate, not a formality. But most milestones pass — bias toward "pass" unless you find concrete evidence of unmet criteria or meaningful gaps.
+This is remediation round {{remediationRound}}. If this is round 0, this is the first validation pass. If > 0, prior validation found issues and remediation slices were added and executed — verify those remediation slices resolved the issues.
 
 All relevant context has been preloaded below — the roadmap, all slice summaries, UAT results, requirements, decisions, and project context are inlined. Start working immediately without re-reading these files.
 
 {{inlinedContext}}
 
-If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during validation, without relaxing required verification or artifact rules.
+## Validation Steps
 
-Then:
+1. For each **success criterion** in `{{roadmapPath}}`, check whether slice summaries and UAT results provide evidence that it was met. Record pass/fail per criterion.
+2. For each **slice** in the roadmap, verify its demo/deliverable claim against its summary. Flag any slice whose summary does not substantiate its claimed output.
+3. Check **cross-slice integration points** — do boundary map entries (produces/consumes) align with what was actually built?
+4. Check **requirement coverage** — are all active requirements addressed by at least one slice?
+5. Determine a verdict:
+   - `pass` — all criteria met, all slices delivered, no gaps
+   - `needs-attention` — minor gaps that do not block completion (document them)
+   - `needs-remediation` — material gaps found; add remediation slices to the roadmap
 
-### Step 1: Audit Success Criteria
+## Output
 
-Enumerate each success criterion from the roadmap's `## Success Criteria` section. For each criterion, map it to concrete evidence from slice summaries, UAT results, or observable behavior.
+Write `{{validationPath}}` with this structure:
 
-Format each criterion as:
+```markdown
+---
+verdict: <pass|needs-attention|needs-remediation>
+remediation_round: {{remediationRound}}
+---
 
-- `Criterion text` — **MET** — evidence: {{specific slice summary, UAT result, test output, or observable behavior}}
-- `Criterion text` — **NOT MET** — gap: {{what's missing and why}}
+# Milestone Validation: {{milestoneId}}
 
-Every criterion must have a definitive verdict. Do not mark a criterion as MET without specific evidence.
+## Success Criteria Checklist
+- [x] Criterion 1 — evidence: ...
+- [ ] Criterion 2 — gap: ...
 
-### Step 2: Inventory Deferred Work
+## Slice Delivery Audit
+| Slice | Claimed | Delivered | Status |
+|-------|---------|-----------|--------|
+| S01   | ...     | ...       | pass   |
 
-Scan ALL slice summaries for:
-- `Known Limitations` sections
-- `Follow-ups` sections
-- `Deviations` sections
+## Cross-Slice Integration
+(any boundary mismatches)
 
-Scan ALL UAT results for:
-- `Not Proven By This UAT` sections
-- Any PARTIAL or FAIL verdicts
+## Requirement Coverage
+(any unaddressed requirements)
 
-Check:
-- `.gsd/REQUIREMENTS.md` for Active requirements not yet Validated
-- `.gsd/CAPTURES.md` for unresolved deferred captures
+## Verdict Rationale
+(why this verdict was chosen)
 
-Collect every item into a single inventory. Do not skip items because they seem minor — the classification step handles prioritization.
+## Remediation Plan
+(only if verdict is needs-remediation — list new slices to add to the roadmap)
+```
 
-### Step 3: Classify Each Gap
-
-For every unmet criterion and every deferred work item, classify it as one of:
-
-- **auto-remediable** — can be fixed by adding a new slice (missing feature, unfixed bug, untested path, incomplete integration)
-- **human-required** — needs Lex's input (design decision, external service dependency, manual verification, judgment call, ambiguous requirement)
-- **acceptable** — known limitation that's OK to ship (documented trade-off, explicitly scoped for a future milestone, minor rough edge with no user impact)
-
-Be conservative with **auto-remediable**. Only classify a gap as auto-remediable if you're confident a slice can resolve it without human judgment. When in doubt, classify as **human-required**.
-
-### Step 4: Act on Gaps
-
-**If this is remediation round 0 AND auto-remediable gaps exist:**
-
-1. Define remediation slices to address auto-remediable gaps. Follow the exact roadmap slice format:
-   `- [ ] **S0X: Title** \`risk:medium\` \`depends:[]\``
-   Include a brief description of what each slice must accomplish.
-2. Append these slices to `{{roadmapPath}}` after existing slices (do not modify completed slices).
-3. Update the boundary map in the roadmap if the new slices introduce new integration points.
-4. Set verdict to `needs-remediation`.
-
-**If this is remediation round 1 or higher:**
-
-Do NOT add more slices. At this point either:
-- All remaining gaps are acceptable — set verdict to `pass`
-- Remaining gaps need Lex's input — set verdict to `needs-attention`
-
-Never add remediation slices after round 0. If round 0 remediation didn't close the gaps, escalate.
-
-**If no auto-remediable gaps exist (any round):**
-
-- If all criteria are MET and deferred items are acceptable or human-required only — set verdict to `pass` (with human-required items noted)
-- If human-required items are blocking — set verdict to `needs-attention`
-
-### Step 5: Write Validation Report
-
-Write `{{validationPath}}` using the milestone-validation template. Fill all frontmatter fields and every section. The report must be a complete record of the validation — a future agent reading only this file should understand what was checked, what passed, and what remains.
+If verdict is `needs-remediation`:
+- Add new slices to `{{roadmapPath}}` with unchecked `[ ]` status
+- These slices will be planned and executed before validation re-runs
 
 **You MUST write `{{validationPath}}` before finishing.**
 
-When done, say: "Milestone {{milestoneId}} validated."
+When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>."

package/dist/resources/extensions/gsd/provider-error-pause.ts

@@ -2,11 +2,38 @@ export type ProviderErrorPauseUI = {
   notify(message: string, level?: "info" | "warning" | "error" | "success"): void;
 };
 
+/**
+ * Pause auto-mode due to a provider error.
+ *
+ * For rate-limit errors with a known reset delay, schedules an automatic
+ * resume after the delay and shows a countdown notification. For all other
+ * errors, pauses indefinitely (user must manually resume).
+ */
 export async function pauseAutoForProviderError(
   ui: ProviderErrorPauseUI,
   errorDetail: string,
   pause: () => Promise<void>,
+  options?: {
+    isRateLimit?: boolean;
+    retryAfterMs?: number;
+    resume?: () => void;
+  },
 ): Promise<void> {
-  ui.notify(`Auto-mode paused due to provider error${errorDetail}`, "warning");
-  await pause();
+  if (options?.isRateLimit && options.retryAfterMs && options.retryAfterMs > 0 && options.resume) {
+    const delaySec = Math.ceil(options.retryAfterMs / 1000);
+    ui.notify(
+      `Rate limited${errorDetail}. Auto-resuming in ${delaySec}s...`,
+      "warning",
+    );
+    await pause();
+
+    // Schedule auto-resume after the rate limit window
+    setTimeout(() => {
+      ui.notify("Rate limit window elapsed. Resuming auto-mode.", "info");
+      options.resume!();
+    }, options.retryAfterMs);
+  } else {
+    ui.notify(`Auto-mode paused due to provider error${errorDetail}`, "warning");
+    await pause();
+  }
 }

package/dist/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/dist/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/dist/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/dist/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");