gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -0,0 +1,187 @@
+/**
+ * MCP Status — `/gsd mcp` command handler.
+ *
+ * Shows configured MCP servers, their connection status, and available tools.
+ *
+ * Subcommands:
+ *   /gsd mcp             — Overview of all servers (alias: /gsd mcp status)
+ *   /gsd mcp status      — Same as bare /gsd mcp
+ *   /gsd mcp check <srv> — Detailed status for a specific server
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function readMcpConfigs() {
+    const servers = [];
+    const seen = new Set();
+    const configPaths = [
+        join(process.cwd(), ".mcp.json"),
+        join(process.cwd(), ".gsd", "mcp.json"),
+    ];
+    for (const configPath of configPaths) {
+        try {
+            if (!existsSync(configPath))
+                continue;
+            const raw = readFileSync(configPath, "utf-8");
+            const data = JSON.parse(raw);
+            const mcpServers = (data.mcpServers ?? data.servers);
+            if (!mcpServers || typeof mcpServers !== "object")
+                continue;
+            for (const [name, config] of Object.entries(mcpServers)) {
+                if (seen.has(name))
+                    continue;
+                seen.add(name);
+                const hasCommand = typeof config.command === "string";
+                const hasUrl = typeof config.url === "string";
+                const transport = hasCommand
+                    ? "stdio"
+                    : hasUrl
+                        ? "http"
+                        : "unknown";
+                servers.push({
+                    name,
+                    transport,
+                    ...(hasCommand && {
+                        command: config.command,
+                        args: Array.isArray(config.args) ? config.args : undefined,
+                    }),
+                    ...(hasUrl && { url: config.url }),
+                });
+            }
+        }
+        catch {
+            // Non-fatal — config file may not exist or be malformed
+        }
+    }
+    return servers;
+}
+// ─── Formatters (exported for testing) ──────────────────────────────────────
+export function formatMcpStatusReport(servers) {
+    if (servers.length === 0) {
+        return [
+            "No MCP servers configured.",
+            "",
+            "Add servers to .mcp.json or .gsd/mcp.json to enable MCP integrations.",
+            "See: https://modelcontextprotocol.io/quickstart",
+        ].join("\n");
+    }
+    const lines = [`MCP Server Status — ${servers.length} server(s)\n`];
+    for (const s of servers) {
+        const icon = s.error ? "✗" : s.connected ? "✓" : "○";
+        const status = s.error
+            ? `error: ${s.error}`
+            : s.connected
+                ? `connected — ${s.toolCount} tools`
+                : "disconnected";
+        lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}`);
+    }
+    lines.push("");
+    lines.push("Use /gsd mcp check <server> for details on a specific server.");
+    lines.push("Use mcp_discover to connect and list tools for a server.");
+    return lines.join("\n");
+}
+export function formatMcpServerDetail(server) {
+    const lines = [`MCP Server: ${server.name}\n`];
+    lines.push(`  Transport: ${server.transport}`);
+    if (server.error) {
+        lines.push(`  Status:    error`);
+        lines.push(`  Error:     ${server.error}`);
+    }
+    else if (server.connected) {
+        lines.push(`  Status:    connected`);
+        lines.push(`  Tools:     ${server.toolCount}`);
+        if (server.tools.length > 0) {
+            lines.push("");
+            lines.push("  Available tools:");
+            for (const tool of server.tools) {
+                lines.push(`    - ${tool}`);
+            }
+        }
+    }
+    else {
+        lines.push(`  Status:    disconnected`);
+        lines.push("");
+        lines.push(`  Run mcp_discover("${server.name}") to connect and list tools.`);
+    }
+    return lines.join("\n");
+}
+// ─── Command handler ────────────────────────────────────────────────────────
+/**
+ * Handle `/gsd mcp [status|check <server>]`.
+ */
+export async function handleMcpStatus(args, ctx) {
+    const trimmed = args.trim().toLowerCase();
+    const configs = readMcpConfigs();
+    // /gsd mcp check <server>
+    if (trimmed.startsWith("check ")) {
+        const serverName = args.trim().slice("check ".length).trim();
+        const config = configs.find((c) => c.name === serverName);
+        if (!config) {
+            const available = configs.map((c) => c.name).join(", ") || "(none)";
+            ctx.ui.notify(`Unknown MCP server: "${serverName}"\n\nAvailable: ${available}`, "warning");
+            return;
+        }
+        // Try to get connection/tool info from the mcp-client module if available
+        let connected = false;
+        let toolNames = [];
+        let error;
+        try {
+            const mcpClient = await import("../mcp-client/index.js");
+            // Access the module's connection state if exported; fall back gracefully
+            const mod = mcpClient;
+            if (typeof mod.getConnectionStatus === "function") {
+                const status = mod.getConnectionStatus(serverName);
+                connected = status.connected;
+                toolNames = status.tools;
+                error = status.error;
+            }
+        }
+        catch {
+            // mcp-client may not expose status helpers — that's fine
+        }
+        ctx.ui.notify(formatMcpServerDetail({
+            name: config.name,
+            transport: config.transport,
+            connected,
+            toolCount: toolNames.length,
+            tools: toolNames,
+            error,
+        }), "info");
+        return;
+    }
+    // /gsd mcp or /gsd mcp status
+    if (!trimmed || trimmed === "status") {
+        // Build status for each server
+        const statuses = [];
+        for (const config of configs) {
+            let connected = false;
+            let toolCount = 0;
+            let error;
+            try {
+                const mcpClient = await import("../mcp-client/index.js");
+                const mod = mcpClient;
+                if (typeof mod.getConnectionStatus === "function") {
+                    const status = mod.getConnectionStatus(config.name);
+                    connected = status.connected;
+                    toolCount = status.tools.length;
+                    error = status.error;
+                }
+            }
+            catch {
+                // Fall back to unknown state
+            }
+            statuses.push({
+                name: config.name,
+                transport: config.transport,
+                connected,
+                toolCount,
+                error,
+            });
+        }
+        ctx.ui.notify(formatMcpStatusReport(statuses), "info");
+        return;
+    }
+    // Unknown subcommand
+    ctx.ui.notify("Usage: /gsd mcp [status|check <server>]\n\n" +
+        "  status           Show all MCP server statuses (default)\n" +
+        "  check <server>   Detailed status for a specific server", "warning");
+}

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

