@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

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

@@ -280,6 +280,31 @@ describe('gsd-db', () => {
     }
   });
 
+  test("gsd-db: insertTask stamps completed_at for every complete-alias but not for skipped", () => {
+    openDatabase(":memory:");
+
+    try {
+      insertMilestone({ id: "M001", title: "Completion stamp", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", sequence: 1 });
+      insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Closed", status: "closed", sequence: 1 });
+      insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Done", status: "done", sequence: 2 });
+      insertTask({ id: "T03", sliceId: "S01", milestoneId: "M001", title: "Skipped", status: "skipped", sequence: 3 });
+
+      assert.ok(
+        getTask("M001", "S01", "T01")?.completed_at,
+        "a task imported as 'closed' is terminal and must carry a completed_at",
+      );
+      assert.ok(getTask("M001", "S01", "T02")?.completed_at, "'done' alias must stamp completed_at");
+      assert.equal(
+        getTask("M001", "S01", "T03")?.completed_at,
+        null,
+        "a skipped task was never completed and must have null completed_at",
+      );
+    } finally {
+      closeDatabase();
+    }
+  });
+
   test('gsd-db: active_decisions view excludes superseded', () => {
     openDatabase(':memory:');
 

package/src/resources/extensions/gsd/tests/import-slice-milestone-completion-preserve.test.ts

@@ -0,0 +1,116 @@
+// Project/App: gsd-pi
+// File Purpose: Regression for #1291 — a full markdown re-import must NOT rewrite
+// the completed_at of an already-complete slice or milestone with the current
+// import time. The task path was fixed for this (#1222/#1228) via
+// preserveCompletionMetadata; the slice and milestone backfills in
+// migrateHierarchyToDb had no such guard, so every re-import re-stamped every
+// complete slice/milestone. The fix threads preserveCompletion through
+// updateSliceStatus/updateMilestoneStatus so an existing completed_at survives.
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+  getMilestoneSlices,
+  updateSliceStatus,
+  updateMilestoneStatus,
+} from '../gsd-db.ts';
+import { migrateHierarchyToDb } from '../md-importer.ts';
+import { describe, test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-preserve-completion-'));
+  tmpDirs.push(base);
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, '.gsd', relativePath);
+  mkdirSync(join(full, '..'), { recursive: true });
+  writeFileSync(full, content);
+}
+
+// All slices [x] → milestone imports complete, slices import complete.
+const ROADMAP_ALL_DONE = `# M001: Finished Milestone
+
+**Vision:** Done work.
+
+## Slices
+
+- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+
+- [x] **S02: Second Slice** \`risk:medium\` \`depends:[S01]\`
+  > After this: Also done.
+`;
+
+const REAL_S01 = '2026-07-05T19:52:04.672Z';
+const REAL_S02 = '2026-07-05T20:36:51.313Z';
+const REAL_M001 = '2026-07-05T21:00:00.000Z';
+
+describe('migrateHierarchyToDb: re-import preserves existing completion timestamps (#1291)', () => {
+  test('a re-import does not rewrite already-complete slice completed_at', () => {
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    // Simulate the durable completion timestamps the real run wrote hours apart.
+    updateSliceStatus('M001', 'S01', 'complete', REAL_S01);
+    updateSliceStatus('M001', 'S02', 'complete', REAL_S02);
+
+    // A second full re-import (the class of event that bit the reporter).
+    migrateHierarchyToDb(base);
+
+    const slices = getMilestoneSlices('M001');
+    const s01 = slices.find((s) => s.id === 'S01')!;
+    const s02 = slices.find((s) => s.id === 'S02')!;
+    assert.equal(s01.completed_at, REAL_S01, 'S01 completed_at must survive re-import unchanged');
+    assert.equal(s02.completed_at, REAL_S02, 'S02 completed_at must survive re-import unchanged');
+  });
+
+  test('a re-import does not rewrite an already-complete milestone completed_at', () => {
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    updateMilestoneStatus('M001', 'complete', REAL_M001);
+
+    migrateHierarchyToDb(base);
+
+    const m001 = getAllMilestones().find((m) => m.id === 'M001')!;
+    assert.equal(m001.completed_at, REAL_M001, 'M001 completed_at must survive re-import unchanged');
+  });
+
+  test('an initial import of a complete slice still backfills a completed_at when the row has none', () => {
+    // The guard preserves an existing timestamp but must not suppress the
+    // legitimate first-time backfill for a slice imported as complete.
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    const slices = getMilestoneSlices('M001');
+    for (const s of slices) {
+      assert.ok(s.completed_at, `complete slice ${s.id} should receive a backfilled completed_at on first import`);
+    }
+    const m001 = getAllMilestones().find((m) => m.id === 'M001')!;
+    assert.ok(m001.completed_at, 'complete milestone should receive a backfilled completed_at on first import');
+  });
+});

package/src/resources/extensions/gsd/tests/integration/paths.test.ts

@@ -1,6 +1,6 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -12,6 +12,8 @@ import {
   resolveGsdPathContract,
   resolveSliceFile,
   resolveTaskFile,
+  resolveTaskFiles,
+  taskIdFromTaskFileName,
   _clearGsdRootCache,
 } from "../../paths.ts";
 /** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
@@ -171,21 +173,37 @@ describe('paths', () => {
   test('Case 9: flat-phase task SUMMARY resolves at phase root despite a stray slices/SID/ dir', () => {
     const root = tmp();
     try {
-      // Hybrid flat-phase milestone: phase dir holds flat TID-SUMMARY.md, but a
+      // Hybrid flat-phase milestone: phase dir holds flat task summaries, but a
       // stray slices/S01/ folder also exists on disk. resolveSlicePath then points
       // under slices/, so layout (phases/ vs milestones/) — not slicePath===phaseDir
       // — must decide the flat-phase task summary location.
       const phaseDir = join(root, ".gsd", "phases", "01-foo");
       mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
-      const flatSummary = join(phaseDir, "T01-SUMMARY.md");
+      const flatSummary = join(phaseDir, "S01-T01-SUMMARY.md");
+      const legacyFlatSummary = join(phaseDir, "T01-SUMMARY.md");
       writeFileSync(flatSummary, "# task summary\n");
+      writeFileSync(legacyFlatSummary, "# legacy task summary\n");
 
       _clearGsdRootCache();
 
+      assert.deepStrictEqual(resolveTaskFiles(phaseDir, "SUMMARY").sort(), [
+        "S01-T01-SUMMARY.md",
+        "T01-SUMMARY.md",
+      ]);
+      assert.equal(taskIdFromTaskFileName("S01-T01-SUMMARY.md", "SUMMARY"), "T01");
+      assert.equal(taskIdFromTaskFileName("T01-SUMMARY.md", "SUMMARY"), "T01");
+
       assert.deepStrictEqual(
         resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
         flatSummary,
-        "flat-phase TID-SUMMARY.md at phase root is found even when slices/S01/ exists",
+        "flat-phase S01-T01-SUMMARY.md at phase root is preferred even when slices/S01/ exists",
+      );
+
+      unlinkSync(flatSummary);
+      assert.deepStrictEqual(
+        resolveTaskFile(root, "M001", "S01", "T01", "SUMMARY"),
+        legacyFlatSummary,
+        "legacy flat T01-SUMMARY.md is still found as a fallback",
       );
     } finally { cleanup(root); }
   });

package/src/resources/extensions/gsd/tests/integration-branch-meta-location.test.ts

@@ -0,0 +1,62 @@
+// gsd-pi — Integration-branch META lives OUTSIDE milestones/<MID>/ (ADR-045).
+// Verifies the relocation from milestones/<MID>/<MID>-META.json to the flat
+// .gsd/<MID>-META.json so it can never poison isLegacyMilestonesLayout.
+
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, test } from "node:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { readIntegrationBranch, writeIntegrationBranch } from "../git-service.js";
+import { gsdRoot, isLegacyMilestonesLayout } from "../paths.js";
+
+let repo: string;
+
+beforeEach(() => {
+  repo = mkdtempSync(join(tmpdir(), "gsd-meta-loc-"));
+});
+
+afterEach(() => {
+  rmSync(repo, { recursive: true, force: true });
+});
+
+test("write goes to the new flat .gsd/<MID>-META.json, not milestones/<MID>/", () => {
+  writeIntegrationBranch(repo, "M001", "main");
+
+  assert.ok(
+    existsSync(join(gsdRoot(repo), "M001-META.json")),
+    "META written to flat .gsd/<MID>-META.json",
+  );
+  assert.ok(
+    !existsSync(join(gsdRoot(repo), "milestones", "M001", "M001-META.json")),
+    "no META in legacy milestones/<MID>/ location",
+  );
+});
+
+test("round-trip: read returns what write recorded", () => {
+  writeIntegrationBranch(repo, "M001", "main");
+  assert.equal(readIntegrationBranch(repo, "M001"), "main");
+});
+
+test("read falls back to the legacy milestones/<MID>/ location", () => {
+  const legacyDir = join(gsdRoot(repo), "milestones", "M001");
+  mkdirSync(legacyDir, { recursive: true });
+  writeFileSync(
+    join(legacyDir, "M001-META.json"),
+    JSON.stringify({ integrationBranch: "develop" }) + "\n",
+    "utf-8",
+  );
+
+  assert.equal(readIntegrationBranch(repo, "M001"), "develop");
+});
+
+test("writing META does not create milestones/<MID>/ or flip layout detection", () => {
+  assert.equal(isLegacyMilestonesLayout(repo), false, "clean tree is not legacy layout");
+  writeIntegrationBranch(repo, "M001", "main");
+  assert.equal(
+    isLegacyMilestonesLayout(repo),
+    false,
+    "writing integration-branch META must not poison layout detection",
+  );
+});

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

@@ -824,9 +824,9 @@ test('── markdown-renderer: renderTaskSummary round-trip ──', async () =
 
     // Verify file exists on disk
     const summaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md written to disk');
+    assert.ok(fs.existsSync(summaryPath), 'S01-T01-SUMMARY.md written to disk');
 
     // Parse and verify
     const rendered = fs.readFileSync(summaryPath, 'utf-8');
@@ -1020,7 +1020,7 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
 
     // Verify task summary written
     const taskSummaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
     assert.ok(fs.existsSync(taskSummaryPath), 'T01 summary written by renderAll');
   } finally {
@@ -1546,9 +1546,9 @@ test('── markdown-renderer: repairStaleRenders writes missing task summary
 
     // Verify file written
     const summaryPath = path.join(
-      tmpDir, '.gsd', 'phases', '01-test', 'T01-SUMMARY.md',
+      tmpDir, '.gsd', 'phases', '01-test', 'S01-T01-SUMMARY.md',
     );
-    assert.ok(fs.existsSync(summaryPath), 'T01-SUMMARY.md should exist after repair');
+    assert.ok(fs.existsSync(summaryPath), 'S01-T01-SUMMARY.md should exist after repair');
 
     // Second detect should be empty
     clearAllCaches();

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

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { createMigrationPlan, splitValidationIssues } from "../migrate/plan.ts";
+import type { ValidationResult } from "../migrate/types.ts";
+
+function makeBase(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+function write(path: string, content: string): void {
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, content);
+}
+
+test("splitValidationIssues separates warnings from fatals without dropping issue order", () => {
+  const validation: ValidationResult = {
+    valid: false,
+    issues: [
+      { file: "ROADMAP.md", severity: "warning", message: "missing roadmap" },
+      { file: ".planning", severity: "fatal", message: "missing directory" },
+      { file: "PROJECT.md", severity: "warning", message: "missing project" },
+    ],
+  };
+
+  assert.deepEqual(splitValidationIssues(validation), {
+    warnings: [
+      { file: "ROADMAP.md", severity: "warning", message: "missing roadmap" },
+      { file: "PROJECT.md", severity: "warning", message: "missing project" },
+    ],
+    fatals: [
+      { file: ".planning", severity: "fatal", message: "missing directory" },
+    ],
+  });
+});
+
+test("createMigrationPlan reports a missing .planning source without parsing", async () => {
+  const base = makeBase("gsd-migrate-plan-missing-");
+  try {
+    const result = await createMigrationPlan(base);
+
+    assert.equal(result.status, "missing-source");
+    assert.equal(result.sourcePath, join(base, ".planning"));
+    assert.equal(result.targetRoot, base);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("createMigrationPlan reports zero-slice migrations as blocked after validation", async () => {
+  const base = makeBase("gsd-migrate-plan-blocked-");
+  try {
+    mkdirSync(join(base, ".planning"), { recursive: true });
+    write(join(base, ".planning", "PROJECT.md"), "# Legacy Project\n");
+
+    const result = await createMigrationPlan(base);
+
+    assert.equal(result.status, "blocked");
+    assert.match(result.message, /zero slices/);
+    assert.equal(result.validation.valid, true);
+    assert.ok(result.warnings.some((issue) => issue.file === "ROADMAP.md"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/migrate-presentation.test.ts

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  buildMigrationPreviewSummary,
+  buildReviewPrompt,
+  formatMigrationPreviewStats,
+} from "../migrate/presentation.ts";
+import { gsdRoot } from "../paths.ts";
+import type { MigrationPreview } from "../migrate/writer.ts";
+
+function previewFixture(overrides: Partial<MigrationPreview> = {}): MigrationPreview {
+  return {
+    decisions: { total: 2 },
+    migrationInputs: {
+      milestonePhaseDirs: 3,
+      decisions: 2,
+      seeds: 1,
+    },
+    milestoneCount: 1,
+    totalSlices: 2,
+    totalTasks: 5,
+    doneSlices: 1,
+    doneTasks: 3,
+    sliceCompletionPct: 50,
+    taskCompletionPct: 60,
+    requirements: {
+      active: 1,
+      validated: 2,
+      deferred: 1,
+      outOfScope: 1,
+      total: 5,
+    },
+    ...overrides,
+  };
+}
+
+test("buildMigrationPreviewSummary includes counts, legacy inputs, and existing-target warning", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrate-presentation-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    assert.deepEqual(buildMigrationPreviewSummary(previewFixture(), base), [
+      "Decisions: 2",
+      "Milestones: 1",
+      "Slices: 2 (1 done — 50%)",
+      "Tasks: 5 (3 done — 60%)",
+      "Requirements: 5 (2 validated, 1 active, 1 deferred, 1 out of scope)",
+      "Legacy inputs: 3 milestone phase dir(s), 2 decision file(s), 1 seed file(s)",
+      "",
+      `⚠ A .gsd directory already exists at ${gsdRoot(base)}.`,
+      "It will be backed up, deleted, and rewritten fresh before DB import.",
+    ]);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatMigrationPreviewStats uses bullet formatting for review prompts", () => {
+  assert.equal(
+    formatMigrationPreviewStats(previewFixture({ requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, total: 0 } })),
+    [
+      "- Decisions: 2",
+      "- Milestones: 1",
+      "- Slices: 2 (1 done — 50%)",
+      "- Tasks: 5 (3 done — 60%)",
+      "- Legacy inputs: 3 milestone phase dir(s), 2 decision file(s), 1 seed file(s)",
+    ].join("\n"),
+  );
+});
+
+test("buildReviewPrompt interpolates source, target, and preview stats", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrate-prompt-"));
+  try {
+    const promptsDir = join(base, "prompts");
+    mkdirSync(promptsDir, { recursive: true });
+    writeFileSync(
+      join(promptsDir, "review-migration.md"),
+      "Source={{sourcePath}}\nTarget={{gsdPath}}\nStats:\n{{previewStats}}\n",
+    );
+
+    const prompt = buildReviewPrompt({
+      sourcePath: "/legacy/.planning",
+      gsdPath: "/project/.gsd",
+      preview: previewFixture(),
+      templatePath: join(promptsDir, "review-migration.md"),
+    });
+
+    assert.match(prompt, /Source=\/legacy\/\.planning/);
+    assert.match(prompt, /Target=\/project\/\.gsd/);
+    assert.match(prompt, /- Requirements: 5 \(2 validated, 1 active, 1 deferred, 1 out of scope\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/migrate-safety-audit.test.ts

@@ -19,7 +19,7 @@ import {
   archiveLegacyPlanningDirectory,
   verifyMigrationProjection,
 } from "../migrate/audit.ts";
-import { assertMigrationDbReadiness, executeMigrationWrite, importWrittenMigrationToDb } from "../migrate/command.ts";
+import { assertMigrationDbReadiness, executeMigrationWrite, importWrittenMigrationToDb } from "../migrate/execution.ts";
 import { writeGSDDirectory } from "../migrate/writer.ts";
 import { closeDatabase, getArtifact } from "../gsd-db.ts";
 import type { GSDProject } from "../migrate/types.ts";

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

@@ -18,6 +18,7 @@ import {
   releaseMilestoneLease,
   refreshMilestoneLease,
   getMilestoneLease,
+  forceReleaseLeasesForWorker,
 } from "../db/milestone-leases.ts";
 
 function makeBase(): string {
@@ -163,6 +164,60 @@ test("refreshMilestoneLease only succeeds with the matching fencing token", (t)
   assert.equal(refreshMilestoneLease(w1, "M001", claim.token - 1), false);
 });
 
+test("forceReleaseLeasesForWorker frees only the dead worker's leases, not a live peer's", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "One", status: "active" });
+  insertMilestone({ id: "M002", title: "Two", status: "active" });
+
+  // Distinct project roots → distinct processes (not re-entrant peers).
+  const wA = registerAutoWorker({ projectRootRealpath: base });
+  const wB = registerAutoWorker({ projectRootRealpath: join(base, "peer") });
+  assert.equal(claimMilestoneLease(wA, "M001").ok, true);
+  assert.equal(claimMilestoneLease(wB, "M002").ok, true);
+
+  const freed = forceReleaseLeasesForWorker(wA);
+  assert.equal(freed, 1, "exactly A's one held lease is released");
+
+  assert.equal(getMilestoneLease("M001")!.status, "released", "A's M001 lease is released");
+  const m2 = getMilestoneLease("M002")!;
+  assert.equal(m2.status, "held", "B's M002 lease must stay held (no over-release)");
+  assert.equal(m2.worker_id, wB);
+});
+
+test("after force release a fresh claim on the freed milestone gets a larger fencing token", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "One", status: "active" });
+
+  const wA = registerAutoWorker({ projectRootRealpath: base });
+  const wB = registerAutoWorker({ projectRootRealpath: join(base, "peer") });
+  const first = claimMilestoneLease(wA, "M001");
+  assert.equal(first.ok, true);
+  const releasedToken = first.ok ? first.token : 0;
+
+  assert.equal(forceReleaseLeasesForWorker(wA), 1);
+
+  const takeover = claimMilestoneLease(wB, "M001");
+  assert.equal(takeover.ok, true);
+  if (takeover.ok) {
+    assert.ok(takeover.token > releasedToken, "takeover token must exceed the released lease's token");
+  }
+  assert.equal(getMilestoneLease("M001")!.worker_id, wB);
+});
+
+test("forceReleaseLeasesForWorker returns 0 for a worker holding no leases", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "One", status: "active" });
+
+  const wA = registerAutoWorker({ projectRootRealpath: base });
+  assert.equal(forceReleaseLeasesForWorker(wA), 0);
+});
+
 test("claimMilestoneLease rethrows foreign-key failures instead of treating them as lease contention", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

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

@@ -74,7 +74,7 @@ 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.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",
   ];
   for (const model of codexModels) {
     assert.ok(ids.includes(model), `cost table should include openai-codex model "${model}"`);
@@ -109,3 +109,11 @@ test("gpt-5.5 uses official OpenAI list pricing", () => {
   assert.equal(entry.outputPer1k, 0.03);
   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");
+});

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", "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", "o4-mini", "o4-mini-deep-research"];
   for (const model of heavyModels) {
     const result = resolveModelForComplexity(
       makeClassification("heavy"),