gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/src/resources/extensions/gsd/tests/commands-pr-branch.test.ts

@@ -0,0 +1,68 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the filtering logic used by /gsd pr-branch.
+// Full integration requires git operations, so we test the path filtering.
+
+test("pr-branch: identifies .gsd/ paths", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    "src/main.ts",
+    "package.json",
+    ".planning/PLAN.md",
+    "PLAN.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.deepEqual(codeFiles, ["src/main.ts", "package.json"]);
+});
+
+test("pr-branch: all .gsd/ files returns empty", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    ".gsd/BACKLOG.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.equal(codeFiles.length, 0);
+});
+
+test("pr-branch: mixed commits with code changes", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    "src/auth.ts",
+    "src/auth.test.ts",
+  ];
+
+  const hasCodeChanges = files.some(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.ok(hasCodeChanges);
+});
+
+test("pr-branch: --dry-run flag", () => {
+  assert.ok("--dry-run".includes("--dry-run"));
+  assert.ok(!"--name my-branch".includes("--dry-run"));
+});
+
+test("pr-branch: --name flag parsing", () => {
+  const args = "--name my-clean-pr";
+  const nameMatch = args.match(/--name\s+(\S+)/);
+  assert.ok(nameMatch);
+  assert.equal(nameMatch[1], "my-clean-pr");
+});
+
+test("pr-branch: default branch name", () => {
+  const currentBranch = "feat/add-auth";
+  const prBranch = `pr/${currentBranch}`;
+  assert.equal(prBranch, "pr/feat/add-auth");
+});

package/src/resources/extensions/gsd/tests/commands-scan.test.ts

