@opengsd/gsd-pi 1.1.1-dev.a5a2de8 → 1.1.1-dev.b2556262

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

@@ -723,7 +723,9 @@ test('(u) run-uat prompt promotes artifact-driven browser specs to browser-execu
 
       assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`browser-executable`/);
       assert.match(prompt, /uatType: "browser-executable"/);
-      assert.match(prompt, /use gsd-browser tools/i);
+      assert.match(prompt, /use browser tools/i);
+      assert.match(prompt, /"browser_navigate"/);
+      assert.match(prompt, /"browser_assert"/);
     } finally {
       cleanup(base);
     }
@@ -741,6 +743,7 @@ test('(v) run-uat prompt keeps deferred browser work artifact-driven', async ()
       assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`artifact-driven`/);
       assert.match(prompt, /uatType: "artifact-driven"/);
       assert.doesNotMatch(prompt, /uatType: "browser-executable"/);
+      assert.doesNotMatch(prompt, /"browser_navigate"/);
     } finally {
       cleanup(base);
     }

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

@@ -226,6 +226,33 @@ test("direct /gsd auto skips paused-session replay when recovered unit already c
   }
 });
 
+test("paused-session resume skips replay when unit identity was never recorded", () => {
+  const base = makeTmpBase();
+  try {
+    // No currentUnit and no persisted unit type/id — identity is unknown. The
+    // old code fell back to the literal "unknown" unit, which can neither be
+    // verified nor correctly targeted, and synthesized a full tool-call replay
+    // (the thrash that turns one stuck unit into several). The fix skips the
+    // replay and resumes from rebuilt disk state instead.
+    const state = {
+      pausedSessionFile: join(base, ".gsd", "activity", "paused-session.jsonl"),
+      currentUnit: null,
+      pausedUnitType: null,
+      pausedUnitId: null,
+      pendingCrashRecovery: "stale-recovery-prompt",
+    };
+
+    const result = _handlePausedSessionResumeRecoveryForTest(base, state);
+    assert.equal(result.skippedReplay, true);
+    assert.equal(state.pausedSessionFile, null);
+    assert.equal(state.pendingCrashRecovery, null, "must not synthesize a replay for an unknown unit");
+    assert.equal(state.pausedUnitType, null);
+    assert.equal(state.pausedUnitId, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("interrupted-session source preserves raw lock and excludes same-pid from running classification", async () => {
   const source = await import(`node:fs/promises`).then((fs) =>
     fs.readFile(new URL("../interrupted-session.ts", import.meta.url), "utf-8")

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -30,6 +30,7 @@ import {
   insertTask,
   openDatabase,
 } from "../gsd-db.js";
+import { SourceObservationStore } from "../source-observations.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -186,6 +187,7 @@ function makeSession() {
     currentMilestoneId: "M001",
     currentUnit: null,
     currentUnitRouting: null,
+    sourceObservations: new SourceObservationStore(),
     completedUnits: [],
     resourceVersionOnStart: null,
     lastPromptCharCount: undefined,
@@ -200,12 +202,26 @@ function makeSession() {
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),
     verificationRetryCount: new Map<string, number>(),
+    zeroToolRetryCount: new Map<string, number>(),
     gitService: null,
     autoStartTime: Date.now(),
     cmdCtx: {
       newSession: () => Promise.resolve({ cancelled: false }),
       getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
     },
+    setCurrentUnit(this: any, unit: any) {
+      this.currentUnit = unit;
+      this.sourceObservations.beginUnit({
+        unitType: unit.type,
+        unitId: unit.id,
+        startedAt: unit.startedAt,
+        basePath: unit.workspaceRoot ?? this.basePath,
+      });
+    },
+    clearCurrentUnit(this: any) {
+      this.currentUnit = null;
+      this.sourceObservations.clear();
+    },
     clearTimers: () => {},
   } as any;
 }

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

@@ -393,6 +393,48 @@ test('── markdown-renderer: renderPlanCheckboxes round-trip ──', async (
   }
 });
 
+test('── markdown-renderer: renderPlanCheckboxes re-renders DB tasks added after the plan artifact ──', async () => {
+  // Regression for the lossy-projection root cause: renderPlanCheckboxes used to
+  // patch the cached PLAN artifact in place, silently dropping tasks added to
+  // the DB after the artifact was first written (the 4S/0T-vs-5S/13T drift).
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  clearAllCaches();
+
+  try {
+    scaffoldDirs(tmpDir, 'M001', ['S01']);
+    insertMilestone({ id: 'M001', title: 'Test', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'pending' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'First task', status: 'pending' });
+
+    // PLAN.md on disk reflects an earlier state with only T01.
+    const planPath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md');
+    fs.writeFileSync(planPath, makePlanContent('S01', [{ id: 'T01', title: 'First task', done: false }]));
+    clearAllCaches();
+
+    // Two more tasks are written to the DB after the artifact already exists.
+    insertTask({ id: 'T02', sliceId: 'S01', milestoneId: 'M001', title: 'Second task', status: 'done' });
+    insertTask({ id: 'T03', sliceId: 'S01', milestoneId: 'M001', title: 'Third task', status: 'pending' });
+
+    const ok = await renderPlanCheckboxes(tmpDir, 'M001', 'S01');
+    assert.ok(ok, 'renderPlanCheckboxes returns true');
+
+    const parsed = parsePlan(fs.readFileSync(planPath, 'utf-8'));
+    clearAllCaches();
+    assert.deepStrictEqual(
+      parsed.tasks.map(t => t.id).sort(),
+      ['T01', 'T02', 'T03'],
+      'full re-render must include tasks added after the artifact was written',
+    );
+    assert.ok(parsed.tasks.find(t => t.id === 'T02')!.done, 'T02 reflects done status from DB');
+    assert.ok(!parsed.tasks.find(t => t.id === 'T03')!.done, 'T03 reflects pending status from DB');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+});
+
 test('── markdown-renderer: renderPlanCheckboxes bidirectional ──', async () => {
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -54,7 +54,13 @@ test("ensureProjectWorkflowMcpConfig creates .mcp.json with workflow and browser
       "--identity-scope",
       "project",
     ]);
-    assert.equal(browserArgs[mcpArgIndex + 6], projectRoot);
+    // --identity-scope requires a non-empty --identity-key or gsd-browser exits
+    // immediately ("Connection closed"); the key must be stable per project.
+    assert.equal(browserArgs[mcpArgIndex + 5], "--identity-key");
+    assert.equal(typeof browserArgs[mcpArgIndex + 6], "string");
+    assert.ok((browserArgs[mcpArgIndex + 6] ?? "").length > 0, "identity-key must be non-empty");
+    assert.equal(browserArgs[mcpArgIndex + 7], "--identity-project");
+    assert.equal(browserArgs[mcpArgIndex + 8], projectRoot);
     assert.equal((browserServer as { cwd?: string })?.cwd, projectRoot);
 
     const settings = JSON.parse(readFileSync(join(projectRoot, ".claude", "settings.local.json"), "utf-8")) as {

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -342,7 +342,7 @@ describe("formatMcpInitResult", () => {
     assert.match(result, /\/tmp\/project\/\.mcp\.json/);
     assert.match(result, /mcp-capable clients/i);
     assert.match(result, /workflow and gsd-browser MCP servers/i);
-    assert.match(result, /Pi Providers use the managed gsd-browser engine/i);
+    assert.match(result, /Pi Providers use built-in browser tools/i);
     assert.doesNotMatch(result, /claude code/i);
   });
 

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

@@ -151,6 +151,105 @@ test("migration auto-check leaves matching DB hierarchy alone", async () => {
   }
 });
 
+test("migration auto-check flags a populated DB with missing markdown and points at rebuild (not recover)", async () => {
+  const base = makeBase();
+  try {
+    // A project with no milestone markdown: simulate lost/empty projections
+    // over a populated DB. The previous early return treated all-zero markdown
+    // as 'no project' and never even opened the DB, silently hiding the rows.
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    assert.deepEqual(countMarkdownHierarchy(base), { milestones: 0, slices: 0, tasks: 0 });
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(result.action, "recovery-required");
+    assert.equal(result.reason, "markdown-missing");
+    // The DB is the richer side, so recover (md → DB) would DELETE rows. The
+    // safe repair is to re-project from the DB.
+    assert.equal(result.recoveryCommand, "/gsd rebuild markdown");
+    assert.match(result.message ?? "", /rebuild markdown/);
+    assert.match(result.message ?? "", /Do NOT run/);
+    // The check must not mutate the DB.
+    assert.equal(getAllMilestones().length, 1);
+    assert.equal(getSliceTasks("M001", "S01").length, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check detects identity drift even when counts match", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    // Same cardinalities (1M/1S/1T) but a DIFFERENT slice identity (S99 vs S01).
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S99", milestoneId: "M001", title: "Other Slice", status: "pending", risk: "medium", depends: [], demo: "d", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S99", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    // Counts are equal on both sides, so the old count-only comparison reported
+    // 'in-sync'. Identity comparison must catch the divergence instead.
+    assert.equal(result.action, "recovery-required");
+    assert.notEqual(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 1 });
+    // The DB holds S99 (which markdown lacks), so recover would DELETE it. Even
+    // at equal counts the safe recommendation must be rebuild, not recover.
+    assert.equal(result.recoveryCommand, "/gsd rebuild markdown");
+    assert.match(result.message ?? "", /Do NOT run/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("recoverWouldDeleteDbRows flags identity drift the markdown lacks (even at equal counts)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // markdown: M001 / S01 / T01
+    assert.equal(await ensureDbOpen(base), true);
+    // DB row identity (S99) differs from markdown (S01) at the same count.
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S99", milestoneId: "M001", title: "Other Slice", status: "pending", risk: "medium", depends: [], demo: "d", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S99", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const { recoverWouldDeleteDbRows } = await import("../migration-auto-check.ts");
+    assert.equal(recoverWouldDeleteDbRows(base), true, "DB S99 is absent from markdown — recover would delete it");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check canonicalizes a legacy descriptor milestone dir (no false drift)", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base); // creates .gsd/milestones/M001
+    // Rename the dir to a legacy descriptor form while the DB id stays "M001".
+    // scanMarkdownHierarchy must canonicalize "M001-old" → "M001" so the
+    // identity sets line up with scanDbHierarchy (which uses milestone.id).
+    const milestonesRoot = join(base, ".gsd", "milestones");
+    renameSync(join(milestonesRoot, "M001"), join(milestonesRoot, "M001-old"));
+
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "M001", title: "Legacy Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Legacy Slice", status: "pending", risk: "medium", depends: [], demo: "Legacy slice demo", sequence: 1 });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Legacy Task", status: "pending" });
+
+    const result = await checkMarkdownHierarchyAgainstDb(base);
+    // Must be in-sync: the raw dir name "M001-old" would otherwise mismatch the
+    // DB id "M001" and be flagged as false drift.
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("migration auto-check refreshes a stale open DB handle before comparing", async () => {
   const base = makeBase();
   try {

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

@@ -133,6 +133,36 @@ test('handlePlanSlice persists explicit slice/task target repositories', async (
   }
 });
 
+test('handlePlanSlice honors configured gate-evaluation gate sets', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'gate_evaluation:',
+        '  enabled: true',
+        '  slice_gates:',
+        '    - Q3',
+        '  task_gates: false',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const gateIds = getGateResults('M001', 'S02').map((gate) => gate.gate_id).sort();
+    assert.deepEqual(gateIds, ['Q3', 'Q8']);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects unknown target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -196,6 +226,50 @@ test('handlePlanSlice enforces absolute path scope to declared target repositori
   }
 });
 
+test('handlePlanSlice resolves relative task IO paths against declared target repository roots', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    mkdirSync(join(base, 'frontend'), { recursive: true });
+    writeFileSync(join(base, 'frontend', 'app.js'), 'export {};\n', 'utf-8');
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'workspace:',
+        '  mode: parent',
+        '  repositories:',
+        '    frontend:',
+        '      path: frontend',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const params = validParams();
+    const result = await handlePlanSlice({
+      ...params,
+      targetRepositories: ['frontend'],
+      tasks: [
+        {
+          ...params.tasks[0],
+          files: ['app.js'],
+          inputs: ['app.js'],
+          expectedOutput: ['app.js'],
+          targetRepositories: ['frontend'],
+        },
+      ],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.deepEqual(getSliceTasks('M001', 'S02').map((task) => task.id), ['T01']);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects relative traversal outside declared target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -749,7 +823,7 @@ test('regression: validateTasks surfaces clean per-field errors for non-array IO
   }
 });
 
-test('handlePlanSlice skips prose and sentinel values in planning path scope', async () => {
+test('handlePlanSlice skips prose and sentinel input values in planning path scope', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
 
@@ -760,7 +834,7 @@ test('handlePlanSlice skips prose and sentinel values in planning path scope', a
       tasks: [{
         ...validParams().tasks[0],
         inputs: ['Current enum shape in codebase', 'None'],
-        expectedOutput: ['Updated planning-path-scope.ts — validates paths only'],
+        expectedOutput: ['src/resources/extensions/gsd/planning-path-scope.ts'],
       }],
     }, base);
 
@@ -771,6 +845,29 @@ test('handlePlanSlice skips prose and sentinel values in planning path scope', a
   }
 });
 
+test('handlePlanSlice rejects prose expectedOutput entries before path-scope validation', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [{
+        ...validParams().tasks[0],
+        expectedOutput: ['Browser UI supports due-date add/edit flows and mixed-list urgency rendering.'],
+      }],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /expectedOutput must contain only file paths/);
+    assert.doesNotMatch(result.error, /outside allowed repository roots/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid output contract must not persist tasks');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice resolves relative task IO paths against worktree roots', async () => {
   const base = makeTmpBase();
   const worktree = join(base, '.gsd', 'worktrees', 'M001');

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -96,6 +96,25 @@ test('handlePlanTask explains string IO fields must be arrays', async () => {
   }
 });
 
+test('handlePlanTask rejects prose expectedOutput entries', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      expectedOutput: ['Browser UI supports due-date add/edit flows and mixed-list urgency rendering.'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: expectedOutput must contain only file paths/);
+    assert.doesNotMatch(result.error, /outside allowed repository roots/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid output contract must not persist the task');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects absolute task IO paths outside the active worktree', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/planner-handoff.test.ts

@@ -0,0 +1,100 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { GSD_COMMAND_DESCRIPTION, getGsdArgumentCompletions, TOP_LEVEL_SUBCOMMANDS } from "../commands/catalog.ts";
+import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { DISPATCH_RULES } from "../auto-dispatch.ts";
+import {
+  buildGsdPlannerSpawnPlan,
+  formatGsdPlannerCommand,
+  hasPlannerHandoffBeenOffered,
+  markPlannerHandoffOffered,
+  PLANNER_HANDOFF_RULE_NAME,
+} from "../planner-handoff.ts";
+
+describe("planner handoff command catalog", () => {
+  test("/gsd planner is hidden from description and completions", () => {
+    assert.doesNotMatch(GSD_COMMAND_DESCRIPTION, /\|planner(?:\||$)/);
+    assert.equal(
+      TOP_LEVEL_SUBCOMMANDS.some((command) => command.cmd === "planner"),
+      false,
+      "planner should not appear in top-level commands",
+    );
+
+    const completions = getGsdArgumentCompletions("pla");
+
+    assert.equal(
+      completions.some((completion) => completion.value === "planner"),
+      false,
+      "planner should not appear in top-level completions",
+    );
+
+    assert.deepEqual(
+      getGsdArgumentCompletions("planner --"),
+      [],
+      "planner should not expose nested completions",
+    );
+  });
+});
+
+describe("planner handoff command handler", () => {
+  test("/gsd planner falls through to the unknown-command path", async () => {
+    const notifications: Array<{ message: string; level?: string }> = [];
+    const ctx = {
+      ui: {
+        notify(message: string, level?: string) {
+          notifications.push({ message, level });
+        },
+      },
+    };
+
+    const handled = await handleCoreCommand("planner M001 --dry-run --inspect", ctx as any);
+
+    assert.equal(handled, false);
+    assert.deepEqual(notifications, []);
+  });
+});
+
+describe("planner handoff launcher", () => {
+  test("builds gsd-planner command with project and milestone context", () => {
+    const plan = buildGsdPlannerSpawnPlan({
+      basePath: "/tmp/project with spaces",
+      milestoneId: "M001",
+      extraArgs: ["--inspect"],
+    });
+
+    assert.deepEqual(plan, {
+      command: "gsd-planner",
+      args: ["--project", "/tmp/project with spaces", "--milestone", "M001", "--inspect"],
+      cwd: "/tmp/project with spaces",
+    });
+    assert.equal(
+      formatGsdPlannerCommand(plan),
+      'gsd-planner --project "/tmp/project with spaces" --milestone M001 --inspect',
+    );
+  });
+
+  test("records one-shot handoff markers per milestone", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-planner-marker-"));
+    try {
+      assert.equal(hasPlannerHandoffBeenOffered(basePath, "M001"), false);
+      markPlannerHandoffOffered(basePath, "M001");
+      assert.equal(hasPlannerHandoffBeenOffered(basePath, "M001"), true);
+      assert.equal(hasPlannerHandoffBeenOffered(basePath, "M002"), false);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("planner handoff dispatch rule", () => {
+  test("rule is not registered while /gsd planner is disabled", () => {
+    assert.equal(
+      DISPATCH_RULES.some((rule) => rule.name === PLANNER_HANDOFF_RULE_NAME),
+      false,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -467,6 +467,20 @@ test("notification fields validate correctly", () => {
   assert.equal(preferences.notifications?.on_complete, false);
 });
 
+test("gate_evaluation slice_gates only accepts gate-evaluate-owned gates", () => {
+  const valid = validatePreferences({
+    gate_evaluation: { enabled: true, slice_gates: ["Q3", "Q4"], task_gates: false },
+  });
+  assert.equal(valid.errors.length, 0);
+  assert.deepEqual(valid.preferences.gate_evaluation?.slice_gates, ["Q3", "Q4"]);
+  assert.equal(valid.preferences.gate_evaluation?.task_gates, false);
+
+  const invalid = validatePreferences({
+    gate_evaluation: { enabled: true, slice_gates: ["Q3", "Q8"] },
+  });
+  assert.ok(invalid.errors.some((error) => error.includes("gate_evaluation.slice_gates")));
+});
+
 test("cmux fields validate correctly", () => {
   const { preferences, errors } = validatePreferences({
     cmux: {

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -18,6 +18,7 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   skill_rules: [{ when: "unit:execute-task", use: ["test-writer-fixer"] }],
   custom_instructions: ["Keep changes focused."],
   models: { execution: "openai/gpt-5" },
+  thinking: { planning: "xhigh", execution: "low" },
   skill_discovery: "auto",
   skill_staleness_days: 7,
   auto_supervisor: { soft_timeout_minutes: 20, idle_timeout_minutes: 10, hard_timeout_minutes: 30 },