gsd-pi 2.44.0-dev.73f2fd5 → 2.44.0-dev.8894d5b

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -162,7 +162,6 @@ export function syncGsdStateToWorktree(
     "OVERRIDES.md",
     "QUEUE.md",
     "completed-units.json",
-    "metrics.json",
   ];
   for (const f of rootFiles) {
     const src = join(mainGsd, f);
@@ -326,9 +325,8 @@ export function syncWorktreeStateBack(
   // ── 1. Sync root-level .gsd/ files back ──────────────────────────────
   // The worktree is authoritative — complete-milestone updates REQUIREMENTS,
   // PROJECT, etc. These must overwrite main's copies so they survive teardown.
-  // Also includes QUEUE.md, completed-units.json, and metrics.json which are
-  // written during milestone closeout and lost on teardown without explicit sync
-  // (#1787, #2313).
+  // Also includes QUEUE.md and completed-units.json which are written during
+  // milestone closeout and lost on teardown without explicit sync (#1787).
   const rootFiles = [
     "DECISIONS.md",
     "REQUIREMENTS.md",
@@ -337,7 +335,6 @@ export function syncWorktreeStateBack(
     "OVERRIDES.md",
     "QUEUE.md",
     "completed-units.json",
-    "metrics.json",
   ];
   for (const f of rootFiles) {
     const src = join(wtGsd, f);
@@ -1323,9 +1320,9 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 9b. Auto-create PR if enabled (#2302: no longer gated on pushed/auto_push)
+  // 9b. Auto-create PR if enabled (requires push_branches + push succeeded)
   let prCreated = false;
-  if (prefs.auto_pr === true && !nothingToCommit) {
+  if (prefs.auto_pr === true && pushed) {
     const remote = prefs.remote ?? "origin";
     const prTarget = prefs.pr_target_branch ?? mainBranch;
     try {
@@ -1335,9 +1332,9 @@ export function mergeMilestoneToMain(
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
       });
-      // Create PR via gh CLI with explicit --head and --base (#2302)
+      // Create PR via gh CLI
       execFileSync("gh", [
-        "pr", "create", "--draft",
+        "pr", "create",
         "--base", prTarget,
         "--head", milestoneBranch,
         "--title", `Milestone ${milestoneId} complete`,

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

@@ -610,48 +610,14 @@ export async function stopAuto(
     }
 
     // ── Step 4: Auto-worktree exit ──
-    // When the milestone is complete (has a SUMMARY), merge the worktree branch
-    // back to main so code isn't stranded on the worktree branch (#2317).
-    // For incomplete milestones, preserve the branch for later resumption.
     try {
       if (s.currentMilestoneId) {
         const notifyCtx = ctx
           ? { notify: ctx.ui.notify.bind(ctx.ui) }
           : { notify: () => {} };
-        const resolver = buildResolver();
-
-        // Check if the milestone is complete — SUMMARY file is the authoritative signal.
-        let milestoneComplete = false;
-        try {
-          const summaryPath = resolveMilestoneFile(
-            s.originalBasePath || s.basePath,
-            s.currentMilestoneId,
-            "SUMMARY",
-          );
-          if (!summaryPath) {
-            // Also check in the worktree path (SUMMARY may not be synced yet)
-            const wtSummaryPath = resolveMilestoneFile(
-              s.basePath,
-              s.currentMilestoneId,
-              "SUMMARY",
-            );
-            milestoneComplete = wtSummaryPath !== null;
-          } else {
-            milestoneComplete = true;
-          }
-        } catch {
-          // Non-fatal — fall through to preserveBranch path
-        }
-
-        if (milestoneComplete) {
-          // Milestone is complete — merge worktree branch back to main
-          resolver.mergeAndExit(s.currentMilestoneId, notifyCtx);
-        } else {
-          // Milestone still in progress — preserve branch for later resumption
-          resolver.exitMilestone(s.currentMilestoneId, notifyCtx, {
-            preserveBranch: true,
-          });
-        }
+        buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
+          preserveBranch: true,
+        });
       }
     } catch (e) {
       debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });

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

@@ -1,6 +1,5 @@
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-import { Text } from "@gsd/pi-tui";
 
 import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMilestoneIds } from "../guided-flow.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
@@ -88,22 +87,6 @@ export function registerDbTools(pi: ExtensionAPI): void {
       ], { description: "Who made this decision: 'human' (user directed), 'agent' (LLM decided autonomously), or 'collaborative' (discussed and agreed). Default: 'agent'" })),
     }),
     execute: decisionSaveExecute,
-    renderCall(args: any, theme: any) {
-      let text = theme.fg("toolTitle", theme.bold("decision_save "));
-      if (args.scope) text += theme.fg("accent", `[${args.scope}] `);
-      if (args.decision) text += theme.fg("muted", args.decision);
-      if (args.choice) text += theme.fg("dim", ` — ${args.choice}`);
-      return new Text(text, 0, 0);
-    },
-    renderResult(result: any, _options: any, theme: any) {
-      const d = result.details;
-      if (result.isError || d?.error) {
-        return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
-      }
-      let text = theme.fg("success", `Decision ${d?.id ?? ""} saved`);
-      if (d?.id) text += theme.fg("dim", ` → DECISIONS.md`);
-      return new Text(text, 0, 0);
-    },
   };
 
   pi.registerTool(decisionSaveTool);
