@opengsd/gsd-pi 1.9.0-dev.e10b60d4 → 1.10.0-dev.a5e42e99

package/src/resources/extensions/gsd/tests/doctor-scope-db-unavailable.test.ts

@@ -167,6 +167,77 @@ test("checkEngineHealth keeps PLAN checkbox divergence after stale projection fl
   assert.match(readFileSync(plan.planPath, "utf-8"), /- \[ \] \*\*T01\*\*:/);
 });
 
+test("checkEngineHealth ignores stale suffixed flat-phase duplicate when bare milestone exists", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-flat-duplicate-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M003", title: "M003-vaz73w: New milestone M003-vaz73w", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  for (const taskId of ["T01", "T02", "T03"]) {
+    insertTask({ id: taskId, milestoneId: "M003", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
+  }
+
+  insertMilestone({ id: "M003-vaz73w", title: "New milestone M003-vaz73w", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003-vaz73w", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  for (const taskId of ["T01", "T02", "T03"]) {
+    insertTask({ id: taskId, milestoneId: "M003-vaz73w", sliceId: "S01", title: taskId, status: "complete", sequence: Number(taskId.slice(1)) });
+  }
+
+  const canonicalPlan = await renderPlanFromDb(base, "M003", "S01");
+  const staleDir = join(gsdDir, "phases", "03-vaz73w-new-milestone-m003-vaz73w");
+  mkdirSync(staleDir, { recursive: true });
+  writeFileSync(
+    join(staleDir, "03-01-PLAN.md"),
+    canonicalPlan.content.replace("- [x] **T03**:", "- [ ] **T03**:"),
+    "utf-8",
+  );
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.deepEqual(
+    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
+    [],
+    "stale suffixed duplicate phase projection must not compete with the bare milestone projection",
+  );
+});
+
+test("checkEngineHealth reads task checkboxes from the canonical milestone worktree", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-checkbox-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertMilestone({ id: "M003", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "Slice", status: "pending", risk: "low", depends: [], sequence: 1 });
+  insertTask({ id: "T03", milestoneId: "M003", sliceId: "S01", title: "Task", status: "complete", sequence: 1 });
+
+  const plan = await renderPlanFromDb(base, "M003", "S01");
+  const checkedPlan = readFileSync(plan.planPath, "utf-8");
+  writeFileSync(plan.planPath, checkedPlan.replace("- [x] **T03**:", "- [ ] **T03**:"), "utf-8");
+
+  const worktree = join(base, ".gsd-worktrees", "M003");
+  const worktreePlan = join(worktree, ".gsd", "phases", "03-milestone", "03-01-PLAN.md");
+  mkdirSync(join(worktree, ".gsd", "phases", "03-milestone"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M003")}\n`);
+  writeFileSync(worktreePlan, checkedPlan, "utf-8");
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.deepEqual(
+    issues.filter((issue) => issue.code === "checkbox_db_status_divergence").map((issue) => issue.unitId),
+    [],
+    "the stale project-root PLAN must not compete with the live milestone worktree projection",
+  );
+});
+
 test("checkEngineHealth reads task checkboxes from the <tasks> block, not a stray line above it", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-task-section-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -336,6 +407,38 @@ test("checkEngineHealth reports artifact rows whose files are missing on disk",
   assert.equal(missing.fixable, false);
 });
 
+test("checkEngineHealth resolves artifact rows through the canonical milestone worktree", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-artifact-worktree-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const artifactPath = "phases/03-milestone/03-01-PLAN.md";
+  const worktree = join(base, ".gsd-worktrees", "M003");
+  mkdirSync(gsdDir, { recursive: true });
+  mkdirSync(join(worktree, ".gsd", "phases", "03-milestone"), { recursive: true });
+  writeFileSync(join(worktree, ".git"), `gitdir: ${join(base, ".git", "worktrees", "M003")}\n`);
+  writeFileSync(join(worktree, ".gsd", artifactPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: artifactPath,
+    artifact_type: "PLAN",
+    milestone_id: "M003",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# Plan\n",
+  });
+
+  const issues: any[] = [];
+  await checkEngineHealth(base, issues, []);
+
+  assert.equal(
+    issues.some((issue) => issue.code === "artifact_file_missing" && issue.file === artifactPath),
+    false,
+    "worktree-local artifact rows must not be reported missing from the project root",
+  );
+});
+
 test("checkEngineHealth resolves escaped .gsd artifact rows against the project .gsd directory", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-escaped-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));
