gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.b741afb

package/src/resources/extensions/gsd/db-writer.ts

@@ -346,8 +346,7 @@ export async function saveRequirementToDb(
     } catch (diskErr) {
       logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String((diskErr as Error).message) });
       try {
-        const rollbackAdapter = db._getAdapter();
-        rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
+        db.deleteRequirementById(id);
       } catch (rollbackErr) {
         logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveRequirementToDb', id, error: String((rollbackErr as Error).message) });
       }
@@ -471,7 +470,7 @@ export async function saveDecisionToDb(
     } catch (diskErr) {
       logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String((diskErr as Error).message) });
       try {
-        adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
+        db.deleteDecisionById(id);
       } catch (rollbackErr) {
         logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveDecisionToDb', id, error: String((rollbackErr as Error).message) });
       }
@@ -714,8 +713,7 @@ export async function saveArtifactToDb(
         await saveFile(fullPath, opts.content);
       } catch (diskErr) {
         logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String((diskErr as Error).message) });
-        const rollbackAdapter = db._getAdapter();
-        rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+        db.deleteArtifactByPath(opts.path);
         throw diskErr;
       }
     }

package/src/resources/extensions/gsd/graph-context.ts

@@ -0,0 +1,85 @@
+/**
+ * Graph-aware context injection for dispatch prompt builders.
+ *
+ * Reads the pre-built graph.json and returns a formatted context block
+ * for injection into prompts. Gracefully returns null when no graph exists
+ * or the query yields no results — callers must handle null.
+ */
+
+import { logWarning } from "./workflow-logger.js";
+import type { GraphQueryResult, GraphStatusResult } from "@gsd-build/mcp-server";
+
+export interface GraphSubgraphOptions {
+  /** Budget in tokens passed to graphQuery (1 node ≈ 20 tokens, 1 edge ≈ 10 tokens) */
+  budget: number;
+}
+
+/**
+ * Query the knowledge graph for nodes related to the given term and format
+ * the result as an inlined context block.
+ *
+ * Returns null when:
+ * - @gsd-build/mcp-server fails to import
+ * - graph.json does not exist (graphQuery already handles this gracefully)
+ * - query returns zero nodes
+ *
+ * Annotates the block header when the graph is stale (> 24 hours old).
+ */
+export async function inlineGraphSubgraph(
+  projectDir: string,
+  term: string,
+  opts: GraphSubgraphOptions,
+): Promise<string | null> {
+  if (!term || !term.trim()) return null;
+
+  try {
+    const { graphQuery, graphStatus } = await import("@gsd-build/mcp-server") as {
+      graphQuery: (projectDir: string, term: string, budget?: number) => Promise<GraphQueryResult>;
+      graphStatus: (projectDir: string) => Promise<GraphStatusResult>;
+    };
+
+    const result = await graphQuery(projectDir, term, opts.budget);
+    if (result.nodes.length === 0) return null;
+
+    // Check staleness for annotation
+    let staleAnnotation = "";
+    try {
+      const status = await graphStatus(projectDir);
+      if (status.exists && status.stale && status.ageHours !== undefined) {
+        const hours = Math.round(status.ageHours);
+        staleAnnotation = `\n> ⚠ Graph last built ${hours}h ago — context may be outdated`;
+      }
+    } catch {
+      // Non-fatal — skip annotation on error
+    }
+
+    // Format nodes as a compact list
+    const nodeLines = result.nodes.map((n) => {
+      const desc = n.description ? ` — ${n.description}` : "";
+      return `- **${n.label}** (\`${n.type}\`, ${n.confidence})${desc}`;
+    });
+
+    // Format edges as relations (only if present)
+    const edgeLines = result.edges.length > 0
+      ? result.edges.map((e) => `- \`${e.from}\` →[${e.type}]→ \`${e.to}\``)
+      : [];
+
+    const sections: string[] = [
+      `### Knowledge Graph Context (term: "${term}")`,
+      `Source: \`.gsd/graphs/graph.json\``,
+      staleAnnotation,
+      "",
+      `**Nodes (${result.nodes.length}):**`,
+      ...nodeLines,
+    ];
+
+    if (edgeLines.length > 0) {
+      sections.push("", `**Relations (${result.edges.length}):**`, ...edgeLines);
+    }
+
+    return sections.filter((l) => l !== undefined).join("\n");
+  } catch (err) {
+    logWarning("prompt", `inlineGraphSubgraph failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}

package/src/resources/extensions/gsd/gsd-db.ts

@@ -4,6 +4,21 @@
 //
 // Exposes a unified sync API for decisions and requirements storage.
 // Schema is initialized on first open with WAL mode for file-backed DBs.
+//
+// ─── Single-writer invariant ─────────────────────────────────────────────
+// This file is the ONLY place in the codebase that issues write SQL
+// (INSERT / UPDATE / DELETE / REPLACE / BEGIN-COMMIT transactions) against
+// the engine database at `.gsd/gsd.db`. All other modules must call the
+// typed wrappers exported here. The structural test
+// `tests/single-writer-invariant.test.ts` fails CI if a new bypass appears.
+//
+// `_getAdapter()` is retained for read-only SELECTs in query modules
+// (context-store, memory-store queries, doctor checks, projections).
+// Do NOT use it for writes — add a wrapper here instead.
+//
+// The separate `.gsd/unit-claims.db` managed by `unit-ownership.ts` is an
+// intentionally independent store for cross-worktree claim races and is
+// excluded from this invariant.
 
 import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
@@ -12,6 +27,10 @@ import type { Decision, Requirement, GateRow, GateId, GateScope, GateStatus, Gat
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
 import { getGateIdsForTurn, type OwnerTurn } from "./gate-registry.js";
 import { logError, logWarning } from "./workflow-logger.js";
+// Type-only import to avoid a circular runtime dep. The runtime side of
+// workflow-manifest.ts depends on this file, but the StateManifest type is
+// pure structure with no runtime coupling.
+import type { StateManifest } from "./workflow-manifest.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -922,6 +941,48 @@ export function transaction<T>(fn: () => T): T {
   }
 }
 
+/**
+ * Wrap a block of reads in a DEFERRED transaction so that all SELECTs observe
+ * a consistent snapshot of the DB even if a concurrent writer commits between
+ * them. Use this for multi-query read flows (e.g. tool executors that query
+ * milestone + slices + counts and want one snapshot). Re-entrant — if already
+ * inside a transaction, runs fn() without starting a nested one.
+ */
+export function readTransaction<T>(fn: () => T): T {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+
+  if (_txDepth > 0) {
+    _txDepth++;
+    try {
+      return fn();
+    } finally {
+      _txDepth--;
+    }
+  }
+
+  _txDepth++;
+  currentDb.exec("BEGIN DEFERRED");
+  try {
+    const result = fn();
+    currentDb.exec("COMMIT");
+    return result;
+  } catch (err) {
+    try {
+      currentDb.exec("ROLLBACK");
+    } catch (rollbackErr) {
+      // A failed ROLLBACK after a failed read is a split-brain signal —
+      // the transaction is in an indeterminate state. Surface it via the
+      // logger instead of swallowing it.
+      logError("db", "snapshotState ROLLBACK failed", {
+        error: (rollbackErr as Error).message,
+      });
+    }
+    throw err;
+  } finally {
+    _txDepth--;
+  }
+}
+
 export function insertDecision(d: Omit<Decision, "seq">): void {
   if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
   currentDb.prepare(
@@ -2451,3 +2512,409 @@ export function getPendingGateCountForTurn(
 ): number {
   return getPendingGatesForTurn(milestoneId, sliceId, turn).length;
 }
+
+// ─── Single-writer bypass wrappers ───────────────────────────────────────
+// These wrappers exist so modules outside this file never need to call
+// `_getAdapter()` for writes. Each one is a byte-equivalent replacement for
+// a raw prepare/run previously issued from another module. Keep them
+// minimal and direct — they exist to hold SQL text in one place, not to
+// add new behavior.
+
+/** Delete a decision row by id. Used by db-writer.ts rollback on disk-write failure. */
+export function deleteDecisionById(id: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare("DELETE FROM decisions WHERE id = :id").run({ ":id": id });
+}
+
+/** Delete a requirement row by id. Used by db-writer.ts rollback on disk-write failure. */
+export function deleteRequirementById(id: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare("DELETE FROM requirements WHERE id = :id").run({ ":id": id });
+}
+
+/** Delete an artifact row by path. Used by db-writer.ts rollback on disk-write failure. */
+export function deleteArtifactByPath(path: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare("DELETE FROM artifacts WHERE path = :path").run({ ":path": path });
+}
+
+/**
+ * Drop all rows from tasks/slices/milestones in dependency order inside a
+ * transaction. Used by `gsd recover` to rebuild engine state from markdown.
+ */
+export function clearEngineHierarchy(): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  transaction(() => {
+    currentDb!.exec("DELETE FROM tasks");
+    currentDb!.exec("DELETE FROM slices");
+    currentDb!.exec("DELETE FROM milestones");
+  });
+}
+
+/**
+ * INSERT OR IGNORE a slice during event replay (workflow-reconcile.ts).
+ * Strict insert-or-ignore semantics are required here to avoid the
+ * `insertSlice` ON CONFLICT path that could downgrade an already-completed
+ * slice back to 'pending'.
+ */
+export function insertOrIgnoreSlice(args: {
+  milestoneId: string;
+  sliceId: string;
+  title: string;
+  createdAt: string;
+}): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    `INSERT OR IGNORE INTO slices (milestone_id, id, title, status, created_at)
+     VALUES (:mid, :sid, :title, 'pending', :ts)`,
+  ).run({
+    ":mid": args.milestoneId,
+    ":sid": args.sliceId,
+    ":title": args.title,
+    ":ts": args.createdAt,
+  });
+}
+
+/**
+ * INSERT OR IGNORE a task during event replay (workflow-reconcile.ts).
+ * Same rationale as `insertOrIgnoreSlice`.
+ */
+export function insertOrIgnoreTask(args: {
+  milestoneId: string;
+  sliceId: string;
+  taskId: string;
+  title: string;
+  createdAt: string;
+}): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    `INSERT OR IGNORE INTO tasks (milestone_id, slice_id, id, title, status, created_at)
+     VALUES (:mid, :sid, :tid, :title, 'pending', :ts)`,
+  ).run({
+    ":mid": args.milestoneId,
+    ":sid": args.sliceId,
+    ":tid": args.taskId,
+    ":title": args.title,
+    ":ts": args.createdAt,
+  });
+}
+
+/**
+ * Stamp the `replan_triggered_at` column on a slice. Used by triage-resolution
+ * when a user capture requests a replan so the dispatcher can detect the
+ * trigger via DB in addition to the on-disk REPLAN-TRIGGER.md marker.
+ */
+export function setSliceReplanTriggeredAt(milestoneId: string, sliceId: string, ts: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    "UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid",
+  ).run({ ":ts": ts, ":mid": milestoneId, ":sid": sliceId });
+}
+
+/**
+ * INSERT OR REPLACE a quality_gates row. Used by milestone-validation-gates.ts
+ * to persist milestone-level (MV*) gate outcomes after validate-milestone runs.
+ */
+export function upsertQualityGate(g: {
+  milestoneId: string;
+  sliceId: string;
+  gateId: string;
+  scope: string;
+  taskId: string;
+  status: string;
+  verdict: string;
+  rationale: string;
+  findings: string;
+  evaluatedAt: string;
+}): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    `INSERT OR REPLACE INTO quality_gates
+     (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
+     VALUES (:mid, :sid, :gid, :scope, :tid, :status, :verdict, :rationale, :findings, :evaluated_at)`,
+  ).run({
+    ":mid": g.milestoneId,
+    ":sid": g.sliceId,
+    ":gid": g.gateId,
+    ":scope": g.scope,
+    ":tid": g.taskId,
+    ":status": g.status,
+    ":verdict": g.verdict,
+    ":rationale": g.rationale,
+    ":findings": g.findings,
+    ":evaluated_at": g.evaluatedAt,
+  });
+}
+
+/**
+ * Atomically replace all workflow state from a manifest. Lifted verbatim from
+ * workflow-manifest.ts so the single-writer invariant holds. Only touches
+ * engine tables + decisions. Does NOT modify artifacts or memories.
+ */
+export function restoreManifest(manifest: StateManifest): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  const db = currentDb;
+
+  transaction(() => {
+    // Clear engine tables (order matters for foreign-key-like consistency)
+    db.exec("DELETE FROM verification_evidence");
+    db.exec("DELETE FROM tasks");
+    db.exec("DELETE FROM slices");
+    db.exec("DELETE FROM milestones");
+    db.exec("DELETE FROM decisions WHERE 1=1");
+
+    // Restore milestones
+    const msStmt = db.prepare(
+      `INSERT INTO milestones (id, title, status, depends_on, created_at, completed_at,
+        vision, success_criteria, key_risks, proof_strategy,
+        verification_contract, verification_integration, verification_operational, verification_uat,
+        definition_of_done, requirement_coverage, boundary_map_markdown)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const m of manifest.milestones) {
+      msStmt.run(
+        m.id, m.title, m.status,
+        JSON.stringify(m.depends_on), m.created_at, m.completed_at,
+        m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks),
+        JSON.stringify(m.proof_strategy),
+        m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat,
+        JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown,
+      );
+    }
+
+    // Restore slices
+    const slStmt = db.prepare(
+      `INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,
+        created_at, completed_at, full_summary_md, full_uat_md,
+        goal, success_criteria, proof_level, integration_closure, observability_impact,
+        sequence, replan_triggered_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const s of manifest.slices) {
+      slStmt.run(
+        s.milestone_id, s.id, s.title, s.status, s.risk,
+        JSON.stringify(s.depends), s.demo,
+        s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md,
+        s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact,
+        s.sequence, s.replan_triggered_at,
+      );
+    }
+
+    // Restore tasks
+    const tkStmt = db.prepare(
+      `INSERT INTO tasks (milestone_id, slice_id, id, title, status,
+        one_liner, narrative, verification_result, duration, completed_at,
+        blocker_discovered, deviations, known_issues, key_files, key_decisions,
+        full_summary_md, description, estimate, files, verify,
+        inputs, expected_output, observability_impact, sequence)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const t of manifest.tasks) {
+      tkStmt.run(
+        t.milestone_id, t.slice_id, t.id, t.title, t.status,
+        t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at,
+        t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues,
+        JSON.stringify(t.key_files), JSON.stringify(t.key_decisions),
+        t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify,
+        JSON.stringify(t.inputs), JSON.stringify(t.expected_output),
+        t.observability_impact, t.sequence,
+      );
+    }
+
+    // Restore decisions
+    const dcStmt = db.prepare(
+      `INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const d of manifest.decisions) {
+      dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.superseded_by);
+    }
+
+    // Restore verification evidence
+    const evStmt = db.prepare(
+      `INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const e of manifest.verification_evidence) {
+      evStmt.run(e.task_id, e.slice_id, e.milestone_id, e.command, e.exit_code, e.verdict, e.duration_ms, e.created_at);
+    }
+  });
+}
+
+// ─── Legacy markdown → DB bulk migration ─────────────────────────────────
+
+export interface LegacyMilestoneInsert {
+  id: string;
+  title: string;
+  status: string;
+}
+
+export interface LegacySliceInsert {
+  id: string;
+  milestoneId: string;
+  title: string;
+  status: string;
+  risk: string;
+  sequence: number;
+}
+
+export interface LegacyTaskInsert {
+  id: string;
+  sliceId: string;
+  milestoneId: string;
+  title: string;
+  status: string;
+  sequence: number;
+}
+
+/**
+ * Bulk delete + insert a legacy milestone hierarchy for markdown → DB migration.
+ * Used by workflow-migration.ts to populate engine tables from parsed ROADMAP/PLAN
+ * files. All operations run inside a single transaction.
+ */
+export function bulkInsertLegacyHierarchy(payload: {
+  milestones: LegacyMilestoneInsert[];
+  slices: LegacySliceInsert[];
+  tasks: LegacyTaskInsert[];
+  clearMilestoneIds: string[];
+  createdAt: string;
+}): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  const db = currentDb;
+  const { milestones, slices, tasks, clearMilestoneIds, createdAt } = payload;
+
+  if (clearMilestoneIds.length === 0) return;
+  const placeholders = clearMilestoneIds.map(() => "?").join(",");
+
+  transaction(() => {
+    db.prepare(`DELETE FROM tasks WHERE milestone_id IN (${placeholders})`).run(...clearMilestoneIds);
+    db.prepare(`DELETE FROM slices WHERE milestone_id IN (${placeholders})`).run(...clearMilestoneIds);
+    db.prepare(`DELETE FROM milestones WHERE id IN (${placeholders})`).run(...clearMilestoneIds);
+
+    const insertMilestone = db.prepare(
+      "INSERT INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)",
+    );
+    for (const m of milestones) {
+      insertMilestone.run(m.id, m.title, m.status, createdAt);
+    }
+
+    const insertSliceStmt = db.prepare(
+      "INSERT INTO slices (id, milestone_id, title, status, risk, depends, sequence, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+    );
+    for (const s of slices) {
+      insertSliceStmt.run(s.id, s.milestoneId, s.title, s.status, s.risk, "[]", s.sequence, createdAt);
+    }
+
+    const insertTaskStmt = db.prepare(
+      "INSERT INTO tasks (id, slice_id, milestone_id, title, description, status, estimate, files, sequence) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+    );
+    for (const t of tasks) {
+      insertTaskStmt.run(t.id, t.sliceId, t.milestoneId, t.title, "", t.status, "", "[]", t.sequence);
+    }
+  });
+}
+
+// ─── Memory store writers ────────────────────────────────────────────────
+// All memory writes go through gsd-db.ts so the single-writer invariant
+// holds. These are direct pass-throughs to the SQL previously in
+// memory-store.ts — same bindings, same behavior.
+
+export function insertMemoryRow(args: {
+  id: string;
+  category: string;
+  content: string;
+  confidence: number;
+  sourceUnitType: string | null;
+  sourceUnitId: string | null;
+  createdAt: string;
+  updatedAt: string;
+}): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.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": args.id,
+    ":category": args.category,
+    ":content": args.content,
+    ":confidence": args.confidence,
+    ":source_unit_type": args.sourceUnitType,
+    ":source_unit_id": args.sourceUnitId,
+    ":created_at": args.createdAt,
+    ":updated_at": args.updatedAt,
+  });
+}
+
+export function rewriteMemoryId(placeholderId: string, realId: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare("UPDATE memories SET id = :real_id WHERE id = :placeholder").run({
+    ":real_id": realId,
+    ":placeholder": placeholderId,
+  });
+}
+
+export function updateMemoryContentRow(
+  id: string,
+  content: string,
+  confidence: number | undefined,
+  updatedAt: string,
+): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  if (confidence != null) {
+    currentDb.prepare(
+      "UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id",
+    ).run({ ":content": content, ":confidence": confidence, ":updated_at": updatedAt, ":id": id });
+  } else {
+    currentDb.prepare(
+      "UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id",
+    ).run({ ":content": content, ":updated_at": updatedAt, ":id": id });
+  }
+}
+
+export function incrementMemoryHitCount(id: string, updatedAt: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    "UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id",
+  ).run({ ":updated_at": updatedAt, ":id": id });
+}
+
+export function supersedeMemoryRow(oldId: string, newId: string, updatedAt: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    "UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id",
+  ).run({ ":new_id": newId, ":updated_at": updatedAt, ":old_id": oldId });
+}
+
+export function markMemoryUnitProcessed(
+  unitKey: string,
+  activityFile: string,
+  processedAt: string,
+): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    `INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
+     VALUES (:key, :file, :at)`,
+  ).run({ ":key": unitKey, ":file": activityFile, ":at": processedAt });
+}
+
+export function decayMemoriesBefore(cutoffTs: string, now: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.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": now, ":cutoff": cutoffTs });
+}
+
+export function supersedeLowestRankedMemories(limit: number, now: string): void {
+  if (!currentDb) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  currentDb.prepare(
+    `UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
+     WHERE id IN (
+       SELECT id FROM memories
+       WHERE superseded_by IS NULL
+       ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
+       LIMIT :limit
+     )`,
+  ).run({ ":now": now, ":limit": limit });
+}