@@ -174,22 +157,6 @@ export function registerDbTools(pi: ExtensionAPI): void {
       supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
     }),
     execute: requirementUpdateExecute,
-    renderCall(args: any, theme: any) {
-      let text = theme.fg("toolTitle", theme.bold("requirement_update "));
-      if (args.id) text += theme.fg("accent", args.id);
-      const fields = ["status", "validation", "notes", "description"].filter((f) => args[f]);
-      if (fields.length > 0) text += theme.fg("dim", ` (${fields.join(", ")})`);
-      return new Text(text, 0, 0);
-    },
-    renderResult(result: any, _options: any, theme: any) {
-      const d = result.details;
-      if (result.isError || d?.error) {
-        return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
-      }
-      let text = theme.fg("success", `Requirement ${d?.id ?? ""} updated`);
-      text += theme.fg("dim", ` → REQUIREMENTS.md`);
-      return new Text(text, 0, 0);
-    },
   };
 
   pi.registerTool(requirementUpdateTool);
@@ -268,22 +235,6 @@ export function registerDbTools(pi: ExtensionAPI): void {
       content: Type.String({ description: "The full markdown content of the artifact" }),
     }),
     execute: summarySaveExecute,
-    renderCall(args: any, theme: any) {
-      let text = theme.fg("toolTitle", theme.bold("summary_save "));
-      if (args.artifact_type) text += theme.fg("accent", args.artifact_type);
-      const path = [args.milestone_id, args.slice_id, args.task_id].filter(Boolean).join("/");
-      if (path) text += theme.fg("dim", ` ${path}`);
-      return new Text(text, 0, 0);
-    },
-    renderResult(result: any, _options: any, theme: any) {
-      const d = result.details;
-      if (result.isError || d?.error) {
-        return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
-      }
-      let text = theme.fg("success", `${d?.artifact_type ?? "Artifact"} saved`);
-      if (d?.path) text += theme.fg("dim", ` → ${d.path}`);
-      return new Text(text, 0, 0);
-    },
   };
 
   pi.registerTool(summarySaveTool);
@@ -356,18 +307,6 @@ export function registerDbTools(pi: ExtensionAPI): void {
     ],
     parameters: Type.Object({}),
     execute: milestoneGenerateIdExecute,
-    renderCall(_args: any, theme: any) {
-      return new Text(theme.fg("toolTitle", theme.bold("milestone_generate_id")), 0, 0);
-    },
-    renderResult(result: any, _options: any, theme: any) {
-      const d = result.details;
-      if (result.isError || d?.error) {
-        return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
-      }
-      let text = theme.fg("success", `Generated ${d?.id ?? "ID"}`);
-      if (d?.source === "reserved") text += theme.fg("dim", " (reserved)");
-      return new Text(text, 0, 0);
-    },
   };
 
   pi.registerTool(milestoneGenerateIdTool);
