gsd-pi 2.82.0-dev.c22380fc3 → 2.82.0-dev.e7a7f1ed5

package/dist/resources/extensions/gsd/prompts/queue.md

@@ -114,10 +114,10 @@ Once the user is satisfied, in one pass for **each** new milestone:
 
 After all milestone directories and context files are written:
 
-3. Update `.gsd/PROJECT.md` by adding new milestones to the Milestone Sequence. Keep existing entries exactly as-is; only add new lines.
-4. If `.gsd/REQUIREMENTS.md` exists and the queued work introduces new in-scope capabilities or promotes Deferred items, update it.
-5. If discussion produced decisions relevant to existing work, append to `.gsd/DECISIONS.md`.
-6. Append to `.gsd/QUEUE.md`.
+3. Refresh project state through `gsd_summary_save` with `artifact_type: "PROJECT"` and full PROJECT content that includes the new milestones in the Milestone Sequence; omit `milestone_id`.
+4. If the queued work introduces new in-scope capabilities or promotes Deferred items, persist those changes with `gsd_requirement_save` or `gsd_requirement_update`, then call `gsd_summary_save` with `artifact_type: "REQUIREMENTS"` so `.gsd/REQUIREMENTS.md` renders from DB rows.
+5. If discussion produced decisions relevant to existing work, call `gsd_decision_save` for each decision; the tool regenerates `.gsd/DECISIONS.md`.
+6. If `.gsd/QUEUE.md` is maintained, update it only as an audit projection of queued intent. Runtime queue state must come from the DB-backed milestone/context tool calls above.
 7. {{commitInstruction}}
 
 **Do NOT write roadmaps for queued milestones.**

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

@@ -64,10 +64,10 @@ Then:
 2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
 3. Define slice-level verification: the objective stopping condition. Plan real test files with real assertions; for simple slices, executable commands are fine.
 4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
