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

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

@@ -403,10 +403,13 @@ function getExpectedOutputsUpTo(tasks: TaskRow[], taskIndex: number): Set<string
 /**
  * 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.
  */
@@ -419,6 +422,7 @@ export function checkFilePathConsistency(
   for (let i = 0; i < tasks.length; i++) {
     const task = tasks[i];
     const priorOutputs = getExpectedOutputsUpTo(tasks, i);
+    const ownOutputs = new Set<string>(task.expected_output.map(normalizeFilePath));
     const filesToCheck = [...task.inputs];
 
     for (const file of filesToCheck) {
@@ -436,23 +440,23 @@ export function checkFilePathConsistency(
 
       // 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/src/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/src/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/src/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.

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

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
 
 import {
   unitVerb,
@@ -15,6 +16,10 @@ import {
   getWidgetMode,
   cycleWidgetMode,
   _resetWidgetModeForTests,
+  _resetLastCommitCacheForTests,
+  _refreshLastCommitForTests,
+  _getLastCommitForTests,
+  _getLastCommitFetchedAtForTests,
 } from "../auto-dashboard.ts";
 
 const autoSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto.ts"), "utf-8");
@@ -215,6 +220,50 @@ test("auto progress widget renders RTK savings under the footer stats line", ()
   assert.match(dashboardSource, /lines\.push\(rightAlign\("", theme\.fg\("dim", cachedRtkLabel\), width\)\);/);
 });
 
+test("last commit refresh backs off cleanly when base path is not a git repo", (t) => {
+  const dir = makeTempDir("non-git");
+  mkdirSync(dir, { recursive: true });
+
+  t.after(() => {
+    cleanup(dir);
+    _resetLastCommitCacheForTests();
+  });
+
+  _resetLastCommitCacheForTests();
+  _refreshLastCommitForTests(dir);
+
+  assert.equal(_getLastCommitForTests(dir), null);
+  assert.ok(
+    _getLastCommitFetchedAtForTests() > 0,
+    "non-git refresh should still advance fetchedAt to avoid render-loop retries",
+  );
+});
+
+test("last commit refresh still returns commit info for a valid git repo", (t) => {
+  const dir = makeTempDir("git");
+  mkdirSync(dir, { recursive: true });
+
+  execFileSync("git", ["init", "-b", "main"], { cwd: dir, stdio: "pipe" });
+  execFileSync("git", ["config", "user.name", "GSD Test"], { cwd: dir, stdio: "pipe" });
+  execFileSync("git", ["config", "user.email", "gsd@example.com"], { cwd: dir, stdio: "pipe" });
+  writeFileSync(join(dir, "README.md"), "hello\n", "utf-8");
+  execFileSync("git", ["add", "README.md"], { cwd: dir, stdio: "pipe" });
+  execFileSync("git", ["commit", "-m", "test: seed dashboard repo"], { cwd: dir, stdio: "pipe" });
+
+  t.after(() => {
+    cleanup(dir);
+    _resetLastCommitCacheForTests();
+  });
+
+  _resetLastCommitCacheForTests();
+  _refreshLastCommitForTests(dir);
+
+  const lastCommit = _getLastCommitForTests(dir);
+  assert.ok(lastCommit, "git repo should produce last commit metadata");
+  assert.match(lastCommit!.message, /test: seed dashboard repo/);
+  assert.ok(lastCommit!.timeAgo.length > 0, "relative time should be populated");
+});
+
 // ─── extractUatSliceId ───────────────────────────────────────────────────
 
 test("extractUatSliceId extracts slice ID from M001/S01 format", () => {

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();