gsd-pi 2.78.1-dev.8a893322c → 2.78.1-dev.8e0e96cfc

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -11,9 +11,10 @@
  * prefs to the runner's cwd .gsd/PREFERENCES.md and clean up in finally.
  */
 
-import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { mkdirSync, writeFileSync, rmSync, existsSync, mkdtempSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
 
 import { shouldUseWorktreeIsolation } from "../auto.ts";
 import { getIsolationMode } from "../preferences.ts";
@@ -70,6 +71,54 @@ try {
 }
 });
 
+test('worktree isolation is disabled for an unborn repo until the first commit', (t) => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-unborn-worktree-"));
+  t.after(() => {
+    rmSync(repo, { recursive: true, force: true });
+    invalidateAllCaches();
+  });
+
+  execFileSync("git", ["init"], { cwd: repo, stdio: ["ignore", "ignore", "ignore"] });
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(join(repo, ".gsd", "PREFERENCES.md"), [
+    "---",
+    "git:",
+    '  isolation: "worktree"',
+    "---",
+    "",
+  ].join("\n"));
+  invalidateAllCaches();
+
+  assert.deepStrictEqual(
+    getIsolationMode(repo),
+    "none",
+    "startup gates should not attempt worktree isolation before HEAD exists",
+  );
+  assert.deepStrictEqual(
+    shouldUseWorktreeIsolation(repo),
+    false,
+    "worktree-specific gates should share the same unborn-repo guard",
+  );
+
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: repo });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: repo });
+  writeFileSync(join(repo, "README.md"), "seed\n");
+  execFileSync("git", ["add", "."], { cwd: repo });
+  execFileSync("git", ["commit", "-m", "chore: init"], { cwd: repo, stdio: ["ignore", "ignore", "ignore"] });
+  invalidateAllCaches();
+
+  assert.deepStrictEqual(
+    getIsolationMode(repo),
+    "worktree",
+    "worktree isolation should re-enable once the repo has a committed HEAD",
+  );
+  assert.deepStrictEqual(
+    shouldUseWorktreeIsolation(repo),
+    true,
+    "worktree-specific gates should re-enable once the repo has a committed HEAD",
+  );
+});
+
 // Test 4: shouldUseWorktreeIsolation returns false for no prefs (default: none)
 // Worktree isolation requires explicit opt-in — default is "none" so GSD
 // works out of the box without PREFERENCES.md (#2480).
@@ -149,4 +198,3 @@ test('Test 7: System prompt worktree block absent without active worktree', () =
   const ctx = getActiveAutoWorktreeContext();
   assert.ok(ctx === null, "getActiveAutoWorktreeContext() null confirms system prompt worktree block will not be injected");
 });
-

package/src/resources/extensions/gsd/tests/park-milestone.test.ts

@@ -20,6 +20,8 @@ import {
 } from "../gsd-db.ts";
 import { createWorktree } from "../worktree-manager.ts";
 
+// This suite exercises the explicit legacy markdown derivation path.
+process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = '1';
 
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/plan-milestone-artifact-verification.test.ts

@@ -18,6 +18,12 @@ function writeRoadmap(base: string, milestoneId: string, content: string): void
   writeFileSync(join(milestoneDir, `${milestoneId}-ROADMAP.md`), content, "utf-8");
 }
 
