gsd-pi 2.75.0-dev.063e5a3 → 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/metrics.ts

@@ -90,6 +90,7 @@ export function classifyUnitPhase(unitType: string): MetricsPhase {
       return "discussion";
     case "plan-milestone":
     case "plan-slice":
+    case "refine-slice":
       return "planning";
     case "execute-task":
       return "execution";

package/src/resources/extensions/gsd/model-cost-table.ts

@@ -22,7 +22,8 @@ export interface ModelCostEntry {
  */
 export const BUNDLED_COST_TABLE: ModelCostEntry[] = [
   // Anthropic
-  { id: "claude-opus-4-6", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
+  { id: "claude-opus-4-6", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-04-16" },
+  { id: "claude-opus-4-7", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-04-16" },
   { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
   { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
   { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
@@ -55,6 +56,7 @@ export const BUNDLED_COST_TABLE: ModelCostEntry[] = [
   { id: "gpt-5.3-codex", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
   { id: "gpt-5.3-codex-spark", inputPer1k: 0.0003, outputPer1k: 0.0012, updatedAt: "2026-03-29" },
   { id: "gpt-5.4", inputPer1k: 0.005, outputPer1k: 0.02, updatedAt: "2026-03-29" },
+  { id: "gpt-5.4-mini", inputPer1k: 0.00075, outputPer1k: 0.0045, updatedAt: "2026-04-18" },
 
   // Google
   { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },

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

@@ -23,6 +23,14 @@ export interface DynamicRoutingConfig {
   budget_pressure?: boolean;       // default: true
   cross_provider?: boolean;        // default: true
   hooks?: boolean;                 // default: true
+  /**
+   * Opt into dynamic routing for flat-rate providers (e.g. claude-code,
+   * GitHub Copilot). Default false preserves the #3453 bypass that skips
+   * routing when the subscription makes per-request cost identical.
+   * Enable only when you want per-task model selection across a flat-rate
+   * subscription (e.g. haiku for research, opus for architecture). (#4386)
+   */
+  allow_flat_rate_providers?: boolean;
 }
 
 export interface RoutingDecision {
@@ -73,6 +81,7 @@ export const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
   "gpt-4.1-nano": "light",
   "gpt-5-mini": "light",
   "gpt-5-nano": "light",
+  "gpt-5.4-mini": "light",
   "gpt-5.1-codex-mini": "light",
   "gpt-5.3-codex-spark": "light",
   "gemini-2.0-flash": "light",
@@ -90,6 +99,7 @@ export const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
 
   // Heavy-tier models (most capable)
   "claude-opus-4-6": "heavy",
+  "claude-opus-4-7": "heavy",
   "claude-3-opus-latest": "heavy",
   "gpt-4-turbo": "heavy",
   "gpt-5": "heavy",
@@ -114,7 +124,8 @@ const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
   "claude-3-5-haiku-latest": 0.0008,
   "claude-sonnet-4-6": 0.003,
   "claude-sonnet-4-5-20250514": 0.003,
-  "claude-opus-4-6": 0.015,
+  "claude-opus-4-6": 0.005,
+  "claude-opus-4-7": 0.005,
   "gpt-4o-mini": 0.00015,
   "gpt-4o": 0.0025,
   "gpt-4.1": 0.002,
@@ -123,6 +134,7 @@ const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
   "gpt-5": 0.01,
   "gpt-5-mini": 0.0003,
   "gpt-5-nano": 0.0001,
+  "gpt-5.4-mini": 0.00075,
   "gpt-5-pro": 0.015,
   "gpt-5.1": 0.005,
   "gpt-5.1-codex-max": 0.003,
@@ -146,6 +158,7 @@ const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
 export const MODEL_CAPABILITY_PROFILES: Record<string, ModelCapabilities> = {
   // ── Anthropic ──────────────────────────────────────────────────────────────
   "claude-opus-4-6":              { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
+  "claude-opus-4-7":              { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
   "claude-sonnet-4-6":            { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
   "claude-sonnet-4-5-20250514":   { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
   "claude-3-5-sonnet-latest":     { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 70, instruction: 82 },
@@ -164,6 +177,7 @@ export const MODEL_CAPABILITY_PROFILES: Record<string, ModelCapabilities> = {
   "gpt-5":                        { coding: 92, debugging: 88, research: 85, reasoning: 92, speed: 40, longContext: 85, instruction: 90 },
   "gpt-5-mini":                   { coding: 62, debugging: 52, research: 48, reasoning: 52, speed: 88, longContext: 52, instruction: 74 },
   "gpt-5-nano":                   { coding: 42, debugging: 32, research: 28, reasoning: 32, speed: 95, longContext: 32, instruction: 62 },
+  "gpt-5.4-mini":                 { coding: 70, debugging: 60, research: 55, reasoning: 60, speed: 84, longContext: 60, instruction: 78 },
   "gpt-5-pro":                    { coding: 94, debugging: 90, research: 88, reasoning: 94, speed: 35, longContext: 88, instruction: 92 },
   "gpt-5.1":                      { coding: 93, debugging: 89, research: 86, reasoning: 93, speed: 42, longContext: 86, instruction: 91 },
   "gpt-5.1-codex-max":            { coding: 90, debugging: 85, research: 70, reasoning: 85, speed: 55, longContext: 75, instruction: 85 },
@@ -265,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 };
@@ -502,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];
@@ -518,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;
@@ -527,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];
@@ -542,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) ───────────────────────────
 
 /**