gsd-pi 2.75.0-dev.b6ad8c5f7 → 2.75.0-dev.e41b70b10

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/pre-execution-checks.js

@@ -347,10 +347,13 @@ function getExpectedOutputsUpTo(tasks, taskIndex) {
 /**
  * Check that all files referenced in task.inputs either:
  *   1. Exist on disk, OR
- *   2. Are in a prior task's expected_output
+ *   2. Are in a prior task's expected_output, OR
+ *   3. Are in the current task's own expected_output — the task produces them,
+ *      so they don't need to pre-exist (#4459, mirroring the exemption #3626
+ *      introduced for task.files).
  *
- * task.files ("files likely touched") is excluded — it intentionally includes
- * files the task will create, so they don't need to pre-exist (#3626).
+ * task.files ("files likely touched") is excluded entirely from this check —
+ * it intentionally includes files the task will create (#3626).
  *
  * All paths are normalized before comparison to ensure ./src/a.ts matches src/a.ts.
  */
@@ -359,6 +362,7 @@ export function checkFilePathConsistency(tasks, basePath) {
     for (let i = 0; i < tasks.length; i++) {
         const task = tasks[i];
         const priorOutputs = getExpectedOutputsUpTo(tasks, i);
+        const ownOutputs = new Set(task.expected_output.map(normalizeFilePath));
         const filesToCheck = [...task.inputs];
         for (const file of filesToCheck) {
             // Skip empty strings
@@ -375,21 +379,21 @@ export function checkFilePathConsistency(tasks, basePath) {
             const existsOnDisk = existsSync(absolutePath);
             // Check if file is in prior expected outputs (priorOutputs already normalized)
             const inPriorOutputs = priorOutputs.has(normalizedFile);
+            const inOwnOutputs = ownOutputs.has(normalizedFile);
             // Directory inputs are satisfied when something produces a file beneath
             // them — either a prior task or the current task itself.
             let directorySatisfied = false;
-            if (!existsOnDisk && !inPriorOutputs && isDirectoryReference(file)) {
-                const sameTaskOutputs = task.expected_output.map(normalizeFilePath);
+            if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && isDirectoryReference(file)) {
                 directorySatisfied =
                     anyOutputUnderDirectory(normalizedFile, priorOutputs) ||
-                        anyOutputUnderDirectory(normalizedFile, sameTaskOutputs);
+                        anyOutputUnderDirectory(normalizedFile, ownOutputs);
             }
-            if (!existsOnDisk && !inPriorOutputs && !directorySatisfied) {
+            if (!existsOnDisk && !inPriorOutputs && !inOwnOutputs && !directorySatisfied) {
                 results.push({
                     category: "file",
                     target: file,
                     passed: false,
-                    message: `Task ${task.id} references '${file}' which doesn't exist and isn't created by prior tasks`,
+                    message: `Task ${task.id} references '${file}' which doesn't exist and isn't created by prior or same-task outputs`,
                     blocking: true,
                 });
             }

package/dist/resources/extensions/gsd/prompts/add-tests.md

@@ -31,5 +31,6 @@ You are generating tests for recently completed GSD work.
 - Do NOT modify implementation files — only create or update test files
 - Name test files consistently with the project's conventions
 - Keep tests focused and readable
+- Tests must only reference files that are tracked in git. Do NOT import, read, or depend on paths listed in `.gitignore` — in particular GSD-local state such as `.gsd/`, `.planning/`, and `.audits/`. If a test seems to need one of those files, replace it with an inline fixture or a tracked sample; otherwise the test will fail for everyone but the author.
 
 {{skillActivation}}

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -36,7 +36,7 @@ Then:
 2. Execute the steps in the inlined task plan, adapting minor local mismatches when the surrounding code differs from the planner's snapshot
 3. Before any `Write` that creates an artifact or output file, check whether that path already exists. If it does, read it first and decide whether the work is already done, should be extended, or truly needs replacement. "Create" in the plan does **not** mean the file is missing — a prior session may already have started it.
 4. Build the real thing. If the task plan says "create login endpoint", build an endpoint that actually authenticates against a real store, not one that returns a hardcoded success response. If the task plan says "create dashboard page", build a page that renders real data from the API, not a component with hardcoded props. Stubs and mocks are for tests, not for the shipped feature.
-5. Write or update tests as part of execution — tests are verification, not an afterthought. If the slice plan defines test files in its Verification section and this is the first task, create them (they should initially fail).
+5. Write or update tests as part of execution — tests are verification, not an afterthought. If the slice plan defines test files in its Verification section and this is the first task, create them (they should initially fail). Tests must only reference files tracked in git; never import, read, or assert on paths listed in `.gitignore` (e.g. `.gsd/`, `.planning/`, `.audits/`) — those files are local-only and the test will fail for anyone else. Use inline fixtures or tracked samples instead.
 6. When implementing non-trivial runtime behavior (async flows, API boundaries, background processes, error paths), add or preserve agent-usable observability. Skip this for simple changes where it doesn't apply.
 
    **Background process rule:** Never use bare `command &` to run background processes. The shell's `&` operator leaves stdout/stderr attached to the parent, which causes the Bash tool to hang indefinitely waiting for those streams to close. Always redirect output before backgrounding:

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -53,6 +53,7 @@ Then:
    - For simple slices: executable commands or script assertions are fine.
    - If the project is non-trivial and has no test framework, the first task should set one up.
    - If this slice establishes a boundary contract, verification must exercise that contract.
+   - Planned test files must only read from or import paths that are tracked in git. Do NOT plan tests whose inputs or fixtures are paths listed in `.gitignore` (e.g. `.gsd/`, `.planning/`, `.audits/`). If the scenario seems to require such a file, plan an inline fixture or a tracked sample instead.
 4. **For non-trivial slices only** — plan observability, proof level, and integration closure:
    - Include `Observability / Diagnostics` for backend, integration, async, stateful, or UI slices where failure diagnosis matters.
    - Fill `Proof Level` and `Integration Closure` when the slice crosses runtime boundaries or has meaningful integration concerns.