gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

package/dist/resources/extensions/gsd/post-unit-hooks.js

@@ -1,436 +1,48 @@
-// GSD Extension — Hook Engine (Post-Unit, Pre-Dispatch, State Persistence)
-// Manages hook queue, cycle tracking, artifact verification, pre-dispatch
-// interception, and durable hook state for user-configured extensibility.
-import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-// ─── Hook Queue State ──────────────────────────────────────────────────────
-/** Currently executing hook, or null if in normal dispatch flow. */
-let activeHook = null;
-/** Queue of hooks remaining for the current trigger unit. */
-let hookQueue = [];
-/** Cycle counts per hook+trigger, keyed as "hookName/triggerUnitType/triggerUnitId". */
-const cycleCounts = new Map();
-/** Set when a hook completes with retry_on artifact present — signals caller to re-run trigger. */
-let retryPending = false;
-/** Stores the trigger unit info for pending retries so caller knows what to re-run. */
-let retryTrigger = null;
-// ─── Public API ────────────────────────────────────────────────────────────
-/**
- * Called after a unit completes. Returns the next hook unit to dispatch,
- * or null if no hooks apply (normal dispatch should proceed).
- *
- * Call flow:
- * 1. A core unit (e.g. execute-task) completes → handleAgentEnd calls this
- * 2. If hooks match, returns first hook to dispatch. Caller sends the prompt.
- * 3. Hook unit completes → handleAgentEnd calls this again (activeHook is set)
- * 4. Checks retry_on / next hook / done → returns next action or null
- */
+// GSD Extension — Hook Engine Facade
+//
+// Thin facade over RuleRegistry. All mutable state and logic lives in the
+// registry instance; these exported functions delegate through getOrCreateRegistry()
+// so existing call-sites and tests work without modification.
+import { getOrCreateRegistry } from "./rule-registry.js";
+// Re-export resolveHookArtifactPath so existing importers still work.
+export { resolveHookArtifactPath } from "./rule-registry.js";
+// ─── Post-Unit Hooks ───────────────────────────────────────────────────────
 export function checkPostUnitHooks(completedUnitType, completedUnitId, basePath) {
-    // If we just completed a hook unit, handle its result
-    if (activeHook) {
-        return handleHookCompletion(basePath);
-    }
-    // Don't trigger hooks for other hook units (prevent hook-on-hook chains)
-    // Don't trigger hooks for triage units (prevent hook-on-triage chains)
-    // Don't trigger hooks for quick-task units (lightweight one-offs from captures)
-    if (completedUnitType.startsWith("hook/") || completedUnitType === "triage-captures" || completedUnitType === "quick-task")
-        return null;
-    // Check if any hooks are configured for this unit type
-    const hooks = resolvePostUnitHooks().filter(h => h.after.includes(completedUnitType));
-    if (hooks.length === 0)
-        return null;
-    // Build hook queue for this trigger
-    hookQueue = hooks.map(config => ({
-        config,
-        triggerUnitType: completedUnitType,
-        triggerUnitId: completedUnitId,
-    }));
-    return dequeueNextHook(basePath);
+    return getOrCreateRegistry().evaluatePostUnit(completedUnitType, completedUnitId, basePath);
 }
-/**
- * Returns whether a hook is currently active (for progress display).
- */
 export function getActiveHook() {
-    return activeHook;
+    return getOrCreateRegistry().getActiveHook();
 }
-/**
- * Returns true if a retry of the trigger unit was requested by a hook.
- * Caller should re-dispatch the original trigger unit, then hooks will
- * fire again on its next completion.
- */
 export function isRetryPending() {
-    return retryPending;
+    return getOrCreateRegistry().isRetryPending();
 }
-/**
- * Returns the trigger unit info for a pending retry, or null.
- * Clears the retry state after reading.
- */
 export function consumeRetryTrigger() {
-    if (!retryPending || !retryTrigger)
-        return null;
-    const trigger = { ...retryTrigger };
-    retryPending = false;
-    retryTrigger = null;
-    return trigger;
+    return getOrCreateRegistry().consumeRetryTrigger();
 }