-5. Decompose the slice into tasks that fit one context window each. Every task must have Why / Files / Do / Verify / Done-when, plus a task plan with description, steps, must-haves, verification, inputs (backtick-wrapped paths), and expected output (backtick-wrapped paths).
+5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`).
 6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.
 7. **Self-audit the plan.** If every task were completed exactly as written, the slice goal/demo should be true. Every must-have maps to a task. Inputs and Expected Output are backtick-wrapped file paths.
-8. If refinement produced structural decisions that diverge from the sketch, append them to `.gsd/DECISIONS.md`.
+8. If refinement produced structural decisions that diverge from the sketch, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
 9. {{commitInstruction}}
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir.

package/dist/resources/extensions/gsd/prompts/rewrite-docs.md

@@ -23,7 +23,7 @@ An override was issued by the user that changes a fundamental decision or approa
    - For DECISIONS.md: append a new decision entry documenting the override and why. Do NOT delete prior decisions — mark them as superseded with a note.
    - For slice plans (S##-PLAN.md): update Goal, Demo, and Verification sections if affected. Update Files Likely Touched if the override changes scope. Do NOT modify completed task entries.
    - For REQUIREMENTS.md: update requirement descriptions if the override changes what "done" means, but do not remove requirements.
-   - For PROJECT.md: update if the override changes project-level facts.
+   - For PROJECT.md: do not edit the projection directly. If the override changes project-level facts, persist the revised Project content through `gsd_summary_save` with `artifact_type: "PROJECT"` so the DB remains authoritative.
    - Milestone context files are reference only — do not modify them.
 4. Mark all active overrides as resolved: change `**Scope:** active` to `**Scope:** resolved` in `{{overridesPath}}`
 5. Do not commit manually — the system auto-commits your changes after this unit completes.

package/dist/resources/extensions/gsd/queue-reorder-ui.js

@@ -24,6 +24,7 @@ export async function showQueueReorder(ctx, completed, pending) {
         const items = [...pending];
         let cursor = 0;
         let grabbed = false;
+        let scrollOffset = 0;
         let cachedLines;
         let validation;
         // Mutable deps map — tracks removals during this session
@@ -128,9 +129,11 @@ export async function showQueueReorder(ctx, completed, pending) {
                 return cachedLines;
             const ui = makeUI(theme, width);
             const lines = [];
+            const queueRows = [];
             const push = (...rows) => { for (const r of rows)
                 lines.push(...r); };
             const add = (s) => truncateToWidth(s, width);
+            let cursorQueueRow = 0;
             const headerText = grabbed ? "  Queue Reorder — Moving Item" : "  Queue Reorder";
             push(ui.bar(), ui.blank(), ui.header(headerText), ui.blank());
             // Completed milestones (dimmed)
@@ -153,13 +156,15 @@ export async function showQueueReorder(ctx, completed, pending) {
                 const num = i + 1;
                 const label = item.title && item.title !== item.id ? `${item.id}  ${item.title}` : item.id;
                 if (isCursor && grabbed) {
-                    lines.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
+                    cursorQueueRow = queueRows.length;
+                    queueRows.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
                 }
                 else if (isCursor) {
-                    lines.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
+                    cursorQueueRow = queueRows.length;
+                    queueRows.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
                 }
                 else {
-                    lines.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
+                    queueRows.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
                 }
                 // depends_on annotations
                 const deps = liveDeps.get(item.id) ?? [];
@@ -168,34 +173,35 @@ export async function showQueueReorder(ctx, completed, pending) {
                         continue;
                     const pairKey = `${item.id}:${dep}`;
                     if (violatedPairs.has(pairKey)) {
-                        lines.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
+                        queueRows.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
                     }
                     else if (redundantPairs.has(pairKey)) {
-                        lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
+                        queueRows.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
                     }
                     else {
-                        lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
+                        queueRows.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
                     }
                 }
                 // Missing deps
                 for (const v of validation.violations.filter(v => v.milestone === item.id && v.type === 'missing_dep')) {
-                    lines.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
+                    queueRows.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
                 }
             }
             // Removed deps feedback
+            const trailingLines = [];
             if (removedDeps.length > 0) {
-                push(ui.blank());
+                trailingLines.push(...ui.blank());
                 for (const r of removedDeps) {
-                    lines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
+                    trailingLines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
                 }
             }
             // Circular warning
             const circ = validation.violations.find(v => v.type === 'circular');
             if (circ) {
-                push(ui.blank());
-                lines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
+                trailingLines.push(...ui.blank());
+                trailingLines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
             }
-            push(ui.blank());
+            trailingLines.push(...ui.blank());
             // Hints — context-sensitive based on grab state
             const hints = [];
             if (grabbed) {
@@ -215,7 +221,18 @@ export async function showQueueReorder(ctx, completed, pending) {
                 hints.push("enter ok");
             }
             hints.push("esc");
-            push(ui.hints(hints), ui.bar());
+            trailingLines.push(...ui.hints(hints), ...ui.bar());
+            const maxOverlayRows = Math.max(10, process.stdout.rows ? Math.floor(process.stdout.rows * 0.8) : 24);
+            const availableQueueRows = Math.max(1, maxOverlayRows - lines.length - trailingLines.length);
+            const maxScroll = Math.max(0, queueRows.length - availableQueueRows);
+            if (cursorQueueRow < scrollOffset) {
+                scrollOffset = cursorQueueRow;
+            }
+            else if (cursorQueueRow >= scrollOffset + availableQueueRows) {
+                scrollOffset = cursorQueueRow - availableQueueRows + 1;
+            }
+            scrollOffset = Math.min(Math.max(scrollOffset, 0), maxScroll);
+            lines.push(...queueRows.slice(scrollOffset, scrollOffset + availableQueueRows), ...trailingLines);
             cachedLines = lines;
             return lines;
         }

package/dist/resources/extensions/gsd/smart-entry-routing.js

@@ -0,0 +1,36 @@
+// GSD-2 — Smart entry routing decisions.
+// Pure route selection for /gsd guided wizard choices.
+export function resolveGuidedExecuteLaunchMode(isolationMode) {
+    return isolationMode === "worktree" ? "auto-step" : "guided-dispatch";
+}
+export function resolveActiveTaskChoiceRoute(input) {
+    if (input.choice === "auto") {
+        return {
+            kind: "auto-bootstrap",
+            verboseMode: false,
+        };
+    }
+    if (input.choice === "execute") {
+        if (resolveGuidedExecuteLaunchMode(input.isolationMode) === "auto-step") {
+            return {
+                kind: "auto-bootstrap",
+                verboseMode: false,
+                options: {
+                    step: true,
+                    milestoneLock: input.milestoneId,
+                },
+            };
+        }
+        return {
+            kind: "guided-dispatch",
+            unitType: "execute-task",
+        };
+    }
+    if (input.choice === "status") {
+        return { kind: "status" };
+    }
+    if (input.choice === "milestone_actions") {
+        return { kind: "milestone-actions" };
+    }
+    throw new Error(`Invalid ActiveTaskChoice: ${input.choice}`);
+}

package/dist/resources/extensions/gsd/state-reconciliation/drift/merge-state.js

@@ -10,6 +10,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { getErrorMessage } from "../../error-utils.js";
 import { nativeAddPaths, nativeCheckoutTheirs, nativeCommit, nativeConflictFiles, nativeMergeAbort, nativeRebaseAbort, nativeResetHard, } from "../../native-git-bridge.js";
 import { logError, logWarning } from "../../workflow-logger.js";
+import { isGsdWorktreePath } from "../../worktree-root.js";
 const SILENT_NOTIFY = () => { };
 function resolveGitDir(basePath) {
     try {
@@ -23,7 +24,11 @@ function resolveGitDir(basePath) {
         }
     }
     catch (err) {
-        logWarning("recovery", `gitdir resolution failed: ${getErrorMessage(err)}`);
+        const message = getErrorMessage(err);
+        logWarning("recovery", `gitdir resolution failed: ${message}`);
+        if (isGsdWorktreePath(basePath)) {
+            throw new Error(`Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${message.split("\n")[0]}). Repair or recreate the worktree before retrying.`);
+        }
     }
     return join(basePath, ".git");
 }

package/dist/resources/extensions/gsd/state-reconciliation/drift/project-md.js

@@ -1,12 +1,11 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 unregistered-milestone drift handler. Detects
 // milestones whose on-disk directory has meaningful content (ROADMAP/
-// CONTEXT/SUMMARY) but no DB row, then runs the markdown importer to
-// reconcile. PROJECT.md is the human-facing index — the importer's source
-// of truth is the .gsd/milestones/ directory tree.
+// CONTEXT/SUMMARY) but no DB row, then fails closed with an explicit recovery
+// instruction. Markdown hierarchy import is reserved for operator-controlled
+// migration/recovery commands, not automatic runtime reconciliation.
 import { existsSync } from "node:fs";
 import { getMilestone, isDbAvailable } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { resolveMilestoneFile } from "../../paths.js";
 function milestoneHasContent(basePath, milestoneId) {
@@ -31,17 +30,13 @@ export function detectUnregisteredMilestoneDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair: invoke the markdown importer. migrateHierarchyToDb walks the same
- * findMilestoneIds list the detector uses and INSERTs OR IGNOREs every
- * missing milestone (and its slices/tasks) — idempotent under cap=2 retry.
- *
- * Note: even though we receive one record at a time, the importer is a
- * project-wide operation. Repeated invocation across multiple drift records
- * in the same pass is wasteful but safe; a future optimization could
- * coalesce by checking whether the importer has already run this pass.
+ * Repair intentionally fails closed. The project-root DB is authoritative at
+ * runtime; markdown-only milestones must be imported through an explicit
+ * migration/recovery command so operators opt into changing canonical state.
  */
-export function repairUnregisteredMilestone(_record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
+export function repairUnregisteredMilestone(record, _ctx) {
+    throw new Error(`Milestone ${record.milestoneId} exists only as markdown projection. ` +
+        "Runtime reconciliation will not import markdown into the authoritative DB; run explicit GSD recovery/migration if this markdown should repopulate the database.");
 }
 export const unregisteredMilestoneHandler = {
     kind: "unregistered-milestone",

package/dist/resources/extensions/gsd/state-reconciliation/drift/roadmap.js

@@ -1,14 +1,15 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 roadmap-divergence drift handler. Detects mismatches
-// between ROADMAP.md (parsed slice sequence + depends declarations) and the
-// DB slice rows for that milestone, then reconciles via the markdown
-// importer plus an explicit junction-table sync.
+// between ROADMAP.md (parsed slice sequence, depends declarations, and
+// checkboxes) and the DB slice rows for that milestone, then re-renders the
+// ROADMAP projection from the authoritative DB rows.
 import { existsSync, readFileSync } from "node:fs";
-import { getMilestone, getMilestoneSlices, isDbAvailable, syncSliceDependencies, } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
+import { getMilestone, getMilestoneSlices, isDbAvailable, } from "../../gsd-db.js";
+import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
+import { isClosedStatus } from "../../status-guards.js";
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -30,8 +31,10 @@ function milestoneHasDivergence(basePath, milestoneId) {
     }
     const dbSlices = getMilestoneSlices(milestoneId);
     const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+    const roadmapSliceIds = new Set();
     for (let i = 0; i < roadmap.slices.length; i++) {
         const roadmapSlice = roadmap.slices[i];
+        roadmapSliceIds.add(roadmapSlice.id);
         const expectedSequence = i + 1;
         const dbSlice = dbSliceMap.get(roadmapSlice.id);
         if (!dbSlice)
@@ -40,6 +43,12 @@ function milestoneHasDivergence(basePath, milestoneId) {
             return true;
         if (!arraysEqual(dbSlice.depends, roadmapSlice.depends))
             return true;
+        if (isClosedStatus(dbSlice.status) !== roadmapSlice.done)
+            return true;
+    }
+    for (const dbSlice of dbSlices) {
+        if (!roadmapSliceIds.has(dbSlice.id))
+            return true;
     }
     return false;
 }
@@ -59,26 +68,12 @@ export function detectRoadmapDivergenceDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair a milestone's roadmap divergence:
- *   1. migrateHierarchyToDb upserts slice rows (sequence + depends JSON
- *      update via ON CONFLICT DO UPDATE).
- *   2. syncSliceDependencies updates the junction table per slice — the
- *      importer only writes the JSON column, not the relational view.
+ * Repair a milestone's roadmap divergence by regenerating the projection from
+ * DB rows. ROADMAP.md is a projection; runtime reconciliation must not import
+ * slice presence, sequence, dependencies, or checkbox state from markdown.
  */
-export function repairRoadmapDivergence(record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
-    const roadmapPath = resolveMilestoneFile(ctx.basePath, record.milestoneId, "ROADMAP");
-    if (!roadmapPath || !existsSync(roadmapPath))
-        return;
-    try {
-        const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
-        for (const slice of roadmap.slices) {
-            syncSliceDependencies(record.milestoneId, slice.id, slice.depends);
-        }
-    }
-    catch {
-        /* parse failure: detector will fire again next pass */
-    }
+export async function repairRoadmapDivergence(record, ctx) {
+    await renderRoadmapFromDb(ctx.basePath, record.milestoneId);
 }
 export const roadmapDivergenceHandler = {
     kind: "roadmap-divergence",

package/dist/resources/extensions/gsd/status-guards.js

@@ -22,3 +22,14 @@ export function isDeferredStatus(status) {
 export function isInactiveStatus(status) {
     return isClosedStatus(status) || isDeferredStatus(status);
 }
+/** Returns true when a prior milestone should not block dispatch ordering. */
+export function isSkippedForDispatch(status) {
+    return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
+}
+/**
+ * Returns true when a milestone is future/backlog work (not currently executing).
+ * Includes legacy/project-specific alias "planned" for compatibility.
+ */
+export function isFutureMilestoneStatus(status) {
+    return status === "pending" || status === "queued" || status === "planned";
+}

package/dist/resources/extensions/gsd/templates/plan.md

@@ -99,11 +99,11 @@
   - "Improve UI"
 
   Each task should usually include:
-  - Why: why this task exists / what part of the slice it closes
-  - Files: the main files likely touched
-  - Do: concrete implementation steps and important constraints
-  - Verify: the command, test, or runtime check that proves it worked
-  - Done when: a measurable acceptance condition
+  - description: why this task exists, concrete steps, and done-when acceptance
+  - files: JSON array of likely touched paths
+  - verify: the command, test, or runtime check that proves it worked
+  - inputs: JSON array of existing paths or prior task outputs this task consumes
+  - expectedOutput: JSON array of paths this task creates or overwrites
 
   Keep the checkbox line format exactly:
   - [ ] **T01: Title** `est:30m`
@@ -131,10 +131,13 @@
 
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `python3 -m pytest tests/ -q --tb=short`
   - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
 
   Integration closure rule:

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -72,7 +72,8 @@ skills_used:
 <!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
      derive task dependencies — vague descriptions without paths break dependency detection.
      For the first task in a slice with no prior task outputs, list the existing source files
-     this task reads or modifies. -->
+     this task reads or modifies.
+     Tool field: inputs must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
 
@@ -82,6 +83,7 @@ skills_used:
      or modifies. These paths are machine-parsed to derive task dependencies.
      This task should produce a real increment toward making the slice goal/demo true. A full
      slice plan should not be able to mark every task complete while the claimed slice behavior
-     still does not work at the stated proof level. -->
+     still does not work at the stated proof level.
+     Tool field: expectedOutput must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -24,11 +24,11 @@ function renderMilestoneSummaryMarkdown(params, completedAt) {
     const keyFiles = params.keyFiles ?? [];
     const lessonsLearned = params.lessonsLearned ?? [];
     const keyDecisionsYaml = keyDecisions.length > 0
-        ? keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     const keyFilesYaml = keyFiles.length > 0
-        ? keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const lessonsYaml = lessonsLearned.length > 0
         ? lessonsLearned.map(l => `  - ${l}`).join("\n")
         : "  - (none)";
@@ -37,10 +37,8 @@ id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
 completed_at: ${completedAt}
-key_decisions:
-${keyDecisionsYaml}
-key_files:
-${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
+key_files:${keyFilesYaml}
 lessons_learned:
 ${lessonsYaml}
 ---

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -65,11 +65,11 @@ function renderSliceSummaryMarkdown(params) {
         ? affects.map(a => `  - ${a}`).join("\n")
         : "  []";
     const keyFilesYaml = keyFiles.length > 0
-        ? keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const keyDecisionsYaml = keyDecisions.length > 0
-        ? keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     const patternsYaml = patternsEstablished.length > 0
         ? patternsEstablished.map(p => `  - ${p}`).join("\n")
         : "  - (none)";
@@ -106,10 +106,8 @@ requires:
 ${requiresYaml}
 affects:
 ${affectsYaml}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 patterns_established:
 ${patternsYaml}
 observability_surfaces:

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,6 +1,6 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { isNonEmptyString, validateStringArray, validateTitle } from "../validation.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
@@ -77,6 +77,9 @@ function validateSlices(value) {
         seen.add(sliceId);
         if (!isNonEmptyString(title))
             throw new Error(`slices[${index}].title must be a non-empty string`);
+        const titleIssue = validateTitle(title);
+        if (titleIssue)
+            throw new Error(`slices[${index}].title is invalid: ${titleIssue}`);
         if (!isNonEmptyString(risk))
             throw new Error(`slices[${index}].risk must be a non-empty string`);
         if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
@@ -127,6 +130,9 @@ function validateParams(params) {
         throw new Error("title is required");
     if (!isNonEmptyString(params?.vision))
         throw new Error("vision is required");
+    const milestoneTitleIssue = validateTitle(params.title);
+    if (milestoneTitleIssue)
+        throw new Error(`title is invalid: ${milestoneTitleIssue}`);
     return {
         ...params,
         dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],