gsd-pi 2.24.0 → 2.26.0

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

@@ -0,0 +1,441 @@
+// GSD Memory Store — CRUD, ranked queries, maintenance, and prompt formatting
+//
+// 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 } from './gsd-db.js';
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface Memory {
+  seq: number;
+  id: string;
+  category: string;
+  content: string;
+  confidence: number;
+  source_unit_type: string | null;
+  source_unit_id: string | null;
+  created_at: string;
+  updated_at: string;
+  superseded_by: string | null;
+  hit_count: number;
+}
+
+export type MemoryActionCreate = {
+  action: 'CREATE';
+  category: string;
+  content: string;
+  confidence?: number;
+};
+
+export type MemoryActionUpdate = {
+  action: 'UPDATE';
+  id: string;
+  content: string;
+  confidence?: number;
+};
+
+export type MemoryActionReinforce = {
+  action: 'REINFORCE';
+  id: string;
+};
+
+export type MemoryActionSupersede = {
+  action: 'SUPERSEDE';
+  id: string;
+  superseded_by: string;
+};
+
+export type MemoryAction =
+  | MemoryActionCreate
+  | MemoryActionUpdate
+  | MemoryActionReinforce
+  | MemoryActionSupersede;
+
+// ─── Category Display Order ─────────────────────────────────────────────────
+
+const CATEGORY_PRIORITY: Record<string, number> = {
+  gotcha: 0,
+  convention: 1,
+  architecture: 2,
+  pattern: 3,
+  environment: 4,
+  preference: 5,
+};
+
+// ─── Row Mapping ────────────────────────────────────────────────────────────
+
+function rowToMemory(row: Record<string, unknown>): Memory {
+  return {
+    seq: row['seq'] as number,
+    id: row['id'] as string,
+    category: row['category'] as string,
+    content: row['content'] as string,
+    confidence: row['confidence'] as number,
+    source_unit_type: (row['source_unit_type'] as string) ?? null,
+    source_unit_id: (row['source_unit_id'] as string) ?? null,
+    created_at: row['created_at'] as string,
+    updated_at: row['updated_at'] as string,
+    superseded_by: (row['superseded_by'] as string) ?? null,
+    hit_count: row['hit_count'] as number,
+  };
+}
+
+// ─── Query Functions ────────────────────────────────────────────────────────
+
+/**
+ * Get all memories where superseded_by IS NULL.
+ * Returns [] if DB is not available. Never throws.
+ */
+export function getActiveMemories(): Memory[] {
+  if (!isDbAvailable()) return [];
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+
+  try {
+    const rows = adapter.prepare('SELECT * FROM memories WHERE superseded_by IS NULL').all();
+    return rows.map(rowToMemory);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get active memories ordered by ranking score: confidence * (1 + hit_count * 0.1).
+ * Higher-scored memories are more relevant and frequently confirmed.
+ */
+export function getActiveMemoriesRanked(limit = 30): Memory[] {
+  if (!isDbAvailable()) return [];
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+
+  try {
+    const rows = adapter.prepare(
+      `SELECT * FROM memories
+       WHERE superseded_by IS NULL
+       ORDER BY (confidence * (1.0 + hit_count * 0.1)) DESC
+       LIMIT :limit`,
+    ).all({ ':limit': limit });
+    return rows.map(rowToMemory);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Generate the next memory ID: MEM + zero-padded 3-digit from MAX(seq).
+ * Returns MEM001 if no memories exist.
+ */
+export function nextMemoryId(): string {
+  if (!isDbAvailable()) return 'MEM001';
+  const adapter = _getAdapter();
+  if (!adapter) return 'MEM001';
+
+  try {
+    const row = adapter
+      .prepare('SELECT MAX(seq) as max_seq FROM memories')
+      .get();
+    const maxSeq = row ? (row['max_seq'] as number | null) : null;
+    if (maxSeq == null || isNaN(maxSeq)) return 'MEM001';
+    const next = maxSeq + 1;
+    return `MEM${String(next).padStart(3, '0')}`;
+  } catch {
+    return 'MEM001';
+  }
+}
+
+// ─── Mutation Functions ─────────────────────────────────────────────────────
+
+/**
+ * Insert a new memory with auto-assigned ID.
+ * Returns the assigned ID, or null on failure.
+ */
+export function createMemory(fields: {
+  category: string;
+  content: string;
+  confidence?: number;
+  source_unit_type?: string;
+  source_unit_id?: string;
+}): string | null {
+  if (!isDbAvailable()) return null;
+  const adapter = _getAdapter();
+  if (!adapter) return null;
+
+  try {
+    const id = nextMemoryId();
+    const now = new Date().toISOString();
+    adapter.prepare(
+      `INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
+       VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`,
+    ).run({
+      ':id': id,
+      ':category': fields.category,
+      ':content': fields.content,
+      ':confidence': fields.confidence ?? 0.8,
+      ':source_unit_type': fields.source_unit_type ?? null,
+      ':source_unit_id': fields.source_unit_id ?? null,
+      ':created_at': now,
+      ':updated_at': now,
+    });
+    return id;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Update a memory's content and optionally its confidence.
+ */
+export function updateMemoryContent(id: string, content: string, confidence?: number): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    const now = new Date().toISOString();
+    if (confidence != null) {
+      adapter.prepare(
+        'UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id',
+      ).run({ ':content': content, ':confidence': confidence, ':updated_at': now, ':id': id });
+    } else {
+      adapter.prepare(
+        'UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id',
+      ).run({ ':content': content, ':updated_at': now, ':id': id });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reinforce a memory: increment hit_count, update timestamp.
+ */
+export function reinforceMemory(id: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    adapter.prepare(
+      'UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id',
+    ).run({ ':updated_at': new Date().toISOString(), ':id': id });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Mark a memory as superseded by another.
+ */
+export function supersedeMemory(oldId: string, newId: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    adapter.prepare(
+      'UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id',
+    ).run({ ':new_id': newId, ':updated_at': new Date().toISOString(), ':old_id': oldId });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Processed Unit Tracking ────────────────────────────────────────────────
+
+/**
+ * Check if a unit has already been processed for memory extraction.
+ */
+export function isUnitProcessed(unitKey: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    const row = adapter.prepare(
+      'SELECT 1 FROM memory_processed_units WHERE unit_key = :key',
+    ).get({ ':key': unitKey });
+    return row != null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Record that a unit has been processed for memory extraction.
+ */
+export function markUnitProcessed(unitKey: string, activityFile: string): boolean {
+  if (!isDbAvailable()) return false;
+  const adapter = _getAdapter();
+  if (!adapter) return false;
+
+  try {
+    adapter.prepare(
+      `INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
+       VALUES (:key, :file, :at)`,
+    ).run({ ':key': unitKey, ':file': activityFile, ':at': new Date().toISOString() });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Maintenance ────────────────────────────────────────────────────────────
+
+/**
+ * Reduce confidence for memories not updated within the last N processed units.
+ * "Stale" = updated_at is older than the Nth most recent processed_at.
+ */
+export function decayStaleMemories(thresholdUnits = 20): void {
+  if (!isDbAvailable()) return;
+  const adapter = _getAdapter();
+  if (!adapter) return;
+
+  try {
+    // Find the timestamp of the Nth most recent processed unit
+    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
+
+    const cutoff = row['processed_at'] as string;
+    adapter.prepare(
+      `UPDATE memories
+       SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
+       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`,
+    ).run({ ':now': new Date().toISOString(), ':cutoff': cutoff });
+  } catch {
+    // non-fatal
+  }
+}
+
+/**
+ * Supersede lowest-ranked memories when count exceeds cap.
+ */
+export function enforceMemoryCap(max = 50): void {
+  if (!isDbAvailable()) return;
+  const adapter = _getAdapter();
+  if (!adapter) return;
+
+  try {
+    const countRow = adapter.prepare(
+      'SELECT count(*) as cnt FROM memories WHERE superseded_by IS NULL',
+    ).get();
+    const count = (countRow?.['cnt'] as number) ?? 0;
+    if (count <= max) return;
+
+    const excess = count - max;
+    // Find the IDs of the lowest-ranked active memories
+    const rows = 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 });
+
+    const now = new Date().toISOString();
+    for (const row of rows) {
+      adapter.prepare(
+        'UPDATE memories SET superseded_by = :reason, updated_at = :now WHERE id = :id',
+      ).run({ ':reason': 'CAP_EXCEEDED', ':now': now, ':id': row['id'] as string });
+    }
+  } catch {
+    // non-fatal
+  }
+}
+
+// ─── Action Application ─────────────────────────────────────────────────────
+
+/**
+ * Process an array of memory actions in a transaction.
+ * Calls enforceMemoryCap at the end.
+ */
+export function applyMemoryActions(
+  actions: MemoryAction[],
+  unitType?: string,
+  unitId?: string,
+): void {
+  if (!isDbAvailable() || actions.length === 0) return;
+
+  try {
+    transaction(() => {
+      for (const action of actions) {
+        switch (action.action) {
+          case 'CREATE':
+            createMemory({
+              category: action.category,
+              content: action.content,
+              confidence: action.confidence,
+              source_unit_type: unitType,
+              source_unit_id: unitId,
+            });
+            break;
+          case 'UPDATE':
+            updateMemoryContent(action.id, action.content, action.confidence);
+            break;
+          case 'REINFORCE':
+            reinforceMemory(action.id);
+            break;
+          case 'SUPERSEDE':
+            supersedeMemory(action.id, action.superseded_by);
+            break;
+        }
+      }
+      enforceMemoryCap();
+    });
+  } catch {
+    // non-fatal — transaction will have rolled back
+  }
+}
+
+// ─── Prompt Formatting ──────────────────────────────────────────────────────
+
+/**
+ * Format memories as categorized markdown for system prompt injection.
+ * Truncates to token budget (~4 chars per token).
+ */
+export function formatMemoriesForPrompt(memories: Memory[], tokenBudget = 2000): string {
+  if (memories.length === 0) return '';
+
+  const charBudget = tokenBudget * 4;
+  const header = '## Project Memory (auto-learned)\n';
+  let output = header;
+  let remaining = charBudget - header.length;
+
+  // Group by category
+  const grouped = new Map<string, Memory[]>();
+  for (const m of memories) {
+    const list = grouped.get(m.category) ?? [];
+    list.push(m);
+    grouped.set(m.category, list);
+  }
+
+  // Sort categories by priority
+  const sortedCategories = [...grouped.keys()].sort(
+    (a, b) => (CATEGORY_PRIORITY[a] ?? 99) - (CATEGORY_PRIORITY[b] ?? 99),
+  );
+
+  for (const category of sortedCategories) {
+    const items = grouped.get(category)!;
+    const catHeader = `\n### ${category.charAt(0).toUpperCase() + category.slice(1)}\n`;
+
+    if (remaining < catHeader.length + 10) break;
+    output += catHeader;
+    remaining -= catHeader.length;
+
+    for (const item of items) {
+      const bullet = `- ${item.content}\n`;
+      if (remaining < bullet.length) break;
+      output += bullet;
+      remaining -= bullet.length;
+    }
+  }
+
+  return output.trimEnd();
+}

package/dist/resources/extensions/gsd/migrate/command.ts

@@ -151,7 +151,7 @@ export async function handleMigrate(
   }
 
   // ── Confirmation via showNextAction ────────────────────────────────────────
-  const choice = await showNextAction(ctx as any, {
+  const choice = await showNextAction(ctx, {
     title: "Migration preview",
     summary: lines,
     actions: [
@@ -187,7 +187,7 @@ export async function handleMigrate(
   );
 
   // ── Post-write review offer ────────────────────────────────────────────────
-  const reviewChoice = await showNextAction(ctx as any, {
+  const reviewChoice = await showNextAction(ctx, {
     title: "Migration written",
     summary: [
       `${result.paths.length} files written to .gsd/`,

package/dist/resources/extensions/gsd/migrate/writer.ts

@@ -483,6 +483,45 @@ export async function writeGSDDirectory(
       counts.research++;
     }
 
+    // For fully-completed milestones (all slices done), write a pass-through
+    // validation file so deriveState() doesn't enter validating-milestone
+    // phase for historical milestones that predate the validation gate (#819).
+    const allSlicesDone = milestone.slices.length > 0 && milestone.slices.every(s => s.done);
+    if (allSlicesDone) {
+      const validationPath = join(mDir, `${milestone.id}-VALIDATION.md`);
+      const validationContent = [
+        `---`,
+        `verdict: pass`,
+        `migrated: true`,
+        `---`,
+        ``,
+        `# ${milestone.id} Validation`,
+        ``,
+        `Migrated milestone — all slices were completed in the original project.`,
+        ``,
+      ].join('\n');
+      await saveFile(validationPath, validationContent);
+      paths.push(validationPath);
+      counts.other++;
+
+      // Also write a milestone summary if one doesn't exist
+      const summaryPath = join(mDir, `${milestone.id}-SUMMARY.md`);
+      const summaryContent = [
+        `---`,
+        `status: done`,
+        `migrated: true`,
+        `---`,
+        ``,
+        `# ${milestone.id}: ${milestone.title}`,
+        ``,
+        `Migrated from .planning — ${milestone.slices.length} slices completed.`,
+        ``,
+      ].join('\n');
+      await saveFile(summaryPath, summaryContent);
+      paths.push(summaryPath);
+      counts.other++;
+    }
+
     // Slices
     for (const slice of milestone.slices) {
       const sDir = join(mDir, 'slices', slice.id);

package/dist/resources/extensions/gsd/parallel-orchestrator.ts

@@ -124,6 +124,12 @@ export async function startParallel(
   const toStart = milestoneIds.slice(0, config.max_workers);
 
   for (const mid of toStart) {
+    // Check budget ceiling before each spawn
+    if (isBudgetExceeded()) {
+      errors.push({ mid, error: `Budget ceiling ($${config.budget_ceiling}) reached — skipping` });
+      continue;
+    }
+
     try {
       // Create the worktree (without chdir — coordinator stays in project root)
       let wtPath: string;
@@ -233,7 +239,7 @@ export function spawnWorker(
 
   let child: ChildProcess;
   try {
-    child = spawn(process.execPath, [binPath, "--print", "/gsd auto"], {
+    child = spawn(process.execPath, [binPath, "--mode", "json", "--print", "/gsd auto"], {
       cwd: worker.worktreePath,
       env: {
         ...process.env,
@@ -267,6 +273,28 @@ export function spawnWorker(
     return false;
   }
 
+  // ── NDJSON stdout monitoring ────────────────────────────────────────
+  // Workers run with --mode json, emitting one JSON event per line.
+  // We parse message_end events to extract cost/token usage, keeping
+  // the coordinator's cost tracking in sync with actual API spend.
+  if (child.stdout) {
+    let stdoutBuffer = "";
+    child.stdout.on("data", (data: Buffer) => {
+      stdoutBuffer += data.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        processWorkerLine(basePath, milestoneId, line);
+      }
+    });
+    // Flush remaining buffer on close
+    child.stdout.on("close", () => {
+      if (stdoutBuffer.trim()) {
+        processWorkerLine(basePath, milestoneId, stdoutBuffer);
+      }
+    });
+  }
+
   // Update session status with real PID
   writeSessionStatus(basePath, {
     milestoneId,
@@ -343,6 +371,90 @@ function resolveGsdBin(): string | null {
   return null;
 }
 
+// ─── NDJSON Processing ──────────────────────────────────────────────────────
+
+/**
+ * Process a single NDJSON line from a worker's stdout.
+ * Extracts cost and token usage from message_end events and updates
+ * the worker's tracking state + session status file.
+ */
+function processWorkerLine(basePath: string, milestoneId: string, line: string): void {
+  if (!line.trim() || !state) return;
+
+  let event: Record<string, unknown>;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return; // Not valid JSON — skip (stderr leakage, debug output, etc.)
+  }
+
+  const type = String(event.type ?? "");
+
+  // message_end carries usage data with cost
+  if (type === "message_end" && event.message) {
+    const msg = event.message as Record<string, unknown>;
+    const usage = msg.usage as Record<string, unknown> | undefined;
+
+    if (usage) {
+      const cost = (usage.cost as Record<string, unknown>)?.total;
+      if (typeof cost === "number") {
+        const worker = state.workers.get(milestoneId);
+        if (worker) {
+          worker.cost += cost;
+          // Update aggregate
+          state.totalCost = 0;
+          for (const w of state.workers.values()) {
+            state.totalCost += w.cost;
+          }
+        }
+      }
+    }
+
+    // Track completed units (each message_end from assistant = progress)
+    if (msg.role === "assistant") {
+      const worker = state.workers.get(milestoneId);
+      if (worker) {
+        worker.completedUnits++;
+      }
+    }
+
+    // Update session status file so dashboard sees live cost
+    const worker = state.workers.get(milestoneId);
+    if (worker) {
+      writeSessionStatus(basePath, {
+        milestoneId,
+        pid: worker.pid,
+        state: worker.state,
+        currentUnit: null,
+        completedUnits: worker.completedUnits,
+        cost: worker.cost,
+        lastHeartbeat: Date.now(),
+        startedAt: worker.startedAt,
+        worktreePath: worker.worktreePath,
+      });
+    }
+  }
+
+  // tool_execution_start can track current unit
+  if (type === "extension_ui_request" && event.method === "notify") {
+    // GSD auto-mode sends notifications about current unit
+    const worker = state.workers.get(milestoneId);
+    if (worker) {
+      writeSessionStatus(basePath, {
+        milestoneId,
+        pid: worker.pid,
+        state: worker.state,
+        currentUnit: null,
+        completedUnits: worker.completedUnits,
+        cost: worker.cost,
+        lastHeartbeat: Date.now(),
+        startedAt: worker.startedAt,
+        worktreePath: worker.worktreePath,
+      });
+    }
+  }
+}
+
 // ─── Stop ──────────────────────────────────────────────────────────────────
 
 /**
@@ -366,10 +478,16 @@ export async function stopParallel(
     // Send stop signal via file-based IPC (worker checks on next dispatch)
     sendSignal(basePath, mid, "stop");
 
-    // Also send SIGTERM to the process for immediate response
-    if (worker.process && worker.pid > 0) {
+    // Send SIGTERM to the process for immediate response.
+    // Use process handle when available, fall back to PID-based kill
+    // (handles are null after coordinator restart / deserialization).
+    if (worker.pid > 0) {
       try {
-        worker.process.kill("SIGTERM");
+        if (worker.process) {
+          worker.process.kill("SIGTERM");
+        } else {
+          process.kill(worker.pid, "SIGTERM");
+        }
       } catch { /* process may already be dead */ }
     }
 

package/dist/resources/extensions/gsd/preferences.ts

@@ -916,8 +916,9 @@ export function validatePreferences(preferences: GSDPreferences): {
       if (p.skip_reassess !== undefined) validatedPhases.skip_reassess = !!p.skip_reassess;
       if (p.skip_slice_research !== undefined) validatedPhases.skip_slice_research = !!p.skip_slice_research;
       if (p.skip_milestone_validation !== undefined) validatedPhases.skip_milestone_validation = !!p.skip_milestone_validation;
+      if ((p as any).require_slice_discussion !== undefined) (validatedPhases as any).require_slice_discussion = !!(p as any).require_slice_discussion;
       // Warn on unknown phase keys
-      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation"]);
+      const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "require_slice_discussion"]);
       for (const key of Object.keys(p)) {
         if (!knownPhaseKeys.has(key)) {
           warnings.push(`unknown phases key "${key}" — ignored`);

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

@@ -28,7 +28,7 @@ Then:
 7. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
 8. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
 9. Mark {{sliceId}} done in `{{roadmapPath}}` (change `[ ]` to `[x]`)
-10. Do not commit or squash-merge manually — the system auto-commits your changes and handles the merge after this unit succeeds.
+10. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
 11. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed.
 12. Update `.gsd/STATE.md`