package/src/resources/extensions/gsd/index.ts

@@ -16,6 +16,22 @@ export {
 } from "./bootstrap/write-gate.js";
 
 export default async function registerExtension(pi: ExtensionAPI) {
-  const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
-  registerGsdExtension(pi);
+  // Always register the core /gsd command first, in isolation.
+  // This ensures /gsd is available even if the full bootstrap (shortcuts,
+  // tools, hooks) fails — e.g. due to a Windows-specific import error.
+  const { registerGSDCommand } = await import("./commands/index.js");
+  registerGSDCommand(pi);
+
+  // Full setup (shortcuts, tools, hooks) in a separate try/catch so that
+  // any platform-specific load failure doesn't take out the core command.
+  try {
+    const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
+    registerGsdExtension(pi);
+  } catch (err) {
+    const { logWarning } = await import("./workflow-logger.js");
+    logWarning(
+      "bootstrap",
+      `Extension setup partially failed — /gsd commands are available but shortcuts/tools may be missing: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
 }

package/src/resources/extensions/gsd/md-importer.ts

@@ -16,6 +16,7 @@ import {
   insertTask,
   openDatabase,
   transaction,
+  updateSliceStatus,
   _getAdapter,
 } from './gsd-db.js';
 import {
@@ -672,11 +673,8 @@ export function migrateHierarchyToDb(basePath: string): {
           return t.done && existsSync(summaryFile);
         });
         if (allTasksDone && hasSliceSummary) {
-          const adapter = _getAdapter();
-          if (adapter) {
-            adapter.prepare(
-              `UPDATE slices SET status = 'complete' WHERE id = :sid AND milestone_id = :mid`,
-            ).run({ ':sid': sliceEntry.id, ':mid': milestoneId });
+          if (_getAdapter()) {
+            updateSliceStatus(milestoneId, sliceEntry.id, 'complete');
             process.stderr.write(
               `gsd-migrate: ${milestoneId}/${sliceEntry.id} all tasks + slice summary complete — upgrading slice to complete\n`,
             );