@@ -8,10 +8,11 @@
 // Critical invariant: generated markdown must round-trip through
 // parseDecisionsTable() and parseRequirementsSections() with field fidelity.
 import { resolve } from 'node:path';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
 import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
+import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
@@ -200,7 +201,7 @@ export async function nextDecisionId() {
         return `D${String(next).padStart(3, '0')}`;
     }
     catch (err) {
-        process.stderr.write(`gsd-db: nextDecisionId failed: ${err.message}\n`);
+        logError('manifest', 'nextDecisionId failed', { fn: 'nextDecisionId', error: String(err.message) });
         return 'D001';
     }
 }
@@ -269,7 +270,7 @@ export async function saveDecisionToDb(fields, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            process.stderr.write(`gsd-db: saveDecisionToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
+            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
             adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
             throw diskErr;
         }
@@ -281,7 +282,7 @@ export async function saveDecisionToDb(fields, basePath) {
         return { id };
     }
     catch (err) {
-        process.stderr.write(`gsd-db: saveDecisionToDb failed: ${err.message}\n`);
+        logError('manifest', 'saveDecisionToDb failed', { fn: 'saveDecisionToDb', error: String(err.message) });
         throw err;
     }
 }
@@ -333,7 +334,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            process.stderr.write(`gsd-db: updateRequirementInDb — disk write failed, reverting DB row: ${diskErr.message}\n`);
+            logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
             db.upsertRequirement(existing);
             throw diskErr;
         }
@@ -344,7 +345,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
         clearParseCache();
     }
     catch (err) {
-        process.stderr.write(`gsd-db: updateRequirementInDb failed: ${err.message}\n`);
+        logError('manifest', 'updateRequirementInDb failed', { fn: 'updateRequirementInDb', error: String(err.message) });
         throw err;
     }
 }
@@ -356,28 +357,45 @@ export async function updateRequirementInDb(id, updates, basePath) {
 export async function saveArtifactToDb(opts, basePath) {
     try {
         const db = await import('./gsd-db.js');
+        // Guard against path traversal before any reads/writes
+        const gsdDir = resolve(basePath, '.gsd');
+        const fullPath = resolve(basePath, '.gsd', opts.path);
+        if (!fullPath.startsWith(gsdDir)) {
+            throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
+        }
+        // Shrinkage guard: if the file already exists and the new content is
+        // significantly smaller (<50%), preserve the richer file on disk and
+        // store its content in the DB instead of the abbreviated version.
+        let dbContent = opts.content;
+        let skipDiskWrite = false;
+        if (existsSync(fullPath)) {
+            const existingSize = statSync(fullPath).size;
+            const newSize = Buffer.byteLength(opts.content, 'utf-8');
+            if (existingSize > 0 && newSize < existingSize * 0.5) {
+                logWarning('manifest', `new content (${newSize}B) is <50% of existing file (${existingSize}B), preserving disk file`, { fn: 'saveArtifactToDb', path: opts.path });
+                dbContent = readFileSync(fullPath, 'utf-8');
+                skipDiskWrite = true;
+            }
+        }
         db.insertArtifact({
             path: opts.path,
             artifact_type: opts.artifact_type,
             milestone_id: opts.milestone_id ?? null,
             slice_id: opts.slice_id ?? null,
             task_id: opts.task_id ?? null,
-            full_content: opts.content,
+            full_content: dbContent,
         });
-        // Write the file to disk (guard against path traversal)
-        const gsdDir = resolve(basePath, '.gsd');
-        const fullPath = resolve(basePath, '.gsd', opts.path);
-        if (!fullPath.startsWith(gsdDir)) {
-            throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
-        }
-        try {
-            await saveFile(fullPath, opts.content);
-        }
-        catch (diskErr) {
-            process.stderr.write(`gsd-db: saveArtifactToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
-            const rollbackAdapter = db._getAdapter();
-            rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
-            throw diskErr;
+        // Write the file to disk (only if we're not preserving a richer existing file)
+        if (!skipDiskWrite) {
+            try {
+                await saveFile(fullPath, opts.content);
+            }
+            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 });
+                throw diskErr;
+            }
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.
@@ -386,7 +404,7 @@ export async function saveArtifactToDb(opts, basePath) {
         clearParseCache();
     }
     catch (err) {
-        process.stderr.write(`gsd-db: saveArtifactToDb failed: ${err.message}\n`);
+        logError('manifest', 'saveArtifactToDb failed', { fn: 'saveArtifactToDb', error: String(err.message) });
         throw err;
     }
 }

