gsd-pi 2.62.1 → 2.63.0-dev.351157b

package/src/resources/extensions/gsd/tests/worktree-teardown-safety.test.ts

@@ -0,0 +1,148 @@
+/**
+ * worktree-teardown-safety.test.ts — Regression test for #2365.
+ *
+ * Ensures that removeWorktree() and teardownAutoWorktree() never delete
+ * directories outside .gsd/worktrees/.  The bug: removeWorktree overrides
+ * the computed worktree path with whatever `git worktree list` reports.
+ * When .gsd/ was (or is) a symlink, git resolves the symlink at creation
+ * time, so its registered path can point to an external directory.  If that
+ * external path happens to be a project data directory, teardown destroys it.
+ *
+ * The fix adds path validation so rmSync / nativeWorktreeRemove only operate
+ * on paths that are actually under .gsd/worktrees/.
+ */
+
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  realpathSync,
+  readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+import { describe, it, after } from "node:test";
+
+import { createWorktree, removeWorktree, worktreePath, isInsideWorktreesDir } from "../worktree-manager.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-safety-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+  return dir;
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+describe("worktree-teardown-safety", () => {
+  const dirs: string[] = [];
+
+  after(() => {
+    for (const d of dirs) rmSync(d, { recursive: true, force: true });
+    report();
+  });
+
+  it("removeWorktree does not delete sibling data directories", () => {
+    const tempDir = createTempRepo();
+    dirs.push(tempDir);
+
+    // Create a project data directory that lives alongside .gsd/
+    const dataDir = join(tempDir, "project-data");
+    mkdirSync(dataDir, { recursive: true });
+    writeFileSync(join(dataDir, "important.db"), "precious data");
+
+    // Create a worktree normally
+    const wt = createWorktree(tempDir, "test-wt");
+    assertTrue(existsSync(wt.path), "worktree created successfully");
+
+    // Remove the worktree
+    removeWorktree(tempDir, "test-wt");
+
+    // The worktree directory should be gone
+    assertTrue(!existsSync(wt.path), "worktree directory removed");
+
+    // The project data directory MUST still exist
+    assertTrue(existsSync(dataDir), "project data directory survives teardown");
+    assertTrue(
+      existsSync(join(dataDir, "important.db")),
+      "project data files survive teardown",
+    );
+  });
+
+  it("path validation rejects paths outside .gsd/worktrees/", () => {
+    const tempDir = createTempRepo();
+    dirs.push(tempDir);
+
+    const externalDir = join(tempDir, "external-state");
+    mkdirSync(externalDir, { recursive: true });
+    writeFileSync(join(externalDir, "state.json"), '{"critical": true}');
+
+    // Create and then remove a worktree that has a legitimate path
+    const wt2 = createWorktree(tempDir, "safe-wt");
+    assertTrue(existsSync(wt2.path), "second worktree created");
+
+    removeWorktree(tempDir, "safe-wt");
+    assertTrue(!existsSync(wt2.path), "second worktree removed cleanly");
+
+    // External directory must be untouched
+    assertTrue(existsSync(externalDir), "external directory survives second teardown");
+    assertEq(
+      readFileSync(join(externalDir, "state.json"), "utf-8"),
+      '{"critical": true}',
+      "external directory contents intact after teardown",
+    );
+  });
+
+  it("worktreePath always returns paths under .gsd/worktrees/", () => {
+    const tempDir = createTempRepo();
+    dirs.push(tempDir);
+
+    const wtPathResult = worktreePath(tempDir, "anything");
+    assertTrue(
+      wtPathResult.startsWith(join(tempDir, ".gsd", "worktrees")),
+      "worktreePath returns path under .gsd/worktrees/",
+    );
+  });
+
+  it("isInsideWorktreesDir rejects path traversal attempts", () => {
+    const tempDir = createTempRepo();
+    dirs.push(tempDir);
+
+    assertTrue(
+      isInsideWorktreesDir(tempDir, join(tempDir, ".gsd", "worktrees", "my-wt")),
+      "path inside .gsd/worktrees/ is accepted",
+    );
+
+    assertTrue(
+      !isInsideWorktreesDir(tempDir, join(tempDir, "project-data")),
+      "path outside .gsd/worktrees/ is rejected",
+    );
+
+    assertTrue(
+      !isInsideWorktreesDir(tempDir, join(tempDir, ".gsd", "worktrees", "..", "..", "project-data")),
+      "path traversal via .. is rejected",
+    );
+
+    assertTrue(
+      !isInsideWorktreesDir(tempDir, "/tmp/some-other-dir"),
+      "completely external path is rejected",
+    );
+  });
+});

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -20,7 +20,7 @@ import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { isClosedStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { renderAllProjections, stripIdPrefix } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -30,15 +30,23 @@ export interface CompleteMilestoneParams {
   title: string;
   oneLiner: string;
   narrative: string;
-  successCriteriaResults: string;
-  definitionOfDoneResults: string;
-  requirementOutcomes: string;
-  keyDecisions: string[];
-  keyFiles: string[];
-  lessonsLearned: string[];
-  followUps: string;
-  deviations: string;
   verificationPassed: boolean;
+  /** @optional — defaults to "Not provided." when omitted by models with limited tool-calling */
+  successCriteriaResults?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  definitionOfDoneResults?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  requirementOutcomes?: string;
+  /** @optional — defaults to [] when omitted */
+  keyDecisions?: string[];
+  /** @optional — defaults to [] when omitted */
+  keyFiles?: string[];
+  /** @optional — defaults to [] when omitted */
+  lessonsLearned?: string[];
+  /** @optional — defaults to "None." when omitted */
+  followUps?: string;
+  /** @optional — defaults to "None." when omitted */
+  deviations?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -52,22 +60,28 @@ export interface CompleteMilestoneResult {
 
 function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
   const now = new Date().toISOString();
+  const displayTitle = stripIdPrefix(params.title, params.milestoneId);
 
-  const keyDecisionsYaml = params.keyDecisions.length > 0
-    ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+  // Apply defaults for optional enrichment fields (#2771)
+  const keyDecisions = params.keyDecisions ?? [];
+  const keyFiles = params.keyFiles ?? [];
+  const lessonsLearned = params.lessonsLearned ?? [];
+
+  const keyDecisionsYaml = keyDecisions.length > 0
+    ? keyDecisions.map(d => `  - ${d}`).join("\n")
     : "  - (none)";
 
-  const keyFilesYaml = params.keyFiles.length > 0
-    ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+  const keyFilesYaml = keyFiles.length > 0
+    ? keyFiles.map(f => `  - ${f}`).join("\n")
     : "  - (none)";
 
-  const lessonsYaml = params.lessonsLearned.length > 0
-    ? params.lessonsLearned.map(l => `  - ${l}`).join("\n")
+  const lessonsYaml = lessonsLearned.length > 0
+    ? lessonsLearned.map(l => `  - ${l}`).join("\n")
     : "  - (none)";
 
   return `---
 id: ${params.milestoneId}
-title: "${params.title}"
+title: "${displayTitle}"
 status: complete
 completed_at: ${now}
 key_decisions:
@@ -78,7 +92,7 @@ lessons_learned:
 ${lessonsYaml}
 ---
 
-# ${params.milestoneId}: ${params.title}
+# ${params.milestoneId}: ${displayTitle}
 
 **${params.oneLiner}**
 
@@ -88,15 +102,15 @@ ${params.narrative}
 
 ## Success Criteria Results
 
-${params.successCriteriaResults}
+${params.successCriteriaResults ?? "Not provided."}
 
 ## Definition of Done Results
 
-${params.definitionOfDoneResults}
+${params.definitionOfDoneResults ?? "Not provided."}
 
 ## Requirement Outcomes
 
-${params.requirementOutcomes}
+${params.requirementOutcomes ?? "Not provided."}
 
 ## Deviations
 

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -46,58 +46,73 @@ export interface CompleteSliceResult {
 function renderSliceSummaryMarkdown(params: CompleteSliceParams): string {
   const now = new Date().toISOString();
 
-  const providesYaml = params.provides.length > 0
-    ? params.provides.map(p => `  - ${p}`).join("\n")
+  // Apply defaults for optional enrichment arrays (#2771)
+  const provides = params.provides ?? [];
+  const requires = params.requires ?? [];
+  const affects = params.affects ?? [];
+  const keyFiles = params.keyFiles ?? [];
+  const keyDecisions = params.keyDecisions ?? [];
+  const patternsEstablished = params.patternsEstablished ?? [];
+  const observabilitySurfaces = params.observabilitySurfaces ?? [];
+  const drillDownPaths = params.drillDownPaths ?? [];
+  const requirementsAdvanced = params.requirementsAdvanced ?? [];
+  const requirementsValidated = params.requirementsValidated ?? [];
+  const requirementsSurfaced = params.requirementsSurfaced ?? [];
+  const requirementsInvalidated = params.requirementsInvalidated ?? [];
+  const filesModified = params.filesModified ?? [];
+
+  const providesYaml = provides.length > 0
+    ? provides.map(p => `  - ${p}`).join("\n")
     : "  - (none)";
 
-  const requiresYaml = params.requires.length > 0
-    ? params.requires.map(r => `  - slice: ${r.slice}\n    provides: ${r.provides}`).join("\n")
+  const requiresYaml = requires.length > 0
+    ? requires.map(r => `  - slice: ${r.slice}\n    provides: ${r.provides}`).join("\n")
     : "  []";
 
-  const affectsYaml = params.affects.length > 0
-    ? params.affects.map(a => `  - ${a}`).join("\n")
+  const affectsYaml = affects.length > 0
+    ? affects.map(a => `  - ${a}`).join("\n")
     : "  []";
 
-  const keyFilesYaml = params.keyFiles.length > 0
-    ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+  const keyFilesYaml = keyFiles.length > 0
+    ? keyFiles.map(f => `  - ${f}`).join("\n")
     : "  - (none)";
 
-  const keyDecisionsYaml = params.keyDecisions.length > 0
-    ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+  const keyDecisionsYaml = keyDecisions.length > 0
+    ? keyDecisions.map(d => `  - ${d}`).join("\n")
     : "  - (none)";
 
-  const patternsYaml = params.patternsEstablished.length > 0
-    ? params.patternsEstablished.map(p => `  - ${p}`).join("\n")
+  const patternsYaml = patternsEstablished.length > 0
+    ? patternsEstablished.map(p => `  - ${p}`).join("\n")
     : "  - (none)";
 
-  const observabilityYaml = params.observabilitySurfaces.length > 0
-    ? params.observabilitySurfaces.map(o => `  - ${o}`).join("\n")
+  const observabilityYaml = observabilitySurfaces.length > 0
+    ? observabilitySurfaces.map(o => `  - ${o}`).join("\n")
     : "  - none";
 
-  const drillDownYaml = params.drillDownPaths.length > 0
-    ? params.drillDownPaths.map(d => `  - ${d}`).join("\n")
+  const drillDownYaml = drillDownPaths.length > 0
+    ? drillDownPaths.map(d => `  - ${d}`).join("\n")
     : "  []";
 
   // Requirements sections
-  const reqAdvanced = params.requirementsAdvanced.length > 0
-    ? params.requirementsAdvanced.map(r => `- ${r.id} — ${r.how}`).join("\n")
+  const reqAdvanced = requirementsAdvanced.length > 0
+    ? requirementsAdvanced.map(r => `- ${r.id} — ${r.how}`).join("\n")
     : "None.";
 
-  const reqValidated = params.requirementsValidated.length > 0
-    ? params.requirementsValidated.map(r => `- ${r.id} — ${r.proof}`).join("\n")
+  const reqValidated = requirementsValidated.length > 0
+    ? requirementsValidated.map(r => `- ${r.id} — ${r.proof}`).join("\n")
     : "None.";
 
-  const reqSurfaced = params.requirementsSurfaced.length > 0
-    ? params.requirementsSurfaced.map(r => `- ${r}`).join("\n")
+  const reqSurfaced = requirementsSurfaced.length > 0
+    ? requirementsSurfaced.map(r => `- ${r}`).join("\n")
     : "None.";
 
-  const reqInvalidated = params.requirementsInvalidated.length > 0
-    ? params.requirementsInvalidated.map(r => `- ${r.id} — ${r.what}`).join("\n")
+  const reqInvalidated = requirementsInvalidated.length > 0
+    ? requirementsInvalidated.map(r => `- ${r.id} — ${r.what}`).join("\n")
     : "None.";
 
   // Files modified
-  const filesMod = params.filesModified.length > 0
-    ? params.filesModified.map(f => `- \`${f.path}\` — ${f.description}`).join("\n")
+  const filesMod = filesModified.length > 0
+    ? filesModified.map(f => `- \`${f.path}\` — ${f.description}`).join("\n")
     : "None.";
 
   return `---
@@ -292,13 +307,11 @@ export async function handleCompleteSlice(
     // Toggle roadmap checkbox via renderer module
     const roadmapToggled = await renderRoadmapCheckboxes(basePath, params.milestoneId);
     if (!roadmapToggled) {
-      process.stderr.write(
-        `gsd-db: complete_slice — could not find roadmap for ${params.milestoneId}, skipping checkbox toggle\n`,
-      );
+      logWarning("tool", `complete_slice — could not find roadmap for ${params.milestoneId}, skipping checkbox toggle`);
     }
   } catch (renderErr) {
     // Disk render failed — roll back DB status so state stays consistent
-    logWarning("tool", `complete_slice — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
+    logWarning("tool", `complete_slice — disk render failed for ${params.milestoneId}/${params.sliceId}, rolling back DB status`, { error: (renderErr as Error).message });
     updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
     invalidateStateCache();
     return { error: `disk render failed: ${(renderErr as Error).message}` };
@@ -325,7 +338,7 @@ export async function handleCompleteSlice(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    logWarning("tool", `complete-slice post-mutation hook warning: ${(hookErr as Error).message}`);
+    logWarning("tool", `complete-slice post-mutation hook failed for ${params.milestoneId}/${params.sliceId}`, { error: (hookErr as Error).message });
   }
 
   return {

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -60,11 +60,11 @@ function paramsToTaskRow(params: CompleteTaskParams, completedAt: string): TaskR
     verification_result: params.verification,
     duration: "",
     completed_at: completedAt,
-    blocker_discovered: params.blockerDiscovered,
-    deviations: params.deviations,
-    known_issues: params.knownIssues,
-    key_files: params.keyFiles,
-    key_decisions: params.keyDecisions,
+    blocker_discovered: params.blockerDiscovered ?? false,
+    deviations: params.deviations ?? "",
+    known_issues: params.knownIssues ?? "",
+    key_files: params.keyFiles ?? [],
+    key_decisions: params.keyDecisions ?? [],
     full_summary_md: "",
     description: "",
     estimate: "",
@@ -152,14 +152,14 @@ export async function handleCompleteTask(
       narrative: params.narrative,
       verificationResult: params.verification,
       duration: "",
-      blockerDiscovered: params.blockerDiscovered,
-      deviations: params.deviations,
-      knownIssues: params.knownIssues,
-      keyFiles: params.keyFiles,
-      keyDecisions: params.keyDecisions,
+      blockerDiscovered: params.blockerDiscovered ?? false,
+      deviations: params.deviations ?? "None.",
+      knownIssues: params.knownIssues ?? "None.",
+      keyFiles: params.keyFiles ?? [],
+      keyDecisions: params.keyDecisions ?? [],
     });
 
-    for (const evidence of params.verificationEvidence) {
+    for (const evidence of (params.verificationEvidence ?? [])) {
       insertVerificationEvidence({
         taskId: params.taskId,
         sliceId: params.sliceId,
@@ -182,7 +182,7 @@ export async function handleCompleteTask(
 
   // Render summary markdown via the single source of truth (#2720)
   const taskRow = paramsToTaskRow(params, completedAt);
-  const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence);
+  const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
 
   // Resolve and write summary to disk
   let summaryPath: string;

package/src/resources/extensions/gsd/tools/plan-milestone.ts

@@ -5,6 +5,7 @@ import {
   transaction,
   getMilestone,
   getMilestoneSlices,
+  getSlice,
   insertMilestone,
   insertSlice,
   upsertMilestonePlanning,
@@ -33,24 +34,34 @@ export interface PlanMilestoneSliceInput {
 export interface PlanMilestoneParams {
   milestoneId: string;
   title: string;
+  vision: string;
+  slices: PlanMilestoneSliceInput[];
   status?: string;
   dependsOn?: string[];
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
   triggerReason?: string;
-  vision: string;
-  successCriteria: string[];
-  keyRisks: Array<{ risk: string; whyItMatters: string }>;
-  proofStrategy: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
-  verificationContract: string;
-  verificationIntegration: string;
-  verificationOperational: string;
-  verificationUat: string;
-  definitionOfDone: string[];
-  requirementCoverage: string;
-  boundaryMapMarkdown: string;
-  slices: PlanMilestoneSliceInput[];
+  /** @optional — defaults to [] when omitted by models with limited tool-calling */
+  successCriteria?: string[];
+  /** @optional — defaults to [] when omitted */
+  keyRisks?: Array<{ risk: string; whyItMatters: string }>;
+  /** @optional — defaults to [] when omitted */
+  proofStrategy?: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationContract?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationIntegration?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationOperational?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  verificationUat?: string;
+  /** @optional — defaults to [] when omitted */
+  definitionOfDone?: string[];
+  /** @optional — defaults to "Not provided." when omitted */
+  requirementCoverage?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  boundaryMapMarkdown?: string;
 }
 
 export interface PlanMilestoneResult {
@@ -149,20 +160,21 @@ function validateParams(params: PlanMilestoneParams): PlanMilestoneParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.title)) throw new Error("title is required");
   if (!isNonEmptyString(params?.vision)) throw new Error("vision is required");
-  if (!isNonEmptyString(params?.verificationContract)) throw new Error("verificationContract is required");
-  if (!isNonEmptyString(params?.verificationIntegration)) throw new Error("verificationIntegration is required");
-  if (!isNonEmptyString(params?.verificationOperational)) throw new Error("verificationOperational is required");
-  if (!isNonEmptyString(params?.verificationUat)) throw new Error("verificationUat is required");
-  if (!isNonEmptyString(params?.requirementCoverage)) throw new Error("requirementCoverage is required");
-  if (!isNonEmptyString(params?.boundaryMapMarkdown)) throw new Error("boundaryMapMarkdown is required");
 
   return {
     ...params,
     dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],
-    successCriteria: validateStringArray(params.successCriteria, "successCriteria"),
-    keyRisks: validateRiskEntries(params.keyRisks),
-    proofStrategy: validateProofStrategy(params.proofStrategy),
-    definitionOfDone: validateStringArray(params.definitionOfDone, "definitionOfDone"),
+    // Apply defaults for optional enrichment fields (#2771)
+    successCriteria: params.successCriteria ? validateStringArray(params.successCriteria, "successCriteria") : [],
+    keyRisks: params.keyRisks ? validateRiskEntries(params.keyRisks) : [],
+    proofStrategy: params.proofStrategy ? validateProofStrategy(params.proofStrategy) : [],
+    verificationContract: params.verificationContract ?? "Not provided.",
+    verificationIntegration: params.verificationIntegration ?? "Not provided.",
+    verificationOperational: params.verificationOperational ?? "Not provided.",
+    verificationUat: params.verificationUat ?? "Not provided.",
+    definitionOfDone: params.definitionOfDone ? validateStringArray(params.definitionOfDone, "definitionOfDone") : [],
+    requirementCoverage: params.requirementCoverage ?? "Not provided.",
+    boundaryMapMarkdown: params.boundaryMapMarkdown ?? "Not provided.",
     slices: validateSlices(params.slices),
   };
 }
@@ -191,15 +203,19 @@ export async function handlePlanMilestone(
         return;
       }
 
-      // Guard: refuse to re-plan a milestone that has completed slices (#2960).
-      // INSERT OR IGNORE on slices won't overwrite existing rows, but a full
-      // re-plan after worktree recreation or DB resync can create new slice rows
-      // that shadow completed work. Block early when any slice is already done.
+      // Guard: refuse to re-plan a milestone that would drop completed slices (#2960).
+      // Allow re-planning when all completed slices are still present in the
+      // incoming plan — their status is preserved below (#2558). Block only when
+      // the new plan omits a completed slice, which could shadow completed work.
       const existingSlices = getMilestoneSlices(params.milestoneId);
       const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
       if (completedSlices.length > 0) {
-        guardError = `cannot re-plan milestone ${params.milestoneId}: ${completedSlices.length} slice(s) already completed (${completedSlices.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
-        return;
+        const incomingSliceIds = new Set(params.slices.map(s => s.sliceId));
+        const droppedCompleted = completedSlices.filter(s => !incomingSliceIds.has(s.id));
+        if (droppedCompleted.length > 0) {
+          guardError = `cannot re-plan milestone ${params.milestoneId}: ${droppedCompleted.length} completed slice(s) would be dropped (${droppedCompleted.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
+          return;
+        }
       }
 
       // Validate depends_on: all dependencies must exist and be complete
@@ -225,6 +241,8 @@ export async function handlePlanMilestone(
       });
 
       upsertMilestonePlanning(params.milestoneId, {
+        title: params.title,
+        status: params.status ?? "active",
         vision: params.vision,
         successCriteria: params.successCriteria,
         keyRisks: params.keyRisks,
@@ -236,14 +254,21 @@ export async function handlePlanMilestone(
         definitionOfDone: params.definitionOfDone,
         requirementCoverage: params.requirementCoverage,
         boundaryMapMarkdown: params.boundaryMapMarkdown,
-      }, params.title);
+      });
 
       for (const slice of params.slices) {
+        // Preserve completed/done status on re-plan (#2558).
+        // Without this, a re-plan after milestone transition would reset
+        // already-completed slices back to "pending".
+        const existing = getSlice(params.milestoneId, slice.sliceId);
+        const status = existing && (existing.status === "complete" || existing.status === "done")
+          ? existing.status
+          : "pending";
         insertSlice({
           id: slice.sliceId,
           milestoneId: params.milestoneId,
           title: slice.title,
-          status: "pending",
+          status,
           risk: slice.risk,
           depends: slice.depends,
           demo: slice.demo,

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -35,11 +35,15 @@ export interface PlanSliceParams {
   milestoneId: string;
   sliceId: string;
   goal: string;
-  successCriteria: string;
-  proofLevel: string;
-  integrationClosure: string;
-  observabilityImpact: string;
   tasks: PlanSliceTaskInput[];
+  /** @optional — defaults to "Not provided." when omitted by models with limited tool-calling */
+  successCriteria?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  proofLevel?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  integrationClosure?: string;
+  /** @optional — defaults to "Not provided." when omitted */
+  observabilityImpact?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
   /** Optional caller-provided reason this action was triggered */
@@ -112,13 +116,14 @@ function validateParams(params: PlanSliceParams): PlanSliceParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
   if (!isNonEmptyString(params?.goal)) throw new Error("goal is required");
-  if (!isNonEmptyString(params?.successCriteria)) throw new Error("successCriteria is required");
-  if (!isNonEmptyString(params?.proofLevel)) throw new Error("proofLevel is required");
-  if (!isNonEmptyString(params?.integrationClosure)) throw new Error("integrationClosure is required");
-  if (!isNonEmptyString(params?.observabilityImpact)) throw new Error("observabilityImpact is required");
 
   return {
     ...params,
+    // Apply defaults for optional enrichment fields (#2771)
+    successCriteria: params.successCriteria ?? "Not provided.",
+    proofLevel: params.proofLevel ?? "Not provided.",
+    integrationClosure: params.integrationClosure ?? "Not provided.",
+    observabilityImpact: params.observabilityImpact ?? "Not provided.",
     tasks: validateTasks(params.tasks),
   };
 }