@@ -874,74 +813,6 @@ export function registerDbTools(pi: ExtensionAPI): void {
   pi.registerTool(milestoneCompleteTool);
   registerAlias(pi, milestoneCompleteTool, "gsd_milestone_complete", "gsd_complete_milestone");
 
-  // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
-
-  const milestoneValidateExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
-    const dbAvailable = await ensureDbOpen();
-    if (!dbAvailable) {
-      return {
-        content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot validate milestone." }],
-        details: { operation: "validate_milestone", error: "db_unavailable" } as any,
-      };
-    }
-    try {
-      const { handleValidateMilestone } = await import("../tools/validate-milestone.js");
-      const result = await handleValidateMilestone(params, process.cwd());
-      if ("error" in result) {
-        return {
-          content: [{ type: "text" as const, text: `Error validating milestone: ${result.error}` }],
-          details: { operation: "validate_milestone", error: result.error } as any,
-        };
-      }
-      return {
-        content: [{ type: "text" as const, text: `Validated milestone ${result.milestoneId} — verdict: ${result.verdict}. Written to ${result.validationPath}` }],
-        details: {
-          operation: "validate_milestone",
-          milestoneId: result.milestoneId,
-          verdict: result.verdict,
-          validationPath: result.validationPath,
-        } as any,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`gsd-db: validate_milestone tool failed: ${msg}\n`);
-      return {
-        content: [{ type: "text" as const, text: `Error validating milestone: ${msg}` }],
-        details: { operation: "validate_milestone", error: msg } as any,
-      };
-    }
-  };
-
-  const milestoneValidateTool = {
-    name: "gsd_validate_milestone",
-    label: "Validate Milestone",
-    description:
-      "Validate a milestone before completion — persist validation results to the DB, render VALIDATION.md to disk. " +
-      "Records verdict (pass/needs-attention/needs-remediation) and rationale.",
-    promptSnippet: "Validate a GSD milestone (DB write + VALIDATION.md render)",
-    promptGuidelines: [
-      "Use gsd_validate_milestone when all slices are done and the milestone needs validation before completion.",
-      "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verdictRationale, remediationPlan (optional).",
-      "If verdict is 'needs-remediation', also provide remediationPlan and use gsd_reassess_roadmap to add remediation slices to the roadmap.",
-      "On success, returns validationPath where VALIDATION.md was written.",
-    ],
-    parameters: Type.Object({
-      milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
-      verdict: StringEnum(["pass", "needs-attention", "needs-remediation"], { description: "Validation verdict" }),
-      remediationRound: Type.Number({ description: "Remediation round (0 for first validation)" }),
-      successCriteriaChecklist: Type.String({ description: "Markdown checklist of success criteria with pass/fail and evidence" }),
-      sliceDeliveryAudit: Type.String({ description: "Markdown table auditing each slice's claimed vs delivered output" }),
-      crossSliceIntegration: Type.String({ description: "Markdown describing any cross-slice boundary mismatches" }),
-      requirementCoverage: Type.String({ description: "Markdown describing any unaddressed requirements" }),
-      verdictRationale: Type.String({ description: "Why this verdict was chosen" }),
-      remediationPlan: Type.Optional(Type.String({ description: "Remediation plan (required if verdict is needs-remediation)" })),
-    }),
-    execute: milestoneValidateExecute,
-  };
-
-  pi.registerTool(milestoneValidateTool);
-  registerAlias(pi, milestoneValidateTool, "gsd_milestone_validate", "gsd_validate_milestone");
-
   // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
 
   const replanSliceExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -15,7 +15,7 @@ export interface GsdCommandDefinition {
 type CompletionMap = Record<string, readonly GsdCommandDefinition[]>;
 
 export const GSD_COMMAND_DESCRIPTION =
-  "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp";
+  "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast";
 
 export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -68,7 +68,6 @@ export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "templates", desc: "List available workflow templates" },
   { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
   { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
-  { cmd: "mcp", desc: "MCP server status and connectivity check (status, check <server>)" },
   { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
 ];
 
@@ -188,10 +187,6 @@ const NESTED_COMPLETIONS: CompletionMap = {
     { cmd: "flex", desc: "Flex tier (0.5x cost, slower)" },
     { cmd: "status", desc: "Show current service tier setting" },
   ],
-  mcp: [
-    { cmd: "status", desc: "Show all MCP server statuses (default)" },
-    { cmd: "check", desc: "Detailed status for a specific server" },
-  ],
   doctor: [
     { cmd: "fix", desc: "Auto-fix detected issues" },
     { cmd: "heal", desc: "AI-driven deep healing" },

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -53,7 +53,6 @@ export function showHelp(ctx: ExtensionCommandContext): void {
     "  /gsd hooks          Show post-unit hook configuration",
     "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
     "  /gsd fast           Toggle OpenAI service tier  [on|off|flex|status]",
-    "  /gsd mcp            MCP server status and connectivity  [status|check <server>]",
     "",
     "MAINTENANCE",
     "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",

package/src/resources/extensions/gsd/commands/handlers/ops.ts

@@ -191,11 +191,6 @@ Examples:
     await handleFast(trimmed.replace(/^fast\s*/, "").trim(), ctx);
     return true;
   }
-  if (trimmed === "mcp" || trimmed.startsWith("mcp ")) {
-    const { handleMcpStatus } = await import("../../commands-mcp-status.js");
-    await handleMcpStatus(trimmed.replace(/^mcp\s*/, "").trim(), ctx);
-    return true;
-  }
   if (trimmed === "extensions" || trimmed.startsWith("extensions ")) {
     const { handleExtensions } = await import("../../commands-extensions.js");
     await handleExtensions(trimmed.replace(/^extensions\s*/, "").trim(), ctx);

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

@@ -9,7 +9,7 @@
 // parseDecisionsTable() and parseRequirementsSections() with field fidelity.
 
 import { join, resolve } from 'node:path';
-import { readFileSync, existsSync, statSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import type { Decision, Requirement } from './types.js';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
@@ -428,52 +428,30 @@ 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) {
-        process.stderr.write(
-          `gsd-db: saveArtifactToDb — new content (${newSize}B) is <50% of existing file ` +
-          `(${existingSize}B) at ${opts.path}. Preserving disk file to prevent data loss.\n`,
-        );
-        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: dbContent,
+      full_content: opts.content,
     });
 
-    // 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) {
-        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 (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;
     }
     // Invalidate file-read caches so deriveState() sees the updated markdown.
     // Do NOT clear the artifacts table — we just wrote to it intentionally.

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

@@ -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 & { pending?: boolean };
+    type NormSlice = RoadmapSliceEntry;
     let slices: NormSlice[];
     if (isDbAvailable()) {
       const dbSlices = getMilestoneSlices(milestoneId);
@@ -478,7 +478,6 @@ 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,
@@ -565,9 +564,6 @@ 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",
@@ -590,8 +586,6 @@ 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,17 +684,13 @@ export function createDraftPR(
   milestoneId: string,
   title: string,
   body: string,
-  opts?: { head?: string; base?: string },
 ): string | null {
   try {
-    const args = [
+    const result = execFileSync("gh", [
       "pr", "create", "--draft",
       "--title", title,
       "--body", body,
-    ];
-    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 });
+    ], { 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

@@ -301,7 +301,6 @@ 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)
@@ -617,15 +616,6 @@ 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");
@@ -933,7 +923,6 @@ export interface TaskPlanningRecord {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact: string;
-  fullPlanMd?: string;
 }
 
 export function insertMilestone(m: {
@@ -1174,8 +1163,7 @@ 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),
-      full_plan_md = COALESCE(:full_plan_md, full_plan_md)
+      observability_impact = COALESCE(:observability_impact, observability_impact)
      WHERE milestone_id = :milestone_id AND slice_id = :slice_id AND id = :id`,
   ).run({
     ":milestone_id": milestoneId,
@@ -1189,7 +1177,6 @@ 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,
   });
 }
 
@@ -1281,7 +1268,6 @@ export interface TaskRow {
   inputs: string[];
   expected_output: string[];
   observability_impact: string;
-  full_plan_md: string;
   sequence: number;
 }
 
@@ -1310,7 +1296,6 @@ 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/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 = task.full_plan_md.trim() ? task.full_plan_md : renderTaskPlanMarkdown(task);
+  const content = renderTaskPlanMarkdown(task);
 
   await writeAndStore(absPath, artifactPath, content, {
     artifact_type: "PLAN",

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. **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.
+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.
 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,4 +31,6 @@ 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 `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.
+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.
 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/src/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:**
 
-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.
+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.
 
 **If changes are needed:**
 
-**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}}
+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}}
 
 When done, say: "Roadmap reassessed."

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

@@ -32,8 +32,19 @@ 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: `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.
+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.
 
 When done, say: "Slice {{sliceId}} replanned."