gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.84a383f51

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

@@ -1,220 +1,147 @@
 /**
- * Budget Prediction — unit tests for M004/S04.
+ * budget-prediction.test.ts — unit tests for budget prediction math
+ * (`getAverageCostPerUnitType`, `predictRemainingCost`) exported from
+ * `metrics.ts`.
  *
- * Tests prediction math, auto-downgrade logic, and dashboard integration.
- * Uses extracted pure functions (avoiding module import chain) and
- * source-level structural checks for dashboard/auto.ts integration.
+ * The previous version (PR #582, `972dd05f4`) re-implemented both
+ * functions inline, citing a `paths.js → @gsd/pi-coding-agent` import
+ * chain as the reason. That chain concern is no longer valid — the
+ * real exports import cleanly from `metrics.ts`. All 10 math tests
+ * were then exercising the test's own copy of the functions, not the
+ * product code. #4840 documented the false-coverage case.
+ *
+ * This rewrite imports the real functions, deletes the inline copies,
+ * drops the 3 source-grep tests (`metricsSrc.includes(...)`) and the
+ * 2 dashboard `includes` tests (dashboard integration should be a
+ * behaviour test against the dashboard builder, not a grep), and
+ * deletes the synthesized `downgrade:` test that exercised a local
+ * closure instead of product code. See #4784 / #4840.
  */
 
-import test from "node:test";
+import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const metricsSrc = readFileSync(join(__dirname, "..", "metrics.ts"), "utf-8");
-const dashboardSrc = readFileSync(join(__dirname, "..", "auto-dashboard.ts"), "utf-8");
-
-// ─── Extract pure functions from metrics.ts source ────────────────────────
-// Can't import directly due to paths.js → @gsd/pi-coding-agent import chain.
-// Extract and evaluate the pure math functions.
-
-interface MockUnitMetrics {
-  type: string;
-  cost: number;
-}
-
-// Re-implement the functions under test (verified against source below)
-function getAverageCostPerUnitType(units: MockUnitMetrics[]): Map<string, number> {
-  const sums = new Map<string, { total: number; count: number }>();
-  for (const u of units) {
-    const entry = sums.get(u.type) ?? { total: 0, count: 0 };
-    entry.total += u.cost;
-    entry.count += 1;
-    sums.set(u.type, entry);
-  }
-  const avgs = new Map<string, number>();
-  for (const [type, { total, count }] of sums) {
-    avgs.set(type, total / count);
-  }
-  return avgs;
-}
 
