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

package/dist/resources/extensions/gsd/memory-store.js

@@ -2,7 +2,8 @@
 //
 // Storage layer for auto-learned project memories. Follows context-store.ts patterns.
 // All functions degrade gracefully: return empty results when DB unavailable, never throw.
-import { isDbAvailable, _getAdapter, transaction, insertMemoryRow, rewriteMemoryId, updateMemoryContentRow, incrementMemoryHitCount, supersedeMemoryRow, markMemoryUnitProcessed, decayMemoriesBefore, supersedeLowestRankedMemories, } from './gsd-db.js';
+import { isDbAvailable, _getAdapter, transaction, insertMemoryRow, rewriteMemoryId, updateMemoryContentRow, incrementMemoryHitCount, supersedeMemoryRow, markMemoryUnitProcessed, decayMemoriesBefore, supersedeLowestRankedMemories, deleteMemoryEmbedding, deleteMemoryRelationsFor, } from './gsd-db.js';
+import { createMemoryRelation, isValidRelation } from './memory-relations.js';
 // ─── Category Display Order ─────────────────────────────────────────────────
 const CATEGORY_PRIORITY = {
     gotcha: 0,
@@ -26,8 +27,21 @@ function rowToMemory(row) {
         updated_at: row['updated_at'],
         superseded_by: row['superseded_by'] ?? null,
         hit_count: row['hit_count'],
+        scope: row['scope'] ?? 'project',
+        tags: parseTags(row['tags']),
     };
 }
+function parseTags(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((t) => typeof t === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
 // ─── Query Functions ────────────────────────────────────────────────────────
 /**
  * Get all memories where superseded_by IS NULL.
@@ -68,6 +82,245 @@ export function getActiveMemoriesRanked(limit = 30) {
         return [];
     }
 }
+export function queryMemoriesRanked(opts) {
+    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',
+        })).filter((hit) => passesFilters(hit.memory, opts));
+    }
+    // 3) Reciprocal rank fusion — each hit contributes 1/(rrfK + rank).
+    const fused = new Map();
+    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 = [];
+    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 = 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, fallback) {
+    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, filters) {
+    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, rawQuery, activeClause, limit) {
+    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 = [];
+    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) {
+    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) {
+    // 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, queryVector, activeClause, limit) {
+    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 = [];
+        for (const row of rows) {
+            const dim = row['embedding_dim'];
+            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, dim) {
+    if (!blob)
+        return null;
+    try {
+        let view = 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.buffer && blob.byteLength != null) {
+            const buf = blob;
+            view = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        else if (Array.isArray(blob)) {
+            return new Float32Array(blob);
+        }
+        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, b) {
+    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.
@@ -121,6 +374,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 });
@@ -213,29 +468,34 @@ export function markUnitProcessed(unitKey, activityFile) {
 /**
  * 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) {
     if (!isDbAvailable())
-        return;
+        return [];
     const adapter = _getAdapter();
     if (!adapter)
-        return;
+        return [];
     try {
         // Find the timestamp of the Nth most recent processed unit (read-only SELECT)
         const row = adapter.prepare(`SELECT processed_at FROM memory_processed_units
        ORDER BY processed_at DESC
        LIMIT 1 OFFSET :offset`).get({ ':offset': thresholdUnits - 1 });
         if (!row)
-            return; // not enough processed units yet
+            return []; // not enough processed units yet
         const cutoff = row['processed_at'];
+        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']);
         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) {
     if (!isDbAvailable())
@@ -249,7 +509,24 @@ export function enforceMemoryCap(max = 50) {
         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']);
         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
@@ -274,6 +551,8 @@ export function applyMemoryActions(actions, unitType, unitId) {
                             confidence: action.confidence,
                             source_unit_type: unitType,
                             source_unit_id: unitId,
+                            scope: action.scope,
+                            tags: action.tags,
                         });
                         break;
                     case 'UPDATE':
@@ -285,6 +564,9 @@ export function applyMemoryActions(actions, unitType, unitId) {
                     case 'SUPERSEDE':
                         supersedeMemory(action.id, action.superseded_by);
                         break;
+                    case 'LINK':
+                        applyLinkAction(action);
+                        break;
                 }
             }
             enforceMemoryCap();
@@ -294,6 +576,17 @@ export function applyMemoryActions(actions, unitType, unitId) {
         // non-fatal — transaction will have rolled back
     }
 }
+// ─── LINK action ────────────────────────────────────────────────────────────
+function applyLinkAction(action) {
+    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 ──────────────────────────────────────────────────────
 /**
  * Format memories as categorized markdown for system prompt injection.

package/dist/resources/extensions/gsd/model-router.js

@@ -189,8 +189,9 @@ export function computeTaskRequirements(unitType, metadata) {
  */
 export function scoreEligibleModels(eligibleModelIds, requirements, capabilityOverrides) {
     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 = builtin
             ? override ? { ...builtin, ...override } : builtin
             : { coding: 50, debugging: 50, research: 50, reasoning: 50, speed: 50, longContext: 50, instruction: 50 };
@@ -400,7 +401,7 @@ export function defaultRoutingConfig() {
 // ─── Internal ────────────────────────────────────────────────────────────────
 function getModelTier(modelId) {
     // 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];
@@ -414,7 +415,7 @@ function getModelTier(modelId) {
 }
 /** Check if a model ID has a known capability tier mapping. (#2192) */
 function isKnownModel(modelId) {
-    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)) {
@@ -424,7 +425,7 @@ function isKnownModel(modelId) {
     return false;
 }
 function getModelCost(modelId) {
-    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];
     }
@@ -436,6 +437,9 @@ function getModelCost(modelId) {
     // Unknown cost — assume expensive to avoid routing to unknown cheap models
     return 999;
 }
+function bareModelId(modelId) {
+    return modelId.includes("/") ? modelId.split("/").pop() : modelId;
+}
 // ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
 /**
  * Check if a tool is compatible with a provider's capabilities.

package/dist/resources/extensions/gsd/notification-overlay.js

@@ -1,7 +1,7 @@
 // GSD Extension — Notification History Overlay
 // Scrollable panel showing all persisted notifications with severity filtering.
 // Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
-import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
 import { readNotifications, markAllRead, clearNotifications, onNotificationStoreChange, } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { padRight, joinColumns } from "../shared/mod.js";
@@ -15,29 +15,14 @@ function severityIcon(severity) {
         default: return "●";
     }
 }
-/** 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, maxWidth) {
-    if (text.length <= maxWidth)
+    if (maxWidth <= 0)
         return [text];
-    const words = text.split(/\s+/);
-    const lines = [];
-    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);
+    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) {
     try {