package/dist/resources/extensions/gsd/doctor-checks.js

@@ -17,7 +17,7 @@ import { getAllWorktreeHealth } from "./worktree-health.js";
 import { readAllSessionStatuses, isSessionStale, removeSessionStatus } from "./session-status-io.js";
 import { recoverFailedMigration } from "./migrate-external.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "worktree") {
+export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
         return; // Not a git repo — skip all git health checks

package/dist/resources/extensions/gsd/doctor.js

@@ -332,8 +332,8 @@ export async function runGSDDoctor(basePath, options) {
     // Git health checks — timed
     const t0git = Date.now();
     const isolationMode = options?.isolationMode ??
-        (prefs?.preferences?.git?.isolation === "none" ? "none" :
-            prefs?.preferences?.git?.isolation === "branch" ? "branch" : "worktree");
+        (prefs?.preferences?.git?.isolation === "worktree" ? "worktree" :
+            prefs?.preferences?.git?.isolation === "branch" ? "branch" : "none");
     await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode);
     const gitMs = Date.now() - t0git;
     // Runtime health checks — timed
@@ -441,6 +441,7 @@ export async function runGSDDoctor(basePath, options) {
                 id: s.id,
                 title: s.title,
                 done: s.status === "complete",
+                pending: s.status === "pending",
                 risk: (s.risk || "medium"),
                 depends: s.depends,
                 demo: s.demo,
@@ -528,6 +529,10 @@ export async function runGSDDoctor(basePath, options) {
             }
             const slicePath = resolveSlicePath(basePath, milestoneId, slice.id);
             if (!slicePath) {
+                // Pending slices haven't been planned yet — directories are created
+                // lazily by ensurePreconditions() at dispatch time. Skip them.
+                if (slice.pending)
+                    continue;
                 const expectedPath = relSlicePath(basePath, milestoneId, slice.id);
                 issues.push({
                     severity: slice.done ? "warning" : "error",
@@ -549,6 +554,9 @@ export async function runGSDDoctor(basePath, options) {
             }
             const tasksDir = resolveTasksDir(basePath, milestoneId, slice.id);
             if (!tasksDir) {
+                // Pending slices haven't been planned yet — tasks/ is created on demand.
+                if (slice.pending)
+                    continue;
                 issues.push({
                     severity: slice.done ? "warning" : "error",
                     code: "missing_tasks_dir",

package/dist/resources/extensions/gsd/git-service.js

@@ -510,13 +510,18 @@ export class GitServiceImpl {
  * Returns the PR URL on success, or null on failure.
  * Non-fatal: callers should treat failure as best-effort.
  */
-export function createDraftPR(basePath, milestoneId, title, body) {
+export function createDraftPR(basePath, milestoneId, title, body, opts) {
     try {
-        const result = execFileSync("gh", [
+        const args = [
             "pr", "create", "--draft",
             "--title", title,
             "--body", body,
-        ], { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
+        ];
+        if (opts?.head)
+            args.push("--head", opts.head);
+        if (opts?.base)
+            args.push("--base", opts.base);
+        const result = execFileSync("gh", args, { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
         return result.trim();
     }
     catch {

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

@@ -56,7 +56,11 @@ function loadProvider() {
     catch {
         // unavailable
     }
-    process.stderr.write("gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3)\n");
+    const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+    const versionHint = nodeMajor < 22
+        ? ` GSD requires Node >= 22.0.0 (current: v${process.versions.node}). Upgrade Node to fix this.`
+        : "";
+    process.stderr.write(`gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3).${versionHint}\n`);
 }
 function normalizeRow(row) {
     if (row == null)
@@ -253,6 +257,7 @@ function initSchema(db, fileBacked) {
         inputs TEXT NOT NULL DEFAULT '[]',
         expected_output TEXT NOT NULL DEFAULT '[]',
         observability_impact TEXT NOT NULL DEFAULT '',
+        full_plan_md TEXT NOT NULL DEFAULT '',
         sequence INTEGER DEFAULT 0, -- DEAD CODE: no tool exposes sequence — always 0
         PRIMARY KEY (milestone_id, slice_id, id),
         FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
@@ -542,6 +547,13 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 11) {
+            ensureColumn(db, "tasks", "full_plan_md", `ALTER TABLE tasks ADD COLUMN full_plan_md TEXT NOT NULL DEFAULT ''`);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 11,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -997,7 +1009,8 @@ export function upsertTaskPlanning(milestoneId, sliceId, taskId, planning) {
       verify = COALESCE(:verify, verify),
       inputs = COALESCE(:inputs, inputs),
       expected_output = COALESCE(:expected_output, expected_output),
-      observability_impact = COALESCE(:observability_impact, observability_impact)
+      observability_impact = COALESCE(:observability_impact, observability_impact),
+      full_plan_md = COALESCE(:full_plan_md, full_plan_md)
      WHERE milestone_id = :milestone_id AND slice_id = :slice_id AND id = :id`).run({
         ":milestone_id": milestoneId,
         ":slice_id": sliceId,
@@ -1010,6 +1023,7 @@ export function upsertTaskPlanning(milestoneId, sliceId, taskId, planning) {
         ":inputs": planning.inputs ? JSON.stringify(planning.inputs) : null,
         ":expected_output": planning.expectedOutput ? JSON.stringify(planning.expectedOutput) : null,
         ":observability_impact": planning.observabilityImpact ?? null,
+        ":full_plan_md": planning.fullPlanMd ?? null,
     });
 }
 function rowToSlice(row) {
@@ -1078,6 +1092,7 @@ function rowToTask(row) {
         inputs: JSON.parse(row["inputs"] || "[]"),
         expected_output: JSON.parse(row["expected_output"] || "[]"),
         observability_impact: row["observability_impact"] ?? "",
+        full_plan_md: row["full_plan_md"] ?? "",
         sequence: row["sequence"] ?? 0,
     };
 }

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -298,7 +298,7 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     mkdirSync(tasksDir, { recursive: true });
     const absPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
     const artifactPath = toArtifactPath(absPath, basePath);
-    const content = renderTaskPlanMarkdown(task);
+    const content = task.full_plan_md.trim() ? task.full_plan_md : renderTaskPlanMarkdown(task);
     await writeAndStore(absPath, artifactPath, content, {
         artifact_type: "PLAN",
         milestone_id: milestoneId,

package/dist/resources/extensions/gsd/preferences-types.js

@@ -13,7 +13,7 @@ export const MODE_DEFAULTS = {
             push_branches: false,
             pre_merge_check: false,
             merge_strategy: "squash",
-            isolation: "worktree",
+            isolation: "none",
         },
         unique_milestone_ids: false,
     },
@@ -23,7 +23,7 @@ export const MODE_DEFAULTS = {
             push_branches: true,
             pre_merge_check: true,
             merge_strategy: "squash",
-            isolation: "worktree",
+            isolation: "none",
         },
         unique_milestone_ids: true,
     },

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

@@ -125,6 +125,11 @@ function loadPreferencesFile(path, scope) {
         ...(allWarnings.length > 0 ? { warnings: allWarnings } : {}),
     };
 }
+let _warnedUnrecognizedFormat = false;
+/** @internal Reset the warn-once flag — exported for testing only. */
+export function _resetParseWarningFlag() {
+    _warnedUnrecognizedFormat = false;
+}
 /** @internal Exported for testing only */
 export function parsePreferencesMarkdown(content) {
     // Use indexOf instead of [\s\S]*? regex to avoid backtracking (#468)
@@ -142,7 +147,10 @@ export function parsePreferencesMarkdown(content) {
     if (/^##\s+\w/m.test(content)) {
         return parseHeadingListFormat(content);
     }
-    console.warn("[parsePreferencesMarkdown] preferences.md exists but uses an unrecognized format — skipping.");
+    if (!_warnedUnrecognizedFormat) {
+        _warnedUnrecognizedFormat = true;
+        console.warn("[parsePreferencesMarkdown] preferences.md exists but uses an unrecognized format — skipping.");
+    }
     return null;
 }
 function parseFrontmatterBlock(frontmatter) {
@@ -385,15 +393,19 @@ export function resolvePreDispatchHooks() {
 // ─── Isolation & Parallel ─────────────────────────────────────────────────────
 /**
  * Resolve the effective git isolation mode from preferences.
- * Returns "worktree" (default), "branch", or "none".
+ * Returns "none" (default), "worktree", or "branch".
+ *
+ * Default is "none" so GSD works out of the box without preferences.md.
+ * Worktree isolation requires explicit opt-in because it depends on git
+ * branch infrastructure that must be set up before use.
  */
 export function getIsolationMode() {
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
-    if (prefs?.isolation === "none")
-        return "none";
+    if (prefs?.isolation === "worktree")
+        return "worktree";
     if (prefs?.isolation === "branch")
         return "branch";
-    return "worktree"; // default
+    return "none"; // default — no isolation, work on current branch
 }
 export function resolveParallelConfig(prefs) {
     return {

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

@@ -21,8 +21,8 @@ Then:
 4. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. List any criterion that was NOT met.
 5. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly.
 6. Validate **requirement status transitions**. For each requirement that changed status during this milestone, confirm the transition is supported by evidence. Requirements can move between Active, Validated, Deferred, Blocked, or Out of Scope — but only with proof.
-7. Write `{{milestoneSummaryPath}}` using the milestone-summary template. Fill all frontmatter fields and narrative sections. The `requirement_outcomes` field must list every requirement that changed status with `from_status`, `to_status`, and `proof`.
-8. Update `.gsd/REQUIREMENTS.md` if any requirement status transitions were validated in step 5.
+7. **Persist completion through `gsd_complete_milestone`.** Call it with: `milestoneId`, `title`, `oneLiner`, `narrative`, `successCriteriaResults`, `definitionOfDoneResults`, `requirementOutcomes`, `keyDecisions`, `keyFiles`, `lessonsLearned`, `followUps`, `deviations`. The tool updates the milestone status in the DB, renders `{{milestoneSummaryPath}}`, and validates all slices are complete before proceeding.
+8. Update `.gsd/REQUIREMENTS.md` if any requirement status transitions were validated in step 6.
 9. Update `.gsd/PROJECT.md` to reflect milestone completion and current project state.
 10. Review all slice summaries for cross-cutting lessons, patterns, or gotchas that emerged during this milestone. Append any non-obvious, reusable insights to `.gsd/KNOWLEDGE.md`.
 11. Do not commit manually — the system auto-commits your changes after this unit completes.
@@ -31,6 +31,4 @@ Then:
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
 
-**You MUST write `{{milestoneSummaryPath}}` AND update PROJECT.md before finishing.**
-
 When done, say: "Milestone {{milestoneId}} complete."

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

@@ -63,7 +63,7 @@ Then:
    - a matching task plan file with description, steps, must-haves, verification, inputs, and expected output
    - **Inputs and Expected Output must list concrete backtick-wrapped file paths** (e.g. `` `src/types.ts` ``). These are machine-parsed to derive task dependencies — vague prose without paths breaks parallel execution. Every task must have at least one output file path.
    - Observability Impact section **only if the task touches runtime boundaries, async flows, or error paths** — omit it otherwise
-6. **Persist planning state through DB-backed tools.** Call `gsd_plan_slice` with the full slice planning payload (goal, demo, must-haves, verification, tasks, and metadata). Then call `gsd_plan_task` for each task to persist its planning fields. These tools write to the DB and render `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` files automatically. Do **not** rely on direct `PLAN.md` writes as the source of truth; the DB-backed tools are the canonical write path for slice and task planning state.
+6. **Persist planning state through `gsd_plan_slice`.** Call it with the full slice planning payload (goal, demo, must-haves, verification, tasks, and metadata). The tool inserts all tasks in the same transaction, writes to the DB, and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` files automatically. Do **not** call `gsd_plan_task` separately — `gsd_plan_slice` handles task persistence. Do **not** rely on direct `PLAN.md` writes as the source of truth; the DB-backed tool is the canonical write path for slice and task planning state.
 7. **Self-audit the plan.** Walk through each check — if any fail, fix the plan files before moving on:
     - **Completion semantics:** If every task were completed exactly as written, the slice goal/demo should actually be true.
     - **Requirement coverage:** Every must-have in the slice maps to at least one task. No must-have is orphaned. If `REQUIREMENTS.md` exists, every Active requirement this slice owns maps to at least one task.

package/dist/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -50,14 +50,14 @@ If all criteria have at least one remaining owning slice, the coverage check pas
 
 **If the roadmap is still good:**
 
-Write `{{assessmentPath}}` with a brief confirmation that roadmap coverage still holds after {{completedSliceId}}. If requirements exist, explicitly note whether requirement coverage remains sound. If `gsd_reassess_roadmap` is available, use it with `verdict: "roadmap-confirmed"`, an empty `sliceChanges` object, and the assessment text — the tool writes the assessment to the DB and renders ASSESSMENT.md.
+Use `gsd_reassess_roadmap` with `verdict: "roadmap-confirmed"`, an empty `sliceChanges` object, and the assessment text — the tool writes the assessment to the DB and renders `{{assessmentPath}}`. If requirements exist, explicitly note whether requirement coverage remains sound.
 
 **If changes are needed:**
 
-1. **Persist changes through `gsd_reassess_roadmap`.** Pass: `milestoneId`, `completedSliceId`, `verdict` (e.g. "roadmap-adjusted"), `assessment` (text explaining the decision), and `sliceChanges` with `modified` (array of sliceId, title, risk, depends, demo), `added` (same shape), `removed` (array of slice ID strings). The tool structurally enforces preservation of completed slices, writes the assessment to the DB, re-renders ROADMAP.md, and renders ASSESSMENT.md. Skip step 2 when this tool succeeds.
-2. **Degraded fallback — direct file writes:** If `gsd_reassess_roadmap` is not available, rewrite the remaining (unchecked) slices in `{{roadmapPath}}` directly. Keep completed slices exactly as they are (`[x]`). Update the boundary map for changed slices. Update the proof strategy if risks changed. Update requirement coverage if ownership or scope changed.
-3. Write `{{assessmentPath}}` explaining what changed and why — keep it brief and concrete.
-4. If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
-5. {{commitInstruction}}
+**Persist changes through `gsd_reassess_roadmap`.** Pass: `milestoneId`, `completedSliceId`, `verdict` (e.g. "roadmap-adjusted"), `assessment` (text explaining the decision), and `sliceChanges` with `modified` (array of sliceId, title, risk, depends, demo), `added` (same shape), `removed` (array of slice ID strings). The tool structurally enforces preservation of completed slices, writes the assessment to the DB, re-renders `{{roadmapPath}}`, and renders `{{assessmentPath}}`.
+
+If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
+
+{{commitInstruction}}
 
 When done, say: "Roadmap reassessed."

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

@@ -32,19 +32,8 @@ Consider these captures when rewriting the remaining tasks — they represent th
 
 1. Read the blocker task summary carefully. Understand exactly what was discovered and why it blocks the current plan.
 2. Analyze the remaining `[ ]` tasks in the slice plan. Determine which are still valid, which need modification, and which should be replaced.
-3. **Persist replan state through `gsd_replan_slice`.** Call it with the following parameters: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders PLAN.md, and renders REPLAN.md. Skip steps 4–5 when this tool succeeds.
-4. **Degraded fallback — direct file writes:** If `gsd_replan_slice` is not available, fall back to writing files directly. Write `{{replanPath}}` documenting:
-   - What blocker was discovered and in which task
-   - What changed in the plan and why
-   - Which incomplete tasks were modified, added, or removed
-   - Any new risks or considerations introduced by the replan
-5. If using the degraded fallback, rewrite `{{planPath}}` with the updated slice plan:
-   - Keep all `[x]` tasks exactly as they were (same IDs, same descriptions, same checkmarks)
-   - Update the `[ ]` tasks to address the blocker
-   - Ensure the slice Goal and Demo sections are still achievable with the new tasks, or update them if the blocker fundamentally changes what the slice can deliver
-   - Update the Files Likely Touched section if the replan changes which files are affected
-   - If a DB-backed planning tool exists for this phase, use it as the source of truth and make any rewritten `PLAN.md` reflect that persisted state rather than bypassing it
-6. If any incomplete task had a `T0x-PLAN.md`, remove or rewrite it to match the new task description.
-7. Do not commit manually — the system auto-commits your changes after this unit completes.
+3. **Persist replan state through `gsd_replan_slice`.** Call it with: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders `{{planPath}}`, and renders `{{replanPath}}`.
+4. If any incomplete task had a `T0x-PLAN.md`, remove or rewrite it to match the new task description.
+5. Do not commit manually — the system auto-commits your changes after this unit completes.
 
 When done, say: "Slice {{sliceId}} replanned."