-function predictRemainingCost(
-  avgCosts: Map<string, number>,
-  remainingUnits: string[],
-  fallbackAvg?: number,
-): number {
-  const allAvgs = [...avgCosts.values()];
-  const overallAvg = fallbackAvg ?? (allAvgs.length > 0 ? allAvgs.reduce((a, b) => a + b, 0) / allAvgs.length : 0);
-  let total = 0;
-  for (const unitType of remainingUnits) {
-    total += avgCosts.get(unitType) ?? overallAvg;
-  }
-  return total;
+import {
+  getAverageCostPerUnitType,
+  predictRemainingCost,
+} from "../metrics.ts";
+import type { UnitMetrics } from "../metrics.ts";
+
+// ─── Fixture helper ───────────────────────────────────────────────────────
+// UnitMetrics has several required fields; this builder lets each test
+// specify only the fields that matter for the cost math.
+
+function makeUnit(partial: Partial<UnitMetrics> & { type: string; cost: number }): UnitMetrics {
+  return {
+    id: "M001/S01/T01",
+    model: "test-model",
+    startedAt: 0,
+    finishedAt: 0,
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    toolCalls: 0,
+    assistantMessages: 0,
+    userMessages: 0,
+    ...partial,
+  };
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Source Verification — confirm our re-implementation matches
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("source: metrics.ts exports getAverageCostPerUnitType", () => {
-  assert.ok(metricsSrc.includes("export function getAverageCostPerUnitType"), "should be exported");
-});
-
-test("source: metrics.ts exports predictRemainingCost", () => {
-  assert.ok(metricsSrc.includes("export function predictRemainingCost"), "should be exported");
-});
-
-test("source: getAverageCostPerUnitType uses Map<string, number>", () => {
-  assert.ok(
-    metricsSrc.includes("Map<string, number>") && metricsSrc.includes("getAverageCostPerUnitType"),
-    "should return Map<string, number>",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Average Cost Per Unit Type
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("avgCost: returns correct averages per unit type", () => {
-  const units: MockUnitMetrics[] = [
-    { type: "execute-task", cost: 0.10 },
-    { type: "execute-task", cost: 0.20 },
-    { type: "plan-slice", cost: 0.05 },
-    { type: "plan-slice", cost: 0.15 },
-    { type: "complete-slice", cost: 0.08 },
-  ];
-  const avgs = getAverageCostPerUnitType(units);
-  assert.ok(Math.abs(avgs.get("execute-task")! - 0.15) < 0.001, "execute-task avg should be 0.15");
-  assert.ok(Math.abs(avgs.get("plan-slice")! - 0.10) < 0.001, "plan-slice avg should be 0.10");
-  assert.ok(Math.abs(avgs.get("complete-slice")! - 0.08) < 0.001, "complete-slice avg should be 0.08");
-});
-
-test("avgCost: returns empty map for empty input", () => {
-  const avgs = getAverageCostPerUnitType([]);
-  assert.equal(avgs.size, 0);
-});
-
-test("avgCost: single unit per type returns exact cost", () => {
-  const avgs = getAverageCostPerUnitType([{ type: "execute-task", cost: 0.42 }]);
-  assert.ok(Math.abs(avgs.get("execute-task")! - 0.42) < 0.001);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Predict Remaining Cost
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("predict: calculates remaining cost from averages", () => {
-  const avgs = new Map([
-    ["execute-task", 0.15],
-    ["plan-slice", 0.10],
-    ["complete-slice", 0.08],
-  ]);
-  const remaining = ["execute-task", "execute-task", "complete-slice"];
-  const cost = predictRemainingCost(avgs, remaining);
-  assert.ok(Math.abs(cost - 0.38) < 0.001);
-});
-
-test("predict: uses overall average for unknown unit types", () => {
-  const avgs = new Map([
-    ["execute-task", 0.10],
-    ["plan-slice", 0.20],
-  ]);
-  const remaining = ["execute-task", "unknown-type"];
-  const cost = predictRemainingCost(avgs, remaining);
-  // unknown: (0.10 + 0.20) / 2 = 0.15 → total 0.10 + 0.15 = 0.25
-  assert.ok(Math.abs(cost - 0.25) < 0.001);
-});
-
-test("predict: returns 0 for empty remaining", () => {
-  const avgs = new Map([["execute-task", 0.15]]);
-  assert.equal(predictRemainingCost(avgs, []), 0);
-});
-
-test("predict: handles no averages with fallback", () => {
-  const avgs = new Map<string, number>();
-  const cost = predictRemainingCost(avgs, ["execute-task", "plan-slice"], 0.10);
-  assert.ok(Math.abs(cost - 0.20) < 0.001);
-});
-
-test("predict: handles no averages and no fallback", () => {
-  const avgs = new Map<string, number>();
-  const cost = predictRemainingCost(avgs, ["execute-task"]);
-  assert.equal(cost, 0);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Dashboard Integration
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("dashboard: AutoDashboardData includes projectedRemainingCost field", () => {
-  assert.ok(
-    dashboardSrc.includes("projectedRemainingCost"),
-    "AutoDashboardData should have projectedRemainingCost field",
-  );
-});
-
-test("dashboard: AutoDashboardData includes profileDowngraded field", () => {
-  assert.ok(
-    dashboardSrc.includes("profileDowngraded"),
-    "AutoDashboardData should have profileDowngraded field",
-  );
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Budget Prediction — End-to-End Math
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("e2e: budget ceiling exceeded triggers downgrade prediction", () => {
-  const units: MockUnitMetrics[] = [
-    { type: "execute-task", cost: 0.50 },
-    { type: "execute-task", cost: 0.60 },
-    { type: "plan-slice", cost: 0.30 },
-    { type: "complete-slice", cost: 0.20 },
-  ];
-  const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 1.60
-  const avgs = getAverageCostPerUnitType(units);
-  const remaining = ["execute-task", "execute-task", "execute-task"];
-  const predictedRemaining = predictRemainingCost(avgs, remaining);
-  const predictedTotal = totalSpent + predictedRemaining;
-  const budgetCeiling = 2.50;
-  assert.ok(predictedTotal > budgetCeiling, "should predict budget exhaustion");
-});
-
-test("e2e: budget ceiling not exceeded does not trigger", () => {
-  const units: MockUnitMetrics[] = [
-    { type: "execute-task", cost: 0.10 },
-    { type: "plan-slice", cost: 0.05 },
-  ];
-  const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 0.15
-  const avgs = getAverageCostPerUnitType(units);
-  const remaining = ["execute-task", "complete-slice"];
-  const predictedRemaining = predictRemainingCost(avgs, remaining);
-  const predictedTotal = totalSpent + predictedRemaining;
-  const budgetCeiling = 5.00;
-  assert.ok(predictedTotal <= budgetCeiling, "should not predict budget exhaustion");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Downgrade Logic
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("downgrade: one-way per D048 — downgrade should not be reversible", () => {
-  // Simulate: first prediction triggers downgrade, second doesn't reverse it
-  let downgraded = false;
-
-  function checkDowngrade(predictedTotal: number, ceiling: number) {
-    if (!downgraded && predictedTotal > ceiling) {
-      downgraded = true;
-    }
-    // Never reverse — per D048
-  }
-
-  checkDowngrade(3.00, 2.50); // triggers
-  assert.ok(downgraded, "should downgrade when prediction exceeds ceiling");
-
-  checkDowngrade(1.50, 2.50); // doesn't reverse
-  assert.ok(downgraded, "should stay downgraded (one-way per D048)");
+describe("getAverageCostPerUnitType (metrics.ts)", () => {
+  test("returns correct averages per unit type", () => {
+    const units = [
+      makeUnit({ type: "execute-task", cost: 0.1 }),
+      makeUnit({ type: "execute-task", cost: 0.2 }),
+      makeUnit({ type: "plan-slice", cost: 0.05 }),
+      makeUnit({ type: "plan-slice", cost: 0.15 }),
+      makeUnit({ type: "complete-slice", cost: 0.08 }),
+    ];
+    const avgs = getAverageCostPerUnitType(units);
+    assert.ok(Math.abs(avgs.get("execute-task")! - 0.15) < 0.001, "execute-task avg");
+    assert.ok(Math.abs(avgs.get("plan-slice")! - 0.10) < 0.001, "plan-slice avg");
+    assert.ok(Math.abs(avgs.get("complete-slice")! - 0.08) < 0.001, "complete-slice avg");
+  });
+
+  test("returns empty map for empty input", () => {
+    assert.equal(getAverageCostPerUnitType([]).size, 0);
+  });
+
+  test("single unit per type returns exact cost", () => {
+    const avgs = getAverageCostPerUnitType([makeUnit({ type: "execute-task", cost: 0.42 })]);
+    assert.ok(Math.abs(avgs.get("execute-task")! - 0.42) < 0.001);
+  });
+});
+
+describe("predictRemainingCost (metrics.ts)", () => {
+  test("calculates remaining cost from known averages", () => {
+    const avgs = new Map([
+      ["execute-task", 0.15],
+      ["plan-slice", 0.10],
+      ["complete-slice", 0.08],
+    ]);
+    const remaining = ["execute-task", "execute-task", "complete-slice"];
+    const cost = predictRemainingCost(avgs, remaining);
+    // 2 × 0.15 + 0.08 = 0.38
+    assert.ok(Math.abs(cost - 0.38) < 0.001);
+  });
+
+  test("uses overall average for unknown unit types", () => {
+    const avgs = new Map([
+      ["execute-task", 0.10],
+      ["plan-slice", 0.20],
+    ]);
+    const remaining = ["execute-task", "unknown-type"];
+    // unknown: (0.10 + 0.20) / 2 = 0.15 → total 0.10 + 0.15 = 0.25
+    assert.ok(Math.abs(predictRemainingCost(avgs, remaining) - 0.25) < 0.001);
+  });
+
+  test("returns 0 for empty remaining list", () => {
+    const avgs = new Map([["execute-task", 0.15]]);
+    assert.equal(predictRemainingCost(avgs, []), 0);
+  });
+
+  test("uses fallback when no averages are known", () => {
+    const cost = predictRemainingCost(new Map(), ["execute-task", "plan-slice"], 0.10);
+    assert.ok(Math.abs(cost - 0.20) < 0.001);
+  });
+
+  test("returns 0 when no averages and no fallback", () => {
+    assert.equal(predictRemainingCost(new Map(), ["execute-task"]), 0);
+  });
+});
+
+describe("end-to-end budget prediction (composes the real functions)", () => {
+  test("budget ceiling exceeded is detectable from real averages + projection", () => {
+    const units = [
+      makeUnit({ type: "execute-task", cost: 0.5 }),
+      makeUnit({ type: "execute-task", cost: 0.6 }),
+      makeUnit({ type: "plan-slice", cost: 0.3 }),
+      makeUnit({ type: "complete-slice", cost: 0.2 }),
+    ];
+    const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 1.60
+    const avgs = getAverageCostPerUnitType(units);
+    const predicted = predictRemainingCost(avgs, [
+      "execute-task",
+      "execute-task",
+      "execute-task",
+    ]);
+    // avg execute-task = 0.55, predicted remaining = 3 × 0.55 = 1.65
+    // total = 1.60 + 1.65 = 3.25 > 2.50 ceiling
+    assert.ok(
+      totalSpent + predicted > 2.5,
+      "spent + predicted should exceed test ceiling",
+    );
+  });
+
+  test("budget ceiling not exceeded when averages stay low", () => {
+    const units = [
+      makeUnit({ type: "execute-task", cost: 0.1 }),
+      makeUnit({ type: "plan-slice", cost: 0.05 }),
+    ];
+    const totalSpent = units.reduce((sum, u) => sum + u.cost, 0); // 0.15
+    const avgs = getAverageCostPerUnitType(units);
+    const predicted = predictRemainingCost(avgs, ["execute-task", "complete-slice"]);
+    assert.ok(
+      totalSpent + predicted <= 5.0,
+      "spent + predicted should stay under test ceiling",
+    );
+  });
 });

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

@@ -1,73 +1,156 @@
 /**
- * Regression test for #3580 — complete-slice verification gate
+ * Behavioural regression test for #3580 — complete-slice verification gate.
  *
- * Without the gate, a prompt regression could silently advance a blocked
- * or failed slice to "complete" status. The fix adds a BLOCKED_SIGNALS
- * regex that rejects completion when verification/UAT content clearly
- * indicates blocked or failed state.
+ * The gate must reject completion when the verification or UAT content
+ * indicates a blocked or failed slice. Drives the real handler with
+ * blocked-signal fixtures and asserts on the returned error. Replaces an
+ * earlier test file that only string-matched the BLOCKED_SIGNALS regex
+ * literal in the source (Refs #4826/#4831).
  */
 
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { extractSourceRegion } from "./test-helpers.ts";
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'tools', 'complete-slice.ts'),
-  'utf-8',
-)
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from '../gsd-db.ts';
+import { handleCompleteSlice } from '../tools/complete-slice.ts';
+import type { CompleteSliceParams } from '../types.ts';
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-blocked-gate-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanupDb(dbPath: string): void {
+  closeDatabase();
+  try { fs.rmSync(path.dirname(dbPath), { recursive: true, force: true }); } catch { /* */ }
+}
+
+function makeProject(): string {
+  const basePath = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-gate-proj-'));
+  fs.mkdirSync(path.join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
+  fs.writeFileSync(
+    path.join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md'),
+    `# M001\n\n## Slices\n- [ ] **S01: Test** \`risk:low\` \`depends:[]\`\n  - After this: works\n`,
+  );
+  return basePath;
+}
+
+function makeParams(overrides: Partial<CompleteSliceParams>): CompleteSliceParams {
+  return {
+    sliceId: 'S01',
+    milestoneId: 'M001',
+    sliceTitle: 'Test Slice',
+    oneLiner: 'one liner',
+    narrative: 'narrative',
+    verification: 'all green',
+    deviations: 'None.',
+    knownLimitations: 'None.',
+    followUps: 'None.',
+    keyFiles: [],
+    keyDecisions: [],
+    patternsEstablished: [],
+    observabilitySurfaces: [],
+    provides: [],
+    requirementsSurfaced: [],
+    drillDownPaths: [],
+    affects: [],
+    requirementsAdvanced: [],
+    requirementsValidated: [],
+    requirementsInvalidated: [],
+    filesModified: [],
+    requires: [],
+    uatContent: 'UAT body.',
+    ...overrides,
+  };
+}
 
 describe('complete-slice verification gate (#3580)', () => {
-  it('BLOCKED_SIGNALS regex is defined', () => {
-    assert.ok(
-      src.includes('BLOCKED_SIGNALS'),
-      'BLOCKED_SIGNALS constant must be defined in complete-slice.ts',
-    )
-  })
+  let dbPath: string;
+  let basePath: string;
+
+  beforeEach(() => {
+    dbPath = tempDbPath();
+    openDatabase(dbPath);
+    basePath = makeProject();
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', status: 'complete', title: 'T1' });
+  });
 
-  it('BLOCKED_SIGNALS is a regex that tests verification content', () => {
-    // Extract the BLOCKED_SIGNALS definition line
-    const idx = src.indexOf('BLOCKED_SIGNALS')
-    assert.ok(idx !== -1)
-    const lineEnd = src.indexOf(';', idx)
-    const definition = src.slice(idx, lineEnd)
+  afterEach(() => {
+    cleanupDb(dbPath);
+    try { fs.rmSync(basePath, { recursive: true, force: true }); } catch { /* */ }
+  });
 
-    // Must be a regex (starts with /)
-    assert.ok(
-      definition.includes('= /'),
-      'BLOCKED_SIGNALS must be assigned a regex literal',
-    )
+  test('rejects when verification text contains "verification failed"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'verification failed: the regression came back' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-    // Must match key blocked/failed signals
-    assert.ok(definition.includes('blocked'), 'regex must match "blocked" signals')
-    assert.ok(definition.includes('failed'), 'regex must match "failed" signals')
-  })
+  test('rejects when uatContent contains "verification_result: failed"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: '## Result\nverification_result: failed\n' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-  it('gate checks params.verification and params.uatContent', () => {
-    // Find usage of BLOCKED_SIGNALS.test
-    const testCalls = src.match(/BLOCKED_SIGNALS\.test\([^)]+\)/g)
-    assert.ok(testCalls, 'BLOCKED_SIGNALS.test() must be called')
-    assert.ok(testCalls.length >= 2, 'must check at least verification and uatContent')
+  test('rejects when verification declares "status: blocked"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'status: blocked — db unavailable' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-    const joined = testCalls.join(' ')
-    assert.ok(joined.includes('verification'), 'must test params.verification')
-    assert.ok(joined.includes('uatContent'), 'must test params.uatContent')
-  })
+  test('rejects when uatContent says "slice is blocked"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ uatContent: 'slice is blocked on upstream' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-  it('gate returns an error message when blocked signals detected', () => {
-    // Find the return statement after BLOCKED_SIGNALS check
-    const gateIdx = src.indexOf('BLOCKED_SIGNALS.test(')
-    assert.ok(gateIdx !== -1)
+  test('rejects when verification says "cannot complete"', async () => {
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'cannot complete: requirements unmet' }),
+      basePath,
+    );
+    assert.ok('error' in result, 'expected handler to return an error');
+    assert.match((result as { error: string }).error, /blocked|failed|do not complete/i);
+  });
 
-    const afterGate = extractSourceRegion(src, 'BLOCKED_SIGNALS.test(')
-    assert.ok(
-      afterGate.includes('return { error:'),
-      'blocked signal detection must return an error',
-    )
-    assert.ok(
-      afterGate.includes('do not complete'),
-      'error message must explain why completion is rejected',
-    )
-  })
-})
+  test('passes the gate when verification + uatContent are clean', async () => {
+    // Sanity: the gate is not over-eager. Clean inputs reach the rest of
+    // the handler. (This call may still fail downstream because we provide
+    // a thin fixture; the only guarantee here is that the error — if any —
+    // is NOT the blocked-signals error.)
+    const result = await handleCompleteSlice(
+      makeParams({ verification: 'all 8 sections pass', uatContent: 'green across the board' }),
+      basePath,
+    );
+    if ('error' in result) {
+      assert.doesNotMatch(
+        result.error,
+        /blocked\/failed state — do not complete/,
+        `clean inputs should not be rejected by the BLOCKED_SIGNALS gate, got: ${result.error}`,
+      );
+    }
+  });
+});

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

@@ -13,6 +13,7 @@ import {
   getSlice,
   updateSliceStatus,
   getSliceTasks,
+  SCHEMA_VERSION,
 } from '../gsd-db.ts';
 import { handleCompleteSlice } from '../tools/complete-slice.ts';
 import type { CompleteSliceParams } from '../types.ts';
@@ -115,19 +116,21 @@ Run the test suite and verify all assertions pass.
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// complete-slice: Schema v6 migration
+// complete-slice: fresh DB migrates to current schema version
 // ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n=== complete-slice: schema v6 migration ===');
+console.log('\n=== complete-slice: fresh DB migrates to current schema version ===');
 {
   const dbPath = tempDbPath();
   openDatabase(dbPath);
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v22 — quality_gates DDL fix)
+  // Pin schema version against the source-of-truth constant so this test
+  // survives migration bumps but still catches a "fresh DB was not migrated"
+  // regression.
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 22, 'schema version should be 22');
+  assertEq(versionRow?.['v'], SCHEMA_VERSION, 'fresh DB should be migrated to current SCHEMA_VERSION');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();