-/**
- * Reset all hook state. Called on auto-mode start/stop.
- */
 export function resetHookState() {
-    activeHook = null;
-    hookQueue = [];
-    cycleCounts.clear();
-    retryPending = false;
-    retryTrigger = null;
+    getOrCreateRegistry().resetState();
 }
-// ─── Internal ──────────────────────────────────────────────────────────────
-function dequeueNextHook(basePath) {
-    while (hookQueue.length > 0) {
-        const entry = hookQueue.shift();
-        const { config, triggerUnitType, triggerUnitId } = entry;
-        // Check idempotency — if artifact already exists, skip this hook
-        if (config.artifact) {
-            const artifactPath = resolveHookArtifactPath(basePath, triggerUnitId, config.artifact);
-            if (existsSync(artifactPath))
-                continue;
-        }
-        // Check cycle limit
-        const cycleKey = `${config.name}/${triggerUnitType}/${triggerUnitId}`;
-        const currentCycle = (cycleCounts.get(cycleKey) ?? 0) + 1;
-        const maxCycles = config.max_cycles ?? 1;
-        if (currentCycle > maxCycles)
-            continue;
-        cycleCounts.set(cycleKey, currentCycle);
-        activeHook = {
-            hookName: config.name,
-            triggerUnitType,
-            triggerUnitId,
-            cycle: currentCycle,
-            pendingRetry: false,
-        };
-        // Build the prompt with variable substitution
-        const [mid, sid, tid] = triggerUnitId.split("/");
-        let prompt = config.prompt
-            .replace(/\{milestoneId\}/g, mid ?? "")
-            .replace(/\{sliceId\}/g, sid ?? "")
-            .replace(/\{taskId\}/g, tid ?? "");
-        // Inject browser safety instruction for hooks that may use browser tools (#1345).
-        // Vite HMR and other persistent connections prevent networkidle from resolving.
-        prompt += "\n\n**Browser tool safety:** Do NOT use `browser_wait_for` with `condition: \"network_idle\"` — it hangs indefinitely when dev servers keep persistent connections (Vite HMR, WebSocket). Use `selector_visible`, `text_visible`, or `delay` instead.";
-        return {
-            hookName: config.name,
-            prompt,
-            model: config.model,
-            unitType: `hook/${config.name}`,
-            unitId: triggerUnitId,
-        };
-    }
-    // No more hooks — clear active state and return null for normal dispatch
-    activeHook = null;
-    return null;
-}
-function handleHookCompletion(basePath) {
-    const hook = activeHook;
-    const hooks = resolvePostUnitHooks();
-    const config = hooks.find(h => h.name === hook.hookName);
-    // Check if retry was requested via retry_on artifact
-    if (config?.retry_on) {
-        const retryArtifactPath = resolveHookArtifactPath(basePath, hook.triggerUnitId, config.retry_on);
-        if (existsSync(retryArtifactPath)) {
-            // Check cycle limit before allowing retry
-            const cycleKey = `${config.name}/${hook.triggerUnitType}/${hook.triggerUnitId}`;
-            const currentCycle = cycleCounts.get(cycleKey) ?? 1;
-            const maxCycles = config.max_cycles ?? 1;
-            if (currentCycle < maxCycles) {
-                // Signal retry — caller will re-dispatch the trigger unit
-                activeHook = null;
-                hookQueue = [];
-                retryPending = true;
-                retryTrigger = { unitType: hook.triggerUnitType, unitId: hook.triggerUnitId, retryArtifact: config.retry_on };
-                return null;
-            }
-            // Max cycles reached — fall through to normal completion
-        }
-    }
-    // Hook completed normally — try next hook in queue
-    activeHook = null;
-    return dequeueNextHook(basePath);
-}
-/**
- * Resolve the path where a hook artifact is expected to be written.
- * Uses the trigger unit's directory context:
- *   - Task-level (M001/S01/T01): .gsd/milestones/M001/slices/S01/tasks/T01-{artifact}
- *   - Slice-level (M001/S01):    .gsd/milestones/M001/slices/S01/{artifact}
- *   - Milestone-level (M001):    .gsd/milestones/M001/{artifact}
- */
-export function resolveHookArtifactPath(basePath, unitId, artifactName) {
-    const parts = unitId.split("/");
-    if (parts.length === 3) {
-        const [mid, sid, tid] = parts;
-        return join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks", `${tid}-${artifactName}`);
-    }
-    if (parts.length === 2) {
-        const [mid, sid] = parts;
-        return join(basePath, ".gsd", "milestones", mid, "slices", sid, artifactName);
-    }
-    return join(basePath, ".gsd", "milestones", parts[0], artifactName);
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// Phase 2: Pre-Dispatch Hooks
-// ═══════════════════════════════════════════════════════════════════════════
-/**
- * Run pre-dispatch hooks for a unit about to be dispatched.
- * Returns a result indicating whether the unit should proceed (with optional
- * prompt modifications), be skipped, or be replaced entirely.
- *
- * Multiple hooks can fire for the same unit type. They compose:
- * - "modify" hooks stack (all prepend/append applied in order)
- * - "skip" short-circuits (first matching skip wins)
- * - "replace" short-circuits (first matching replace wins)
- * - Skip/replace hooks take precedence over modify hooks
- */
+// ─── Pre-Dispatch Hooks ────────────────────────────────────────────────────
 export function runPreDispatchHooks(unitType, unitId, prompt, basePath) {
-    // Don't intercept hook units
-    if (unitType.startsWith("hook/")) {
-        return { action: "proceed", prompt, firedHooks: [] };
-    }
-    const hooks = resolvePreDispatchHooks().filter(h => h.before.includes(unitType));
-    if (hooks.length === 0) {
-        return { action: "proceed", prompt, firedHooks: [] };
-    }
-    const [mid, sid, tid] = unitId.split("/");
-    const substitute = (text) => text
-        .replace(/\{milestoneId\}/g, mid ?? "")
-        .replace(/\{sliceId\}/g, sid ?? "")
-        .replace(/\{taskId\}/g, tid ?? "");
-    const firedHooks = [];
-    let currentPrompt = prompt;
-    for (const hook of hooks) {
-        if (hook.action === "skip") {
-            // Check optional skip condition
-            if (hook.skip_if) {
-                const conditionPath = resolveHookArtifactPath(basePath, unitId, hook.skip_if);
-                if (!existsSync(conditionPath))
-                    continue; // Condition not met, don't skip
-            }
-            firedHooks.push(hook.name);
-            return { action: "skip", firedHooks };
-        }
-        if (hook.action === "replace") {
-            firedHooks.push(hook.name);
-            return {
-                action: "replace",
-                prompt: substitute(hook.prompt ?? ""),
-                unitType: hook.unit_type,
-                model: hook.model,
-                firedHooks,
-            };
-        }
-        if (hook.action === "modify") {
-            firedHooks.push(hook.name);
-            if (hook.prepend) {
-                currentPrompt = `${substitute(hook.prepend)}\n\n${currentPrompt}`;
-            }
-            if (hook.append) {
-                currentPrompt = `${currentPrompt}\n\n${substitute(hook.append)}`;
-            }
-        }
-    }
-    return {
-        action: "proceed",
-        prompt: currentPrompt,
-        model: hooks.find(h => h.action === "modify" && h.model)?.model,
-        firedHooks,
-    };
-}
-// ═══════════════════════════════════════════════════════════════════════════
-// Phase 3: Hook State Persistence
-// ═══════════════════════════════════════════════════════════════════════════
-const HOOK_STATE_FILE = "hook-state.json";
-function hookStatePath(basePath) {
-    return join(basePath, ".gsd", HOOK_STATE_FILE);
+    return getOrCreateRegistry().evaluatePreDispatch(unitType, unitId, prompt, basePath);
 }
-/**
- * Persist current hook cycle counts to disk so they survive crashes/restarts.
- * Called after each hook dispatch and on auto-mode pause.
- */
+// ─── State Persistence ─────────────────────────────────────────────────────
 export function persistHookState(basePath) {
-    const state = {
-        cycleCounts: Object.fromEntries(cycleCounts),
-        savedAt: new Date().toISOString(),
-    };
-    try {
-        const dir = join(basePath, ".gsd");
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        writeFileSync(hookStatePath(basePath), JSON.stringify(state, null, 2), "utf-8");
-    }
-    catch {
-        // Non-fatal — state is recreatable from artifacts
-    }
+    getOrCreateRegistry().persistState(basePath);
 }
-/**
- * Restore hook cycle counts from disk after a crash/restart.
- * Called during auto-mode resume.
- */
 export function restoreHookState(basePath) {
-    try {
-        const filePath = hookStatePath(basePath);
-        if (!existsSync(filePath))
-            return;
-        const raw = readFileSync(filePath, "utf-8");
-        const state = JSON.parse(raw);
-        if (state.cycleCounts && typeof state.cycleCounts === "object") {
-            cycleCounts.clear();
-            for (const [key, value] of Object.entries(state.cycleCounts)) {
-                if (typeof value === "number") {
-                    cycleCounts.set(key, value);
-                }
-            }
-        }
-    }
-    catch {
-        // Non-fatal — fresh state is fine
-    }
+    getOrCreateRegistry().restoreState(basePath);
 }
-/**
- * Clear persisted hook state file from disk.
- * Called on clean auto-mode stop.
- */
 export function clearPersistedHookState(basePath) {
-    try {
-        const filePath = hookStatePath(basePath);
-        if (existsSync(filePath)) {
-            writeFileSync(filePath, JSON.stringify({ cycleCounts: {}, savedAt: new Date().toISOString() }, null, 2), "utf-8");
-        }
-    }
-    catch {
-        // Non-fatal
-    }
+    getOrCreateRegistry().clearPersistedState(basePath);
 }
-// ═══════════════════════════════════════════════════════════════════════════
-// Phase 3: Hook Status Reporting
-// ═══════════════════════════════════════════════════════════════════════════
-/**
- * Get status of all configured hooks for display by /gsd hooks.
- */
+// ─── Status & Manual Trigger ───────────────────────────────────────────────
 export function getHookStatus() {
-    const entries = [];
-    // Post-unit hooks
-    const postHooks = resolvePostUnitHooks();
-    for (const hook of postHooks) {
-        const activeCycles = {};
-        for (const [key, count] of cycleCounts) {
-            if (key.startsWith(`${hook.name}/`)) {
-                activeCycles[key] = count;
-            }
-        }
-        entries.push({
-            name: hook.name,
-            type: "post",
-            enabled: hook.enabled !== false,
-            targets: hook.after,
-            activeCycles,
-        });
-    }
-    // Pre-dispatch hooks
-    const preHooks = resolvePreDispatchHooks();
-    for (const hook of preHooks) {
-        entries.push({
-            name: hook.name,
-            type: "pre",
-            enabled: hook.enabled !== false,
-            targets: hook.before,
-            activeCycles: {},
-        });
-    }
-    return entries;
+    return getOrCreateRegistry().getHookStatus();
 }
-/**
- * Manually trigger a specific hook for a unit.
- * This bypasses the normal flow and forces the hook to run even if its artifact exists.
- *
- * @param hookName - The name of the hook to trigger (e.g., "code-review")
- * @param unitType - The type of unit that triggered the hook (e.g., "execute-task")
- * @param unitId - The unit ID (e.g., "M001/S01/T01")
- * @param basePath - The project base path
- * @returns The hook dispatch result or null if hook not found
- */
 export function triggerHookManually(hookName, unitType, unitId, basePath) {
-    // Find the hook configuration
-    const hook = resolvePostUnitHooks().find(h => h.name === hookName);
-    if (!hook) {
-        console.error(`[triggerHookManually] Hook "${hookName}" not found in post_unit_hooks`);
-        return null;
-    }
-    if (!hook.prompt || typeof hook.prompt !== 'string' || hook.prompt.trim().length === 0) {
-        console.error(`[triggerHookManually] Hook "${hookName}" has empty prompt`);
-        return null;
-    }
-    // Reset any active hook state to allow manual triggering
-    activeHook = {
-        hookName: hook.name,
-        triggerUnitType: unitType,
-        triggerUnitId: unitId,
-        cycle: 1,
-        pendingRetry: false,
-    };
-    // Build the hook queue with just this hook
-    hookQueue = [{
-            config: hook,
-            triggerUnitType: unitType,
-            triggerUnitId: unitId,
-        }];
-    // Set the cycle count for this specific hook+trigger
-    const cycleKey = `${hook.name}/${unitType}/${unitId}`;
-    const currentCycle = (cycleCounts.get(cycleKey) ?? 0) + 1;
-    cycleCounts.set(cycleKey, currentCycle);
-    // Update active hook with the cycle count
-    activeHook.cycle = currentCycle;
-    // Build the prompt with variable substitution
-    const [mid, sid, tid] = unitId.split("/");
-    const prompt = hook.prompt
-        .replace(/\{milestoneId\}/g, mid ?? "")
-        .replace(/\{sliceId\}/g, sid ?? "")
-        .replace(/\{taskId\}/g, tid ?? "");
-    console.log(`[triggerHookManually] Built prompt for ${hookName}, length: ${prompt.length}`);
-    return {
-        hookName: hook.name,
-        prompt,
-        model: hook.model,
-        unitType: `hook/${hook.name}`,
-        unitId,
-    };
+    return getOrCreateRegistry().triggerHookManually(hookName, unitType, unitId, basePath);
 }
-/**
- * Format hook status for terminal display.
- */
 export function formatHookStatus() {
-    const entries = getHookStatus();
-    if (entries.length === 0) {
-        return "No hooks configured. Add post_unit_hooks or pre_dispatch_hooks to .gsd/preferences.md";
-    }
-    const lines = ["Configured Hooks:", ""];
-    const postHooks = entries.filter(e => e.type === "post");
-    const preHooks = entries.filter(e => e.type === "pre");
-    if (postHooks.length > 0) {
-        lines.push("Post-Unit Hooks (run after unit completes):");
-        for (const hook of postHooks) {
-            const status = hook.enabled ? "enabled" : "disabled";
-            const cycles = Object.keys(hook.activeCycles).length;
-            const cycleInfo = cycles > 0 ? ` (${cycles} active cycle${cycles === 1 ? "" : "s"})` : "";
-            lines.push(`  ${hook.name} [${status}] → after: ${hook.targets.join(", ")}${cycleInfo}`);
-        }
-        lines.push("");
-    }
-    if (preHooks.length > 0) {
-        lines.push("Pre-Dispatch Hooks (run before unit dispatches):");
-        for (const hook of preHooks) {
-            const status = hook.enabled ? "enabled" : "disabled";
-            lines.push(`  ${hook.name} [${status}] → before: ${hook.targets.join(", ")}`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n");
+    return getOrCreateRegistry().formatHookStatus();
 }

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

@@ -66,6 +66,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "widget_mode",
     "reactive_execution",
     "github",
+    "service_tier",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

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

@@ -214,6 +214,7 @@ function mergePreferences(base, override) {
         github: (base.github || override.github)
             ? { ...(base.github ?? {}), ...(override.github ?? {}) }
             : undefined,
+        service_tier: override.service_tier ?? base.service_tier,
     };
 }
 function mergeStringLists(base, override) {

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -16,11 +16,34 @@
  * mid-session — especially for late-loading templates like complete-milestone
  * that aren't read until the end of a long auto-mode run.
  */
-import { readFileSync, readdirSync } from "node:fs";
+import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-const __extensionDir = dirname(fileURLToPath(import.meta.url));
+import { homedir } from "node:os";
+/**
+ * Resolve the GSD extension directory.
+ *
+ * `import.meta.url` resolves to whichever copy of this module is executing.
+ * On Windows (npm global install via MSYS2 / Git Bash) this can resolve to
+ * the npm-global `AppData/Roaming/npm/…` path, which does NOT contain the
+ * prompts/ and templates/ subtrees that initResources() copies to
+ * `~/.gsd/agent/extensions/gsd/`. Detect the mismatch and fall back to
+ * the user-local agent directory.
+ */
+function resolveExtensionDir() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    if (existsSync(join(moduleDir, "prompts")))
+        return moduleDir;
+    // Fallback: user-local agent directory
+    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+    const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
+    if (existsSync(join(agentGsdDir, "prompts")))
+        return agentGsdDir;
+    // Last resort: return the module dir (warmCache will silently handle the miss)
+    return moduleDir;
+}
+const __extensionDir = resolveExtensionDir();
 const promptsDir = join(__extensionDir, "prompts");
 const templatesDir = join(__extensionDir, "templates");
 // Cache all templates eagerly at module load — a running session uses the
@@ -43,7 +66,11 @@ function warmCache() {
         }
     }
     catch {
-        // prompts/ may not exist in test environments — lazy loading still works
+        // prompts/ may not exist in test environments — lazy loading still works.
+        // Emit a diagnostic when running outside tests so wrong-path bugs are visible.
+        if (!process.env.VITEST && !process.env.NODE_TEST) {
+            process.stderr.write(`[gsd:prompt-loader] warmCache: prompts dir not found: ${promptsDir}\n`);
+        }
     }
     try {
         for (const file of readdirSync(templatesDir)) {
@@ -56,7 +83,10 @@ function warmCache() {
         }
     }
     catch {
-        // templates/ may not exist in test environments — lazy loading still works
+        // templates/ may not exist in test environments — lazy loading still works.
+        if (!process.env.VITEST && !process.env.NODE_TEST) {
+            process.stderr.write(`[gsd:prompt-loader] warmCache: templates dir not found: ${templatesDir}\n`);
+        }
     }
 }
 // Snapshot all templates at module load time

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

@@ -17,16 +17,17 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 Then:
 1. Use the **Milestone Summary** output template from the inlined context above
 2. {{skillActivation}}
-3. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. List any criterion that was NOT met.
-4. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly.
-5. 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. Write `{{milestoneSummaryPath}}` using the milestone-summary template. Fill all frontmatter fields and narrative sections. The `requirement_outcomes` field must list every requirement that changed status with `from_status`, `to_status`, and `proof`.
-7. Update `.gsd/REQUIREMENTS.md` if any requirement status transitions were validated in step 5.
-8. Update `.gsd/PROJECT.md` to reflect milestone completion and current project state.
-9. 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`.
-10. Do not commit manually — the system auto-commits your changes after this unit completes.
-
-**Important:** Do NOT skip the success criteria and definition of done verification (steps 3-4). The milestone summary must reflect actual verified outcomes, not assumed success. If any criterion was not met, document it clearly in the summary and do not mark the milestone as passing verification.
+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. In that case, do NOT mark the milestone as passing verification — document the gap clearly in the summary and state that implementation is missing.
+4. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. List any criterion that was NOT met.
+5. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly.
+6. Validate **requirement status transitions**. For each requirement that changed status during this milestone, confirm the transition is supported by evidence. Requirements can move between Active, Validated, Deferred, Blocked, or Out of Scope — but only with proof.
+7. Write `{{milestoneSummaryPath}}` using the milestone-summary template. Fill all frontmatter fields and narrative sections. The `requirement_outcomes` field must list every requirement that changed status with `from_status`, `to_status`, and `proof`.
+8. Update `.gsd/REQUIREMENTS.md` if any requirement status transitions were validated in step 5.
+9. Update `.gsd/PROJECT.md` to reflect milestone completion and current project state.
+10. Review all slice summaries for cross-cutting lessons, patterns, or gotchas that emerged during this milestone. Append any non-obvious, reusable insights to `.gsd/KNOWLEDGE.md`.
+11. Do not commit manually — the system auto-commits your changes after this unit completes.
+
+**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. If any criterion was not met or no code changes exist, document it clearly in the summary and do not mark the milestone as passing verification.
 
 **File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
 

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -56,7 +56,7 @@ Use these templates exactly:
 9. Say exactly: "Milestone {{milestoneId}} ready."
 
 **For multi-milestone**, write in this order:
-1. For each milestone, call `gsd_generate_milestone_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices` for each.
+1. For each milestone, call `gsd_milestone_generate_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices` for each.
 2. Write `.gsd/PROJECT.md` — full vision across ALL milestones (using Project template)
 3. Write `.gsd/REQUIREMENTS.md` — full capability contract (using Requirements template)
 4. Seed `.gsd/DECISIONS.md` (using Decisions template)
@@ -82,5 +82,5 @@ Use these templates exactly:
 - **Investigate before writing** — always scout the codebase first
 - **Use depends_on frontmatter** for multi-milestone sequences (the state machine reads this field to determine execution order)
 - **Anti-reduction rule** — if the spec describes a big vision, plan the big vision. Do not ask "what's the minimum viable version?" or reduce scope. Phase complex/risky work into later milestones — do not cut it.
-- **Naming convention** — always use `gsd_generate_milestone_id` to get milestone IDs. Directories use bare IDs (e.g. `M001/` or `M001-r5jzab/`), files use ID-SUFFIX format (e.g. `M001-CONTEXT.md` or `M001-r5jzab-CONTEXT.md`). Never invent milestone IDs manually.
+- **Naming convention** — always use `gsd_milestone_generate_id` to get milestone IDs. Directories use bare IDs (e.g. `M001/` or `M001-r5jzab/`), files use ID-SUFFIX format (e.g. `M001-CONTEXT.md` or `M001-r5jzab-CONTEXT.md`). Never invent milestone IDs manually.
 - **End with "Milestone {{milestoneId}} ready."** — this triggers auto-start detection

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

@@ -214,7 +214,7 @@ Once the user confirms the milestone split:
 
 #### Phase 1: Shared artifacts
 
-1. For each milestone, call `gsd_generate_milestone_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
+1. For each milestone, call `gsd_milestone_generate_id` to get its ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
 2. Write `.gsd/PROJECT.md` — use the **Project** output template below.
 3. Write `.gsd/REQUIREMENTS.md` — use the **Requirements** output template below. Capture Active, Deferred, Out of Scope, and any already Validated requirements. Later milestones may have provisional ownership where slice plans do not exist yet.
 4. Seed `.gsd/DECISIONS.md` — use the **Decisions** output template below.

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

@@ -107,7 +107,7 @@ The user confirms or corrects before you write. One depth verification per miles
 
 Once the user is satisfied, in a single pass for **each** new milestone:
 
-1. Call `gsd_generate_milestone_id` to get the milestone ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
+1. Call `gsd_milestone_generate_id` to get the milestone ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
 2. Write `.gsd/milestones/<ID>/<ID>-CONTEXT.md` — use the **Context** output template below. Capture intent, scope, risks, constraints, integration points, and relevant requirements. Mark the status as "Queued — pending auto-mode execution." **If this milestone depends on other milestones, add YAML frontmatter with `depends_on`:**
    ```yaml
    ---