+function writeLegacyRoadmap(base: string, milestoneId: string, content: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(join(milestoneDir, "ROADMAP.md"), content, "utf-8");
+}
+
 test("#3405: plan-milestone roadmap stub does not count as a verified artifact", () => {
   const base = createFixtureBase();
   try {
@@ -60,3 +66,37 @@ test("#3405: plan-milestone roadmap with real slices still passes artifact verif
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("plan-milestone verification accepts legacy ROADMAP.md via shared resolver", () => {
+  const base = createFixtureBase();
+  try {
+    writeLegacyRoadmap(base, "M001", [
+      "# M001: Legacy roadmap",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+      "  > After this: a real slice exists.",
+      "",
+    ].join("\n"));
+
+    const result = verifyExpectedArtifact("plan-milestone", "M001", base);
+    assert.equal(result, true, "legacy unprefixed ROADMAP.md should resolve");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("discuss-milestone verification accepts legacy CONTEXT.md via shared resolver", () => {
+  const base = createFixtureBase();
+  try {
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(milestoneDir, "CONTEXT.md"), "# M001 Context\n", "utf-8");
+
+    const result = verifyExpectedArtifact("discuss-milestone", "M001", base);
+    assert.equal(result, true, "legacy unprefixed CONTEXT.md should resolve");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -81,9 +81,6 @@ test("domain-work prompts use skillActivation placeholder", () => {
     "plan-slice",
     "execute-task",
     "guided-research-slice",
-    "guided-plan-milestone",
-    "guided-plan-slice",
-    "guided-execute-task",
     "guided-resume-task",
   ];
 
@@ -143,20 +140,6 @@ test("custom skillActivation is substituted into execute-task", () => {
   assert.ok(!result.includes("{{skillActivation}}"));
 });
 
-test("guided execute prompt substitutes skillActivation", () => {
-  const result = loadPrompt("guided-execute-task", {
-    milestoneId: "M001",
-    sliceId: "S01",
-    taskId: "T01",
-    taskTitle: "Implement feature",
-    inlinedTemplates: "Template",
-    skillActivation: "Load React skill first.",
-  });
-
-  assert.ok(result.includes("Load React skill first."));
-  assert.ok(!result.includes("{{skillActivation}}"));
-});
-
 test("guided resume prompt substitutes skillActivation", () => {
   const result = loadPrompt("guided-resume-task", {
     milestoneId: "M001",
@@ -258,32 +241,6 @@ test("plan-milestone prompt substitutes skillActivation", () => {
   assert.ok(!result.includes("{{skillActivation}}"));
 });
 
-test("guided plan milestone prompt substitutes skillActivation", () => {
-  const result = loadPrompt("guided-plan-milestone", {
-    milestoneId: "M001",
-    milestoneTitle: "Test Milestone",
-    secretsOutputPath: ".gsd/milestones/M001/M001-SECRETS.md",
-    inlinedTemplates: "Templates",
-    skillActivation: "Load guided planning skills first.",
-  });
-
-  assert.ok(result.includes("Load guided planning skills first."));
-  assert.ok(!result.includes("{{skillActivation}}"));
-});
-
-test("guided plan slice prompt substitutes skillActivation", () => {
-  const result = loadPrompt("guided-plan-slice", {
-    milestoneId: "M001",
-    sliceId: "S01",
-    sliceTitle: "Test Slice",
-    inlinedTemplates: "Templates",
-    skillActivation: "Load guided slice planning skills first.",
-  });
-
-  assert.ok(result.includes("Load guided slice planning skills first."));
-  assert.ok(!result.includes("{{skillActivation}}"));
-});
-
 test("guided research slice prompt substitutes skillActivation", () => {
   const result = loadPrompt("guided-research-slice", {
     milestoneId: "M001",

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

@@ -98,6 +98,39 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice leaves omitted enrichment fields empty instead of rendering placeholders', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const { successCriteria, proofLevel, integrationClosure, observabilityImpact, ...params } = validParams();
+    void successCriteria;
+    void proofLevel;
+    void integrationClosure;
+    void observabilityImpact;
+
+    const result = await handlePlanSlice(params, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const slice = getSlice('M001', 'S02');
+    assert.ok(slice);
+    assert.equal(slice?.success_criteria, '');
+    assert.equal(slice?.proof_level, '');
+    assert.equal(slice?.integration_closure, '');
+    assert.equal(slice?.observability_impact, '');
+
+    const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const content = readFileSync(planPath, 'utf-8');
+    assert.doesNotMatch(content, /Not provided/i);
+    assert.doesNotMatch(content, /^## Proof Level$/m);
+    assert.doesNotMatch(content, /^## Integration Closure$/m);
+    assert.match(content, /- Complete the planned slice outcomes\./);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects invalid payloads', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/planning-depth-setter.test.ts

@@ -0,0 +1,172 @@
+// GSD-2 — Deep planning mode setPlanningDepth helper.
+// Verifies the helper correctly creates and updates .gsd/PREFERENCES.md while
+// preserving existing frontmatter keys and body content.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+
+import { setPlanningDepth } from "../planning-depth.ts";
+
+function makeBase(): string {
+  const base = join(tmpdir(), `gsd-planning-depth-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
+  return base;
+}
+
+function readFrontmatter(path: string): { frontmatter: Record<string, unknown>; body: string } {
+  const content = readFileSync(path, "utf-8");
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  assert.ok(match, "PREFERENCES.md must have frontmatter delimiters");
+  const parsed = parseYaml(match[1]);
+  assert.ok(parsed && typeof parsed === "object", "frontmatter must parse to an object");
+  return { frontmatter: parsed as Record<string, unknown>, body: match[2] };
+}
+
+test("Deep mode: setPlanningDepth creates PREFERENCES.md when missing", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  setPlanningDepth(base, "deep");
+
+  const path = join(base, ".gsd", "PREFERENCES.md");
+  assert.ok(existsSync(path), "PREFERENCES.md must be created");
+  const { frontmatter } = readFrontmatter(path);
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+  assert.strictEqual(frontmatter.workflow_prefs_captured, true);
+  assert.strictEqual(frontmatter.commit_policy, "per-task");
+  assert.strictEqual(frontmatter.branch_model, "single");
+  assert.strictEqual(frontmatter.uat_dispatch, true);
+  assert.deepStrictEqual(frontmatter.models, { executor_class: "balanced" });
+  assert.ok(existsSync(join(base, ".gsd", "runtime", "research-decision.json")));
+  const researchDecision = JSON.parse(
+    readFileSync(join(base, ".gsd", "runtime", "research-decision.json"), "utf-8"),
+  );
+  assert.strictEqual(researchDecision.decision, "skip");
+  assert.strictEqual(researchDecision.source, "workflow-preferences");
+  assert.strictEqual(researchDecision.reason, "deterministic-default");
+});
+
+test("Deep mode: setPlanningDepth updates existing planning_depth", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "---\nplanning_depth: light\n---\n");
+  setPlanningDepth(base, "deep");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+});
+
+test("Deep mode: setPlanningDepth preserves other frontmatter keys", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 1\nmode: solo\nuat_dispatch: true\n---\n",
+  );
+  setPlanningDepth(base, "deep");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+  assert.strictEqual(frontmatter.version, 1);
+  assert.strictEqual(frontmatter.mode, "solo");
+  assert.strictEqual(frontmatter.uat_dispatch, true);
+});
+
+test("Deep mode: setPlanningDepth preserves explicit workflow preference values", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    [
+      "---",
+      "planning_depth: deep",
+      "commit_policy: manual",
+      "branch_model: per-milestone-worktree",
+      "uat_dispatch: false",
+      "models:",
+      "  executor_class: heavy",
+      "---",
+      "",
+    ].join("\n"),
+  );
+  setPlanningDepth(base, "deep");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.workflow_prefs_captured, true);
+  assert.strictEqual(frontmatter.commit_policy, "manual");
+  assert.strictEqual(frontmatter.branch_model, "per-milestone-worktree");
+  assert.strictEqual(frontmatter.uat_dispatch, false);
+  assert.deepStrictEqual(frontmatter.models, { executor_class: "heavy" });
+});
+
+test("Deep mode: setPlanningDepth preserves body content", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const original = "---\nversion: 1\n---\n\n# User notes\n\nKeep this body intact.\n";
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), original);
+  setPlanningDepth(base, "deep");
+
+  const content = readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8");
+  assert.ok(content.includes("# User notes"), "body header must survive");
+  assert.ok(content.includes("Keep this body intact."), "body text must survive");
+});
+
+test("Deep mode: setPlanningDepth handles file without frontmatter delimiters", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  // Some agents write preferences without frontmatter delimiters (#2036 case)
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "version: 1\nmode: solo\n");
+  setPlanningDepth(base, "deep");
+
+  const content = readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8");
+  assert.ok(content.startsWith("---\n"), "result must have frontmatter delimiters");
+  const { frontmatter, body } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "deep");
+  // The legacy non-frontmatter content is preserved as body
+  assert.ok(body.includes("version: 1"), "legacy content preserved as body");
+});
+
+test("Deep mode: setPlanningDepth can flip back to light", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  setPlanningDepth(base, "deep");
+  setPlanningDepth(base, "light");
+
+  const { frontmatter } = readFrontmatter(join(base, ".gsd", "PREFERENCES.md"));
+  assert.strictEqual(frontmatter.planning_depth, "light");
+});
+
+test("Deep mode: setPlanningDepth preserves explicit user research decision", (t) => {
+  const base = makeBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "runtime", "research-decision.json"),
+    JSON.stringify({ decision: "research", source: "research-decision", decided_at: "2026-04-27T00:00:00Z" }),
+  );
+
+  setPlanningDepth(base, "deep");
+
+  const researchDecision = JSON.parse(
+    readFileSync(join(base, ".gsd", "runtime", "research-decision.json"), "utf-8"),
+  );
+  assert.strictEqual(researchDecision.decision, "research");
+  assert.strictEqual(researchDecision.source, "research-decision");
+});

package/src/resources/extensions/gsd/tests/post-unit-git-failure.test.ts

@@ -0,0 +1,18 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractSourceRegion } from "./test-helpers.ts";
+
+const source = readFileSync(
+  join(import.meta.dirname, "..", "auto-post-unit.ts"),
+  "utf-8",
+);
+
+test("postUnitPreVerification blocks on git action failure", () => {
+  const failureBlock = extractSourceRegion(source, 'if (gitResult.status === "failed")');
+  assert.ok(failureBlock.includes('ctx.ui.notify(failureMsg, "error")'));
+  assert.ok(failureBlock.includes("await pauseAuto(ctx, pi)"));
+  assert.ok(failureBlock.includes('return "dispatched"'));
+  assert.ok(!failureBlock.includes("git-action-failed-nonblocking"));
+});

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

@@ -810,6 +810,78 @@ test("loadEffectiveGSDPreferences merges min_request_interval_ms with project ov
   }
 });
 
+test("loadEffectiveGSDPreferences does not inherit global planning_depth into fresh projects", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-depth-global-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-depth-global-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "planning_depth: deep",
+        "language: German",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.planning_depth, undefined);
+    assert.equal(loaded!.preferences.language, "German", "other global preferences still carry over");
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
+test("loadEffectiveGSDPreferences keeps project-local planning_depth explicit", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-depth-local-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-depth-local-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempGsdHome, "PREFERENCES.md"),
+      ["---", "version: 1", "planning_depth: deep", "---"].join("\n"),
+      "utf-8",
+    );
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      ["---", "version: 1", "planning_depth: light", "---"].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.planning_depth, "light");
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("preferences paths use canonical uppercase filenames", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

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

@@ -16,6 +16,7 @@ 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
 ]);
 
 test("every KNOWN_PREFERENCE_KEYS entry is reachable from the wizard source", () => {

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -6,6 +6,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { performance } from "node:perf_hooks";
 
 import {
   openDatabase,
@@ -99,21 +100,21 @@ test("ADR-011: sketch slice + progressive_planning ON → phase='refining'", asy
   assert.equal(state.phase, "refining", "sketch slice with flag ON must yield refining phase");
 });
 
-test("ADR-011: sketch slice + progressive_planning OFF → phase='planning' (backwards compat)", async (t) => {
+test("ADR-011: sketch slice + progressive_planning OFF → DB sketch metadata still yields refining", async (t) => {
   const originalCwd = process.cwd();
   const base = makeFixtureBase();
   t.after(() => cleanup(base, originalCwd));
 
   seedMilestoneWithSketchedS02(base);
   writeS01Artifacts(base);
-  // Write a PREFERENCES.md without the flag so loadEffectiveGSDPreferences finds
-  // a valid file but progressive_planning resolves to undefined.
+  // Write a PREFERENCES.md without the flag. DB slice metadata remains
+  // authoritative for whether this slice needs refinement.
   writePreferences(base, "phases:\n  skip_research: false");
   process.chdir(base);
 
   const state = await deriveStateFromDb(base);
   assert.equal(state.activeSlice?.id, "S02");
-  assert.equal(state.phase, "planning", "flag absent → must fall through to planning");
+  assert.equal(state.phase, "refining", "flag absent must not override DB sketch metadata");
 });
 
 test("ADR-011: dispatch rule maps refining → refine-slice unit", async (t) => {
@@ -516,24 +517,32 @@ test("ADR-011 P3 #26: refine-slice dispatch latency is bounded vs plan-slice bas
   await buildPlanSlicePrompt("M001", "Test", "S02", "Feature", base);
   await buildRefineSlicePrompt("M001", "Test", "S02", "Feature", base);
 
-  const planStart = Date.now();
-  await buildPlanSlicePrompt("M001", "Test", "S02", "Feature", base);
-  const planElapsed = Date.now() - planStart;
+  const measure = async (fn: () => Promise<string>): Promise<number> => {
+    const start = performance.now();
+    await fn();
+    return performance.now() - start;
+  };
 
-  const refineStart = Date.now();
-  await buildRefineSlicePrompt("M001", "Test", "S02", "Feature", base);
-  const refineElapsed = Date.now() - refineStart;
+  const planSamples: number[] = [];
+  const refineSamples: number[] = [];
+  for (let i = 0; i < 5; i++) {
+    planSamples.push(await measure(() => buildPlanSlicePrompt("M001", "Test", "S02", "Feature", base)));
+    refineSamples.push(await measure(() => buildRefineSlicePrompt("M001", "Test", "S02", "Feature", base)));
+  }
+  const bestPlan = Math.min(...planSamples);
+  const bestRefine = Math.min(...refineSamples);
 
   assert.ok(
-    refineElapsed < 500,
-    `refine-slice prompt build must complete under 500ms (took ${refineElapsed}ms)`,
+    bestRefine < 500,
+    `refine-slice prompt build must complete under 500ms (best=${bestRefine.toFixed(1)}ms, samples=${refineSamples.map(n => n.toFixed(1)).join(",")})`,
   );
   // Guard the ratio only when the baseline is large enough to be meaningful —
-  // if plan-slice measures 0-2ms the ratio is dominated by timer noise.
-  if (planElapsed >= 5) {
+  // if plan-slice measures in single-digit milliseconds, the ratio is dominated
+  // by scheduler and filesystem noise under the concurrent test runner.
+  if (bestPlan >= 20) {
     assert.ok(
-      refineElapsed < planElapsed * 3,
-      `refine-slice must not exceed 3x plan-slice baseline (refine=${refineElapsed}ms, plan=${planElapsed}ms)`,
+      bestRefine < bestPlan * 3,
+      `refine-slice must not exceed 3x plan-slice baseline (refine=${bestRefine.toFixed(1)}ms, plan=${bestPlan.toFixed(1)}ms)`,
     );
   }
 });

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

@@ -3,7 +3,7 @@
  *
  * When the working directory is deleted (e.g. worktree teardown), process.cwd()
  * throws ENOENT. The fix wraps process.cwd() in a try/catch and falls back to
- * process.env.HOME.
+ * os.homedir().
  *
  * Also verifies #3589 — nativeBranchExists validation for prefs.main_branch
  * in auto-worktree.ts to prevent merge failures with stale preferences.
@@ -29,9 +29,9 @@ describe('projectRoot cwd crash guard (#3598)', () => {
       'process.cwd() should be inside a try block');
   });
 
-  test('catch block falls back to process.env.HOME', () => {
-    assert.match(contextSource, /catch[\s\S]*?process\.env\.HOME/,
-      'catch block should fall back to process.env.HOME');
+  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', () => {

package/src/resources/extensions/gsd/tests/projection-regression.test.ts

@@ -91,6 +91,7 @@ function makeMilestoneRow() {
     definition_of_done: [],
     requirement_coverage: '',
     boundary_map_markdown: '',
+    sequence: 0,
   };
 }
 

package/src/resources/extensions/gsd/tests/prompt-budget-enforcement.test.ts

@@ -521,7 +521,7 @@ describe("prompt-budget: modelRegistry + sessionContextWindow wiring", () => {
     );
     assert.match(
       autoPromptsSrc,
-      /formatExecutorConstraints\(sessionContextWindow,\s*modelRegistry\)/,
+      /formatExecutorConstraints\(sessionContextWindow,\s*modelRegistry(?:,\s*sessionProvider)?\)/,
       "renderSlicePrompt must forward both to formatExecutorConstraints",
     );
   });
@@ -612,4 +612,4 @@ describe("prompt-budget: modelRegistry + sessionContextWindow wiring", () => {
       `dispatchDirectPhase must forward the pair at both prompt-builder call sites (≥2), got ${passes}`,
     );
   });
-});
+});