gsd-pi 2.65.0-dev.5c8557b → 2.65.0-dev.d0517ff

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Regression test for #3696 — prompt step ordering and runtime fixes
+ *
+ * 1. complete-milestone.md: gsd_requirement_update (step 9) before
+ *    gsd_complete_milestone (step 10)
+ * 2. complete-slice.md: uses gsd_requirement_update
+ * 3. register-extension.ts: _gsdEpipeGuard logs instead of re-throwing
+ * 4. register-hooks.ts: session_before_compact only checks isAutoActive
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const completeMilestoneMd = readFileSync(
+  join(__dirname, '..', 'prompts', 'complete-milestone.md'),
+  'utf-8',
+);
+const completeSliceMd = readFileSync(
+  join(__dirname, '..', 'prompts', 'complete-slice.md'),
+  'utf-8',
+);
+const registerExtSrc = readFileSync(
+  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
+  'utf-8',
+);
+const registerHooksSrc = readFileSync(
+  join(__dirname, '..', 'bootstrap', 'register-hooks.ts'),
+  'utf-8',
+);
+
+describe('prompt step ordering (#3696)', () => {
+  test('gsd_requirement_update step appears before gsd_complete_milestone step', () => {
+    // Search for the numbered step definitions, not early "Do NOT call" warnings
+    const reqUpdateMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_requirement_update/m);
+    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
+    assert.ok(reqUpdateMatch, 'gsd_requirement_update should appear in a numbered step');
+    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
+    const reqUpdateIdx = completeMilestoneMd.indexOf(reqUpdateMatch![0]);
+    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
+    assert.ok(
+      reqUpdateIdx < completeMilestoneIdx,
+      'gsd_requirement_update step must come before gsd_complete_milestone step',
+    );
+  });
+
+  test('complete-slice.md uses gsd_requirement_update', () => {
+    assert.match(completeSliceMd, /gsd_requirement_update/,
+      'complete-slice.md should reference gsd_requirement_update');
+  });
+});
+
+describe('register-extension _gsdEpipeGuard (#3696)', () => {
+  test('_gsdEpipeGuard exists and does not re-throw', () => {
+    assert.match(registerExtSrc, /_gsdEpipeGuard/,
+      '_gsdEpipeGuard should be defined in register-extension.ts');
+    // After the fix, the handler logs instead of throwing
+    assert.ok(
+      !registerExtSrc.includes('throw err'),
+      '_gsdEpipeGuard should NOT contain "throw err"',
+    );
+  });
+});
+
+describe('register-hooks session_before_compact (#3696)', () => {
+  test('session_before_compact only checks isAutoActive', () => {
+    // Extract the session_before_compact handler
+    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
+    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
+    // The first check in the handler should be isAutoActive(), not isAutoPaused()
+    const afterCompact = registerHooksSrc.slice(compactIdx, compactIdx + 300);
+    assert.match(afterCompact, /isAutoActive\(\)/,
+      'session_before_compact should check isAutoActive()');
+    // Should NOT block compaction when paused
+    assert.ok(
+      !afterCompact.includes('isAutoPaused()'),
+      'session_before_compact should not check isAutoPaused',
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -464,7 +464,8 @@ test("agent-session retryable error regex matches server_error (underscore)", ()
   // This regex is extracted from _isRetryableError in agent-session.ts.
   // It must match both "server error" (space) and "server_error" (underscore)
   // to properly classify Codex streaming errors as retryable.
-  const retryableRegex = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|temporarily backed off/i;
+  // "temporarily backed off" intentionally excluded — see #3429
+  const retryableRegex = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|extra usage is required/i;
 
   // server_error (with underscore — Codex streaming error format)
   assert.ok(retryableRegex.test("Codex server_error: An error occurred"));

package/src/resources/extensions/gsd/tests/query-tools-db-open.test.ts

@@ -0,0 +1,47 @@
+/**
+ * Regression test for #3672 — query-tools uses ensureDbOpen
+ *
+ * gsd_milestone_status previously called isDbAvailable() but never
+ * ensureDbOpen(), making it always fail outside auto-mode sessions.
+ * The fix imports ensureDbOpen from dynamic-tools and calls it before
+ * querying the DB.
+ *
+ * This structural test verifies the ensureDbOpen import and usage exist
+ * in query-tools.ts.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'bootstrap', 'query-tools.ts'), 'utf-8');
+
+describe('query-tools ensureDbOpen usage (#3672)', () => {
+  test('imports ensureDbOpen from dynamic-tools', () => {
+    assert.match(source, /ensureDbOpen.*import\(|import.*ensureDbOpen/,
+      'query-tools should import ensureDbOpen');
+  });
+
+  test('calls ensureDbOpen() before DB queries', () => {
+    assert.match(source, /await ensureDbOpen\(\)/,
+      'query-tools should call await ensureDbOpen()');
+  });
+
+  test('no longer imports isDbAvailable in the execute path', () => {
+    // The old code imported isDbAvailable and checked it; the fix removed that
+    // The execute function should not destructure isDbAvailable from gsd-db
+    const executeBlock = source.slice(source.indexOf('async execute('));
+    assert.doesNotMatch(executeBlock, /isDbAvailable,/,
+      'execute path should not destructure isDbAvailable (replaced by ensureDbOpen)');
+  });
+
+  test('uses dbAvailable result from ensureDbOpen', () => {
+    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\(\)/,
+      'should store ensureDbOpen result in dbAvailable');
+  });
+});

package/src/resources/extensions/gsd/tests/queued-discuss-fast-path.test.ts

@@ -0,0 +1,107 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function guidedFlowSrc(): string {
+  return readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
+}
+
+function promptSrc(): string {
+  return readFileSync(join(__dirname, "..", "prompts", "guided-discuss-milestone.md"), "utf-8");
+}
+
+describe("queued-discuss-fast-path", () => {
+  test("1. guided-discuss-milestone.md contains {{fastPathInstruction}}", () => {
+    const prompt = promptSrc();
+    assert.ok(
+      prompt.includes("{{fastPathInstruction}}"),
+      "guided-discuss-milestone.md must contain {{fastPathInstruction}} template variable",
+    );
+  });
+
+  test("2. dispatchDiscussForMilestone computes fastPathInstruction and passes it to loadPrompt", () => {
+    const source = guidedFlowSrc();
+    const fnStart = source.indexOf("async function dispatchDiscussForMilestone(");
+    assert.ok(fnStart > 0, "dispatchDiscussForMilestone must exist");
+    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
+    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 2000);
+    assert.ok(
+      fnBody.includes("fastPathInstruction"),
+      "dispatchDiscussForMilestone must compute fastPathInstruction",
+    );
+    assert.ok(
+      fnBody.includes("loadPrompt("),
+      "dispatchDiscussForMilestone must call loadPrompt",
+    );
+    const loadPromptIdx = fnBody.indexOf("loadPrompt(");
+    const fastPathIdx = fnBody.indexOf("fastPathInstruction", loadPromptIdx);
+    assert.ok(
+      fastPathIdx > loadPromptIdx,
+      "fastPathInstruction must be passed to loadPrompt in dispatchDiscussForMilestone",
+    );
+  });
+
+  test("3. fast path instruction mentions scouting and conflict checking", () => {
+    const source = guidedFlowSrc();
+    assert.ok(
+      source.includes("scouting pass"),
+      "fast path instruction must mention scouting pass",
+    );
+    assert.ok(
+      source.includes("conflicts with existing work"),
+      "fast path instruction must mention conflict checking",
+    );
+  });
+
+  test("4. showDiscussQueuedMilestone shows a mode picker when no draft", () => {
+    const source = guidedFlowSrc();
+    const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
+    assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
+    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
+    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    assert.ok(
+      fnBody.includes("hasDraft"),
+      "showDiscussQueuedMilestone must check hasDraft",
+    );
+    assert.ok(
+      fnBody.includes('"full"') || fnBody.includes("\"full\""),
+      "showDiscussQueuedMilestone must offer a 'full' discussion mode",
+    );
+    assert.ok(
+      fnBody.includes('"fast"') || fnBody.includes("\"fast\""),
+      "showDiscussQueuedMilestone must offer a 'fast' path mode",
+    );
+  });
+
+  test("5. showDiscussQueuedMilestone fast-paths automatically when draft exists", () => {
+    const source = guidedFlowSrc();
+    const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
+    assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
+    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
+    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    assert.ok(
+      fnBody.includes("let fastPath = hasDraft"),
+      "showDiscussQueuedMilestone must set fastPath = hasDraft so draft presence auto-enables fast path",
+    );
+    assert.ok(
+      fnBody.includes("if (!hasDraft)"),
+      "showDiscussQueuedMilestone must skip the mode picker when hasDraft is true",
+    );
+  });
+
+  test("6. dispatchDiscussForMilestone accepts opts with fastPath parameter", () => {
+    const source = guidedFlowSrc();
+    const fnStart = source.indexOf("async function dispatchDiscussForMilestone(");
+    assert.ok(fnStart > 0, "dispatchDiscussForMilestone must exist");
+    const signatureEnd = source.indexOf("): Promise<void>", fnStart);
+    const signature = source.slice(fnStart, signatureEnd + 16);
+    assert.ok(
+      signature.includes("opts") && signature.includes("fastPath"),
+      "dispatchDiscussForMilestone must accept opts: { fastPath?: boolean } parameter",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/reactive-graph.test.ts

@@ -5,6 +5,7 @@ import {
   getReadyTasks,
   chooseNonConflictingSubset,
   isGraphAmbiguous,
+  getMissingAnnotationTasks,
   detectDeadlock,
   graphMetrics,
 } from "../reactive-graph.ts";
@@ -297,3 +298,47 @@ test("graphMetrics computes correct values", () => {
   assert.equal(metrics.readySetSize, 2); // T02 (T01 done) and T03 (no deps)
   assert.equal(metrics.ambiguous, false);
 });
+
+// ─── getMissingAnnotationTasks ─────────────────────────────────────────────
+
+test("getMissingAnnotationTasks: returns empty array when all tasks have annotations", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: ["src/c.ts"], done: false, dependsOn: [] },
+  ];
+  assert.deepEqual(getMissingAnnotationTasks(graph), []);
+});
+
+test("getMissingAnnotationTasks: returns tasks with missing annotations", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: [], done: false, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: ["src/a.ts"], outputFiles: ["src/b.ts"], done: false, dependsOn: [] },
+    { id: "T03", title: "C", inputFiles: [], outputFiles: [], done: false, dependsOn: [] },
+  ];
+  assert.deepEqual(getMissingAnnotationTasks(graph), [
+    { id: "T01", title: "A" },
+    { id: "T03", title: "C" },
+  ]);
+});
+
+test("getMissingAnnotationTasks: skips done tasks", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "A", inputFiles: [], outputFiles: [], done: true, dependsOn: [] },
+    { id: "T02", title: "B", inputFiles: [], outputFiles: [], done: false, dependsOn: [] },
+  ];
+  assert.deepEqual(getMissingAnnotationTasks(graph), [
+    { id: "T02", title: "B" },
+  ]);
+});
+
+test("getMissingAnnotationTasks: returns only tasks missing BOTH inputFiles and outputFiles", () => {
+  const graph: DerivedTaskNode[] = [
+    { id: "T01", title: "InputOnly", inputFiles: ["src/a.ts"], outputFiles: [], done: false, dependsOn: [] },
+    { id: "T02", title: "OutputOnly", inputFiles: [], outputFiles: ["src/b.ts"], done: false, dependsOn: [] },
+    { id: "T03", title: "Neither", inputFiles: [], outputFiles: [], done: false, dependsOn: [] },
+    { id: "T04", title: "Both", inputFiles: ["src/c.ts"], outputFiles: ["src/d.ts"], done: false, dependsOn: [] },
+  ];
+  assert.deepEqual(getMissingAnnotationTasks(graph), [
+    { id: "T03", title: "Neither" },
+  ]);
+});

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Regression test for #3628 — restore tool set after discuss flow scoping
+ *
+ * The discuss flow narrows the active tool set to avoid "grammar too complex"
+ * errors. Without restoring after sendMessage, the narrowed tools leaked into
+ * subsequent dispatches, breaking plan/execute flows.
+ *
+ * The fix saves the full tool set before scoping and restores it after
+ * sendMessage returns.
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const src = readFileSync(
+  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'guided-flow.ts'),
+  'utf-8',
+)
+
+describe('restore tools after discuss flow scoping (#3628)', () => {
+  it('savedTools is declared before the discuss scoping block', () => {
+    // savedTools must be declared before the discuss-* check
+    const savedToolsDecl = src.indexOf('let savedTools')
+    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
+    assert.ok(savedToolsDecl !== -1, 'savedTools variable must be declared')
+    assert.ok(discussCheck !== -1, 'discuss-* type check must exist')
+    assert.ok(
+      savedToolsDecl < discussCheck,
+      'savedTools must be declared before the discuss scoping block',
+    )
+  })
+
+  it('savedTools captures current tools inside the discuss block', () => {
+    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
+    assert.ok(discussCheck !== -1)
+
+    // Look for savedTools assignment within the discuss block
+    const blockAfter = src.slice(discussCheck, discussCheck + 500)
+    assert.ok(
+      blockAfter.includes('savedTools = currentTools'),
+      'savedTools must be assigned from currentTools inside the discuss block',
+    )
+  })
+
+  it('savedTools is restored after sendMessage', () => {
+    // Find the sendMessage call
+    const sendMsg = src.indexOf('triggerTurn: true')
+    assert.ok(sendMsg !== -1, 'sendMessage with triggerTurn must exist')
+
+    // After sendMessage, savedTools should be restored via setActiveTools
+    const afterSend = src.slice(sendMsg, sendMsg + 500)
+    assert.ok(
+      afterSend.includes('if (savedTools)'),
+      'savedTools restoration guard must exist after sendMessage',
+    )
+    assert.ok(
+      afterSend.includes('setActiveTools(savedTools)'),
+      'setActiveTools(savedTools) must be called to restore the full tool set',
+    )
+  })
+})

package/src/resources/extensions/gsd/tests/rogue-file-detection.test.ts

@@ -149,7 +149,7 @@ test("rogue detection: DB not available → returns empty array (graceful degrad
   }
 });
 
-test("rogue detection: slice summary on disk, no DB row → detected as rogue", () => {
+test("rogue detection: slice summary on disk, no DB row → auto-remediated (not rogue)", () => {
   const basePath = createTmpBase();
   const dbPath = join(basePath, ".gsd", "gsd.db");
   mkdirSync(join(basePath, ".gsd"), { recursive: true });
@@ -160,11 +160,10 @@ test("rogue detection: slice summary on disk, no DB row → detected as rogue",
     const summaryPath = createSliceSummaryOnDisk(basePath, "M001", "S01");
     assert.ok(existsSync(summaryPath), "Slice summary file should exist on disk");
 
+    // Fix #3633: stale slice DB status is auto-remediated via updateSliceStatus()
+    // instead of being reported as rogue, so rogues array should be empty.
     const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
-    assert.equal(rogues.length, 1, "Should detect one rogue slice file");
-    assert.equal(rogues[0].path, summaryPath);
-    assert.equal(rogues[0].unitType, "complete-slice");
-    assert.equal(rogues[0].unitId, "M001/S01");
+    assert.equal(rogues.length, 0, "Should auto-remediate stale slice, not report as rogue");
   } finally {
     closeDatabase();
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/run-uat-replay-cap.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Regression test for #3624 — cap run-uat dispatch attempts
+ *
+ * When verification commands fail before writing a verdict, the run-uat
+ * dispatch rule fires repeatedly in an infinite loop. The fix adds a
+ * MAX_UAT_ATTEMPTS constant and calls incrementUatCount before dispatch
+ * to cap the number of attempts.
+ *
+ * Structural verification test — reads source to confirm MAX_UAT_ATTEMPTS
+ * and incrementUatCount exist.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'auto-dispatch.ts'), 'utf-8');
+
+describe('run-uat replay cap (#3624)', () => {
+  test('MAX_UAT_ATTEMPTS constant is defined', () => {
+    assert.match(source, /const MAX_UAT_ATTEMPTS\s*=\s*\d+/,
+      'MAX_UAT_ATTEMPTS constant should be defined');
+  });
+
+  test('incrementUatCount function is exported', () => {
+    assert.match(source, /export function incrementUatCount\(/,
+      'incrementUatCount should be an exported function');
+  });
+
+  test('getUatCount function is exported', () => {
+    assert.match(source, /export function getUatCount\(/,
+      'getUatCount should be an exported function');
+  });
+
+  test('incrementUatCount is called before dispatch in rule', () => {
+    // incrementUatCount should be called before the dispatch return
+    const ruleSection = source.slice(source.indexOf('checkNeedsRunUat'));
+    assert.match(ruleSection, /incrementUatCount\(/,
+      'incrementUatCount should be called in the dispatch rule');
+  });
+
+  test('attempts are compared against MAX_UAT_ATTEMPTS', () => {
+    assert.match(source, /attempts\s*>\s*MAX_UAT_ATTEMPTS/,
+      'dispatch should check attempts > MAX_UAT_ATTEMPTS');
+  });
+});

package/src/resources/extensions/gsd/tests/show-config-command.test.ts

@@ -0,0 +1,56 @@
+/**
+ * /gsd show-config command — structural tests.
+ *
+ * Verifies the config overlay class and command handler exist
+ * with correct structure.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const overlaySrc = readFileSync(join(__dirname, "..", "config-overlay.ts"), "utf-8");
+const coreSrc = readFileSync(join(__dirname, "..", "commands", "handlers", "core.ts"), "utf-8");
+
+// ─── Config overlay ───────────────────────────────────────────────────────
+
+test("GSDConfigOverlay class is exported", () => {
+  assert.ok(
+    overlaySrc.includes("export class GSDConfigOverlay"),
+    "GSDConfigOverlay should be exported",
+  );
+});
+
+test("GSDConfigOverlay implements Component interface methods", () => {
+  assert.ok(overlaySrc.includes("render("), "should have render method");
+  assert.ok(overlaySrc.includes("handleInput("), "should have handleInput method");
+  assert.ok(overlaySrc.includes("invalidate("), "should have invalidate method");
+  assert.ok(overlaySrc.includes("dispose("), "should have dispose method");
+});
+
+test("formatConfigText function is exported", () => {
+  assert.ok(
+    overlaySrc.includes("export function formatConfigText"),
+    "formatConfigText should be exported for non-overlay fallback",
+  );
+});
+
+// ─── Command handler ──────────────────────────────────────────────────────
+
+test("core handler routes show-config command", () => {
+  assert.ok(
+    coreSrc.includes('"show-config"'),
+    "core handler should match show-config command",
+  );
+});
+
+test("show-config has text fallback via formatConfigText", () => {
+  assert.ok(
+    coreSrc.includes("formatConfigText"),
+    "show-config should use formatConfigText as fallback",
+  );
+});

package/src/resources/extensions/gsd/tests/skip-slice-state-rebuild.test.ts

@@ -0,0 +1,31 @@
+/**
+ * Regression test for #3477: gsd_skip_slice tool must rebuild STATE.md
+ * after updating the DB so auto-mode reads the correct state.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("gsd_skip_slice tool calls rebuildState after DB update (#3477)", () => {
+  const src = readFileSync(
+    join(import.meta.dirname, "..", "bootstrap", "db-tools.ts"),
+    "utf-8",
+  );
+  // The fix adds a rebuildState call after updateSliceStatus in skip_slice
+  assert.ok(
+    src.includes("rebuildState"),
+    "gsd_skip_slice must call rebuildState after updating slice status",
+  );
+});
+
+test("rethink prompt warns against markdown-only edits for skip (#3477)", () => {
+  const prompt = readFileSync(
+    join(import.meta.dirname, "..", "prompts", "rethink.md"),
+    "utf-8",
+  );
+  assert.ok(
+    prompt.includes("MUST") && prompt.includes("gsd_skip_slice"),
+    "Rethink prompt must emphasize gsd_skip_slice tool requirement",
+  );
+});

package/src/resources/extensions/gsd/tests/skipped-validation-completion.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Regression test for #3698 — allow milestone completion when validation
+ * was skipped by preference
+ *
+ * When validation is skipped due to user preference (e.g. budget profile),
+ * auto-dispatch should recognize the "skipped by preference" pattern and
+ * allow completion instead of treating it as a missing validation.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const autoDispatchSrc = readFileSync(
+  join(__dirname, '..', 'auto-dispatch.ts'),
+  'utf-8',
+);
+
+describe('skipped validation completion (#3698)', () => {
+  test('skippedByPreference regex detection exists', () => {
+    assert.match(autoDispatchSrc, /skippedByPreference/,
+      'skippedByPreference variable should exist in auto-dispatch.ts');
+  });
+
+  test('regex matches skip-by-preference patterns', () => {
+    assert.match(autoDispatchSrc, /skip\(\?:ped\)\?\[\\s\\-\]\+\(\?:by\|per\|due to\)/,
+      'should have regex matching "skipped by/per/due to" patterns');
+  });
+
+  test('skippedByPreference feeds into operational check', () => {
+    assert.match(autoDispatchSrc, /hasOperationalCheck\s*=\s*skippedByPreference/,
+      'skippedByPreference should be part of hasOperationalCheck');
+  });
+});

package/src/resources/extensions/gsd/tests/slice-sequence-insert.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Regression test for #3697 — set slice sequence on insert
+ *
+ * All three insertSlice call sites must pass a sequence value so slices
+ * are ordered correctly instead of defaulting to 0.
+ */
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const planMilestoneSrc = readFileSync(
+  join(__dirname, '..', 'tools', 'plan-milestone.ts'),
+  'utf-8',
+);
+const reassessRoadmapSrc = readFileSync(
+  join(__dirname, '..', 'tools', 'reassess-roadmap.ts'),
+  'utf-8',
+);
+const mdImporterSrc = readFileSync(
+  join(__dirname, '..', 'md-importer.ts'),
+  'utf-8',
+);
+
+describe('slice sequence on insert (#3697)', () => {
+  test('plan-milestone.ts passes sequence to insertSlice', () => {
+    assert.match(planMilestoneSrc, /insertSlice\(/,
+      'plan-milestone.ts should call insertSlice');
+    assert.match(planMilestoneSrc, /sequence:\s*i\s*\+\s*1/,
+      'plan-milestone.ts should pass sequence: i + 1');
+  });
+
+  test('reassess-roadmap.ts passes sequence to insertSlice', () => {
+    assert.match(reassessRoadmapSrc, /insertSlice\(/,
+      'reassess-roadmap.ts should call insertSlice');
+    assert.match(reassessRoadmapSrc, /sequence:\s*existingCount\s*\+\s*i\s*\+\s*1/,
+      'reassess-roadmap.ts should pass sequence: existingCount + i + 1');
+  });
+
+  test('md-importer.ts passes sequence to insertSlice', () => {
+    assert.match(mdImporterSrc, /insertSlice\(/,
+      'md-importer.ts should call insertSlice');
+    assert.match(mdImporterSrc, /sequence:\s*si\s*\+\s*1/,
+      'md-importer.ts should pass sequence: si + 1');
+  });
+});

package/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts

@@ -49,5 +49,5 @@ test("guided-flow complete branch offers a chooser for next milestone or status"
   assert.match(branchChunk, /showNextAction\(/, "complete branch should present a chooser");
   assert.match(branchChunk, /findMilestoneIds\(basePath\)/, "complete branch should compute the next milestone id");
   assert.match(branchChunk, /nextMilestoneId(?:Reserved)?\(milestoneIds, uniqueMilestoneIds\)/, "complete branch should derive the next milestone id");
-  assert.match(branchChunk, /dispatchWorkflow\(pi, buildDiscussPrompt\(/, "complete branch should dispatch the discuss prompt");
+  assert.match(branchChunk, /dispatchWorkflow\(pi, await prepareAndBuildDiscussPrompt\(/, "complete branch should dispatch the prepared discuss prompt");
 });