gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -12,32 +12,30 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { syncWorktreeStateBack } from "../auto-worktree.ts";
 
-test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
+test("#2684: syncWorktreeStateBack does not overwrite project PREFERENCES.md", () => {
+  const mainBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-main-"));
+  const wtBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-worktree-"));
+  const mainGsd = join(mainBase, ".gsd");
+  const wtGsd = join(wtBase, ".gsd");
+  mkdirSync(mainGsd, { recursive: true });
+  mkdirSync(wtGsd, { recursive: true });
 
-  const constIdx = src.indexOf("ROOT_STATE_FILES");
-  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
+  try {
+    const authoritative = "---\nversion: 1\n---\n\nmode: team\n";
+    writeFileSync(join(mainGsd, "PREFERENCES.md"), authoritative);
+    writeFileSync(join(wtGsd, "PREFERENCES.md"), "---\nversion: 1\n---\n\nmode: solo\n");
 
-  const arrayStart = src.indexOf("[", constIdx);
-  const arrayEnd = src.indexOf("] as const", arrayStart);
-  const block = src.slice(arrayStart, arrayEnd);
+    const result = syncWorktreeStateBack(mainBase, wtBase, "M001");
 
-  // Project preferences must NOT be in ROOT_STATE_FILES — they are handled separately
-  // in syncGsdStateToWorktree() (forward-only, additive). Including it in
-  // ROOT_STATE_FILES would cause syncWorktreeStateBack() to overwrite the
-  // authoritative project root copy (#2684).
-  const entries = block.split("\n")
-    .map(l => l.trim())
-    .filter(l => l.startsWith('"') && l.includes(".md"));
-  const hasPrefs = entries.some(
-    l => l.includes("PREFERENCES.md") || l.includes("preferences.md"),
-  );
-  assert.ok(
-    !hasPrefs,
-    "preferences files must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
-  );
+    assert.equal(readFileSync(join(mainGsd, "PREFERENCES.md"), "utf-8"), authoritative);
+    assert.ok(!result.synced.includes("PREFERENCES.md"));
+    assert.ok(!result.synced.includes("preferences.md"));
+  } finally {
+    rmSync(mainBase, { recursive: true, force: true });
+    rmSync(wtBase, { recursive: true, force: true });
+  }
 });
 
 // Phase C: copyPlanningArtifacts was deleted. Worktrees no longer

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

@@ -1,45 +1,143 @@
-// Guard test — every key in KNOWN_PREFERENCE_KEYS must be reachable from the
-// /gsd prefs wizard.  Without this guard, a new preference can be added to the
-// schema without anyone wiring it into the TUI, silently re-creating the gap
-// this test exists to prevent.
+// GSD-2 + prefs-wizard-coverage.test.ts - Behavioral coverage for preferences wizard persistence.
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
+import { buildCategorySummaries, handlePrefsWizard } from "../commands-prefs-wizard.ts";
 import { KNOWN_PREFERENCE_KEYS } from "../preferences-types.ts";
 
