gsd-pi 2.75.0-dev.2203010a0 → 2.75.0-dev.96d4bb599

package/src/resources/extensions/gsd/memory-store.ts

@@ -15,7 +15,10 @@ import {
   markMemoryUnitProcessed,
   decayMemoriesBefore,
   supersedeLowestRankedMemories,
+  deleteMemoryEmbedding,
+  deleteMemoryRelationsFor,
 } from './gsd-db.js';
+import { createMemoryRelation, isValidRelation } from './memory-relations.js';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -31,6 +34,8 @@ export interface Memory {
   updated_at: string;
   superseded_by: string | null;
   hit_count: number;
+  scope: string;
+  tags: string[];
 }
 
 export type MemoryActionCreate = {
@@ -38,6 +43,8 @@ export type MemoryActionCreate = {
   category: string;
   content: string;
   confidence?: number;
+  scope?: string;
+  tags?: string[];
 };
 
 export type MemoryActionUpdate = {
@@ -58,11 +65,20 @@ export type MemoryActionSupersede = {
   superseded_by: string;
 };
 
+export type MemoryActionLink = {
+  action: 'LINK';
+  from: string;
+  to: string;
+  rel: string;
+  confidence?: number;
+};
+
 export type MemoryAction =
   | MemoryActionCreate
   | MemoryActionUpdate
   | MemoryActionReinforce
-  | MemoryActionSupersede;
+  | MemoryActionSupersede
+  | MemoryActionLink;
 
 // ─── Category Display Order ─────────────────────────────────────────────────
 
@@ -90,9 +106,21 @@ function rowToMemory(row: Record<string, unknown>): Memory {
     updated_at: row['updated_at'] as string,
     superseded_by: (row['superseded_by'] as string) ?? null,
     hit_count: row['hit_count'] as number,
+    scope: (row['scope'] as string) ?? 'project',
+    tags: parseTags(row['tags']),
   };
 }
 
+function parseTags(raw: unknown): string[] {
+  if (typeof raw !== 'string' || raw.length === 0) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((t): t is string => typeof t === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
 // ─── Query Functions ────────────────────────────────────────────────────────
 
 /**
@@ -134,6 +162,280 @@ export function getActiveMemoriesRanked(limit = 30): Memory[] {
   }
 }
 
+// ─── Hybrid query (keyword FTS + optional semantic) ─────────────────────────
+
+export interface QueryMemoriesFilters {
+  category?: string;
+  scope?: string;
+  tag?: string;
+  include_superseded?: boolean;
+}
+
+export interface QueryMemoriesOptions extends QueryMemoriesFilters {
+  query: string;
+  k?: number;
+  /**
+   * Optional query-side embedding. When provided and embeddings exist in the
+   * DB, results are fused with cosine similarity via reciprocal-rank-fusion.
+   */
+  queryVector?: Float32Array | null;
+  /** RRF fusion constant (default 60). */
+  rrfK?: number;
+}
+
+export interface RankedMemory {
+  memory: Memory;
+  score: number;
+  keywordRank: number | null;
+  semanticRank: number | null;
+  confidenceBoost: number;
+  reason: 'keyword' | 'semantic' | 'both' | 'ranked';
+}
+
+export function queryMemoriesRanked(opts: QueryMemoriesOptions): RankedMemory[] {
+  if (!isDbAvailable()) return [];
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+
+  const k = clampLimit(opts.k, 10);
+  const rrfK = opts.rrfK ?? 60;
+  const activeClause = opts.include_superseded === true ? '' : 'WHERE superseded_by IS NULL';
+  const trimmedQuery = (opts.query ?? '').trim();
+
+  // 1) Keyword hits — try FTS5 first, fall back to LIKE when unavailable.
+  const keywordHits = trimmedQuery ? keywordSearch(adapter, trimmedQuery, activeClause, 50) : [];
+
+  // 2) Semantic hits — cosine over memory_embeddings. Requires opts.queryVector.
+  const semanticHits = opts.queryVector
+    ? semanticSearch(adapter, opts.queryVector, activeClause, 50)
+    : [];
+
+  if (keywordHits.length === 0 && semanticHits.length === 0 && !trimmedQuery) {
+    // No query at all — fall back to the existing ranked-by-score listing.
+    return getActiveMemoriesRanked(k).map((memory) => ({
+      memory,
+      score: memory.confidence * (1 + memory.hit_count * 0.1),
+      keywordRank: null,
+      semanticRank: null,
+      confidenceBoost: memory.confidence * (1 + memory.hit_count * 0.1),
+      reason: 'ranked' as const,
+    })).filter((hit) => passesFilters(hit.memory, opts));
+  }
+
+  // 3) Reciprocal rank fusion — each hit contributes 1/(rrfK + rank).
+  const fused = new Map<string, { memory: Memory; kwRank: number | null; semRank: number | null; score: number }>();
+
+  for (let i = 0; i < keywordHits.length; i++) {
+    const hit = keywordHits[i];
+    const existing = fused.get(hit.id);
+    const rrf = 1 / (rrfK + i + 1);
+    if (existing) {
+      existing.kwRank = i + 1;
+      existing.score += rrf;
+    } else {
+      fused.set(hit.id, { memory: hit, kwRank: i + 1, semRank: null, score: rrf });
+    }
+  }
+
+  for (let i = 0; i < semanticHits.length; i++) {
+    const hit = semanticHits[i];
+    const existing = fused.get(hit.id);
+    const rrf = 1 / (rrfK + i + 1);
+    if (existing) {
+      existing.semRank = i + 1;
+      existing.score += rrf;
+    } else {
+      fused.set(hit.id, { memory: hit, kwRank: null, semRank: i + 1, score: rrf });
+    }
+  }
+
+  // 4) Apply filters + confidence boost, then sort.
+  const ranked: RankedMemory[] = [];
+  for (const entry of fused.values()) {
+    if (!passesFilters(entry.memory, opts)) continue;
+    const boost = entry.memory.confidence * (1 + entry.memory.hit_count * 0.1);
+    const reason: RankedMemory['reason'] =
+      entry.kwRank != null && entry.semRank != null
+        ? 'both'
+        : entry.kwRank != null
+          ? 'keyword'
+          : 'semantic';
+    ranked.push({
+      memory: entry.memory,
+      score: entry.score * boost,
+      keywordRank: entry.kwRank,
+      semanticRank: entry.semRank,
+      confidenceBoost: boost,
+      reason,
+    });
+  }
+
+  ranked.sort((a, b) => b.score - a.score);
+  return ranked.slice(0, k);
+}
+
+function clampLimit(value: unknown, fallback: number): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
+  if (value < 1) return 1;
+  if (value > 100) return 100;
+  return Math.floor(value);
+}
+
+function passesFilters(memory: Memory, filters: QueryMemoriesFilters): boolean {
+  if (filters.category && memory.category.toLowerCase() !== filters.category.toLowerCase()) return false;
+  if (filters.scope && memory.scope !== filters.scope) return false;
+  if (filters.tag) {
+    const needle = filters.tag.toLowerCase();
+    if (!memory.tags.map((t) => t.toLowerCase()).includes(needle)) return false;
+  }
+  return true;
+}
+
+function keywordSearch(
+  adapter: NonNullable<ReturnType<typeof _getAdapter>>,
+  rawQuery: string,
+  activeClause: string,
+  limit: number,
+): Memory[] {
+  const ftsAvailable = isFtsAvailable(adapter);
+  if (ftsAvailable) {
+    try {
+      const matchExpr = toFtsMatchExpr(rawQuery);
+      if (!matchExpr) return [];
+      const activePart = activeClause ? `AND m.${activeClause.replace(/^WHERE\s+/i, '')}` : '';
+      const rows = adapter.prepare(
+        `SELECT m.*
+         FROM memories_fts f
+         JOIN memories m ON m.seq = f.rowid
+         WHERE memories_fts MATCH :match
+         ${activePart}
+         ORDER BY bm25(memories_fts)
+         LIMIT :limit`,
+      ).all({ ':match': matchExpr, ':limit': limit });
+      return rows.map(rowToMemory);
+    } catch {
+      // fall through to LIKE
+    }
+  }
+
+  // LIKE fallback — scans the candidate pool.
+  const terms = rawQuery
+    .toLowerCase()
+    .split(/[^a-z0-9_]+/)
+    .filter((t) => t.length >= 2);
+  if (terms.length === 0) return [];
+
+  const rows = adapter.prepare(`SELECT * FROM memories ${activeClause}`).all();
+  const scored: Array<{ memory: Memory; score: number }> = [];
+  for (const row of rows) {
+    const memory = rowToMemory(row);
+    const lower = memory.content.toLowerCase();
+    let score = 0;
+    for (const term of terms) {
+      const idx = lower.indexOf(term);
+      if (idx === -1) continue;
+      score += 1 + (term.length >= 5 ? 0.5 : 0);
+    }
+    if (score > 0) scored.push({ memory, score });
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit).map((s) => s.memory);
+}
+
+function isFtsAvailable(adapter: NonNullable<ReturnType<typeof _getAdapter>>): boolean {
+  try {
+    const row = adapter
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'")
+      .get();
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+
+function toFtsMatchExpr(query: string): string | null {
+  // Build a tolerant AND expression: quote each bare term with a trailing *.
+  const tokens = query
+    .toLowerCase()
+    .split(/[^a-z0-9_]+/)
+    .filter((t) => t.length >= 2)
+    .slice(0, 8);
+  if (tokens.length === 0) return null;
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"*`).join(' OR ');
+}
+
+function semanticSearch(
+  adapter: NonNullable<ReturnType<typeof _getAdapter>>,
+  queryVector: Float32Array,
+  activeClause: string,
+  limit: number,
+): Memory[] {
+  try {
+    const rows = adapter
+      .prepare(
+        `SELECT m.*, e.vector as embedding_vector, e.dim as embedding_dim
+         FROM memories m
+         JOIN memory_embeddings e ON e.memory_id = m.id
+         ${activeClause}`,
+      )
+      .all();
+
+    const scored: Array<{ memory: Memory; sim: number }> = [];
+    for (const row of rows) {
+      const dim = row['embedding_dim'] as number;
+      if (dim !== queryVector.length) continue;
+      const vector = unpackVector(row['embedding_vector'], dim);
+      if (!vector) continue;
+      const sim = cosine(queryVector, vector);
+      if (sim <= 0) continue;
+      scored.push({ memory: rowToMemory(row), sim });
+    }
+    scored.sort((a, b) => b.sim - a.sim);
+    return scored.slice(0, limit).map((s) => s.memory);
+  } catch {
+    return [];
+  }
+}
+
+function unpackVector(blob: unknown, dim: number): Float32Array | null {
+  if (!blob) return null;
+  try {
+    let view: Uint8Array | null = null;
+    if (blob instanceof Float32Array) return blob;
+    if (blob instanceof Uint8Array) view = blob;
+    else if (blob instanceof ArrayBuffer) view = new Uint8Array(blob);
+    else if ((blob as Buffer).buffer && (blob as Buffer).byteLength != null) {
+      const buf = blob as Buffer;
+      view = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    } else if (Array.isArray(blob)) {
+      return new Float32Array(blob as number[]);
+    }
+    if (!view || view.byteLength % 4 !== 0) return null;
+    const aligned = new ArrayBuffer(view.byteLength);
+    new Uint8Array(aligned).set(view);
+    const f32 = new Float32Array(aligned);
+    return f32.length === dim ? f32 : null;
+  } catch {
+    return null;
+  }
+}
+
+function cosine(a: Float32Array, b: Float32Array): number {
+  if (a.length === 0 || a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
 /**
  * Generate the next memory ID: MEM + zero-padded 3-digit from MAX(seq).
  * Returns MEM001 if no memories exist.
@@ -173,6 +475,8 @@ export function createMemory(fields: {
   confidence?: number;
   source_unit_type?: string;
   source_unit_id?: string;
+  scope?: string;
+  tags?: string[];
 }): string | null {
   if (!isDbAvailable()) return null;
   const adapter = _getAdapter();
@@ -191,6 +495,8 @@ export function createMemory(fields: {
       sourceUnitId: fields.source_unit_id ?? null,
       createdAt: now,
       updatedAt: now,
+      scope: fields.scope ?? 'project',
+      tags: fields.tags ?? [],
     });
     // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
     const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
@@ -285,11 +591,12 @@ export function markUnitProcessed(unitKey: string, activityFile: string): boolea
 /**
  * Reduce confidence for memories not updated within the last N processed units.
  * "Stale" = updated_at is older than the Nth most recent processed_at.
+ * Returns the number of decayed memory IDs for observability.
  */
-export function decayStaleMemories(thresholdUnits = 20): void {
-  if (!isDbAvailable()) return;
+export function decayStaleMemories(thresholdUnits = 20): string[] {
+  if (!isDbAvailable()) return [];
   const adapter = _getAdapter();
-  if (!adapter) return;
+  if (!adapter) return [];
 
   try {
     // Find the timestamp of the Nth most recent processed unit (read-only SELECT)
@@ -299,17 +606,24 @@ export function decayStaleMemories(thresholdUnits = 20): void {
        LIMIT 1 OFFSET :offset`,
     ).get({ ':offset': thresholdUnits - 1 });
 
-    if (!row) return; // not enough processed units yet
+    if (!row) return []; // not enough processed units yet
 
     const cutoff = row['processed_at'] as string;
+    const affected = adapter.prepare(
+      `SELECT id FROM memories
+       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`,
+    ).all({ ':cutoff': cutoff }).map((r) => r['id'] as string);
+
     decayMemoriesBefore(cutoff, new Date().toISOString());
+    return affected;
   } catch {
-    // non-fatal
+    return [];
   }
 }
 
 /**
- * Supersede lowest-ranked memories when count exceeds cap.
+ * Supersede lowest-ranked memories when count exceeds cap. Cascades to the
+ * embedding and relation rows so those tables don't grow unboundedly.
  */
 export function enforceMemoryCap(max = 50): void {
   if (!isDbAvailable()) return;
@@ -324,7 +638,21 @@ export function enforceMemoryCap(max = 50): void {
     if (count <= max) return;
 
     const excess = count - max;
+    // Capture the about-to-be-superseded IDs first so we can cascade cleanup.
+    const victims = adapter.prepare(
+      `SELECT id FROM memories
+       WHERE superseded_by IS NULL
+       ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
+       LIMIT :limit`,
+    ).all({ ':limit': excess }).map((row) => row['id'] as string);
+
     supersedeLowestRankedMemories(excess, new Date().toISOString());
+
+    if (victims.length === 0) return;
+    for (const id of victims) {
+      try { deleteMemoryEmbedding(id); } catch { /* non-fatal */ }
+      try { deleteMemoryRelationsFor(id); } catch { /* non-fatal */ }
+    }
   } catch {
     // non-fatal
   }
@@ -354,6 +682,8 @@ export function applyMemoryActions(
               confidence: action.confidence,
               source_unit_type: unitType,
               source_unit_id: unitId,
+              scope: action.scope,
+              tags: action.tags,
             });
             break;
           case 'UPDATE':
@@ -365,6 +695,9 @@ export function applyMemoryActions(
           case 'SUPERSEDE':
             supersedeMemory(action.id, action.superseded_by);
             break;
+          case 'LINK':
+            applyLinkAction(action);
+            break;
         }
       }
       enforceMemoryCap();
@@ -374,6 +707,17 @@ export function applyMemoryActions(
   }
 }
 
+// ─── LINK action ────────────────────────────────────────────────────────────
+
+function applyLinkAction(action: MemoryActionLink): void {
+  try {
+    if (!isValidRelation(action.rel)) return;
+    createMemoryRelation(action.from, action.to, action.rel, action.confidence);
+  } catch {
+    // Link failures should never break memory extraction.
+  }
+}
+
 // ─── Prompt Formatting ──────────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/model-router.ts

@@ -279,8 +279,9 @@ export function scoreEligibleModels(
   capabilityOverrides?: Record<string, Partial<ModelCapabilities>>,
 ): Array<{ modelId: string; score: number }> {
   const scored = eligibleModelIds.map(modelId => {
-    const builtin = MODEL_CAPABILITY_PROFILES[modelId];
-    const override = capabilityOverrides?.[modelId];
+    const bareId = bareModelId(modelId);
+    const builtin = MODEL_CAPABILITY_PROFILES[bareId];
+    const override = capabilityOverrides?.[modelId] ?? capabilityOverrides?.[bareId];
     const profile: ModelCapabilities = builtin
       ? override ? { ...builtin, ...override } : builtin
       : { coding: 50, debugging: 50, research: 50, reasoning: 50, speed: 50, longContext: 50, instruction: 50 };
@@ -516,7 +517,7 @@ export function defaultRoutingConfig(): DynamicRoutingConfig {
 
 function getModelTier(modelId: string): ComplexityTier {
   // Strip provider prefix if present
-  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  const bareId = bareModelId(modelId);
 
   // Check exact match first
   if (MODEL_CAPABILITY_TIER[bareId]) return MODEL_CAPABILITY_TIER[bareId];
@@ -532,7 +533,7 @@ function getModelTier(modelId: string): ComplexityTier {
 
 /** Check if a model ID has a known capability tier mapping. (#2192) */
 function isKnownModel(modelId: string): boolean {
-  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  const bareId = bareModelId(modelId);
   if (MODEL_CAPABILITY_TIER[bareId]) return true;
   for (const knownId of Object.keys(MODEL_CAPABILITY_TIER)) {
     if (bareId.includes(knownId) || knownId.includes(bareId)) return true;
@@ -541,7 +542,7 @@ function isKnownModel(modelId: string): boolean {
 }
 
 function getModelCost(modelId: string): number {
-  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  const bareId = bareModelId(modelId);
 
   if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {
     return MODEL_COST_PER_1K_INPUT[bareId];
@@ -556,6 +557,10 @@ function getModelCost(modelId: string): number {
   return 999;
 }
 
+function bareModelId(modelId: string): string {
+  return modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+}
+
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 
 /**

package/src/resources/extensions/gsd/notification-overlay.ts

@@ -3,7 +3,7 @@
 // Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
 
 import type { Theme } from "@gsd/pi-coding-agent";
-import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
 
 import {
   readNotifications,
@@ -29,25 +29,15 @@ function severityIcon(severity: NotifySeverity): string {
   }
 }
 
-/** Word-wrap plain text to fit within maxWidth columns. */
+/** Column-aware word wrap using pi-tui's native wrapper (handles unicode/ANSI). */
 function wrapText(text: string, maxWidth: number): string[] {
-  if (text.length <= maxWidth) return [text];
-  const words = text.split(/\s+/);
-  const lines: string[] = [];
-  let current = "";
-  for (const word of words) {
-    if (current.length === 0) {
-      current = word;
-    } else if (current.length + 1 + word.length <= maxWidth) {
-      current += " " + word;
-    } else {
-      lines.push(current);
-      current = word;
-    }
-  }
-  if (current.length > 0) lines.push(current);
-  // If a single word exceeds maxWidth, truncate it
-  return lines.map((l) => l.length > maxWidth ? l.slice(0, maxWidth - 1) + "…" : l);
+  if (maxWidth <= 0) return [text];
+  const lines = wrapTextWithAnsi(text, maxWidth);
+  // Safety clamp: if any line still exceeds maxWidth (e.g. unbreakable long token),
+  // truncate it with an ellipsis so it cannot bleed past the box border.
+  return lines.map((l) =>
+    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
+  );
 }
 
 function formatTimestamp(ts: string): string {

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -247,6 +247,18 @@ test("model policy receives task metadata for requirement-vector decisions", ()
   );
 });
 
+test("dynamic routing passes provider-qualified model keys to the router", () => {
+  const src = readFileSync(join(__dirname, "..", "auto-model-selection.ts"), "utf-8");
+  assert.ok(
+    src.includes("routingEligibleModels.map(m => `${m.provider}/${m.id}`)"),
+    "selectAndApplyModel should preserve provider prefixes for dynamic routing candidates",
+  );
+  assert.ok(
+    !src.includes("routingEligibleModels.map(m => m.id)"),
+    "selectAndApplyModel must not strip providers before resolving tier_models",
+  );
+});
+
 test("resolveModelId: anthropic wins over claude-code when session provider is not claude-code", () => {
   const availableModels = [
     { id: "claude-sonnet-4-6", provider: "claude-code" },

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 (v17 with ADR-011 P2 escalation columns)
+  // Verify schema version is current (v20 — memory system Phase 4 relations)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 17, 'schema version should be 17');
+  assertEq(versionRow?.['v'], 20, 'schema version should be 20');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

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 (v17 with ADR-011 P2 escalation columns)
+  // Verify schema version is current (v20 — memory system Phase 4 relations)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 17, 'schema version should be 17');
+  assertEq(versionRow?.['v'], 20, 'schema version should be 20');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(

package/src/resources/extensions/gsd/tests/escalation.test.ts

@@ -327,7 +327,7 @@ test("ADR-011 P2: listEscalationArtifacts filters to actionable by default", (t)
   assert.equal(all.length, 2, "both surface with --all");
 });
 
-test("ADR-011 P2: schema v17 fresh DB has all escalation columns on tasks + source on decisions", (t) => {
+test("ADR-011 P2: schema v20 fresh DB has all escalation columns on tasks + source on decisions", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
   openDatabase(join(base, ".gsd", "gsd.db"));
@@ -348,7 +348,7 @@ test("ADR-011 P2: schema v17 fresh DB has all escalation columns on tasks + sour
   assert.ok(decCols.includes("source"), "decisions table must have source column");
 
   const version = adapter.prepare("SELECT MAX(version) as v FROM schema_version").get();
-  assert.equal(version?.["v"], 17);
+  assert.equal(version?.["v"], 20);
 });
 
 test("ADR-011 P2: findUnappliedEscalationOverride returns null when escalation_pending=1 (still pending)", (t) => {

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

@@ -81,7 +81,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 17, 'schema version should be 17');
+    assert.deepStrictEqual(version?.['version'], 20, 'schema version should be 20');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 17, 'new DB should be at schema version 17');
+  assert.deepStrictEqual(version?.v, 20, 'new DB should be at schema version 20');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();