@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.97ef11e3

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"),

package/src/resources/extensions/gsd/tests/parallel-eligibility-file-overlap.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Regression tests for batched touched-file collection in parallel eligibility.
+ *
+ * `collectTouchedFiles` used to run one `getSliceTasks` query per slice (N+1);
+ * it now issues a single `getTasksBySliceIds` batch and dedups paths into a
+ * Set. These tests pin the observable contract of that path through the public
+ * `analyzeParallelEligibility` API:
+ *   1. files are collected from EVERY slice of a milestone, not just the first
+ *      (a file present only in a non-first slice must still drive overlap), and
+ *   2. a path repeated across a milestone's slices is deduped (Set semantics),
+ *      so it appears once in the cross-milestone overlap.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+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 { analyzeParallelEligibility } from "../parallel-eligibility.ts";
+import { invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-elig-overlap-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeMilestoneFile(base: string, milestoneId: string, filename: string, content: string): void {
+  const filePath = join(base, ".gsd", "milestones", milestoneId, filename);
+  mkdirSync(join(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, content);
+}
+
+/**
+ * Write the on-disk planning artifacts that make a milestone eligible
+ * (CONTEXT + ROADMAP listing its slices + a PLAN per slice). Mirrors the
+ * proven-eligible setup used by parallel-eligibility-ghost.test.ts.
+ */
+function writeEligibleMilestoneFiles(base: string, milestoneId: string, sliceIds: string[]): void {
+  writeMilestoneFile(base, milestoneId, `${milestoneId}-CONTEXT.md`, `# ${milestoneId}: Fixture\n\nBatch fixture.`);
+  const roadmapSlices = sliceIds
+    .map((sid) => `- [ ] **${sid}: Slice ${sid}** \`risk:low\` \`depends:[]\`\n  > Slice ${sid}.`)
+    .join("\n");
+  writeMilestoneFile(
+    base,
+    milestoneId,
+    `${milestoneId}-ROADMAP.md`,
+    `# ${milestoneId}: Fixture\n\n## Slices\n\n${roadmapSlices}\n`,
+  );
+  for (const sid of sliceIds) {
+    writeMilestoneFile(
+      base,
+      milestoneId,
+      `slices/${sid}/${sid}-PLAN.md`,
+      `# ${sid}: Slice ${sid}\n\n**Goal:** Do ${sid}.\n**Demo:** Done.\n\n## Tasks\n\n- [ ] **T01: Task** \`est:10m\`\n  Do it.\n`,
+    );
+  }
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("parallel-eligibility: batched touched-file collection", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    cleanup(base);
+    invalidateStateCache();
+  });
+
+  test("collects files from every slice (batch) and dedups repeated paths", async () => {
+    // M001 spans two slices. `src/shared.ts` appears in BOTH slices (dedup
+    // target); `src/beta.ts` appears ONLY in the second slice S02 (proves the
+    // batch covers non-first slices). `src/alpha.ts` is unique to M001.
+    writeEligibleMilestoneFiles(base, "M001", ["S01", "S02"]);
+    insertMilestone({ id: "M001", title: "M001: Fixture", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice S01", status: "active", risk: "low", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Slice S02", status: "active", risk: "low", depends: [], sequence: 2 });
+    insertTask({
+      id: "T01", sliceId: "S01", milestoneId: "M001", title: "S01 task", status: "pending",
+      planning: { files: ["src/alpha.ts", "src/shared.ts"] },
+    });
+    insertTask({
+      id: "T01", sliceId: "S02", milestoneId: "M001", title: "S02 task", status: "pending",
+      planning: { files: ["src/shared.ts", "src/beta.ts"] },
+    });
+
+    // M002 overlaps M001 on both `src/shared.ts` and `src/beta.ts`.
+    writeEligibleMilestoneFiles(base, "M002", ["S01"]);
+    insertMilestone({ id: "M002", title: "M002: Fixture", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M002", title: "Slice S01", status: "active", risk: "low", depends: [], sequence: 1 });
+    insertTask({
+      id: "T01", sliceId: "S01", milestoneId: "M002", title: "S01 task", status: "pending",
+      planning: { files: ["src/shared.ts", "src/beta.ts"] },
+    });
+
+    invalidateStateCache();
+    const result = await analyzeParallelEligibility(base);
+
+    // Both milestones must be eligible so Rule 3 (file overlap) runs on them.
+    assert.ok(result.eligible.find((e) => e.milestoneId === "M001"), "M001 should be eligible");
+    assert.ok(result.eligible.find((e) => e.milestoneId === "M002"), "M002 should be eligible");
+
+    const overlap = result.fileOverlaps.find(
+      (o) =>
+        (o.mid1 === "M001" && o.mid2 === "M002") ||
+        (o.mid1 === "M002" && o.mid2 === "M001"),
+    );
+    assert.ok(overlap, "M001 and M002 must be reported as overlapping");
+
+    // `src/beta.ts` lives only in M001's SECOND slice — its presence proves the
+    // batched query collected tasks from every slice, not just the first.
+    assert.ok(
+      overlap!.files.includes("src/beta.ts"),
+      "overlap must include src/beta.ts (only present in M001's non-first slice S02)",
+    );
+    assert.ok(overlap!.files.includes("src/shared.ts"), "overlap must include src/shared.ts");
+
+    // `src/shared.ts` appears in both of M001's slices but must be deduped to a
+    // single entry (Set collection), so the sorted overlap is exactly these two.
+    assert.deepEqual(
+      [...overlap!.files].sort(),
+      ["src/beta.ts", "src/shared.ts"],
+      "overlap files must be deduped and limited to the shared paths",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -108,6 +108,65 @@ describe("parallel-monitor-overlay", () => {
     }
   });
 
+  it("merged worker query renders slice progress and completions across multiple slices", async () => {
+    // Regression guard for the single-open merge: queryWorkerProgress now
+    // returns { slices, completions } from ONE connection per worker per tick.
+    // A worker spanning two slices, each with a completed task, must still
+    // surface every slice's progress AND both completions (previously two
+    // separate DB opens produced these).
+    const base = mkdtempSync(join(tmpdir(), "gsd-parallel-overlay-multi-"));
+
+    try {
+      mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+      assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+      insertMilestone({ id: "M001", title: "Multi-slice Fixture" });
+      insertSlice({ milestoneId: "M001", id: "S01", title: "First", status: "pending", sequence: 1 });
+      insertSlice({ milestoneId: "M001", id: "S02", title: "Second", status: "pending", sequence: 2 });
+      insertTask({ milestoneId: "M001", sliceId: "S01", id: "T01", status: "complete", oneLiner: "alpha done", sequence: 1 });
+      insertTask({ milestoneId: "M001", sliceId: "S01", id: "T02", status: "pending", sequence: 2 });
+      insertTask({ milestoneId: "M001", sliceId: "S02", id: "T01", status: "complete", oneLiner: "beta done", sequence: 1 });
+      insertTask({ milestoneId: "M001", sliceId: "S02", id: "T02", status: "pending", sequence: 2 });
+      closeDatabase();
+
+      writeFileSync(
+        join(base, ".gsd", "parallel", "M001.status.json"),
+        JSON.stringify({
+          milestoneId: "M001",
+          pid: process.pid,
+          state: "running",
+          cost: 0,
+          lastHeartbeat: Date.now(),
+          startedAt: Date.now() - 30_000,
+          worktreePath: join(base, ".gsd-worktrees", "M001"),
+        }),
+        "utf-8",
+      );
+
+      const mod = await import("../parallel-monitor-overlay.js");
+      const mockTui = { requestRender: () => {} };
+      const mockTheme = {
+        fg: (_color: string, text: string) => text,
+        bold: (text: string) => text,
+      };
+      const overlay = new mod.ParallelMonitorOverlay(mockTui, mockTheme as any, () => {}, base);
+
+      try {
+        const joined = overlay.render(120).join("\n");
+        // Both slices' progress must come from the single merged query.
+        assert.match(joined, /S01:1\/2/, "S01 progress should render from the merged query");
+        assert.match(joined, /S02:1\/2/, "S02 progress should render from the merged query");
+        // Completions for tasks in both slices ride along on the same DB open.
+        assert.match(joined, /S01\/T01: alpha done/, "S01 completion should render");
+        assert.match(joined, /S02\/T01: beta done/, "S02 completion should render");
+      } finally {
+        overlay.dispose();
+      }
+    } finally {
+      try { closeDatabase(); } catch { /* already closed */ }
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
   it("progressBar generates correct width", async () => {
     // Dynamic import to test the module loads cleanly
     const mod = await import("../parallel-monitor-overlay.js");

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -29,12 +29,14 @@ import {
 
 const SKILL_NAME = "testskill";
 const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
-const SKILL_ACTIVATION_SUBSTRING = `Read the installed '${SKILL_NAME}' skill file from <available_skills>`;
-const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Read the installed '${COMPLETE_SLICE_SKILL_NAME}' skill file from <available_skills>`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
+function expectedSkillRead(base: string, name: string): string {
+  return `Read the skill file at \`${join(base, ".agents", "skills", name, "SKILL.md")}\``;
+}
+
 function setupProjectWithSkill(options: {
   skillName?: string;
   preferencesLines?: string[];
@@ -139,7 +141,7 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
     "research-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
 });
@@ -164,7 +166,7 @@ test("complete-slice prompt includes <skill_activation> from unit-specific skill
     "complete-slice prompt should contain a <skill_activation> block",
   );
   assert.ok(
-    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, COMPLETE_SLICE_SKILL_NAME)),
     `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
   );
 });
@@ -192,7 +194,7 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
   );
   assert.ok(
-    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    prompt.includes(expectedSkillRead(base, SKILL_NAME)),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
   assert.ok(