-// Keys exposed via a dedicated command rather than the wizard.  They're still
-// reachable by the user, just not inside the category menu flow.  If you add a
-// new key here, add a comment explaining where it lives.
-const EXPOSED_OUTSIDE_WIZARD = new Set<string>([
-  "version",          // auto-managed by writePreferencesFile
-  "modelOverrides",   // advanced routing — edit PREFERENCES.md directly (not in KNOWN_PREFERENCE_KEYS)
-  "context_mode",     // advanced sandbox config (gsd_exec + compaction) — enabled by default; edit PREFERENCES.md directly to tune timeouts/caps. Wizard coverage tracked separately.
-  "planning_depth",   // exposed through /gsd new-project --deep and /gsd new-milestone --deep
-]);
+const PREF_SAMPLE_VALUES: Record<string, unknown> = {
+  version: 1,
+  mode: "team",
+  always_use_skills: ["debug-like-expert"],
+  prefer_skills: ["typescript-expert"],
+  avoid_skills: ["slow-skill"],
+  skill_rules: [{ when: "unit:execute-task", use: ["test-writer-fixer"] }],
+  custom_instructions: ["Keep changes focused."],
+  models: { execution: "openai/gpt-5" },
+  skill_discovery: "auto",
+  skill_staleness_days: 7,
+  auto_supervisor: { soft_timeout_minutes: 20, idle_timeout_minutes: 10, hard_timeout_minutes: 30 },
+  uat_dispatch: true,
+  unique_milestone_ids: true,
+  budget_ceiling: 12.5,
+  budget_enforcement: "warn",
+  context_pause_threshold: 0.8,
+  notifications: {
+    enabled: true,
+    on_complete: true,
+    on_error: true,
+    on_budget: true,
+    on_milestone: true,
+    on_attention: true,
+  },
+  cmux: { enabled: true },
+  remote_questions: { provider: "slack", channel: "C123" },
+  git: {
+    auto_push: false,
+    push_branches: true,
+    pre_merge_check: true,
+    merge_strategy: "squash",
+    isolation: "worktree",
+    main_branch: "main",
+    absorb_snapshot_commits: true,
+  },
+  post_unit_hooks: [{ command: "npm test" }],
+  pre_dispatch_hooks: [{ command: "npm run lint" }],
+  dynamic_routing: { enabled: true },
+  disabled_model_providers: ["slow-provider"],
+  uok: { enabled: true },
+  token_profile: "standard",
+  phases: { progressive_planning: true },
+  auto_visualize: true,
+  auto_report: true,
+  parallel: { enabled: true, max_workers: 2 },
+  verification_commands: ["npm test"],
+  verification_auto_fix: true,
+  verification_max_retries: 1,
+  search_provider: "web",
+  context_selection: "auto",
+  widget_mode: "small",
+  reactive_execution: { enabled: true },
+  gate_evaluation: { enabled: true },
+  github: { enabled: true },
+  service_tier: "default",
+  forensics_dedup: true,
+  show_token_cost: true,
+  min_request_interval_ms: 250,
+  stale_commit_threshold_minutes: 15,
+  context_management: { enabled: true },
+  experimental: { rtk: true },
+  codebase: { indexing: "auto" },
+  slice_parallel: { enabled: true, max_workers: 2 },
+  safety_harness: { enabled: true },
+  enhanced_verification: true,
+  enhanced_verification_pre: true,
+  enhanced_verification_post: true,
+  enhanced_verification_strict: false,
+  discuss_preparation: true,
+  discuss_web_research: true,
+  discuss_depth: "standard",
+  flat_rate_providers: ["openai"],
+  language: "en",
+  context_window_override: 128000,
+  context_mode: { enabled: true },
+  planning_depth: "deep",
+};
 
