gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.786f0ff

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

@@ -6,12 +6,13 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isDeferredStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
-import { extractVerdict } from './verdict-parser.js';
 import { logWarning, logError } from './workflow-logger.js';
+import { extractVerdict } from './verdict-parser.js';
 import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
@@ -568,13 +569,43 @@ export async function deriveStateFromDb(basePath) {
     const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
-    for (const s of activeMilestoneSlices) {
-        if (isStatusDone(s.status))
-            continue;
-        if (s.depends.every(dep => doneSliceIds.has(dep))) {
-            activeSlice = { id: s.id, title: s.title };
-            activeSliceRow = s;
-            break;
+    // ── Slice-level parallel worker isolation ─────────────────────────────
+    // When GSD_SLICE_LOCK is set, this process is a parallel worker scoped
+    // to a single slice. Override activeSlice to only the locked slice ID.
+    const sliceLock = process.env.GSD_SLICE_LOCK;
+    if (sliceLock) {
+        const lockedSlice = activeMilestoneSlices.find(s => s.id === sliceLock);
+        if (lockedSlice) {
+            activeSlice = { id: lockedSlice.id, title: lockedSlice.title };
+            activeSliceRow = lockedSlice;
+        }
+        else {
+            logWarning("state", `GSD_SLICE_LOCK=${sliceLock} not found in active slices — worker has no assigned work`);
+            // Don't silently continue — this is a dispatch error
+            return {
+                activeMilestone, activeSlice: null, activeTask: null,
+                phase: 'blocked',
+                recentDecisions: [], blockers: [`GSD_SLICE_LOCK=${sliceLock} not found in active milestone slices`],
+                nextAction: 'Slice lock references a non-existent slice — check orchestrator dispatch.',
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress },
+            };
+        }
+    }
+    else {
+        for (const s of activeMilestoneSlices) {
+            if (isStatusDone(s.status))
+                continue;
+            // #2661: Skip deferred slices — a decision explicitly deferred this work.
+            // Without this guard the dispatcher would keep dispatching deferred slices
+            // because DECISIONS.md is only contextual, not authoritative for dispatch.
+            if (isDeferredStatus(s.status))
+                continue;
+            if (s.depends.every(dep => doneSliceIds.has(dep))) {
+                activeSlice = { id: s.id, title: s.title };
+                activeSliceRow = s;
+                break;
+            }
         }
     }
     if (!activeSlice) {
@@ -1188,12 +1219,41 @@ export async function _deriveStateImpl(basePath) {
     // Find the active slice (first incomplete with deps satisfied)
     const doneSliceIds = new Set(activeRoadmap.slices.filter(s => s.done).map(s => s.id));
     let activeSlice = null;
-    for (const s of activeRoadmap.slices) {
-        if (s.done)
-            continue;
-        if (s.depends.every(dep => doneSliceIds.has(dep))) {
-            activeSlice = { id: s.id, title: s.title };
-            break;
+    // ── Slice-level parallel worker isolation ─────────────────────────────
+    // When GSD_SLICE_LOCK is set, override activeSlice to only the locked slice.
+    const sliceLockLegacy = process.env.GSD_SLICE_LOCK;
+    if (sliceLockLegacy) {
+        const lockedSlice = activeRoadmap.slices.find(s => s.id === sliceLockLegacy);
+        if (lockedSlice) {
+            activeSlice = { id: lockedSlice.id, title: lockedSlice.title };
+        }
+        else {
+            logWarning("state", `GSD_SLICE_LOCK=${sliceLockLegacy} not found in active slices — worker has no assigned work`);
+            return {
+                activeMilestone,
+                activeSlice: null,
+                activeTask: null,
+                phase: 'blocked',
+                recentDecisions: [],
+                blockers: [`GSD_SLICE_LOCK=${sliceLockLegacy} not found in active milestone slices`],
+                nextAction: 'Slice lock references a non-existent slice — check orchestrator dispatch.',
+                registry,
+                requirements,
+                progress: {
+                    milestones: milestoneProgress,
+                    slices: sliceProgress,
+                },
+            };
+        }
+    }
+    else {
+        for (const s of activeRoadmap.slices) {
+            if (s.done)
+                continue;
+            if (s.depends.every(dep => doneSliceIds.has(dep))) {
+                activeSlice = { id: s.id, title: s.title };
+                break;
+            }
         }
     }
     if (!activeSlice) {

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

@@ -11,3 +11,14 @@
 export function isClosedStatus(status) {
     return status === "complete" || status === "done" || status === "skipped";
 }
+/** Returns true when a slice status indicates it was deferred by a decision. */
+export function isDeferredStatus(status) {
+    return status === "deferred";
+}
+/**
+ * Returns true when a slice should be skipped during active-slice selection.
+ * This includes both closed (complete/done) and deferred slices.
+ */
+export function isInactiveStatus(status) {
+    return isClosedStatus(status) || isDeferredStatus(status);
+}

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

@@ -12,24 +12,29 @@ 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";
 function renderMilestoneSummaryMarkdown(params) {
     const now = new Date().toISOString();
-    const keyDecisionsYaml = params.keyDecisions.length > 0
-        ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+    const displayTitle = stripIdPrefix(params.title, params.milestoneId);
+    // 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:
@@ -40,7 +45,7 @@ lessons_learned:
 ${lessonsYaml}
 ---
 
-# ${params.milestoneId}: ${params.title}
+# ${params.milestoneId}: ${displayTitle}
 
 **${params.oneLiner}**
 
@@ -50,15 +55,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/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -25,46 +25,60 @@ import { logWarning } from "../workflow-logger.js";
  */
 function renderSliceSummaryMarkdown(params) {
     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 `---
 id: ${params.sliceId}

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

@@ -35,11 +35,11 @@ function paramsToTaskRow(params, completedAt) {
         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: "",
@@ -113,13 +113,13 @@ export async function handleCompleteTask(params, basePath) {
             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,
@@ -139,7 +139,7 @@ export async function handleCompleteTask(params, basePath) {
     // verifyExpectedArtifact() stay consistent (both say "not done").
     // 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;
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);

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

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getMilestone, getMilestoneSlices, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.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";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -106,25 +106,20 @@ function validateParams(params) {
         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),
     };
 }
@@ -147,15 +142,19 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
                 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
             if (params.dependsOn && params.dependsOn.length > 0) {
@@ -178,6 +177,8 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 depends_on: params.dependsOn ?? [],
             });
             upsertMilestonePlanning(params.milestoneId, {
+                title: params.title,
+                status: params.status ?? "active",
                 vision: params.vision,
                 successCriteria: params.successCriteria,
                 keyRisks: params.keyRisks,
@@ -189,13 +190,20 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 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/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -72,16 +72,13 @@ function validateParams(params) {
         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),
     };
 }

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -7,6 +7,20 @@ import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
 import { deriveState } from "./state.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────
+/**
+ * Strip a leading ID prefix (e.g. "M001: " or "S04: ") from a title
+ * to prevent double-prefixing when the renderer adds its own prefix.
+ * Handles repeated prefixes (e.g. "M001: M001: M001: Title" → "Title").
+ */
+export function stripIdPrefix(title, id) {
+    const prefix = `${id}: `;
+    let result = title;
+    while (result.startsWith(prefix)) {
+        result = result.slice(prefix.length);
+    }
+    return result.trim() || title;
+}
 // ─── PLAN.md Projection ──────────────────────────────────────────────────
 /**
  * Render PLAN.md content from a slice row and its task rows.
@@ -14,7 +28,8 @@ import { deriveState } from "./state.js";
  */
 export function renderPlanContent(sliceRow, taskRows) {
     const lines = [];
-    lines.push(`# ${sliceRow.id}: ${sliceRow.title}`);
+    const displayTitle = stripIdPrefix(sliceRow.title, sliceRow.id);
+    lines.push(`# ${sliceRow.id}: ${displayTitle}`);
     lines.push("");
     // #2945: never use full_summary_md/full_uat_md as display fallbacks —
     // they contain multi-line rendered markdown that corrupts single-line fields.
@@ -71,7 +86,8 @@ export function renderPlanProjection(basePath, milestoneId, sliceId) {
  */
 export function renderRoadmapContent(milestoneRow, sliceRows) {
     const lines = [];
-    lines.push(`# ${milestoneRow.id}: ${milestoneRow.title}`);
+    const displayTitle = stripIdPrefix(milestoneRow.title, milestoneRow.id);
+    lines.push(`# ${milestoneRow.id}: ${displayTitle}`);
     lines.push("");
     lines.push("## Vision");
     lines.push(milestoneRow.vision || milestoneRow.title || "TBD");
@@ -218,14 +234,14 @@ export function renderStateContent(state) {
     const lines = [];
     lines.push("# GSD State", "");
     const activeSlice = state.activeSlice
-        ? `${state.activeSlice.id}: ${state.activeSlice.title}`
+        ? `${state.activeSlice.id}: ${stripIdPrefix(state.activeSlice.title, state.activeSlice.id)}`
         : "None";
     if (state.phase === 'complete' && state.lastCompletedMilestone) {
         lines.push(`**Last Completed Milestone:** ${state.lastCompletedMilestone.id}: ${state.lastCompletedMilestone.title}`);
     }
     else {
         const activeMilestone = state.activeMilestone
-            ? `${state.activeMilestone.id}: ${state.activeMilestone.title}`
+            ? `${state.activeMilestone.id}: ${stripIdPrefix(state.activeMilestone.title, state.activeMilestone.id)}`
             : "None";
         lines.push(`**Active Milestone:** ${activeMilestone}`);
     }
@@ -238,7 +254,7 @@ export function renderStateContent(state) {
     lines.push("## Milestone Registry");
     for (const entry of state.registry) {
         const glyph = entry.status === "complete" ? "\u2705" : entry.status === "active" ? "\uD83D\uDD04" : entry.status === "parked" ? "\u23F8\uFE0F" : "\u2B1C";
-        lines.push(`- ${glyph} **${entry.id}:** ${entry.title}`);
+        lines.push(`- ${glyph} **${entry.id}:** ${stripIdPrefix(entry.title, entry.id)}`);
     }
     lines.push("");
     lines.push("## Recent Decisions");