gsd-pi 2.73.1-dev.1040fb0 → 2.73.1-dev.49397e5

package/dist/resources/extensions/gsd/commands-ship.js

@@ -0,0 +1,187 @@
+/**
+ * GSD Command — /gsd ship
+ *
+ * Creates a PR from milestone artifacts: generates title + body from
+ * roadmap, slice summaries, and metrics, then opens via `gh pr create`.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { deriveState } from "./state.js";
+import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile } from "./paths.js";
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bridge.js";
+import { formatDuration } from "../shared/format-utils.js";
+function git(basePath, args) {
+    return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
+}
+function isValidRefName(name) {
+    try {
+        execFileSync("git", ["check-ref-format", "--branch", name], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function listSliceIds(basePath, milestoneId) {
+    // Slices live at <milestoneDir>/slices/<sliceId>/ with canonical S\d+ IDs.
+    // Use resolveSlicePath with a probe to find the real slices directory root.
+    const probe = resolveSlicePath(basePath, milestoneId, "S01");
+    let slicesDir = null;
+    if (probe) {
+        // probe looks like <milestoneDir>/slices/S01 — parent is slices dir.
+        slicesDir = probe.replace(/[\\/][^\\/]+$/, "");
+    }
+    else {
+        // Fall back to scanning the milestones roadmap file's sibling slices dir.
+        const roadmap = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        if (roadmap) {
+            slicesDir = roadmap.replace(/[\\/][^\\/]+$/, "") + "/slices";
+        }
+    }
+    if (!slicesDir || !existsSync(slicesDir))
+        return [];
+    try {
+        return readdirSync(slicesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function collectSliceSummaries(basePath, milestoneId) {
+    const summaries = [];
+    for (const sliceId of listSliceIds(basePath, milestoneId)) {
+        const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            continue;
+        try {
+            const content = readFileSync(summaryPath, "utf-8").trim();
+            if (content)
+                summaries.push(`### ${sliceId}\n${content}`);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    return summaries;
+}
+function generatePRContent(basePath, milestoneId, milestoneTitle) {
+    const title = `feat: ${milestoneTitle || milestoneId}`;
+    const sections = [];
+    // TL;DR
+    sections.push("## TL;DR\n");
+    sections.push(`**What:** Ship milestone ${milestoneId} — ${milestoneTitle || "(untitled)"}`);
+    sections.push(`**Why:** Milestone work complete, ready for review.`);
+    sections.push(`**How:** See slice summaries below.\n`);
+    // What — slice summaries
+    const summaries = collectSliceSummaries(basePath, milestoneId);
+    if (summaries.length > 0) {
+        sections.push("## What\n");
+        sections.push(summaries.join("\n\n"));
+        sections.push("");
+    }
+    // Roadmap status
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (roadmapPath && existsSync(roadmapPath)) {
+        try {
+            const roadmap = readFileSync(roadmapPath, "utf-8");
+            const checkboxLines = roadmap.split("\n").filter((l) => /^\s*-\s*\[[ x]\]/.test(l));
+            if (checkboxLines.length > 0) {
+                sections.push("## Roadmap\n");
+                sections.push(checkboxLines.join("\n"));
+                sections.push("");
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    // Metrics
+    const ledger = getLedger();
+    const units = ledger?.units ?? loadLedgerFromDisk(basePath)?.units ?? [];
+    if (units.length > 0) {
+        const totals = getProjectTotals(units);
+        const byModel = aggregateByModel(units);
+        sections.push("## Metrics\n");
+        sections.push(`- **Units executed:** ${units.length}`);
+        sections.push(`- **Total cost:** ${formatCost(totals.cost)}`);
+        sections.push(`- **Tokens:** ${formatTokenCount(totals.tokens.input)} input / ${formatTokenCount(totals.tokens.output)} output`);
+        if (totals.duration > 0) {
+            sections.push(`- **Duration:** ${formatDuration(totals.duration)}`);
+        }
+        if (byModel.length > 0) {
+            sections.push(`- **Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
+        }
+        sections.push("");
+    }
+    // Change type checklist
+    sections.push("## Change type\n");
+    sections.push("- [x] `feat` — New feature or capability");
+    sections.push("- [ ] `fix` — Bug fix");
+    sections.push("- [ ] `refactor` — Code restructuring");
+    sections.push("- [ ] `test` — Adding or updating tests");
+    sections.push("- [ ] `docs` — Documentation only");
+    sections.push("- [ ] `chore` — Build, CI, or tooling changes\n");
+    // AI disclosure
+    sections.push("---\n");
+    sections.push("*This PR was prepared with AI assistance (GSD auto-mode).*");
+    return { title, body: sections.join("\n") };
+}
+export async function handleShip(args, ctx, _pi) {
+    const basePath = process.cwd();
+    const dryRun = args.includes("--dry-run");
+    const draft = args.includes("--draft");
+    const force = args.includes("--force");
+    const baseMatch = args.match(/--base\s+(\S+)/);
+    const base = baseMatch?.[1] ?? nativeDetectMainBranch(basePath);
+    if (!isValidRefName(base)) {
+        ctx.ui.notify(`Invalid base branch name: ${base}`, "error");
+        return;
+    }
+    // 1. Validate milestone state
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+        ctx.ui.notify("No active milestone to ship. Complete milestone work first.", "warning");
+        return;
+    }
+    const milestoneId = state.activeMilestone.id;
+    const milestoneTitle = state.activeMilestone.title ?? "";
+    // 2. Check for incomplete work (use GSD phase as proxy — no phase field on ActiveRef)
+    if (state.phase !== "complete" && !force) {
+        ctx.ui.notify(`Milestone ${milestoneId} may not be complete (phase: ${state.phase}). Use --force to ship anyway.`, "warning");
+        return;
+    }
+    // 3. Generate PR content
+    const { title, body } = generatePRContent(basePath, milestoneId, milestoneTitle);
+    // 4. Dry-run — just show the PR content
+    if (dryRun) {
+        ctx.ui.notify(`--- PR Preview ---\n\nTitle: ${title}\n\n${body}`, "info");
+        return;
+    }
+    // 5. Check git state
+    const currentBranch = nativeGetCurrentBranch(basePath);
+    if (!isValidRefName(currentBranch)) {
+        ctx.ui.notify(`Current branch name is invalid for git: ${currentBranch}`, "error");
+        return;
+    }
+    if (currentBranch === base) {
+        ctx.ui.notify(`You're on ${base} — create a feature branch first.`, "warning");
+        return;
+    }
+    // 6. Push and create PR (all argv-safe, no shell interpolation)
+    try {
+        git(basePath, ["push", "-u", "origin", currentBranch]);
+        const ghArgs = ["pr", "create", "--base", base, "--title", title, "--body", body];
+        if (draft)
+            ghArgs.push("--draft");
+        const prUrl = execFileSync("gh", ghArgs, { cwd: basePath, encoding: "utf-8" }).trim();
+        ctx.ui.notify(`PR created: ${prUrl}`, "success");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to create PR: ${msg}`, "error");
+    }
+}

package/dist/resources/extensions/gsd/db-writer.js

@@ -301,8 +301,7 @@ export async function saveRequirementToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.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.message) });
@@ -405,7 +404,7 @@ export async function saveDecisionToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.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.message) });
@@ -614,8 +613,7 @@ export async function saveArtifactToDb(opts, basePath) {
             }
             catch (diskErr) {
                 logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+                db.deleteArtifactByPath(opts.path);
                 throw diskErr;
             }
         }

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -157,7 +157,7 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `phases`: fine-grained control over which phases run. Usually set by `token_profile`, but can be overridden. Keys:
   - `skip_research`: boolean — skip milestone-level research. Default: `false`.
-  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `false`.
+  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `true`.
   - `skip_reassess`: boolean — force-disable roadmap reassessment even if `reassess_after_slice` is enabled. Default: `false`.
   - `skip_slice_research`: boolean — skip per-slice research. Default: `false`.
 

package/dist/resources/extensions/gsd/gsd-db.js

@@ -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";
 import { dirname } from "node:path";
@@ -863,6 +878,50 @@ export function transaction(fn) {
         _txDepth--;
     }
 }
+/**
+ * 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(fn) {
+    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.message,
+            });
+        }
+        throw err;
+    }
+    finally {
+        _txDepth--;
+    }
+}
 export function insertDecision(d) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -2045,3 +2104,265 @@ export function getPendingGatesForTurn(milestoneId, sliceId, turn, taskId) {
 export function getPendingGateCountForTurn(milestoneId, sliceId, turn) {
     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) {
+    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) {
+    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) {
+    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() {
+    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) {
+    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) {
+    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, sliceId, ts) {
+    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) {
+    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) {
+    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);
+        }
+    });
+}
+/**
+ * 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) {
+    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) {
+    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, realId) {
+    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, content, confidence, updatedAt) {
+    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, updatedAt) {
+    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, newId, updatedAt) {
+    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, activityFile, processedAt) {
+    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, now) {
+    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, now) {
+    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/dist/resources/extensions/gsd/index.js

@@ -1,5 +1,18 @@
 export { isDepthConfirmationAnswer, isDepthVerified, isGateQuestionId, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockPendingGate, shouldBlockPendingGateBash, shouldBlockQueueExecution, setPendingGate, clearPendingGate, getPendingGate, } from "./bootstrap/write-gate.js";
 export default async function registerExtension(pi) {
-    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/dist/resources/extensions/gsd/md-importer.js

@@ -5,7 +5,7 @@
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, openDatabase, transaction, _getAdapter, } from './gsd-db.js';
+import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, openDatabase, transaction, updateSliceStatus, _getAdapter, } from './gsd-db.js';
 import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
@@ -571,9 +571,8 @@ export function migrateHierarchyToDb(basePath) {
                     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`);
                     }
                 }