@@ -428,6 +531,50 @@ test("checkEngineHealth repair prunes stale phases artifact rows with present mi
   assert.deepEqual(rows.map((row) => row.path), []);
 });
 
+test("checkEngineHealth repair prunes stale phases artifact rows with renamed flat-phase files", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-prune-renamed-flat-phase-artifact-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const gsdDir = join(base, ".gsd");
+  const stalePath = "phases/01-new-milestone-m001/01-01-PLAN.md";
+  const replacementPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-01-PLAN.md";
+  mkdirSync(join(gsdDir, "phases", "01-lokably-brand-foundation-and-welcome-pag"), { recursive: true });
+  writeFileSync(join(gsdDir, replacementPath), "# Plan\n", "utf-8");
+
+  openDatabase(join(gsdDir, "gsd.db"));
+  insertArtifact({
+    path: stalePath,
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# stale plan\n",
+  });
+
+  const beforeIssues: any[] = [];
+  await checkEngineHealth(base, beforeIssues, []);
+
+  const beforeIssue = beforeIssues.find((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath);
+  assert.ok(beforeIssue, "stale renamed phases row should be reported when repair is off");
+  assert.equal(beforeIssue.fixable, true, "renamed phases rows with a flat replacement should be fixable");
+
+  const repairIssues: any[] = [];
+  const fixes: string[] = [];
+  await checkEngineHealth(base, repairIssues, fixes, { repair: true });
+
+  assert.equal(
+    repairIssues.some((issue) => issue.code === "artifact_file_missing" && issue.file === stalePath),
+    false,
+    "repair should not report stale rows it pruned",
+  );
+  assert.ok(fixes.includes(`pruned stale flat-phase artifact row ${stalePath}`));
+
+  const rows = _getAdapter()!
+    .prepare("SELECT path FROM artifacts ORDER BY path")
+    .all() as Array<{ path: string }>;
+  assert.deepEqual(rows.map((row) => row.path), []);
+});
+
 test("checkEngineHealth repair keeps phases rows whose own file is still present", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-doctor-keep-present-phase-artifact-"));
   t.after(() => rmSync(base, { recursive: true, force: true }));

package/src/resources/extensions/gsd/tests/flat-phase-migration.test.ts

@@ -122,7 +122,7 @@ test("migrateToFlatPhase creates a backup", async () => {
   assert.ok(backups.length >= 1, "at least one migrate-* backup dir should exist");
 });
 
-test("migrateToFlatPhase backs up existing phases projection before clearing it", async () => {
+test("migrateToFlatPhase removes disposable phases snapshot after successful migration", async () => {
   const base = makeTmp();
   const reviewPath = join(base, ".gsd", "phases", "01-foundation", "PLAN-REVIEW.md");
   mkdirSync(join(base, ".gsd", "phases", "01-foundation"), { recursive: true });
@@ -133,11 +133,10 @@ test("migrateToFlatPhase backs up existing phases projection before clearing it"
   const backupRoot = join(base, ".gsd-backups");
   const backups = readdirSync(backupRoot).filter(d => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "one migrate backup should exist");
-  const backedUpReview = join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md");
   assert.equal(
-    readFileSync(backedUpReview, "utf-8"),
-    "# Plan Review\n\nHand-authored review.",
-    "pre-existing phases/ files should have a recovery copy",
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after success",
   );
 });
 
@@ -202,7 +201,7 @@ test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir",
   assert.equal(leaked.length, 0, "rollback must delete the migrate-* backup it created");
 });
 
-test("resumed migration stores phases backup in retained migrate snapshot", async () => {
+test("resumed migration removes disposable phases snapshot after success", async () => {
   const base = makeTmp();
   const milestonesPath = join(base, ".gsd", "milestones");
   const migratingPath = join(base, ".gsd", "milestones.migrating");
@@ -218,9 +217,9 @@ test("resumed migration stores phases backup in retained migrate snapshot", asyn
   const backups = readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"));
   assert.equal(backups.length, 1, "resumed migration should create one retained migrate backup");
   assert.equal(
-    readFileSync(join(backupRoot, backups[0]!, "__phases", "01-foundation", "PLAN-REVIEW.md"), "utf-8"),
-    "# Plan Review\n\nResume recovery copy.",
-    "resume should retain the phases snapshot under .gsd-backups",
+    existsSync(join(backupRoot, backups[0]!, "__phases")),
+    false,
+    "temporary phases/ recovery snapshot should be removed after resumed success",
   );
   assert.equal(
     existsSync(join(migratingPath, "__phases")),

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

@@ -46,6 +46,9 @@ import {
   tryCreateMemoriesFts,
   _isLikelyWslDrvFsPathForTest,
   _shouldAttemptVacuumRecoveryForTest,
+  insertArtifact,
+  getArtifact,
+  upsertMilestonePlanning,
 } from '../gsd-db.ts';
 import { MigrationBackupError } from '../db-migration-backup.ts';
 import { _resetLogs, peekLogs, setStderrLoggingEnabled } from '../workflow-logger.ts';
@@ -357,6 +360,35 @@ describe('gsd-db', () => {
     closeDatabase();
   });
 
+  test("gsd-db: upsertMilestonePlanning rewrites placeholder phase artifact paths to final title slug", () => {
+    openDatabase(":memory:");
+
+    const stalePath = "phases/01-new-milestone-m001/01-ROADMAP.md";
+    const finalPath = "phases/01-lokably-brand-foundation-and-welcome-pag/01-ROADMAP.md";
+    insertMilestone({ id: "M001", title: "New milestone M001", status: "active" });
+    insertArtifact({
+      path: stalePath,
+      artifact_type: "ROADMAP",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "# Placeholder roadmap\n",
+    });
+
+    upsertMilestonePlanning("M001", {
+      title: "Lokably brand foundation and welcome page rebuild",
+    });
+
+    assert.equal(getArtifact(stalePath), null, "placeholder-derived artifact row should be removed");
+    assert.equal(
+      getArtifact(finalPath)?.full_content,
+      "# Placeholder roadmap\n",
+      "artifact row should move to the final title-derived phase path",
+    );
+
+    closeDatabase();
+  });
+
   test('gsd-db: active_requirements view excludes superseded', () => {
     openDatabase(':memory:');
 

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

@@ -1428,6 +1428,19 @@ process.exit(result.status ?? 0);
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('Integration branch: write does not create legacy milestones scaffold', () => {
+    const repo = initBranchTestRepo();
+    mkdirSync(join(repo, ".gsd", "phases"), { recursive: true });
+
+    writeIntegrationBranch(repo, "M001", "f-123-new-thing");
+
+    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "f-123-new-thing");
+    assert.ok(existsSync(join(repo, ".gsd", "M001-META.json")), "metadata is written at the flat .gsd root");
+    assert.ok(!existsSync(join(repo, ".gsd", "milestones")), "legacy milestones/ root is not created");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── writeIntegrationBranch: updates when branch changes (#300) ──────
 
   test('Integration branch: updates on branch change', () => {

package/src/resources/extensions/gsd/tests/model-cost-table.test.ts

@@ -74,7 +74,8 @@ test("#2885: cost table includes openai-codex provider models", () => {
   const ids = BUNDLED_COST_TABLE.map(e => e.id);
   const codexModels = [
     "gpt-5.1", "gpt-5.1-codex-max", "gpt-5.1-codex-mini",
-    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5", "gpt-5.6",
+    "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.3-codex-spark", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5",
+    "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -110,10 +111,24 @@ test("gpt-5.5 uses official OpenAI list pricing", () => {
   assert.equal(entry.updatedAt, "2026-04-23");
 });
 
-test("gpt-5.6 mirrors gpt-5.5 pricing until official pricing is published", () => {
-  const entry = lookupModelCost("gpt-5.6");
-  assert.ok(entry, "lookupModelCost should find gpt-5.6");
-  assert.equal(entry.inputPer1k, 0.005);
-  assert.equal(entry.outputPer1k, 0.03);
-  assert.equal(entry.updatedAt, "2026-07-08");
+test("gpt-5.6 bare alias is not treated as a real cost-table model", () => {
+  assert.equal(lookupModelCost("gpt-5.6"), undefined);
+});
+
+test("gpt-5.6 variants use published pricing", () => {
+  const sol = lookupModelCost("openai-codex/gpt-5.6-sol");
+  assert.ok(sol, "lookupModelCost should find gpt-5.6-sol");
+  assert.equal(sol.inputPer1k, 0.005);
+  assert.equal(sol.outputPer1k, 0.03);
+  assert.deepEqual(sol.tiers?.[0], { inputTokensAbove: 272000, inputPer1k: 0.01, outputPer1k: 0.045 });
+
+  const terra = lookupModelCost("gpt-5.6-terra");
+  assert.ok(terra, "lookupModelCost should find gpt-5.6-terra");
+  assert.equal(terra.inputPer1k, 0.0025);
+  assert.equal(terra.outputPer1k, 0.015);
+
+  const luna = lookupModelCost("gpt-5.6-luna");
+  assert.ok(luna, "lookupModelCost should find gpt-5.6-luna");
+  assert.equal(luna.inputPer1k, 0.001);
+  assert.equal(luna.outputPer1k, 0.006);
 });

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -10,6 +10,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { isCustomProvider } from "../preferences-models.ts";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────
 
@@ -303,3 +304,57 @@ describe("custom provider session model overrides PREFERENCES.md (#4122)", () =>
   });
 });
 
+describe("custom provider detection (#801)", () => {
+  let originalGsdHome: string | undefined;
+  let tmpGsdHome: string;
+
+  beforeEach(() => {
+    originalGsdHome = process.env.GSD_HOME;
+    tmpGsdHome = makeTmpDir("gsd-home");
+    process.env.GSD_HOME = tmpGsdHome;
+  });
+
+  afterEach(() => {
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    try { rmSync(tmpGsdHome, { recursive: true, force: true }); } catch {}
+  });
+
+  it("detects extension-registered providers that are not declared in models.json", () => {
+    const registry = {
+      getAllWithDiscovered: () => [
+        { provider: "pi-llama-cpp" },
+      ],
+    };
+
+    assert.equal(isCustomProvider("pi-llama-cpp", registry), true,
+      "runtime providers outside the built-in catalog should count as custom");
+  });
+
+  it("does not treat built-in providers as custom just because they are in the registry", () => {
+    const registry = {
+      getAll: () => [
+        { provider: "claude-code" },
+      ],
+    };
+
+    assert.equal(isCustomProvider("claude-code", registry), false,
+      "built-in providers must still defer to PREFERENCES.md");
+  });
+
+  it("does not treat bundled external-CLI providers as custom", () => {
+    // claude-code/cursor-agent/google-gemini-cli/google-antigravity register at
+    // runtime (so they are absent from the generated @gsd/pi-ai catalog), but
+    // they are first-party built-ins that PREFERENCES.md can route to. They must
+    // never be classified as custom, otherwise auto-mode silently ignores
+    // PREFERENCES.md for the default provider.
+    for (const provider of ["cursor-agent", "google-gemini-cli", "google-antigravity"]) {
+      const registry = { getAll: () => [{ provider }] };
+      assert.equal(isCustomProvider(provider, registry), false,
+        `${provider} is a built-in CLI provider and must defer to PREFERENCES.md`);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -900,7 +900,7 @@ test("#2885: openai-codex standard-tier models are recognized", () => {
 
 test("#2885: openai-codex heavy-tier models are recognized", () => {
   const config = { ...defaultRoutingConfig(), enabled: true };
-  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "gpt-5.6", "o4-mini", "o4-mini-deep-research"];
+  const heavyModels = ["gpt-5", "gpt-5-pro", "gpt-5.1", "gpt-5.2", "gpt-5.2-codex", "gpt-5.3-codex", "gpt-5.4", "gpt-5.5", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),

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

@@ -104,6 +104,30 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice re-dispatch preserves completed task checkboxes', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const first = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+
+    updateTaskStatus('M001', 'S02', 'T01', 'complete', '2026-07-11T00:00:00.000Z');
+
+    const second = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    const parsedPlan = parsePlan(readFileSync(planPath, 'utf-8'));
+    assert.equal(parsedPlan.tasks.find((task) => task.id === 'T01')?.done, true);
+    assert.equal(parsedPlan.tasks.find((task) => task.id === 'T02')?.done, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice persists explicit slice/task target repositories', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -11,7 +11,7 @@
 import { describe, test, mock, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { tmpdir } from "node:os";
-import { mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
@@ -113,6 +113,15 @@ ${yamlLines.join("\n")}
   _clearGsdRootCache();
 }
 
+function useFlatPhaseLayout(): string {
+  rmSync(join(tempDir, ".gsd", "milestones"), { recursive: true, force: true });
+  const phaseDir = join(tempDir, ".gsd", "phases", "01-m001");
+  mkdirSync(phaseDir, { recursive: true });
+  invalidateAllCaches();
+  _clearGsdRootCache();
+  return phaseDir;
+}
+
 /**
  * Create a task in DB that will pass basic verification but allows us to test the flow.
  */
@@ -461,6 +470,34 @@ describe("Post-execution blocking failure retry bypass", () => {
     );
   });
 
+  test("flat-phase post-unit evidence writes slice-task VERIFY.json at phase level", async () => {
+    const phaseDir = useFlatPhaseLayout();
+    createPostExecFailureTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    const evidencePath = join(phaseDir, "S01-T01-VERIFY.json");
+    const legacyEvidencePath = join(phaseDir, "tasks", "T01-VERIFY.json");
+    assert.ok(existsSync(evidencePath), "flat-phase evidence should be written at phase level");
+    assert.equal(existsSync(legacyEvidencePath), false, "flat-phase evidence should not create legacy tasks/ path");
+
+    const evidence = JSON.parse(readFileSync(evidencePath, "utf-8"));
+    assert.equal(evidence.passed, false);
+    assert.ok(Array.isArray(evidence.postExecutionChecks), "post-execution checks should be included in rewritten evidence");
+  });
+
   test("strict post-exec warning pause includes warning details", async () => {
     createPostExecWarningTask();
     writePreferences({

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

@@ -836,6 +836,31 @@ test("planning_subagents validation accepts configured read-only planning specia
   assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, ["scout", "security"]);
 });
 
+test("planning_subagents validation accepts custom agents registered as read-only planning specialists", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagent_registry: {
+      "my-custom-planner": { read_only_specialist: true },
+    },
+    planning_subagents: {
+      "plan-milestone": { allowed: ["planner", "my-custom-planner"] },
+      "plan-slice": { allowed: ["scout", "my-custom-planner"] },
+    },
+  } as any);
+
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.planning_subagent_registry?.["my-custom-planner"], {
+    read_only_specialist: true,
+  });
+  assert.deepEqual(preferences.planning_subagents?.["plan-milestone"]?.allowed, [
+    "planner",
+    "my-custom-planner",
+  ]);
+  assert.deepEqual(preferences.planning_subagents?.["plan-slice"]?.allowed, [
+    "scout",
+    "my-custom-planner",
+  ]);
+});
+
 test("planning_subagents validation rejects unsupported units and unsafe agents", () => {
   const { preferences, errors } = validatePreferences({
     planning_subagents: {
@@ -849,6 +874,33 @@ test("planning_subagents validation rejects unsupported units and unsafe agents"
   assert.ok(errors.some(e => e.includes("\"worker\"") && e.includes("read-only planning specialist")));
 });
 
+test("planning_subagents validation explains how to register custom planning agents", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagents: {
+      "plan-slice": { allowed: ["my-custom-planner"] },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagents, undefined);
+  assert.ok(errors.some(e =>
+    e.includes("my-custom-planner") &&
+    e.includes("planning_subagent_registry.my-custom-planner.read_only_specialist: true")
+  ));
+});
+
+test("planning_subagent_registry validation requires explicit read_only_specialist true", () => {
+  const { preferences, errors } = validatePreferences({
+    planning_subagent_registry: {
+      "write-capable-agent": { read_only_specialist: false },
+    },
+  } as any);
+
+  assert.equal(preferences.planning_subagent_registry, undefined);
+  assert.ok(errors.some(e =>
+    e.includes("planning_subagent_registry.write-capable-agent.read_only_specialist must be true")
+  ));
+});
+
 test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -874,9 +926,12 @@ test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) =>
     [
       "---",
       "version: 1",
+      "planning_subagent_registry:",
+      "  global-custom-planner:",
+      "    read_only_specialist: true",
       "planning_subagents:",
       "  plan-slice:",
-      "    allowed: [scout, reviewer]",
+      "    allowed: [scout, reviewer, global-custom-planner]",
       "---",
       "",
     ].join("\n"),
@@ -887,11 +942,14 @@ test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) =>
     [
       "---",
       "version: 1",
+      "planning_subagent_registry:",
+      "  project-custom-planner:",
+      "    read_only_specialist: true",
       "planning_subagents:",
       "  plan-slice:",
-      "    allowed: [security]",
+      "    allowed: [security, project-custom-planner]",
       "  plan-milestone:",
-      "    allowed: [planner]",
+      "    allowed: [planner, project-custom-planner]",
       "---",
       "",
     ].join("\n"),
@@ -899,12 +957,21 @@ test("loadEffectiveGSDPreferences merges planning_subagents allowlists", (t) =>
   );
 
   const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.deepEqual(loaded?.preferences.planning_subagent_registry, {
+    "global-custom-planner": { read_only_specialist: true },
+    "project-custom-planner": { read_only_specialist: true },
+  });
   assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-slice"]?.allowed, [
     "scout",
     "reviewer",
+    "global-custom-planner",
     "security",
+    "project-custom-planner",
+  ]);
+  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, [
+    "planner",
+    "project-custom-planner",
   ]);
-  assert.deepEqual(loaded?.preferences.planning_subagents?.["plan-milestone"]?.allowed, ["planner"]);
 });
 
 // ── Model config parsing ─────────────────────────────────────────────────────

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

@@ -54,6 +54,9 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   },
   post_unit_hooks: [{ command: "npm test" }],
   pre_dispatch_hooks: [{ command: "npm run lint" }],
+  planning_subagent_registry: {
+    "custom-planner": { read_only_specialist: true },
+  },
   planning_subagents: {
     "plan-milestone": { allowed: ["scout", "planner"] },
     "plan-slice": { allowed: ["scout"] },

package/src/resources/extensions/gsd/tests/service-tier.test.ts

@@ -35,8 +35,8 @@ describe("supportsServiceTier", () => {
     assert.equal(supportsServiceTier("gpt-5.5"), false);
   });
 
-  test("returns false for gpt-5.6 until service_tier payload support is verified", () => {
-    assert.equal(supportsServiceTier("gpt-5.6"), false);
+  test("returns false for gpt-5.6 variants until service_tier payload support is verified", () => {
+    assert.equal(supportsServiceTier("gpt-5.6-sol"), false);
   });
 
   test("returns false for provider-only identifier without gpt-5.4 model suffix", () => {

package/src/resources/extensions/gsd/tests/thinking-level-resolution.test.ts

@@ -150,7 +150,7 @@ test("validation warns on an unknown phase key in the block", () => {
 
 test("validation warns on AND strips an illegal inline models thinking level", () => {
   const result = validatePreferences({
-    models: { planning: { model: "m", thinking: "max" } },
+    models: { planning: { model: "m", thinking: "ultra" } },
   } as never);
   assert.ok(result.warnings.some((w) => w.includes("models.planning.thinking") && w.includes("not a valid thinking level")));
   // The bad thinking field must be stripped so it can't reach the resolver,

package/src/resources/extensions/gsd/tests/verification-evidence.test.ts

@@ -99,6 +99,18 @@ test("verification-evidence: writeVerificationJSON creates directory if it doesn
   }
 });
 
+test("verification-evidence: writeVerificationJSON can write flat-phase slice-task filename", () => {
+  const tmp = makeTempDir("ve-flat-name");
+  try {
+    writeVerificationJSON(makeResult(), tmp, "T02", "M001/S03/T02", undefined, undefined, "S03");
+
+    assert.ok(existsSync(join(tmp, "S03-T02-VERIFY.json")), "flat-phase JSON file should exist");
+    assert.equal(existsSync(join(tmp, "T02-VERIFY.json")), false, "legacy JSON file should not be written");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 test("verification-evidence: writeVerificationJSON maps exitCode to verdict correctly", () => {
   const tmp = makeTempDir("ve-verdict");
   try {