@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.65546769

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

@@ -9,14 +9,14 @@
  * All symbols are re-exported here so that existing `import { ... } from "./preferences.js"`
  * statements continue to work without modification.
  */
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { parse as parseYaml } from "yaml";
 import { normalizeStringArray } from "../shared/format-utils.js";
 import { logWarning } from "./workflow-logger.js";
-import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
+import { DEFAULT_TOKEN_PROFILE, resolveProfileDefaults as _resolveProfileDefaults, VALID_TOKEN_PROFILES, resolveDisabledModelProvidersFromPreferences, } from "./preferences-models.js";
 import { nativeHasCommittedHead, nativeIsRepo } from "./native-git-bridge.js";
 import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, formatSkillRef, } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
@@ -67,6 +67,77 @@ export function getLegacyGlobalGSDPreferencesPath() {
 export function getProjectGSDPreferencesPath(basePath) {
     return projectPreferencesPath(basePath);
 }
+/** Format registry models the same way tier resolution and prefs persistence use. */
+export function availableModelIdsFromRegistry(registry) {
+    return registry.getAvailable().map((m) => `${m.provider}/${m.id}`);
+}
+/**
+ * Keep only provider-qualified model IDs for a single provider (case-insensitive).
+ * Bare IDs are excluded — tier resolution requires provider/model form.
+ */
+export function restrictModelIdsToProvider(modelIds, provider) {
+    const normalized = provider.trim().toLowerCase();
+    if (!normalized)
+        return modelIds;
+    return modelIds.filter((id) => {
+        const slash = id.indexOf("/");
+        if (slash <= 0)
+            return false;
+        return id.slice(0, slash).toLowerCase() === normalized;
+    });
+}
+/**
+ * Model IDs for token-profile tier resolution. When an anchor provider is known
+ * (session model / auto-start snapshot), stay on that provider instead of picking
+ * the globally cheapest tier match across every logged-in provider (e.g. Gemini
+ * Flash beating GPT mini on cost).
+ */
+export function modelIdsForProfileResolution(registry, anchorProvider, disabledProviders) {
+    let all = availableModelIdsFromRegistry(registry);
+    if (disabledProviders?.length) {
+        const blocked = new Set(disabledProviders.map((p) => p.trim().toLowerCase()).filter((p) => p.length > 0));
+        all = all.filter((id) => {
+            const slash = id.indexOf("/");
+            if (slash <= 0)
+                return true;
+            return !blocked.has(id.slice(0, slash).toLowerCase());
+        });
+    }
+    if (all.length === 0)
+        return undefined;
+    if (!anchorProvider?.trim())
+        return all;
+    // Stay on the anchor provider — do not fall back to the full registry when the
+    // scoped list is empty (that reintroduces cross-provider cost picks like Gemini).
+    return restrictModelIdsToProvider(all, anchorProvider);
+}
+/** Provider anchor for token-profile tier resolution (auto-start model wins). */
+export function resolveProfileAnchorProvider(sessionProvider, autoModeStartProvider) {
+    const start = autoModeStartProvider?.trim();
+    if (start)
+        return start;
+    const session = sessionProvider?.trim();
+    return session || undefined;
+}
+/**
+ * Load effective preferences with token-profile tiers resolved against models
+ * the user can actually call (from the live registry), not canonical Anthropic
+ * fallbacks.
+ */
+export function loadEffectiveGSDPreferencesWithRegistry(registry, basePath, anchorProvider, preferredModelId) {
+    const preferenceOpts = preferredModelId !== undefined
+        ? { preferredModelId }
+        : undefined;
+    if (!registry) {
+        return loadEffectiveGSDPreferences(basePath, preferenceOpts);
+    }
+    const disabledProviders = resolveDisabledModelProvidersFromPreferences();
+    const availableModelIds = modelIdsForProfileResolution(registry, anchorProvider, disabledProviders);
+    if (!availableModelIds) {
+        return loadEffectiveGSDPreferences(basePath, preferenceOpts);
+    }
+    return loadEffectiveGSDPreferences(basePath, { availableModelIds, preferredModelId });
+}
 /**
  * Normalize a value loaded from disk (or passed from another component) into
  * a plain, mutable bare preferences object.
@@ -97,49 +168,110 @@ export function normalizePreferencesShape(loaded) {
     return { ...candidate };
 }
 // ─── Loading ────────────────────────────────────────────────────────────────
+const EFFECTIVE_PREFERENCES_CACHE_MAX = 64;
+const effectivePreferencesCache = new Map();
+export function clearGSDPreferencesCache() {
+    effectivePreferencesCache.clear();
+}
+function globalPreferencesCandidatePaths() {
+    return [
+        globalPreferencesPath(),
+        legacyGlobalPreferencesPathLowercase(),
+        legacyGlobalPreferencesPath(),
+    ];
+}
+function projectPreferencesCandidatePaths(basePath) {
+    return [
+        projectPreferencesPath(basePath),
+        legacyProjectPreferencesPathLowercase(basePath),
+    ];
+}
+function preferencesFileSignature(path) {
+    try {
+        const stats = statSync(path);
+        return `${path}:${stats.size}:${stats.mtimeMs}`;
+    }
+    catch (err) {
+        const code = err.code ?? "unknown";
+        return `${path}:missing:${code}`;
+    }
+}
+function effectivePreferencesCacheKey(basePath, opts) {
+    return JSON.stringify({
+        basePath: basePath ?? null,
+        global: globalPreferencesCandidatePaths().map(preferencesFileSignature),
+        project: projectPreferencesCandidatePaths(basePath).map(preferencesFileSignature),
+        availableModelIds: opts?.availableModelIds ?? null,
+        preferredModelId: opts?.preferredModelId ?? null,
+    });
+}
+function cloneLoadedPreferences(loaded) {
+    return loaded ? structuredClone(loaded) : null;
+}
+function cacheEffectivePreferences(key, loaded) {
+    if (!effectivePreferencesCache.has(key) && effectivePreferencesCache.size >= EFFECTIVE_PREFERENCES_CACHE_MAX) {
+        effectivePreferencesCache.clear();
+    }
+    effectivePreferencesCache.set(key, cloneLoadedPreferences(loaded));
+}
 export function loadGlobalGSDPreferences() {
-    return loadPreferencesFile(globalPreferencesPath(), "global")
-        ?? loadPreferencesFile(legacyGlobalPreferencesPathLowercase(), "global")
-        ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
+    return loadFirstUsablePreferencesFile(globalPreferencesCandidatePaths(), "global");
 }
 export function loadProjectGSDPreferences(basePath) {
-    return loadPreferencesFile(projectPreferencesPath(basePath), "project")
-        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(basePath), "project");
+    return loadFirstUsablePreferencesFile(projectPreferencesCandidatePaths(basePath), "project");
 }
 export function loadEffectiveGSDPreferences(basePath, opts) {
+    const cacheKey = effectivePreferencesCacheKey(basePath, opts);
+    if (effectivePreferencesCache.has(cacheKey)) {
+        return cloneLoadedPreferences(effectivePreferencesCache.get(cacheKey));
+    }
     const globalPreferences = loadGlobalGSDPreferences();
     const projectPreferences = loadProjectGSDPreferences(basePath);
-    const projectHasPlanningDepth = projectPreferences?.preferences.planning_depth !== undefined;
-    if (!globalPreferences && !projectPreferences)
+    const effectiveGlobalPreferences = globalPreferences?.ignored ? null : globalPreferences;
+    const effectiveProjectPreferences = projectPreferences?.ignored ? null : projectPreferences;
+    const projectHasPlanningDepth = effectiveProjectPreferences?.preferences.planning_depth !== undefined;
+    if (!effectiveGlobalPreferences && !effectiveProjectPreferences) {
+        cacheEffectivePreferences(cacheKey, null);
         return null;
+    }
     let result;
-    if (!globalPreferences) {
-        result = projectPreferences;
+    if (!effectiveGlobalPreferences) {
+        result = effectiveProjectPreferences;
     }
-    else if (!projectPreferences) {
-        result = globalPreferences;
+    else if (!effectiveProjectPreferences) {
+        result = mergePreferenceMetadata(effectiveGlobalPreferences, projectPreferences);
     }
     else {
-        const mergedWarnings = [
-            ...(globalPreferences.warnings ?? []),
-            ...(projectPreferences.warnings ?? []),
-        ];
+        const metadata = mergePreferenceMetadata(effectiveGlobalPreferences, effectiveProjectPreferences);
         result = {
-            path: projectPreferences.path,
+            path: effectiveProjectPreferences.path,
             scope: "project",
-            preferences: mergePreferences(globalPreferences.preferences, projectPreferences.preferences),
-            ...(mergedWarnings.length > 0 ? { warnings: mergedWarnings } : {}),
+            preferences: mergePreferences(effectiveGlobalPreferences.preferences, effectiveProjectPreferences.preferences),
+            ...(metadata.warnings ? { warnings: metadata.warnings } : {}),
+            ...(metadata.diagnostics ? { diagnostics: metadata.diagnostics } : {}),
         };
     }
     // Apply token-profile defaults as the lowest-priority layer so that
     // `token_profile: budget` sets models and phase-skips automatically.
     // Explicit user preferences always override profile defaults.
-    const profile = result.preferences.token_profile;
-    if (profile) {
-        const profileDefaults = _resolveProfileDefaults(profile, opts?.availableModelIds, result.preferences.dynamic_routing);
+    const explicitProfile = result.preferences.token_profile;
+    let profileForDefaults;
+    if (explicitProfile) {
+        if (VALID_TOKEN_PROFILES.has(explicitProfile)) {
+            profileForDefaults = explicitProfile;
+        }
+    }
+    else {
+        profileForDefaults = DEFAULT_TOKEN_PROFILE;
+    }
+    if (profileForDefaults) {
+        const profileDefaults = _resolveProfileDefaults(profileForDefaults, opts?.availableModelIds, result.preferences.dynamic_routing, opts?.preferredModelId);
+        const defaultsToApply = explicitProfile
+            ? profileDefaults
+            : withoutProfilePhaseDefaults(profileDefaults);
         result = {
             ...result,
-            preferences: mergePreferences(profileDefaults, result.preferences),
+            preferences: mergePreferences(defaultsToApply, result.preferences),
         };
     }
     // Apply mode defaults as the lowest-priority layer
@@ -150,8 +282,44 @@ export function loadEffectiveGSDPreferences(basePath, opts) {
         };
     }
     result = stripInheritedPlanningDepth(result, projectHasPlanningDepth);
+    cacheEffectivePreferences(cacheKey, result);
     return result;
 }
+function withoutProfilePhaseDefaults(defaults) {
+    if (defaults.phases === undefined)
+        return defaults;
+    const { phases: _phases, ...rest } = defaults;
+    return rest;
+}
+function mergePreferenceMetadata(primary, secondary) {
+    const mergedWarnings = [
+        ...(primary.warnings ?? []),
+        ...(secondary?.warnings ?? []),
+    ];
+    const mergedDiagnostics = [
+        ...(primary.diagnostics ?? []),
+        ...(secondary?.diagnostics ?? []),
+    ];
+    return {
+        ...primary,
+        ...(mergedWarnings.length > 0 ? { warnings: mergedWarnings } : {}),
+        ...(mergedDiagnostics.length > 0 ? { diagnostics: mergedDiagnostics } : {}),
+    };
+}
+function loadFirstUsablePreferencesFile(paths, scope) {
+    let ignoredPreferences = null;
+    for (const path of paths) {
+        const loaded = loadPreferencesFile(path, scope);
+        if (!loaded)
+            continue;
+        if (!loaded.ignored)
+            return mergePreferenceMetadata(loaded, ignoredPreferences);
+        ignoredPreferences = ignoredPreferences
+            ? mergePreferenceMetadata(ignoredPreferences, loaded)
+            : loaded;
+    }
+    return ignoredPreferences;
+}
 function stripInheritedPlanningDepth(loaded, projectHasPlanningDepth) {
     if (projectHasPlanningDepth || loaded.preferences.planning_depth === undefined) {
         return loaded;
@@ -167,16 +335,39 @@ function loadPreferencesFile(path, scope) {
     if (!existsSync(path))
         return null;
     const raw = readFileSync(path, "utf-8");
-    const preferences = parsePreferencesMarkdown(raw);
-    if (!preferences)
+    const parsed = parsePreferencesMarkdownWithDiagnostics(raw);
+    if (!parsed.preferences && parsed.diagnostics.length === 0)
         return null;
+    const ignored = parsed.diagnostics.some((diagnostic) => diagnostic.ignored === true);
+    const preferences = parsed.preferences ?? {};
     const validation = validatePreferences(preferences);
     const allWarnings = [...validation.warnings, ...validation.errors];
+    const diagnostics = [
+        ...parsed.diagnostics.map((diagnostic) => ({ ...diagnostic, path, scope })),
+        ...validation.errors.map((message) => ({
+            path,
+            scope,
+            severity: "error",
+            kind: "validation",
+            message,
+            sanitized: true,
+        })),
+        ...validation.warnings.map((message) => ({
+            path,
+            scope,
+            severity: "warning",
+            kind: "validation",
+            message,
+            sanitized: true,
+        })),
+    ];
     return {
         path,
         scope,
         preferences: validation.preferences,
+        ...(ignored ? { ignored: true } : {}),
         ...(allWarnings.length > 0 ? { warnings: allWarnings } : {}),
+        ...(diagnostics.length > 0 ? { diagnostics } : {}),
     };
 }
 let _warnedUnrecognizedFormat = false;
@@ -189,20 +380,35 @@ export function _resetParseWarningFlag() {
 }
 /** @internal Exported for testing only */
 export function parsePreferencesMarkdown(content) {
+    return parsePreferencesMarkdownWithDiagnostics(content).preferences;
+}
+function parsePreferencesMarkdownWithDiagnostics(content) {
     // Use indexOf instead of [\s\S]*? regex to avoid backtracking (#468)
     const startMarker = content.startsWith('---\r\n') ? '---\r\n' : '---\n';
     if (content.startsWith(startMarker)) {
         const searchStart = startMarker.length;
         const endIdx = content.indexOf('\n---', searchStart);
-        if (endIdx === -1)
-            return null;
+        if (endIdx === -1) {
+            return {
+                preferences: null,
+                diagnostics: [{
+                        severity: "error",
+                        kind: "parse",
+                        message: "preferences frontmatter is missing a closing --- delimiter",
+                        ignored: true,
+                    }],
+            };
+        }
         const block = content.slice(searchStart, endIdx);
-        return parseFrontmatterBlock(block.replace(/\r/g, ''));
+        return parseFrontmatterBlockWithDiagnostics(block.replace(/\r/g, ''), 1);
     }
     // Fallback: heading+list format (e.g. "## Git\n- isolation: none") (#2036)
     // GSD agents may write preferences files without frontmatter delimiters.
     if (/^##\s+\w/m.test(content)) {
-        return parseHeadingListFormat(content);
+        return {
+            preferences: parseHeadingListFormat(content),
+            diagnostics: [],
+        };
     }
     // Warn when a non-empty file exists but lacks frontmatter delimiters (#2036).
     if (content.trim().length > 0 && !_warnedUnrecognizedFormat) {
@@ -210,16 +416,37 @@ export function parsePreferencesMarkdown(content) {
         console.warn("[GSD] Warning: preferences file has unrecognized format — content does not use YAML frontmatter delimiters (---). " +
             "Wrap your preferences in --- fences. See https://github.com/open-gsd/gsd-pi/issues/2036");
     }
-    return null;
+    return {
+        preferences: null,
+        diagnostics: content.trim().length > 0
+            ? [{
+                    severity: "error",
+                    kind: "parse",
+                    message: "preferences file has unrecognized format; expected YAML frontmatter delimiters (---) or markdown preference sections",
+                    ignored: true,
+                }]
+            : [],
+    };
 }
 let _warnedFrontmatterParse = false;
-function parseFrontmatterBlock(frontmatter) {
+function parseFrontmatterBlockWithDiagnostics(frontmatter, lineOffset) {
     try {
         const parsed = parseYaml(frontmatter);
         if (typeof parsed !== 'object' || parsed === null) {
-            return {};
+            return {
+                preferences: {},
+                diagnostics: [{
+                        severity: "error",
+                        kind: "validation",
+                        message: "preferences frontmatter must be a YAML object",
+                        ignored: true,
+                    }],
+            };
         }
-        return normalizeParsedPreferences(parsed);
+        return {
+            preferences: normalizeParsedPreferences(parsed),
+            diagnostics: [],
+        };
     }
     catch (e) {
         // Warn at most once per session to avoid flooding TUI (#3376)
@@ -227,9 +454,35 @@ function parseFrontmatterBlock(frontmatter) {
             _warnedFrontmatterParse = true;
             logWarning("guided", `YAML parse error in preferences frontmatter (suppressing further): ${e.message}`);
         }
-        return {};
+        const location = extractYamlErrorLocation(e, lineOffset);
+        return {
+            preferences: {},
+            diagnostics: [{
+                    severity: "error",
+                    kind: "parse",
+                    message: cleanYamlErrorMessage(e),
+                    ...(location.line !== undefined ? { line: location.line } : {}),
+                    ...(location.column !== undefined ? { column: location.column } : {}),
+                    ignored: true,
+                }],
+        };
     }
 }
+function cleanYamlErrorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const firstLine = message.split("\n")[0]?.trim() ?? "unknown YAML parse error";
+    return firstLine.replace(/\s+at line \d+, column \d+:?$/, "");
+}
+function extractYamlErrorLocation(error, lineOffset) {
+    const linePos = error?.linePos;
+    const first = Array.isArray(linePos) ? linePos[0] : undefined;
+    const line = typeof first?.line === "number" ? first.line + lineOffset : undefined;
+    const column = typeof first?.col === "number" ? first.col : undefined;
+    return {
+        ...(line !== undefined ? { line } : {}),
+        ...(column !== undefined ? { column } : {}),
+    };
+}
 function normalizeParsedPreferences(preferences) {
     const remoteQuestions = preferences.remote_questions;
     if (remoteQuestions && typeof remoteQuestions === "object" && typeof remoteQuestions.channel_id === "number") {
@@ -581,6 +834,20 @@ export function getIsolationMode(basePath) {
         return "branch";
     return "none"; // default — no isolation, work on current branch
 }
+/**
+ * Resolve the isolation mode a unit actually runs under. A session whose
+ * worktree isolation has degraded (worktree creation failed) falls back to
+ * the milestone branch in the project root, so configured "worktree" becomes
+ * effective "branch". A stranded-work recovery session likewise runs under
+ * the adopted mode (`strandedRecoveryIsolationMode`) rather than the
+ * configured one until the recovered milestone merges — adopting the
+ * milestone branch in the project root is intentional, not degraded.
+ */
+export function resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded, strandedRecoveryIsolationMode = null) {
+    if (configuredMode === "worktree" && isolationDegraded)
+        return "branch";
+    return strandedRecoveryIsolationMode ?? configuredMode;
+}
 export function resolveParallelConfig(prefs) {
     return {
         enabled: prefs?.parallel?.enabled ?? false,

package/dist/resources/extensions/gsd/projection-flush.js

@@ -0,0 +1,7 @@
+// Project/App: gsd-pi
+// File Purpose: Single workflow projection flush seam for mutation exits.
+import { renderAllProjections } from "./workflow-projections.js";
+export async function flushWorkflowProjections(basePath, scope) {
+    await renderAllProjections(basePath, scope.milestoneId);
+    return { milestoneId: scope.milestoneId };
+}

package/dist/resources/extensions/gsd/prompts/ai-integration-phase.md

@@ -0,0 +1,28 @@
+You are running the GSD **ai-integration-phase** workflow — produce an AI design contract (AI-SPEC) for a milestone/slice that builds an AI system.
+
+## Target
+
+{{target}}
+
+## Process
+
+1. **Load intent.** Read the milestone/slice goal and requirements for the AI capability.
+
+2. **Define the AI capability contract:**
+   - **Inputs:** what the model receives (schema, context, examples) and any preprocessing.
+   - **Outputs:** the expected response shape, how it's parsed/validated, and how failures are handled.
+   - **Model & parameters:** which model/provider, temperature, max tokens, fallback chain — never hardcode; reference config.
+   - **Prompt/contract:** the system/user prompt strategy, or tool/function calling schema.
+   - **Evaluation:** how quality is measured (eval set, rubric, human-in-the-loop checkpoints).
+   - **Cost & latency budget:** expected per-call cost and latency, and the ceiling that triggers a redesign.
+
+3. **Risk register.** Hallucination/grounding, prompt injection, data leakage, cost runaway, model deprecation. For each, the mitigation.
+
+4. **Write the AI-SPEC** to the milestone/slice artifact in `.gsd/`. Recommend `/gsd plan-phase` or `/gsd spike` for high-uncertainty model behaviors.
+
+## Success criteria
+
+- Inputs/outputs are schema-defined, not prose-only.
+- Evaluation is concrete (eval set + rubric), not "it looks good".
+- Cost/latency has a budget and a ceiling.
+- The risk register covers the standard AI failure modes.

package/dist/resources/extensions/gsd/prompts/audit-fix.md

@@ -0,0 +1,39 @@
+You are running the GSD **audit-fix** workflow — autonomous audit-to-fix pipeline: find issues, classify them, fix the auto-fixable ones, test after each fix, and commit atomically.
+
+## Source
+
+{{source}}
+
+## Severity filter
+
+{{severity}}
+
+## Max fixes
+
+{{maxFixes}}
+
+## Dry run
+
+{{dryRun}}
+
+## Process
+
+1. **Run the audit.** Use the named source audit (default: the most recent audit-uat / scan findings). If no audit exists, run a fresh `/gsd scan --focus concerns` first and use those findings.
+
+2. **Parse and classify findings.** For each finding, decide: `auto-fixable` (deterministic, localized, no public-behavior change) or `manual-only` (ambiguous, risky, or behavior-changing). Apply the severity filter and the `--max` cap.
+
+3. **Fix loop** (skip entirely if `--dry-run`). For each auto-fixable finding, in priority order:
+   - Apply the fix.
+   - Run the project's tests.
+   - If tests pass, stage the change and record the finding id.
+   - If tests fail, revert that fix, mark it manual-only, and continue.
+   Commit atomically, referencing the finding ids in the commit message for traceability.
+
+4. **Report.** List: fixed (with finding ids + commits), deferred to manual (with reasons), and any that were attempted but reverted due to test failure.
+
+## Success criteria
+
+- Every fix is tested before it's kept; failing fixes are reverted, not left half-applied.
+- Commits are atomic and reference finding ids.
+- `--dry-run` shows what would be fixed without changing anything.
+- Manual-only findings are reported, not silently ignored.

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

@@ -0,0 +1,26 @@
+You are running the GSD **audit-milestone** workflow — verify a milestone achieved its definition of done before it is archived.
+
+## Target
+
+{{target}}
+
+## Process
+
+1. **Load the milestone.** Read the milestone's ROADMAP entry, its slices' plans and SUMMARY/ASSESSMENT artifacts, and the requirements/acceptance criteria. If a specific milestone id was given, target it; otherwise target the active or most-recently-completed milestone.
+
+2. **Aggregate per-slice verification.** For each slice, confirm its tasks were completed and its verification strategy was satisfied (tests pass, UAT recorded). Flag slices with incomplete verification.
+
+3. **Check requirements coverage.** Map each requirement/acceptance criterion to the slice(s) and tasks that delivered it. Flag any requirement with no covering evidence.
+
+4. **Check cross-slice integration.** Identify slices that touch shared resources (APIs, data models, state) and confirm their integration points are consistent — no broken handoffs, conflicting schemas, or sequencing gaps.
+
+5. **Aggregate debt and deferred items.** Collect tech debt, deferred tasks, and known gaps into a single list with severity and owner-hint.
+
+6. **Produce the verdict.** Report: `PASS` (done-of-definition met), `NEEDS-ATTENTION` (gaps that need a human call), or `NEEDS-REMEDIATION` (gaps that block archival). Recommend the matching gsd-pi next step (`/gsd verdict`, `/gsd dispatch validate`, or scheduling remediation).
+
+## Success criteria
+
+- Every requirement is mapped to covering evidence or flagged as uncovered.
+- Cross-slice integration risks are explicit, not assumed away.
+- The verdict is one of the three canonical values with supporting evidence.
+- Debt/deferred items are listed, not silently dropped.

package/dist/resources/extensions/gsd/prompts/audit-uat.md

@@ -0,0 +1,24 @@
+You are running the GSD **audit-uat** workflow — cross-milestone audit of all outstanding UAT and verification items.
+
+## Verify mode
+
+{{verifyMode}}
+
+## Process
+
+1. **Find every outstanding verification item.** Scan all milestones and slices for items in a non-passing state: pending, skipped, blocked, human_needed. Read the slice SUMMARY/ASSESSMENT artifacts and any UAT records.
+
+2. **Classify each item.** For each outstanding item, record: milestone/slice id, the item, its current state, and why it's outstanding (skipped intentionally, blocked by a dependency, awaiting a human, stale).
+
+3. **Verify against the codebase** (only when `--verify` is set): for each item, check whether the code now satisfies it — turning stale "pending" items into pass/fail based on current evidence. Do not modify code; only re-evaluate.
+
+4. **Produce a prioritized test plan.** Order the genuinely-outstanding items into a human test plan: blockers first, then high-risk, then the rest. Each entry has a clear test step and expected result.
+
+5. **Summarize.** Report counts by state, the count turned pass/fail by verification, and the prioritized plan.
+
+## Success criteria
+
+- Every outstanding verification item is listed with its milestone/slice and reason.
+- Stale items are detected (and, in verify mode, re-evaluated against the code).
+- The test plan is prioritized by risk, not alphabetical.
+- No item is silently dropped or assumed resolved.

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

@@ -0,0 +1,31 @@
+You are running the GSD **autonomous** workflow — run all remaining work on a milestone/slice continuously: discuss → plan → execute per slice, then validate, with minimal human intervention.
+
+## Scope
+
+{{scope}}
+
+## Flags
+
+- `--interactive` — {{interactiveFlag}} (pause for confirmation at key boundaries)
+- `--converge` — {{convergeFlag}} (re-run review cycles until concerns resolve before advancing)
+
+## Process
+
+This workflow is the gsd-pi equivalent of `/gsd auto` with explicit phase-ceremony. It drives the milestone through its lifecycle:
+
+1. **For each pending slice**, in order: discuss (if not done) → plan (if not done) → execute (all tasks) → complete slice.
+2. **Between slices**, honor the closeout boundary stop rule: stop after a slice closeout and leave the closeout surface visible, unless the user opted out of pause-at-boundary.
+3. **`--converge`:** before advancing, run a plan-review-convergence pass on the slice; only advance when concerns resolve.
+4. **`--interactive`:** confirm before each slice's discuss→plan→execute transitions.
+5. **At milestone completion,** run validation (`/gsd dispatch validate`) rather than auto-closing.
+
+Prefer delegating each lifecycle step to gsd-pi's native dispatch (`/gsd dispatch discuss|plan|execute`, `/gsd next`, `/gsd auto`) rather than reimplementing the unit machinery.
+
+Never barrel past a closeout boundary silently; never mark a milestone complete without validation.
+
+## Success criteria
+
+- The milestone advances through its lifecycle in the correct order.
+- Closeout boundaries are respected (stop and surface, don't barrel).
+- `--converge` actually gates advancement on resolved concerns.
+- Milestone completion goes through validation, not auto-close.

package/dist/resources/extensions/gsd/prompts/code-review.md

@@ -0,0 +1,37 @@
+You are running the GSD **code-review** workflow — review source files changed during recent work for bugs, security issues, and code quality problems.
+
+## Scope
+
+{{scope}}
+
+## Depth
+
+{{depth}}
+
+## Fix mode
+
+{{fixMode}}
+
+## Process
+
+1. **Determine the file set.** Use the explicit `--files` list if provided. Otherwise derive the changed source files from the active slice's recent commits / SUMMARY, or fall back to the git diff against the base branch. Exclude `.gsd/`, lockfiles, generated/vendored code, and docs unless `--files` names them.
+
+2. **Review each file** at the requested depth:
+   - **quick** — bugs, security, and correctness only.
+   - **standard** (default) — quick + maintainability, error handling, edge cases.
+   - **deep** — standard + performance, concurrency, API design, test coverage gaps.
+
+   Ground every finding in the actual code with file path + line reference. Categorize each by severity (critical / warning / nit) and type (bug, security, quality, performance).
+
+3. **Write the review.** Produce `.gsd/reviews/{{reviewId}}-REVIEW.md` with the findings table and per-finding detail (location, issue, suggested fix).
+
+4. **Present results.** Summarize counts by severity and list the critical findings first.
+
+5. **Fix mode** (only when `--fix` is set): for each finding that is safely auto-fixable (deterministic, no behavior change beyond the fix), apply it. After each fix batch, run the project's tests. Commit atomically with the finding IDs referenced in the message. Do not auto-apply findings that are ambiguous or that change public behavior — surface those for a human decision instead.
+
+## Success criteria
+
+- Every finding cites a concrete file path and line.
+- Findings are categorized by severity and type.
+- The review is written to `.gsd/reviews/`.
+- Fixes only touch safely-auto-fixable findings, and tests run after each batch.