-test("every KNOWN_PREFERENCE_KEYS entry is reachable from the wizard source", () => {
-  const src = readFileSync(
-    new URL("../commands-prefs-wizard.ts", import.meta.url),
-    "utf-8",
-  );
+test("prefs wizard save path preserves every known preference key", async () => {
+  const missingSamples = [...KNOWN_PREFERENCE_KEYS].filter((key) => !(key in PREF_SAMPLE_VALUES));
+  assert.deepEqual(missingSamples, [], "test fixture must cover every known preference key");
+
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  const choices = ["── Save & Exit ──"];
+  const ctx = {
+    ui: {
+      notify() {},
+      select: async () => choices.shift(),
+    },
+    waitForIdle: async () => {},
+    reload: async () => {},
+  } as any;
 
-  const missing: string[] = [];
-  for (const key of KNOWN_PREFERENCE_KEYS) {
-    if (EXPOSED_OUTSIDE_WIZARD.has(key)) continue;
-    // The key must appear somewhere in the wizard — either as a direct
-    // prefs[...] / pref reference, or in the orderedKeys serialization list.
-    // A plain substring match is enough because all prefs-wizard references
-    // use the exact key name.
-    if (!src.includes(`"${key}"`) && !src.includes(`.${key}`)) {
-      missing.push(key);
-    }
+  try {
+    await handlePrefsWizard(ctx, "project", PREF_SAMPLE_VALUES, { pathOverride: prefsPath });
+    const saved = readFileSync(prefsPath, "utf-8");
+    const missingPersisted = [...KNOWN_PREFERENCE_KEYS].filter((key) => !saved.includes(`${key}:`));
+    assert.deepEqual(missingPersisted, []);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
   }
+});
 
+test("category summaries expose the wizard menu surface for configured prefs", () => {
+  const summaries = buildCategorySummaries(PREF_SAMPLE_VALUES);
   assert.deepEqual(
-    missing,
-    [],
-    `These preference keys are in KNOWN_PREFERENCE_KEYS but are not referenced anywhere in the /gsd prefs wizard — they cannot be configured through the UI. Either add wizard coverage or add them to EXPOSED_OUTSIDE_WIZARD with an explanatory comment:\n${missing.join("\n")}`,
+    Object.keys(summaries).sort(),
+    [
+      "advanced",
+      "budget",
+      "context",
+      "discuss",
+      "git",
+      "hooks",
+      "integrations",
+      "mode",
+      "models",
+      "notifications",
+      "parallelism",
+      "phases",
+      "skills",
+      "timeouts",
+      "uok",
+      "verification",
+    ],
   );
+  assert.match(summaries.models, /phase/);
+  assert.match(summaries.integrations, /remote: C123/);
+  assert.match(summaries.verification, /1 cmd/);
 });

package/src/resources/extensions/gsd/tests/project-root-cwd-crash.test.ts

@@ -8,46 +8,28 @@
  * Also verifies #3589 — nativeBranchExists validation for prefs.main_branch
  * in auto-worktree.ts to prevent merge failures with stale preferences.
  *
- * Structural verification test — reads source to confirm the guards exist.
+ * Behavior verification test — exercises the exported projectRoot helper
+ * without reading command source.
  */
 
-import { describe, test } from 'node:test';
+import { describe, test, mock } 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 contextSource = readFileSync(join(__dirname, '..', 'commands', 'context.ts'), 'utf-8');
-const worktreeSource = readFileSync(join(__dirname, '..', 'auto-worktree.ts'), 'utf-8');
+import { GSDNoProjectError, projectRoot } from '../commands/context.ts';
 
 describe('projectRoot cwd crash guard (#3598)', () => {
-  test('projectRoot wraps process.cwd() in try/catch', () => {
-    assert.match(contextSource, /try\s*\{[\s\S]*?process\.cwd\(\)/,
-      'process.cwd() should be inside a try block');
-  });
-
-  test('catch block falls back to homedir()', () => {
-    assert.match(contextSource, /catch[\s\S]*?homedir\(\)/,
-      'catch block should fall back to homedir()');
-  });
-
-  test('projectRoot function is exported', () => {
-    assert.match(contextSource, /export function projectRoot\(\)/,
-      'projectRoot should be an exported function');
-  });
-});
-
-describe('main_branch nativeBranchExists validation (#3589)', () => {
-  test('prefs.main_branch is validated with nativeBranchExists', () => {
-    assert.match(worktreeSource, /nativeBranchExists\(.*prefs\.main_branch\)/,
-      'nativeBranchExists should validate prefs.main_branch');
-  });
-
-  test('validatedPrefBranch falls back to undefined when branch missing', () => {
-    assert.match(worktreeSource, /validatedPrefBranch[\s\S]*?:\s*undefined/,
-      'validatedPrefBranch should fall back to undefined');
+  test('reports the home-directory guard instead of leaking cwd ENOENT', () => {
+    const cwd = mock.method(process, 'cwd', () => {
+      const err = new Error('ENOENT: current working directory was removed') as NodeJS.ErrnoException;
+      err.code = 'ENOENT';
+      throw err;
+    });
+    try {
+      assert.throws(
+        () => projectRoot(),
+        (err) => err instanceof GSDNoProjectError && !String(err.message).includes('ENOENT'),
+      );
+    } finally {
+      cwd.mock.restore();
+    }
   });
 });

package/src/resources/extensions/gsd/tests/projection-no-plan-overwrite.test.ts

@@ -13,80 +13,42 @@
 
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-// Use process.cwd() based resolution instead of import.meta.url
-// to avoid tsx test runner path resolution issues
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'workflow-projections.ts'),
-  'utf-8',
-)
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from '../gsd-db.ts'
+import { renderAllProjections } from '../workflow-projections.ts'
 
 describe('renderAllProjections must not overwrite PLAN.md (#3651)', () => {
-  it('renderAllProjections function body does NOT invoke renderPlanProjection', () => {
-    // Extract the renderAllProjections function body
-    const fnStart = src.indexOf('export async function renderAllProjections(')
-    assert.ok(fnStart !== -1, 'renderAllProjections function must exist')
-
-    // Find the for-loop over sliceRows inside renderAllProjections
-    const loopStart = src.indexOf('for (const slice of sliceRows)', fnStart)
-    assert.ok(loopStart !== -1, 'slice loop must exist in renderAllProjections')
-
-    // Find the closing of renderAllProjections (next section marker)
-    const fnEnd = src.indexOf('\n// ─── ', fnStart + 1)
-    assert.ok(fnEnd !== -1, 'section delimiter after renderAllProjections must exist')
-
-    const fnBody = src.slice(loopStart, fnEnd)
-
-    // The fix: renderPlanProjection must NOT appear as a function call.
-    // Strip comment lines before checking (comments may mention the function name).
-    const codeOnly = fnBody
-      .split('\n')
-      .filter(line => !line.trim().startsWith('//'))
-      .join('\n')
-
-    const hasPlanCall = /renderPlanProjection\s*\(/.test(codeOnly)
-    assert.equal(
-      hasPlanCall,
-      false,
-      'renderPlanProjection must not be called inside the renderAllProjections slice loop — ' +
-        'authoritative PLAN.md is rendered only by plan-slice/replan-slice tools',
-    )
-  })
-
-  it('renderPlanProjection is still defined (available for regenerateIfMissing)', () => {
-    assert.ok(
-      src.includes('function renderPlanProjection('),
-      'renderPlanProjection function definition must still exist for on-demand recovery',
-    )
-  })
-
-  it('renderAllProjections still renders ROADMAP, SUMMARY, and STATE projections', () => {
-    const fnStart = src.indexOf('export async function renderAllProjections(')
-    const fnEnd = src.indexOf('\n// ─── ', fnStart + 1)
-    const fnBody = src.slice(fnStart, fnEnd)
-
-    // #4402: ROADMAP.md is now rendered by the authoritative renderer
-    // (renderRoadmapFromDb) to preserve ## Boundary Map and other sections
-    // that the reduced renderRoadmapProjection would strip.
-    assert.ok(
-      fnBody.includes('renderRoadmapFromDb('),
-      'renderRoadmapFromDb must be called (authoritative roadmap renderer)',
-    )
-    assert.ok(
-      !/renderRoadmapProjection\s*\(/.test(
-        fnBody.split('\n').filter(l => !l.trim().startsWith('//')).join('\n'),
-      ),
-      'renderRoadmapProjection must NOT be called — it clobbers Boundary Map (#4402)',
-    )
-    assert.ok(
-      fnBody.includes('renderSummaryProjection('),
-      'renderSummaryProjection must still be called',
-    )
-    assert.ok(
-      fnBody.includes('renderStateProjection('),
-      'renderStateProjection must still be called',
-    )
+  it('preserves authoritative PLAN.md while rendering other projections', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-projection-plan-'))
+    const msDir = join(base, '.gsd', 'milestones', 'M001')
+    const sliceDir = join(msDir, 'slices', 'S01')
+    const planPath = join(sliceDir, 'S01-PLAN.md')
+    const planContent = [
+      '# S01 Plan',
+      '',
+      '## Must-Haves',
+      '',
+      '- preserve this authoritative section',
+      '',
+    ].join('\n')
+
+    try {
+      mkdirSync(sliceDir, { recursive: true })
+      writeFileSync(join(msDir, 'M001-ROADMAP.md'), '# Roadmap\n\n## Slices\n\n- [ ] **S01: Slice** `risk:low` `depends:[]`\n')
+      writeFileSync(planPath, planContent)
+      openDatabase(join(base, '.gsd', 'gsd.db'))
+      insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' })
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'pending' })
+
+      await renderAllProjections(base, 'M001')
+
+      assert.equal(readFileSync(planPath, 'utf-8'), planContent)
+      assert.ok(readFileSync(join(base, '.gsd', 'STATE.md'), 'utf-8').includes('M001'))
+    } finally {
+      closeDatabase()
+      rmSync(base, { recursive: true, force: true })
+    }
   })
 })