gsd-pi 2.48.0 → 2.49.0-dev.9e177e9

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

@@ -450,7 +450,15 @@ export async function runGSDDoctor(basePath, options) {
             }));
         }
         else {
-            slices = parseLegacyRoadmap(roadmapContent).slices;
+            const activeMilestoneId = state.activeMilestone?.id;
+            const activeSliceId = state.activeSlice?.id;
+            slices = parseLegacyRoadmap(roadmapContent).slices.map(s => ({
+                ...s,
+                // Legacy roadmaps only encode done vs not-done. For doctor's
+                // missing-directory checks, treat every undone slice except the
+                // current active slice as effectively pending/unstarted.
+                pending: !s.done && (milestoneId !== activeMilestoneId || s.id !== activeSliceId),
+            }));
         }
         // Wrap in Roadmap-compatible shape for detectCircularDependencies
         const roadmap = { slices };

package/dist/resources/extensions/gsd/extension-manifest.json

@@ -12,7 +12,7 @@
       "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
-    "hooks": ["session_start"],
+    "hooks": ["session_start", "session_switch"],
     "shortcuts": ["Ctrl+Alt+G"]
   }
 }

package/dist/resources/extensions/gsd/git-service.js

@@ -13,28 +13,31 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { detectWorktreeName, SLICE_BRANCH_RE, } from "./worktree.js";
+import { detectWorktreeName, } from "./worktree.js";
+import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
 /**
  * Build a meaningful conventional commit message from task execution context.
- * Format: `{type}({sliceId}/{taskId}): {description}`
+ * Format: `{type}: {description}` (clean conventional commit — no GSD IDs in subject).
+ *
+ * GSD metadata is placed in a `GSD-Task:` git trailer at the end of the body,
+ * following the same convention as `Signed-off-by:` or `Co-Authored-By:`.
  *
  * The description is the task summary one-liner if available (it describes
  * what was actually built), falling back to the task title (what was planned).
  */
 export function buildTaskCommitMessage(ctx) {
-    const scope = ctx.taskId; // e.g. "S01/T02" or just "T02"
     const description = ctx.oneLiner || ctx.taskTitle;
     const type = inferCommitType(ctx.taskTitle, ctx.oneLiner);
-    // Truncate description to ~72 chars for subject line
-    const maxDescLen = 68 - type.length - scope.length;
+    // Truncate description to ~72 chars for subject line (full budget without scope)
+    const maxDescLen = 70 - type.length;
     const truncated = description.length > maxDescLen
         ? description.slice(0, maxDescLen - 1).trimEnd() + "…"
         : description;
-    const subject = `${type}(${scope}): ${truncated}`;
+    const subject = `${type}: ${truncated}`;
     // Build body with key files if available
     const bodyParts = [];
     if (ctx.keyFiles && ctx.keyFiles.length > 0) {
@@ -44,13 +47,12 @@ export function buildTaskCommitMessage(ctx) {
             .join("\n");
         bodyParts.push(fileLines);
     }
+    // Trailers: GSD-Task first, then Resolves
+    bodyParts.push(`GSD-Task: ${ctx.taskId}`);
     if (ctx.issueNumber) {
         bodyParts.push(`Resolves #${ctx.issueNumber}`);
     }
-    if (bodyParts.length > 0) {
-        return `${subject}\n\n${bodyParts.join("\n\n")}`;
-    }
-    return subject;
+    return `${subject}\n\n${bodyParts.join("\n\n")}`;
 }
 /**
  * Thrown when a slice merge hits code conflicts in non-.gsd files.
@@ -132,8 +134,8 @@ export function readIntegrationBranch(basePath, milestoneId) {
  *
  * The file is committed immediately so the metadata is persisted in git.
  */
-/** Regex matching GSD quick-task branches: gsd/quick/<num>-<slug> */
-export const QUICK_BRANCH_RE = /^gsd\/quick\//;
+/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
+export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 export function writeIntegrationBranch(basePath, milestoneId, branch) {
     // Don't record slice branches as the integration target
     if (SLICE_BRANCH_RE.test(branch))
@@ -143,6 +145,11 @@ export function writeIntegrationBranch(basePath, milestoneId, branch) {
     // target causes milestone merges to land on the wrong branch (#1293).
     if (QUICK_BRANCH_RE.test(branch))
         return;
+    // Don't record workflow-template branches (hotfix, bugfix, spike, etc.) —
+    // same root cause as quick-task branches (#2498). All templates create
+    // gsd/<templateId>/<slug> branches that are ephemeral.
+    if (WORKFLOW_BRANCH_RE.test(branch))
+        return;
     // Validate
     if (!VALID_BRANCH_NAME.test(branch))
         return;
@@ -298,10 +305,6 @@ export class GitServiceImpl {
     setMilestoneId(milestoneId) {
         this._milestoneId = milestoneId;
     }
-    /** Convenience wrapper: run git in this repo's basePath. */
-    git(args, options = {}) {
-        return runGit(this.basePath, args, options);
-    }
     /**
      * Smart staging: `git add -A` excluding GSD runtime paths via pathspec.
      * Falls back to plain `git add -A` if the exclusion pathspec fails.
@@ -385,7 +388,7 @@ export class GitServiceImpl {
             return null;
         const message = taskContext
             ? buildTaskCommitMessage(taskContext)
-            : `chore(${unitId}): auto-commit after ${unitType}`;
+            : `chore: auto-commit after ${unitType}\n\nGSD-Unit: ${unitId}`;
         nativeCommit(this.basePath, message, { allowEmpty: false });
         return message;
     }
@@ -441,9 +444,6 @@ export class GitServiceImpl {
     getCurrentBranch() {
         return nativeGetCurrentBranch(this.basePath);
     }
-    /** True if currently on a GSD slice branch. */
-    // ─── Branch Lifecycle ──────────────────────────────────────────────────
-    // ─── S05 Features ─────────────────────────────────────────────────────
     /**
      * Create a snapshot ref for the given label (typically a slice branch name).
      * Gated on prefs.snapshots === true. Ref path: refs/gsd/snapshots/<label>/<timestamp>

package/dist/resources/extensions/gsd/gsd-db.js

@@ -109,7 +109,7 @@ function openRawDb(path) {
     const Database = providerModule;
     return new Database(path);
 }
-const SCHEMA_VERSION = 11;
+const SCHEMA_VERSION = 12;
 function initSchema(db, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
@@ -302,6 +302,22 @@ function initSchema(db, fileBacked) {
         created_at TEXT NOT NULL DEFAULT '',
         FOREIGN KEY (milestone_id) REFERENCES milestones(id)
       )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS quality_gates (
+        milestone_id TEXT NOT NULL,
+        slice_id TEXT NOT NULL,
+        gate_id TEXT NOT NULL,
+        scope TEXT NOT NULL DEFAULT 'slice',
+        task_id TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        verdict TEXT NOT NULL DEFAULT '',
+        rationale TEXT NOT NULL DEFAULT '',
+        findings TEXT NOT NULL DEFAULT '',
+        evaluated_at TEXT DEFAULT NULL,
+        PRIMARY KEY (milestone_id, slice_id, gate_id, task_id),
+        FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+      )
     `);
         db.exec("CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone ON replan_history(milestone_id, created_at)");
@@ -561,6 +577,28 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 12) {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS quality_gates (
+          milestone_id TEXT NOT NULL,
+          slice_id TEXT NOT NULL,
+          gate_id TEXT NOT NULL,
+          scope TEXT NOT NULL DEFAULT 'slice',
+          task_id TEXT DEFAULT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          verdict TEXT NOT NULL DEFAULT '',
+          rationale TEXT NOT NULL DEFAULT '',
+          findings TEXT NOT NULL DEFAULT '',
+          evaluated_at TEXT DEFAULT NULL,
+          PRIMARY KEY (milestone_id, slice_id, gate_id, COALESCE(task_id, '')),
+          FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+        )
+      `);
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 12,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -1396,3 +1434,88 @@ export function getAssessment(path) {
     const row = currentDb.prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
     return row ?? null;
 }
+// ─── Quality Gates ───────────────────────────────────────────────────────
+function rowToGate(row) {
+    return {
+        milestone_id: row["milestone_id"],
+        slice_id: row["slice_id"],
+        gate_id: row["gate_id"],
+        scope: row["scope"],
+        task_id: row["task_id"] ?? "",
+        status: row["status"],
+        verdict: row["verdict"] || "",
+        rationale: row["rationale"] || "",
+        findings: row["findings"] || "",
+        evaluated_at: row["evaluated_at"] ?? null,
+    };
+}
+export function insertGateRow(g) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`INSERT OR IGNORE INTO quality_gates (milestone_id, slice_id, gate_id, scope, task_id, status)
+     VALUES (:mid, :sid, :gid, :scope, :tid, :status)`).run({
+        ":mid": g.milestoneId,
+        ":sid": g.sliceId,
+        ":gid": g.gateId,
+        ":scope": g.scope,
+        ":tid": g.taskId ?? "",
+        ":status": g.status ?? "pending",
+    });
+}
+export function saveGateResult(g) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.prepare(`UPDATE quality_gates
+     SET status = 'complete', verdict = :verdict, rationale = :rationale,
+         findings = :findings, evaluated_at = :evaluated_at
+     WHERE milestone_id = :mid AND slice_id = :sid AND gate_id = :gid
+       AND task_id = :tid`).run({
+        ":mid": g.milestoneId,
+        ":sid": g.sliceId,
+        ":gid": g.gateId,
+        ":tid": g.taskId ?? "",
+        ":verdict": g.verdict,
+        ":rationale": g.rationale,
+        ":findings": g.findings,
+        ":evaluated_at": new Date().toISOString(),
+    });
+}
+export function getPendingGates(milestoneId, sliceId, scope) {
+    if (!currentDb)
+        return [];
+    const sql = scope
+        ? `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND scope = :scope AND status = 'pending'`
+        : `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND status = 'pending'`;
+    const params = { ":mid": milestoneId, ":sid": sliceId };
+    if (scope)
+        params[":scope"] = scope;
+    return currentDb.prepare(sql).all(params).map(rowToGate);
+}
+export function getGateResults(milestoneId, sliceId, scope) {
+    if (!currentDb)
+        return [];
+    const sql = scope
+        ? `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND scope = :scope`
+        : `SELECT * FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid`;
+    const params = { ":mid": milestoneId, ":sid": sliceId };
+    if (scope)
+        params[":scope"] = scope;
+    return currentDb.prepare(sql).all(params).map(rowToGate);
+}
+export function markAllGatesOmitted(milestoneId, sliceId) {
+    if (!currentDb)
+        return;
+    currentDb.prepare(`UPDATE quality_gates SET status = 'omitted', verdict = 'omitted', evaluated_at = :now
+     WHERE milestone_id = :mid AND slice_id = :sid AND status = 'pending'`).run({
+        ":mid": milestoneId,
+        ":sid": sliceId,
+        ":now": new Date().toISOString(),
+    });
+}
+export function getPendingSliceGateCount(milestoneId, sliceId) {
+    if (!currentDb)
+        return 0;
+    const row = currentDb.prepare(`SELECT COUNT(*) as cnt FROM quality_gates
+     WHERE milestone_id = :mid AND slice_id = :sid AND scope = 'slice' AND status = 'pending'`).get({ ":mid": milestoneId, ":sid": sliceId });
+    return row ? row["cnt"] : 0;
+}

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -186,11 +186,20 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
             sections.push(`### Decisions Register\nSource: \`${relGsdRootFile("DECISIONS")}\`\n\n${decisionsContent.trim()}`);
         }
     }
-    // For each milestone, include context and status
+    // For each milestone, include context and status.
+    // Completed milestones get a compact summary line only — loading their full
+    // CONTEXT.md + SUMMARY.md files is expensive and triggers 429 rate limits on
+    // projects with many completed milestones (#2379).
     for (const mid of milestoneIds) {
         const registryEntry = state.registry.find(m => m.id === mid);
         const status = registryEntry?.status ?? "unknown";
         const title = registryEntry?.title ?? mid;
+        // Completed milestones: emit a one-liner — the LLM only needs to know
+        // they exist for dedup/dependency purposes, not their full content.
+        if (status === "complete") {
+            sections.push(`### ${mid}: ${title}\n**Status:** complete`);
+            continue;
+        }
         const parts = [];
         parts.push(`### ${mid}: ${title}\n**Status:** ${status}`);
         // Include context file — this is the primary content for understanding scope
@@ -211,16 +220,6 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
                 }
             }
         }
-        // For completed milestones, include the summary if it exists
-        if (status === "complete") {
-            const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-            if (summaryFile) {
-                const content = await loadFile(summaryFile);
-                if (content) {
-                    parts.push(`\n**Summary:**\n${content.trim()}`);
-                }
-            }
-        }
         // For active/pending/parked milestones, include the roadmap if it exists
         // (shows what's planned but not yet built)
         if (status === "active" || status === "pending" || status === "parked") {

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -10,7 +10,7 @@
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
-import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, } from "./gsd-db.js";
+import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
 import { saveFile, clearParseCache } from "./files.js";
 import { invalidateStateCache } from "./state.js";
@@ -127,7 +127,7 @@ function renderRoadmapMarkdown(milestone, slices) {
     }
     return `${lines.join("\n").trimEnd()}\n`;
 }
-function renderTaskPlanMarkdown(task) {
+function renderTaskPlanMarkdown(task, taskGates = []) {
     const estimatedSteps = Math.max(1, task.description.trim().split(/\n+/).filter(Boolean).length || 1);
     const estimatedFiles = task.files.length > 0
         ? task.files.length
@@ -186,9 +186,20 @@ function renderTaskPlanMarkdown(task) {
         lines.push(task.observability_impact.trim());
         lines.push("");
     }
+    // ── Quality Gate Sections (Q5/Q6/Q7) ──────────────────────────────────
+    const gateLabels = { Q5: "Failure Modes", Q6: "Load Profile", Q7: "Negative Tests" };
+    for (const [gid, label] of Object.entries(gateLabels)) {
+        const gate = taskGates.find(g => g.gate_id === gid && g.status === "complete");
+        if (gate && gate.verdict !== "omitted") {
+            lines.push(`## ${label}`);
+            lines.push("");
+            lines.push(gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`);
+            lines.push("");
+        }
+    }
     return `${lines.join("\n").trimEnd()}\n`;
 }
-function renderSlicePlanMarkdown(slice, tasks) {
+function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     const lines = [];
     lines.push(`# ${slice.id}: ${slice.title || slice.id}`);
     lines.push("");
@@ -206,6 +217,21 @@ function renderSlicePlanMarkdown(slice, tasks) {
         lines.push("- Complete the planned slice outcomes.");
     }
     lines.push("");
+    // ── Quality Gate Sections (Q3/Q4) ────────────────────────────────────
+    const q3 = gates.find(g => g.gate_id === "Q3" && g.status === "complete");
+    if (q3 && q3.verdict !== "omitted") {
+        lines.push("## Threat Surface");
+        lines.push("");
+        lines.push(q3.findings.trim() || `- **Verdict:** ${q3.verdict}\n- **Rationale:** ${q3.rationale}`);
+        lines.push("");
+    }
+    const q4 = gates.find(g => g.gate_id === "Q4" && g.status === "complete");
+    if (q4 && q4.verdict !== "omitted") {
+        lines.push("## Requirement Impact");
+        lines.push("");
+        lines.push(q4.findings.trim() || `- **Verdict:** ${q4.verdict}\n- **Rationale:** ${q4.rationale}`);
+        lines.push("");
+    }
     if (slice.proof_level.trim()) {
         lines.push("## Proof Level");
         lines.push("");
@@ -275,7 +301,8 @@ export async function renderPlanFromDb(basePath, milestoneId, sliceId) {
     const absPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN")
         ?? join(slicePath, `${sliceId}-PLAN.md`);
     const artifactPath = toArtifactPath(absPath, basePath);
-    const content = renderSlicePlanMarkdown(slice, tasks);
+    const sliceGates = getGateResults(milestoneId, sliceId, "slice");
+    const content = renderSlicePlanMarkdown(slice, tasks, sliceGates);
     await writeAndStore(absPath, artifactPath, content, {
         artifact_type: "PLAN",
         milestone_id: milestoneId,
@@ -298,7 +325,8 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     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 taskGates = getGateResults(milestoneId, sliceId, "task").filter(g => g.task_id === taskId);
+    const content = task.full_plan_md.trim() ? task.full_plan_md : renderTaskPlanMarkdown(task, taskGates);
     await writeAndStore(absPath, artifactPath, content, {
         artifact_type: "PLAN",
         milestone_id: milestoneId,

package/dist/resources/extensions/gsd/preferences-types.js

@@ -65,6 +65,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "context_selection",
     "widget_mode",
     "reactive_execution",
+    "gate_evaluation",
     "github",
     "service_tier",
     "forensics_dedup",
@@ -73,7 +74,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
     "research-milestone", "plan-milestone", "research-slice", "plan-slice",
-    "execute-task", "reactive-execute", "complete-slice", "replan-slice", "reassess-roadmap",
+    "execute-task", "reactive-execute", "gate-evaluate", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone",
 ];
 export const SKILL_ACTIONS = new Set(["use", "prefer", "avoid"]);

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -542,6 +542,45 @@ export function validatePreferences(preferences) {
             errors.push("reactive_execution must be an object");
         }
     }
+    // ─── Gate Evaluation ─────────────────────────────────────────────────────
+    if (preferences.gate_evaluation !== undefined) {
+        if (typeof preferences.gate_evaluation === "object" && preferences.gate_evaluation !== null) {
+            const ge = preferences.gate_evaluation;
+            const validGe = {};
+            if (ge.enabled !== undefined) {
+                if (typeof ge.enabled === "boolean")
+                    validGe.enabled = ge.enabled;
+                else
+                    errors.push("gate_evaluation.enabled must be a boolean");
+            }
+            if (ge.slice_gates !== undefined) {
+                if (Array.isArray(ge.slice_gates) && ge.slice_gates.every((g) => typeof g === "string")) {
+                    validGe.slice_gates = ge.slice_gates;
+                }
+                else {
+                    errors.push("gate_evaluation.slice_gates must be an array of strings");
+                }
+            }
+            if (ge.task_gates !== undefined) {
+                if (typeof ge.task_gates === "boolean")
+                    validGe.task_gates = ge.task_gates;
+                else
+                    errors.push("gate_evaluation.task_gates must be a boolean");
+            }
+            const knownGeKeys = new Set(["enabled", "slice_gates", "task_gates"]);
+            for (const key of Object.keys(ge)) {
+                if (!knownGeKeys.has(key)) {
+                    warnings.push(`unknown gate_evaluation key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(validGe).length > 0) {
+                validated.gate_evaluation = validGe;
+            }
+        }
+        else {
+            errors.push("gate_evaluation must be an object");
+        }
+    }
     // ─── Verification Preferences ───────────────────────────────────────────
     if (preferences.verification_commands !== undefined) {
         if (Array.isArray(preferences.verification_commands)) {

package/dist/resources/extensions/gsd/prompts/complete-milestone.md

@@ -20,11 +20,13 @@ Then:
 3. **Verify code changes exist.** Run `git diff --stat HEAD $(git merge-base HEAD main) -- ':!.gsd/'` (or the equivalent for the integration branch). If no non-`.gsd/` files appear in the diff, the milestone produced only planning artifacts and no actual code. Record this as a **verification failure**.
 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. Record any criterion that was NOT met as a **verification failure**.
 5. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly. Record any unmet items as a **verification failure**.
-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.
+6. If the roadmap includes a **Horizontal Checklist**, verify each item was addressed during the milestone. Note unchecked items in the milestone summary.
+7. Fill the **Decision Re-evaluation** table in the milestone summary. For each key decision from `.gsd/DECISIONS.md` made during this milestone, evaluate whether it is still valid given what was actually built. Flag decisions that should be revisited next milestone.
+8. 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.
 
 ### Verification Gate — STOP if verification failed
 
-**If ANY verification failure was recorded in steps 3, 4, or 5, you MUST follow the failure path below. Do NOT proceed to step 7.**
+**If ANY verification failure was recorded in steps 3, 4, or 5, you MUST follow the failure path below. Do NOT proceed to step 9.**
 
 **Failure path** (verification failed):
 - Do NOT call `gsd_complete_milestone` — the milestone must not be marked as complete.
@@ -33,13 +35,30 @@ Then:
 - Write a clear summary of what failed and why to help the next attempt.
 - Say: "Milestone {{milestoneId}} verification FAILED — not complete." and stop.
 
-**Success path** (all verifications passed — continue with steps 7–11):
+**Success path** (all verifications passed — continue with steps 9–13):
 
-7. **Persist completion through `gsd_complete_milestone`.** Call it with: `milestoneId`, `title`, `oneLiner`, `narrative`, `successCriteriaResults`, `definitionOfDoneResults`, `requirementOutcomes`, `keyDecisions`, `keyFiles`, `lessonsLearned`, `followUps`, `deviations`, `verificationPassed: true`. The tool updates the milestone status in the DB, renders `{{milestoneSummaryPath}}`, and validates all slices are complete before proceeding.
-8. For each requirement whose status changed in step 6, call `gsd_requirement_update` with the requirement ID and updated `status` and `validation` fields — the tool regenerates `.gsd/REQUIREMENTS.md` automatically.
-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.
+9. **Persist completion through `gsd_complete_milestone`.** Call it with the parameters below. The tool updates the milestone status in the DB, renders `{{milestoneSummaryPath}}`, and validates all slices are complete before proceeding.
+
+   **Required parameters:**
+   - `milestoneId` (string) — Milestone ID (e.g. M001)
+   - `title` (string) — Milestone title
+   - `oneLiner` (string) — One-sentence summary of what the milestone achieved
+   - `narrative` (string) — Detailed narrative of what happened during the milestone
+   - `successCriteriaResults` (string) — Markdown detailing how each success criterion was met or not met
+   - `definitionOfDoneResults` (string) — Markdown detailing how each definition-of-done item was met
+   - `requirementOutcomes` (string) — Markdown detailing requirement status transitions with evidence
+   - `keyDecisions` (array of strings) — Key architectural/pattern decisions made during the milestone
+   - `keyFiles` (array of strings) — Key files created or modified during the milestone
+   - `lessonsLearned` (array of strings) — Lessons learned during the milestone
+   - `verificationPassed` (boolean) — Must be `true` — confirms that code change verification, success criteria, and definition of done checks all passed before completion
+
+   **Optional parameters:**
+   - `followUps` (string) — Follow-up items for future milestones
+   - `deviations` (string) — Deviations from the original plan
+10. For each requirement whose status changed in step 8, call `gsd_requirement_update` with the requirement ID and updated `status` and `validation` fields — the tool regenerates `.gsd/REQUIREMENTS.md` automatically.
+11. Update `.gsd/PROJECT.md` to reflect milestone completion and current project state.
+12. 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`.
+13. Do not commit manually — the system auto-commits your changes after this unit completes.
 - Say: "Milestone {{milestoneId}} complete."
 
 **Important:** Do NOT skip the code change verification, success criteria, or definition of done verification (steps 3-5). The milestone summary must reflect actual verified outcomes, not assumed success. Verification failures BLOCK completion — there is no override. The milestone stays in its current state until issues are resolved and verification is re-run.

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

@@ -23,14 +23,15 @@ Then:
 2. {{skillActivation}}
 3. Run all slice-level verification checks defined in the slice plan. All must pass before marking the slice done. If any fail, fix them first.
 4. If the slice plan includes observability/diagnostic surfaces, confirm they work. Skip this for simple slices that don't have observability sections.
-5. If this slice produced evidence that a requirement changed status (Active → Validated, Active → Deferred, etc.), call `gsd_save_decision` with scope="requirement", decision="{requirement-id}", choice="{new-status}", rationale="{evidence}". Do NOT write `.gsd/REQUIREMENTS.md` directly — the engine renders it from the database.
-6. Write `{{sliceSummaryPath}}` (compress all task summaries).
-7. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
-8. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
-9. Review task summaries for patterns, gotchas, or non-obvious lessons learned. If any would save future agents from repeating investigation or hitting the same issues, append them to `.gsd/KNOWLEDGE.md`. Only add entries that are genuinely useful — don't pad with obvious observations.
-10. Call `gsd_complete_slice` with milestone_id, slice_id, the slice summary, and the UAT result. Do NOT manually mark the roadmap checkbox — the tool writes to the DB and renders the ROADMAP.md projection automatically.
-11. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
-12. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed.
+5. If the slice involved runtime behavior, fill the **Operational Readiness** section (Q8) in the slice summary: health signal, failure signal, recovery procedure, and monitoring gaps. Omit entirely for simple slices with no runtime concerns.
+6. If this slice produced evidence that a requirement changed status (Active → Validated, Active → Deferred, etc.), call `gsd_save_decision` with scope="requirement", decision="{requirement-id}", choice="{new-status}", rationale="{evidence}". Do NOT write `.gsd/REQUIREMENTS.md` directly — the engine renders it from the database.
+7. Write `{{sliceSummaryPath}}` (compress all task summaries).
+8. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
+9. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
+10. Review task summaries for patterns, gotchas, or non-obvious lessons learned. If any would save future agents from repeating investigation or hitting the same issues, append them to `.gsd/KNOWLEDGE.md`. Only add entries that are genuinely useful — don't pad with obvious observations.
+11. Call `gsd_complete_slice` with milestone_id, slice_id, the slice summary, and the UAT result. Do NOT manually mark the roadmap checkbox — the tool writes to the DB and renders the ROADMAP.md projection automatically.
+12. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
+13. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed.
 
 **You MUST call `gsd_complete_slice` with the slice summary and UAT content before finishing. The tool persists to both DB and disk and renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}` automatically.**