gsd-pi 2.44.0 → 2.45.0-dev.e0ee972

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -0,0 +1,247 @@
+/**
+ * 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 type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface McpServerStatus {
+  name: string;
+  transport: "stdio" | "http" | "unknown";
+  connected: boolean;
+  toolCount: number;
+  error: string | undefined;
+}
+
+export interface McpServerDetail extends McpServerStatus {
+  tools: string[];
+}
+
+// ─── Config reader (standalone — does not import mcp-client internals) ──────
+
+interface McpServerRawConfig {
+  name: string;
+  transport: "stdio" | "http" | "unknown";
+  command?: string;
+  args?: string[];
+  url?: string;
+}
+
+function readMcpConfigs(): McpServerRawConfig[] {
+  const servers: McpServerRawConfig[] = [];
+  const seen = new Set<string>();
+  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) as Record<string, unknown>;
+      const mcpServers = (data.mcpServers ?? data.servers) as
+        | Record<string, Record<string, unknown>>
+        | undefined;
+      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: McpServerRawConfig["transport"] = hasCommand
+          ? "stdio"
+          : hasUrl
+            ? "http"
+            : "unknown";
+
+        servers.push({
+          name,
+          transport,
+          ...(hasCommand && {
+            command: config.command as string,
+            args: Array.isArray(config.args) ? (config.args as string[]) : undefined,
+          }),
+          ...(hasUrl && { url: config.url as string }),
+        });
+      }
+    } catch {
+      // Non-fatal — config file may not exist or be malformed
+    }
+  }
+
+  return servers;
+}
+
+// ─── Formatters (exported for testing) ──────────────────────────────────────
+
+export function formatMcpStatusReport(servers: McpServerStatus[]): string {
+  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: string[] = [`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: McpServerDetail): string {
+  const lines: string[] = [`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: string,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  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: string[] = [];
+    let error: string | undefined;
+    try {
+      const mcpClient = await import("../mcp-client/index.js");
+      // Access the module's connection state if exported; fall back gracefully
+      const mod = mcpClient as Record<string, unknown>;
+      if (typeof mod.getConnectionStatus === "function") {
+        const status = (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(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: McpServerStatus[] = [];
+
+    for (const config of configs) {
+      let connected = false;
+      let toolCount = 0;
+      let error: string | undefined;
+
+      try {
+        const mcpClient = await import("../mcp-client/index.js");
+        const mod = mcpClient as Record<string, unknown>;
+        if (typeof mod.getConnectionStatus === "function") {
+          const status = (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(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/src/resources/extensions/gsd/db-writer.ts

@@ -9,11 +9,12 @@
 // parseDecisionsTable() and parseRequirementsSections() with field fidelity.
 
 import { join, resolve } from 'node:path';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, statSync } from 'node:fs';
 import type { Decision, Requirement } from './types.js';
 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';
@@ -221,7 +222,7 @@ export async function nextDecisionId(): Promise<string> {
     const next = maxNum + 1;
     return `D${String(next).padStart(3, '0')}`;
   } catch (err) {
-    process.stderr.write(`gsd-db: nextDecisionId failed: ${(err as Error).message}\n`);
+    logError('manifest', 'nextDecisionId failed', { fn: 'nextDecisionId', error: String((err as Error).message) });
     return 'D001';
   }
 }
@@ -311,9 +312,7 @@ export async function saveDecisionToDb(
     try {
       await saveFile(filePath, md);
     } catch (diskErr) {
-      process.stderr.write(
-        `gsd-db: saveDecisionToDb — disk write failed, rolling back DB row: ${(diskErr as Error).message}\n`,
-      );
+      logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String((diskErr as Error).message) });
       adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
       throw diskErr;
     }
@@ -325,7 +324,7 @@ export async function saveDecisionToDb(
 
     return { id };
   } catch (err) {
-    process.stderr.write(`gsd-db: saveDecisionToDb failed: ${(err as Error).message}\n`);
+    logError('manifest', 'saveDecisionToDb failed', { fn: 'saveDecisionToDb', error: String((err as Error).message) });
     throw err;
   }
 }
@@ -388,9 +387,7 @@ export async function updateRequirementInDb(
     try {
       await saveFile(filePath, md);
     } catch (diskErr) {
-      process.stderr.write(
-        `gsd-db: updateRequirementInDb — disk write failed, reverting DB row: ${(diskErr as Error).message}\n`,
-      );
+      logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String((diskErr as Error).message) });
       db.upsertRequirement(existing);
       throw diskErr;
     }
@@ -400,7 +397,7 @@ export async function updateRequirementInDb(
     clearPathCache();
     clearParseCache();
   } catch (err) {
-    process.stderr.write(`gsd-db: updateRequirementInDb failed: ${(err as Error).message}\n`);
+    logError('manifest', 'updateRequirementInDb failed', { fn: 'updateRequirementInDb', error: String((err as Error).message) });
     throw err;
   }
 }
@@ -428,30 +425,47 @@ export async function saveArtifactToDb(
   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 as Error).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 as Error).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.
@@ -459,7 +473,7 @@ export async function saveArtifactToDb(
     clearPathCache();
     clearParseCache();
   } catch (err) {
-    process.stderr.write(`gsd-db: saveArtifactToDb failed: ${(err as Error).message}\n`);
+    logError('manifest', 'saveArtifactToDb failed', { fn: 'saveArtifactToDb', error: String((err as Error).message) });
     throw err;
   }
 }

package/src/resources/extensions/gsd/doctor-checks.ts

@@ -25,7 +25,7 @@ export async function checkGitHealth(
   issues: DoctorIssue[],
   fixesApplied: string[],
   shouldFix: (code: DoctorIssueCode) => boolean,
-  isolationMode: "none" | "worktree" | "branch" = "worktree",
+  isolationMode: "none" | "worktree" | "branch" = "none",
 ): Promise<void> {
   // Degrade gracefully if not a git repo
   if (!nativeIsRepo(basePath)) {

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

@@ -360,8 +360,8 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
   // Git health checks — timed
   const t0git = Date.now();
   const isolationMode: "none" | "worktree" | "branch" = 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;
 
@@ -470,7 +470,7 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
     if (!roadmapContent) continue;
 
     // Normalize slices: prefer DB, fall back to parser
-    type NormSlice = RoadmapSliceEntry;
+    type NormSlice = RoadmapSliceEntry & { pending?: boolean };
     let slices: NormSlice[];
     if (isDbAvailable()) {
       const dbSlices = getMilestoneSlices(milestoneId);
@@ -478,6 +478,7 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
         id: s.id,
         title: s.title,
         done: s.status === "complete",
+        pending: s.status === "pending",
         risk: (s.risk || "medium") as RoadmapSliceEntry["risk"],
         depends: s.depends,
         demo: s.demo,
@@ -564,6 +565,9 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
 
       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",
@@ -586,6 +590,8 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
 
       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/src/resources/extensions/gsd/git-service.ts

@@ -684,13 +684,17 @@ export function createDraftPR(
   milestoneId: string,
   title: string,
   body: string,
+  opts?: { head?: string; base?: string },
 ): string | null {
   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 {
     return null;

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

@@ -78,8 +78,12 @@ function loadProvider(): void {
     // unavailable
   }
 
+  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)\n",
+    `gsd-db: No SQLite provider available (tried node:sqlite, better-sqlite3).${versionHint}\n`,
   );
 }
 
@@ -301,6 +305,7 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
         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)
@@ -616,6 +621,15 @@ function migrateSchema(db: DbAdapter): void {
       });
     }
 
+    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) {
     db.exec("ROLLBACK");
@@ -923,6 +937,7 @@ export interface TaskPlanningRecord {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact: string;
+  fullPlanMd?: string;
 }
 
 export function insertMilestone(m: {
@@ -1163,7 +1178,8 @@ export function upsertTaskPlanning(milestoneId: string, sliceId: string, taskId:
       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,
@@ -1177,6 +1193,7 @@ export function upsertTaskPlanning(milestoneId: string, sliceId: string, taskId:
     ":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,
   });
 }
 
@@ -1268,6 +1285,7 @@ export interface TaskRow {
   inputs: string[];
   expected_output: string[];
   observability_impact: string;
+  full_plan_md: string;
   sequence: number;
 }
 
@@ -1296,6 +1314,7 @@ function rowToTask(row: Record<string, unknown>): TaskRow {
     inputs: JSON.parse((row["inputs"] as string) || "[]"),
     expected_output: JSON.parse((row["expected_output"] as string) || "[]"),
     observability_impact: (row["observability_impact"] as string) ?? "",
+    full_plan_md: (row["full_plan_md"] as string) ?? "",
     sequence: (row["sequence"] as number) ?? 0,
   };
 }

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

@@ -32,7 +32,12 @@ export type JournalEventType =
   | "milestone-transition"
   | "stuck-detected"
   | "sidecar-dequeue"
-  | "iteration-end";
+  | "iteration-end"
+  | "worktree-enter"
+  | "worktree-create-failed"
+  | "worktree-skip"
+  | "worktree-merge-start"
+  | "worktree-merge-failed";
 
 /** A single structured event in the journal. */
 export interface JournalEntry {

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -387,7 +387,7 @@ export async function renderTaskPlanFromDb(
   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",

package/src/resources/extensions/gsd/preferences-types.ts

@@ -34,7 +34,7 @@ export const MODE_DEFAULTS: Record<WorkflowMode, Partial<GSDPreferences>> = {
       push_branches: false,
       pre_merge_check: false,
       merge_strategy: "squash",
-      isolation: "worktree",
+      isolation: "none",
     },
     unique_milestone_ids: false,
   },
@@ -44,7 +44,7 @@ export const MODE_DEFAULTS: Record<WorkflowMode, Partial<GSDPreferences>> = {
       push_branches: true,
       pre_merge_check: true,
       merge_strategy: "squash",
-      isolation: "worktree",
+      isolation: "none",
     },
     unique_milestone_ids: true,
   },

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

@@ -196,6 +196,13 @@ function loadPreferencesFile(path: string, scope: "global" | "project"): LoadedG
   };
 }
 
+let _warnedUnrecognizedFormat = false;
+
+/** @internal Reset the warn-once flag — exported for testing only. */
+export function _resetParseWarningFlag(): void {
+  _warnedUnrecognizedFormat = false;
+}
+
 /** @internal Exported for testing only */
 export function parsePreferencesMarkdown(content: string): GSDPreferences | null {
   // Use indexOf instead of [\s\S]*? regex to avoid backtracking (#468)
@@ -214,7 +221,10 @@ export function parsePreferencesMarkdown(content: string): GSDPreferences | null
     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;
 }
 
@@ -487,13 +497,17 @@ export function resolvePreDispatchHooks(): PreDispatchHookConfig[] {
 
 /**
  * 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(): "none" | "worktree" | "branch" {
   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: GSDPreferences | undefined): import("./types.js").ParallelConfig {

package/src/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/src/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.