gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

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

@@ -1,147 +1,220 @@
 /**
- * budget-prediction.test.ts — unit tests for budget prediction math
- * (`getAverageCostPerUnitType`, `predictRemainingCost`) exported from
- * `metrics.ts`.
+ * Budget Prediction — unit tests for M004/S04.
  *
- * 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.
+ * 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.
  */
 
-import { describe, test } from "node:test";
+import 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;
+}
 
-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,
-  };
+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;
 }
 
-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",
-    );
-  });
+// ═══════════════════════════════════════════════════════════════════════════
+// 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)");
 });

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

@@ -1,156 +1,73 @@
 /**
- * Behavioural regression test for #3580 — complete-slice verification gate.
+ * Regression test for #3580 — complete-slice verification gate
  *
- * 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).
+ * 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.
  */
 
-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';
+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 {
-  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,
-  };
-}
+const src = readFileSync(
+  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'tools', 'complete-slice.ts'),
+  'utf-8',
+)
 
 describe('complete-slice verification gate (#3580)', () => {
-  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 regex is defined', () => {
+    assert.ok(
+      src.includes('BLOCKED_SIGNALS'),
+      'BLOCKED_SIGNALS constant must be defined in complete-slice.ts',
+    )
+  })
 
-  afterEach(() => {
-    cleanupDb(dbPath);
-    try { fs.rmSync(basePath, { recursive: true, force: true }); } catch { /* */ }
-  });
+  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)
 
-  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 be a regex (starts with /)
+    assert.ok(
+      definition.includes('= /'),
+      'BLOCKED_SIGNALS must be assigned a regex literal',
+    )
 
-  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);
-  });
+    // 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 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);
-  });
+  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 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);
-  });
+    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 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);
-  });
+  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('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}`,
-      );
-    }
-  });
-});
+    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',
+    )
+  })
+})

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

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