@@ -0,0 +1,351 @@
+/**
+ * Tests for /gsd scan command — pure functions + handler integration
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  parseScanArgs,
+  resolveScanDocuments,
+  buildScanOutputPaths,
+  checkExistingDocuments,
+  handleScan,
+  VALID_FOCUS_AREAS,
+  DEFAULT_FOCUS,
+} from "../commands-scan.js";
+
+// ─── Test fixtures ────────────────────────────────────────────────────────────
+
+const tmpDirs: string[] = [];
+
+function makeTmpDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-scan-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tmpDirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // best-effort cleanup
+    }
+  }
+  tmpDirs.length = 0;
+});
+
+// ─── parseScanArgs ────────────────────────────────────────────────────────────
+
+describe("parseScanArgs", () => {
+  test("returns default focus when no args provided", () => {
+    const result = parseScanArgs("");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+
+  test("returns default focus for whitespace-only args", () => {
+    const result = parseScanArgs("   ");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+
+  test("parses --focus tech", () => {
+    const result = parseScanArgs("--focus tech");
+    assert.equal(result.focus, "tech");
+  });
+
+  test("parses --focus arch", () => {
+    const result = parseScanArgs("--focus arch");
+    assert.equal(result.focus, "arch");
+  });
+
+  test("parses --focus quality", () => {
+    const result = parseScanArgs("--focus quality");
+    assert.equal(result.focus, "quality");
+  });
+
+  test("parses --focus concerns", () => {
+    const result = parseScanArgs("--focus concerns");
+    assert.equal(result.focus, "concerns");
+  });
+
+  test("parses --focus tech+arch", () => {
+    const result = parseScanArgs("--focus tech+arch");
+    assert.equal(result.focus, "tech+arch");
+  });
+
+  test("is case-insensitive for focus value", () => {
+    const result = parseScanArgs("--focus TECH");
+    assert.equal(result.focus, "tech");
+  });
+
+  test("returns default for unknown focus value", () => {
+    const result = parseScanArgs("--focus unknown");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+
+  test("ignores extra whitespace around flag value", () => {
+    const result = parseScanArgs("  --focus   arch  ");
+    assert.equal(result.focus, "arch");
+  });
+
+  test("rejects shell injection attempts — uses default", () => {
+    const result = parseScanArgs("--focus tech; rm -rf /");
+    assert.equal(result.focus, DEFAULT_FOCUS);
+  });
+});
+
+// ─── resolveScanDocuments ────────────────────────────────────────────────────
+
+describe("resolveScanDocuments", () => {
+  test("tech focus returns STACK and INTEGRATIONS", () => {
+    const docs = resolveScanDocuments("tech");
+    assert.deepEqual(docs, ["STACK", "INTEGRATIONS"]);
+  });
+
+  test("arch focus returns ARCHITECTURE and STRUCTURE", () => {
+    const docs = resolveScanDocuments("arch");
+    assert.deepEqual(docs, ["ARCHITECTURE", "STRUCTURE"]);
+  });
+
+  test("quality focus returns CONVENTIONS and TESTING", () => {
+    const docs = resolveScanDocuments("quality");
+    assert.deepEqual(docs, ["CONVENTIONS", "TESTING"]);
+  });
+
+  test("concerns focus returns CONCERNS only", () => {
+    const docs = resolveScanDocuments("concerns");
+    assert.deepEqual(docs, ["CONCERNS"]);
+  });
+
+  test("tech+arch (default) returns all four tech and arch docs", () => {
+    const docs = resolveScanDocuments("tech+arch");
+    assert.deepEqual(docs, ["STACK", "INTEGRATIONS", "ARCHITECTURE", "STRUCTURE"]);
+  });
+
+  test("unknown focus falls back to default documents", () => {
+    const docs = resolveScanDocuments("unknown-area");
+    assert.deepEqual(docs, resolveScanDocuments(DEFAULT_FOCUS));
+  });
+
+  test("each valid focus area returns at least one document", () => {
+    for (const area of VALID_FOCUS_AREAS) {
+      const docs = resolveScanDocuments(area);
+      assert.ok(docs.length > 0, `focus "${area}" should return at least one document`);
+    }
+  });
+});
+
+// ─── buildScanOutputPaths ────────────────────────────────────────────────────
+
+describe("buildScanOutputPaths", () => {
+  test("returns paths under .gsd/codebase/ relative to basePath", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("tech", base);
+    assert.ok(paths.every((p) => p.startsWith(join(base, ".gsd", "codebase"))));
+  });
+
+  test("each path ends with .md extension", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("arch", base);
+    assert.ok(paths.every((p) => p.endsWith(".md")));
+  });
+
+  test("number of paths matches number of documents for focus", () => {
+    const base = "/some/project";
+    const docs = resolveScanDocuments("quality");
+    const paths = buildScanOutputPaths("quality", base);
+    assert.equal(paths.length, docs.length);
+  });
+
+  test("document names are uppercased in filenames", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("tech", base);
+    assert.ok(paths.some((p) => p.includes("STACK.md")));
+    assert.ok(paths.some((p) => p.includes("INTEGRATIONS.md")));
+  });
+
+  test("falls back to default focus documents for unknown focus", () => {
+    const base = "/some/project";
+    const paths = buildScanOutputPaths("nonexistent-area", base);
+    const expected = buildScanOutputPaths(DEFAULT_FOCUS, base);
+    assert.deepEqual(paths, expected);
+  });
+});
+
+// ─── checkExistingDocuments ──────────────────────────────────────────────────
+
+describe("checkExistingDocuments", () => {
+  test("returns empty array when no documents exist", () => {
+    const tmpDir = makeTmpDir();
+    const paths = [join(tmpDir, "STACK.md"), join(tmpDir, "INTEGRATIONS.md")];
+    const existing = checkExistingDocuments(paths);
+    assert.deepEqual(existing, []);
+  });
+
+  test("returns only the paths that exist on disk", () => {
+    const tmpDir = makeTmpDir();
+    const stackPath = join(tmpDir, "STACK.md");
+    const intPath = join(tmpDir, "INTEGRATIONS.md");
+
+    writeFileSync(stackPath, "# Stack");
+
+    const existing = checkExistingDocuments([stackPath, intPath]);
+    assert.deepEqual(existing, [stackPath]);
+  });
+
+  test("returns all paths when all documents exist", () => {
+    const tmpDir = makeTmpDir();
+    const paths = [
+      join(tmpDir, "STACK.md"),
+      join(tmpDir, "INTEGRATIONS.md"),
+    ];
+
+    for (const p of paths) writeFileSync(p, "content");
+
+    const existing = checkExistingDocuments(paths);
+    assert.deepEqual(existing, paths);
+  });
+
+  test("returns empty array for empty input", () => {
+    const existing = checkExistingDocuments([]);
+    assert.deepEqual(existing, []);
+  });
+});
+
+// ─── handleScan integration ───────────────────────────────────────────────────
+// Verifies the handler creates the output directory and dispatches the correct
+// prompt without running a real AI turn.
+
+function makeMockPi() {
+  const calls: Array<{ msg: unknown; opts: unknown }> = [];
+  return {
+    sendMessage: (msg: unknown, opts: unknown) => { calls.push({ msg, opts }); },
+    calls,
+  };
+}
+
+function makeMockCtx() {
+  const notifications: Array<{ text: string; level: string }> = [];
+  return {
+    ui: {
+      notify: (text: string, level: string) => { notifications.push({ text, level }); },
+    },
+    notifications,
+  };
+}
+
+describe("handleScan — handler integration", () => {
+  test("creates .gsd/codebase/ directory", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("", ctx as never, pi as never);
+
+    assert.ok(existsSync(join(tmpDir, ".gsd", "codebase")));
+  });
+
+  test("calls pi.sendMessage with triggerTurn: true", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("", ctx as never, pi as never);
+
+    assert.equal(pi.calls.length, 1);
+    const opts = pi.calls[0].opts as { triggerTurn: boolean };
+    assert.equal(opts.triggerTurn, true);
+  });
+
+  test("default focus dispatches tech+arch documents", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("", ctx as never, pi as never);
+
+    const msg = pi.calls[0].msg as { content: string };
+    // The "Documents to produce" line lists exactly the active documents
+    assert.ok(
+      msg.content.includes("Documents to produce:** STACK, INTEGRATIONS, ARCHITECTURE, STRUCTURE"),
+      "prompt documents line should list tech+arch docs",
+    );
+  });
+
+  test("--focus quality dispatches only CONVENTIONS and TESTING", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("--focus quality", ctx as never, pi as never);
+
+    const msg = pi.calls[0].msg as { content: string };
+    // The "Documents to produce" line must list exactly CONVENTIONS and TESTING
+    assert.ok(
+      msg.content.includes("Documents to produce:** CONVENTIONS, TESTING"),
+      "prompt documents line should list only quality docs",
+    );
+    // The focus reinforcement line must also reflect quality
+    assert.ok(
+      msg.content.includes("relevant: **CONVENTIONS, TESTING**"),
+      "focus reinforcement line should name only quality docs",
+    );
+  });
+
+  test("notifies user with the active focus before dispatch", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("--focus concerns", ctx as never, pi as never);
+
+    const infoNote = ctx.notifications.find((n) => n.level === "info");
+    assert.ok(infoNote, "should emit an info notification");
+    assert.ok(infoNote.text.includes("concerns"), "notification should mention the active focus");
+  });
+
+  test("warns when documents already exist", async (t) => {
+    const tmpDir = makeTmpDir();
+    const origCwd = process.cwd();
+    process.chdir(tmpDir);
+    t.after(() => { process.chdir(origCwd); });
+
+    // Pre-create one of the output documents
+    const codesbaseDir = join(tmpDir, ".gsd", "codebase");
+    mkdirSync(codesbaseDir, { recursive: true });
+    writeFileSync(join(codesbaseDir, "STACK.md"), "# existing");
+
+    const pi = makeMockPi();
+    const ctx = makeMockCtx();
+
+    await handleScan("--focus tech", ctx as never, pi as never);
+
+    const warning = ctx.notifications.find((n) => n.level === "warning");
+    assert.ok(warning, "should warn about existing documents");
+    assert.ok(warning.text.includes("STACK.md"), "warning should name the existing file");
+  });
+});

package/src/resources/extensions/gsd/tests/commands-session-report.test.ts

@@ -0,0 +1,82 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the formatting logic used by session-report.
+// The actual handler requires runtime context (metrics module), so we
+// test the core formatting and aggregation patterns.
+
+test("session-report: format cost correctly", () => {
+  // Simple cost formatting test
+  const formatCost = (cost: number): string => {
+    if (cost < 0.01) return "<$0.01";
+    return `$${cost.toFixed(2)}`;
+  };
+
+  assert.equal(formatCost(0), "<$0.01");
+  assert.equal(formatCost(0.005), "<$0.01");
+  assert.equal(formatCost(1.5), "$1.50");
+  assert.equal(formatCost(10.999), "$11.00");
+});
+
+test("session-report: format token count", () => {
+  const formatTokenCount = (count: number): string => {
+    if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+    if (count >= 1_000) return `${(count / 1_000).toFixed(1)}K`;
+    return String(count);
+  };
+
+  assert.equal(formatTokenCount(500), "500");
+  assert.equal(formatTokenCount(1500), "1.5K");
+  assert.equal(formatTokenCount(1_200_000), "1.2M");
+});
+
+test("session-report: aggregate by model", () => {
+  interface UnitMetric {
+    model: string;
+    cost: number;
+  }
+
+  const units: UnitMetric[] = [
+    { model: "opus", cost: 1.0 },
+    { model: "opus", cost: 0.8 },
+    { model: "sonnet", cost: 0.3 },
+    { model: "sonnet", cost: 0.5 },
+    { model: "sonnet", cost: 0.2 },
+  ];
+
+  const byModel = new Map<string, { count: number; cost: number }>();
+  for (const u of units) {
+    const existing = byModel.get(u.model) ?? { count: 0, cost: 0 };
+    existing.count++;
+    existing.cost += u.cost;
+    byModel.set(u.model, existing);
+  }
+
+  const opus = byModel.get("opus")!;
+  assert.equal(opus.count, 2);
+  assert.ok(Math.abs(opus.cost - 1.8) < 0.01);
+
+  const sonnet = byModel.get("sonnet")!;
+  assert.equal(sonnet.count, 3);
+  assert.ok(Math.abs(sonnet.cost - 1.0) < 0.01);
+});
+
+test("session-report: --json flag detection", () => {
+  const args1 = "--json";
+  const args2 = "--save --json";
+  const args3 = "something else";
+
+  assert.ok(args1.includes("--json"));
+  assert.ok(args2.includes("--json"));
+  assert.ok(!args3.includes("--json"));
+});
+
+test("session-report: --save flag detection", () => {
+  const args1 = "--save";
+  const args2 = "--save --json";
+  const args3 = "";
+
+  assert.ok(args1.includes("--save"));
+  assert.ok(args2.includes("--save"));
+  assert.ok(!args3.includes("--save"));
+});

package/src/resources/extensions/gsd/tests/commands-ship.test.ts

@@ -0,0 +1,71 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the PR content generation logic used by /gsd ship.
+// Full integration requires gh CLI + git, so we test the text generation.
+
+test("ship: generates TL;DR format", () => {
+  // Simulate generatePRContent output structure
+  const milestoneId = "M001";
+  const milestoneTitle = "User authentication system";
+
+  const title = `feat: ${milestoneTitle}`;
+  assert.equal(title, "feat: User authentication system");
+  assert.ok(title.length < 80); // PR title should be short
+});
+
+test("ship: --dry-run flag detection", () => {
+  const args1 = "--dry-run";
+  const args2 = "--draft --dry-run";
+  const args3 = "--draft";
+
+  assert.ok(args1.includes("--dry-run"));
+  assert.ok(args2.includes("--dry-run"));
+  assert.ok(!args3.includes("--dry-run"));
+});
+
+test("ship: --base flag parsing", () => {
+  const args = "--base develop --draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.ok(baseMatch);
+  assert.equal(baseMatch[1], "develop");
+});
+
+test("ship: --base flag absent defaults", () => {
+  const args = "--draft";
+  const baseMatch = args.match(/--base\s+(\S+)/);
+  assert.equal(baseMatch, null);
+});
+
+test("ship: --force flag detection", () => {
+  const args1 = "--force";
+  const args2 = "";
+
+  assert.ok(args1.includes("--force"));
+  assert.ok(!args2.includes("--force"));
+});
+
+test("ship: change type checklist format", () => {
+  const checklist = [
+    "- [x] `feat` — New feature or capability",
+    "- [ ] `fix` — Bug fix",
+    "- [ ] `refactor` — Code restructuring",
+    "- [ ] `test` — Adding or updating tests",
+    "- [ ] `docs` — Documentation only",
+    "- [ ] `chore` — Build, CI, or tooling changes",
+  ];
+
+  // Verify format matches CONTRIBUTING.md expectations
+  for (const line of checklist) {
+    assert.match(line, /^- \[[ x]\] `\w+` — .+$/);
+  }
+});
+
+test("ship: PR body contains required sections", () => {
+  const requiredSections = ["## TL;DR", "## Change type"];
+  const body = "## TL;DR\n\n**What:** Ship M001\n\n## Change type\n\n- [x] `feat`";
+
+  for (const section of requiredSections) {
+    assert.ok(body.includes(section), `Missing section: ${section}`);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-workflow-custom.test.ts

@@ -119,13 +119,15 @@ describe("workflow catalog registration", () => {
     assert.ok(entry!.desc.includes("run"), "description should mention run");
   });
 
-  it("getGsdArgumentCompletions('workflow ') returns six subcommands", () => {
+  it("getGsdArgumentCompletions('workflow ') returns the full subcommand set", () => {
     const completions = getGsdArgumentCompletions("workflow ");
     const labels = completions.map((c: any) => c.label);
-    for (const sub of ["new", "run", "list", "validate", "pause", "resume"]) {
+    for (const sub of [
+      "new", "run", "list", "info", "install", "uninstall", "validate", "pause", "resume",
+    ]) {
       assert.ok(labels.includes(sub), `missing completion: ${sub}`);
     }
-    assert.equal(labels.length, 6, "should have exactly 6 subcommands");
+    assert.equal(labels.length, 9, "should have exactly 9 subcommands");
   });
 
   it("getGsdArgumentCompletions('workflow r') filters to run and resume", () => {
@@ -190,12 +192,12 @@ describe("workflow command handler", () => {
     return { handled, notifications: ctx.notifications };
   }
 
-  it("bare '/gsd workflow' shows usage", async () => {
+  it("bare '/gsd workflow' lists plugins grouped by mode", async () => {
     const { handled, notifications } = await callHandler("workflow");
     assert.ok(handled, "should be handled");
     assert.ok(
-      notifications.some((n) => n.message.includes("Usage: /gsd workflow")),
-      "should show usage",
+      notifications.some((n) => n.message.includes("Workflow Plugins")),
+      "should list plugins",
     );
   });
 
@@ -217,6 +219,20 @@ describe("workflow command handler", () => {
     );
   });
 
+  it("preserves quoted workflow run overrides (#4130)", async () => {
+    const { parseWorkflowRunArgs } = await import("../commands/handlers/workflow.ts");
+    assert.deepStrictEqual(
+      parseWorkflowRunArgs('demo-workflow target="multi word target" region=\'us east\''),
+      {
+        defName: "demo-workflow",
+        overrides: {
+          target: "multi word target",
+          region: "us east",
+        },
+      },
+    );
+  });
+
   it("'/gsd workflow run nonexistent' shows error for missing definition", async () => {
     const { handled, notifications } = await callHandler("workflow run nonexistent-def-12345");
     assert.ok(handled, "should be handled");

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

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v17 with ADR-011 P2 escalation columns)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 17, 'schema version should be 17');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();
@@ -231,13 +231,11 @@ console.log('\n=== complete-slice: handler happy path ===');
     assertMatch(uatContent, /Milestone:\*\* M001/, 'UAT should reference milestone');
     assertMatch(uatContent, /Smoke Test/, 'UAT should contain smoke test from params');
 
-    // (c) Verify roadmap shows S01 complete (✅) and S02 pending (⬜) in table format
-    // Projection renders roadmap as a Slice Overview table, not checkbox list
+    // (c) Verify roadmap shows S01 complete ([x]) and S02 pending ([ ]) in checkbox list.
+    // Authoritative renderer (renderRoadmapFromDb) emits a checkbox list (#4402).
     const roadmapContent = fs.readFileSync(roadmapPath, 'utf-8');
-    assertMatch(roadmapContent, /\| S01 \|/, 'S01 should appear in roadmap table');
-    assertTrue(roadmapContent.includes('✅'), 'completed S01 should show ✅ in roadmap table');
-    assertMatch(roadmapContent, /\| S02 \|/, 'S02 should appear in roadmap table');
-    assertTrue(roadmapContent.includes('⬜'), 'pending S02 should show ⬜ in roadmap table');
+    assertMatch(roadmapContent, /- \[x\] \*\*S01:/, 'completed S01 should be a checked checkbox list item');
+    assertMatch(roadmapContent, /- \[ \] \*\*S02:/, 'pending S02 should be an unchecked checkbox list item');
 
     // (d) Verify full_summary_md and full_uat_md stored in DB for D004 recovery
     const sliceAfter = getSlice('M001', 'S01');

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v17 with ADR-011 P2 escalation columns)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 17, 'schema version should be 17');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(