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

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -16,7 +16,7 @@
  *   - No AST parsers — uses regex heuristics
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { resolve, dirname, join, extname } from "node:path";
 import type { TaskRow } from "./db-task-slice-rows.js";
 
@@ -364,6 +364,15 @@ interface FunctionSignature {
   lineNum: number;
 }
 
+interface CachedFunctionSignatures {
+  mtimeMs: number;
+  size: number;
+  signatures: FunctionSignature[];
+}
+
+let signatureCacheScope: string | null = null;
+const signatureCache = new Map<string, CachedFunctionSignatures>();
+
 /**
  * Extract function signatures from TypeScript/JavaScript source code.
  */
@@ -404,6 +413,37 @@ function extractFunctionSignatures(
   return signatures;
 }
 
+function signatureCacheFor(taskRow: TaskRow, basePath: string): Map<string, CachedFunctionSignatures> {
+  const scope = `${resolve(basePath)}\0${taskRow.milestone_id}\0${taskRow.slice_id}`;
+
+  if (signatureCacheScope !== scope) {
+    signatureCacheScope = scope;
+    signatureCache.clear();
+  }
+
+  return signatureCache;
+}
+
+function getCachedFunctionSignatures(
+  cache: Map<string, CachedFunctionSignatures>,
+  absolutePath: string,
+  fileName: string
+): FunctionSignature[] {
+  const stat = statSync(absolutePath);
+  const mtimeMs = stat.mtimeMs;
+  const size = stat.size;
+  const cached = cache.get(absolutePath);
+
+  if (cached && cached.mtimeMs === mtimeMs && cached.size === size) {
+    return cached.signatures.map((sig) => ({ ...sig, file: fileName }));
+  }
+
+  const source = readFileSync(absolutePath, "utf-8");
+  const signatures = extractFunctionSignatures(source, fileName);
+  cache.set(absolutePath, { mtimeMs, size, signatures });
+  return signatures;
+}
+
 /**
  * Normalize parameter list for comparison.
  */
@@ -437,6 +477,7 @@ export function checkCrossTaskSignatures(
 
   // Build map of functions from prior tasks' key_files
   const priorSignatures = new Map<string, FunctionSignature[]>();
+  const cache = signatureCacheFor(taskRow, basePath);
 
   for (const task of priorTasks) {
     for (const file of task.key_files) {
@@ -447,8 +488,7 @@ export function checkCrossTaskSignatures(
       if (!existsSync(absolutePath)) continue;
 
       try {
-        const source = readFileSync(absolutePath, "utf-8");
-        const sigs = extractFunctionSignatures(source, file);
+        const sigs = getCachedFunctionSignatures(cache, absolutePath, file);
         for (const sig of sigs) {
           const existing = priorSignatures.get(sig.name) || [];
           existing.push(sig);

package/src/resources/extensions/gsd/preferences-models.ts

@@ -25,7 +25,7 @@ import type {
   ResolvedModelConfig,
   AutoSupervisorConfig,
 } from "./preferences-types.js";
-import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { clearGSDPreferencesCache, loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { getUnitPhaseChain } from "./unit-registry.js";
 
 // Re-export types so existing consumers of ./preferences-models.js keep working
@@ -94,8 +94,16 @@ function resolveWinningPhase(
  * - Legacy: `planning: claude-opus-4-6`
  * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
  */
-export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedModelConfig | undefined {
-  const prefs = loadEffectiveGSDPreferences(undefined, { availableModelIds: [] });
+export function resolveModelWithFallbacksForUnit(
+  unitType: string,
+  basePath?: string,
+  availableModelIds?: string[],
+  preferredModelId?: string,
+): ResolvedModelConfig | undefined {
+  const loadOpts = availableModelIds !== undefined || preferredModelId !== undefined
+    ? { availableModelIds, preferredModelId }
+    : undefined;
+  const prefs = loadEffectiveGSDPreferences(basePath, loadOpts);
   const chain = phaseChainForUnit(unitType);
   if (!chain) return undefined;
   const winner = resolveWinningPhase(prefs?.preferences?.models as GSDModelConfigV2 | undefined, chain);
@@ -141,8 +149,13 @@ export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedMode
  * floor. Session level, defaults, the floor, and capability clamping are NOT
  * applied here.
  */
-export function resolveThinkingLevelForUnit(unitType: string): GSDThinkingLevel | undefined {
-  const prefs = loadEffectiveGSDPreferences(undefined, { availableModelIds: [] })?.preferences;
+export function resolveThinkingLevelForUnit(
+  unitType: string,
+  basePath?: string,
+  availableModelIds?: string[],
+): GSDThinkingLevel | undefined {
+  const loadOpts = availableModelIds !== undefined ? { availableModelIds } : undefined;
+  const prefs = loadEffectiveGSDPreferences(basePath, loadOpts)?.preferences;
   if (!prefs) return undefined;
   const chain = phaseChainForUnit(unitType);
   if (!chain) return undefined;
@@ -178,7 +191,9 @@ export function resolveThinkingLevelForUnit(unitType: string): GSDThinkingLevel
  * `openai-codex/gpt-5.4`).  When a bare ID is found and sessionProvider
  * is available, the session provider is used.  Without sessionProvider,
  * bare IDs are still returned with provider set to the bare ID itself
- * so downstream resolution (resolveModelId) can match it.
+ * so downstream resolution (resolveModelId) can match it. Accepts an optional
+ * `sessionModelId` so token-profile defaults can preserve the selected model
+ * before auto-mode captures its start snapshot.
  *
  * Returns `{ provider, id }` or `undefined` if no model preference is
  * configured.
@@ -186,8 +201,16 @@ export function resolveThinkingLevelForUnit(unitType: string): GSDThinkingLevel
 export function resolveDefaultSessionModel(
   sessionProvider?: string,
   basePath?: string,
+  availableModelIds?: string[],
+  sessionModelId?: string,
 ): { provider: string; id: string } | undefined {
-  const prefs = loadEffectiveGSDPreferences(basePath, { availableModelIds: [] });
+  const preferredModelId = sessionModelId && sessionProvider
+    ? `${sessionProvider}/${sessionModelId}`
+    : sessionModelId;
+  const loadOpts = availableModelIds !== undefined || preferredModelId !== undefined
+    ? { availableModelIds, preferredModelId }
+    : undefined;
+  const prefs = loadEffectiveGSDPreferences(basePath, loadOpts);
   const models = prefs?.preferences?.models;
   if (!models) return undefined;
 
@@ -382,6 +405,7 @@ export function updatePreferencesModels(models: GSDModelConfigV2): void {
   }
 
   writeFileSync(prefsPath, content, "utf-8");
+  clearGSDPreferencesCache();
 }
 
 /**
@@ -413,7 +437,10 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
 
 // ─── Token Profile Resolution ─────────────────────────────────────────────
 
-const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
+export const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
+
+/** D046: balanced is the implicit profile when `token_profile` is omitted. */
+export const DEFAULT_TOKEN_PROFILE: TokenProfile = "balanced";
 
 /**
  * Per-phase tier intentions for each token profile.
@@ -459,27 +486,34 @@ const PROFILE_TIER_MAP: Record<TokenProfile, Record<string, ComplexityTier>> = {
  *
  * Model IDs are resolved from capability tiers, not hardcoded to any
  * provider. When available models are known (runtime), the resolver picks
- * the best match across all configured providers. When not known (e.g.,
- * early startup), falls back to canonical Anthropic model IDs.
+ * the best match on the anchor provider (session / auto-start model). Callers
+ * scope the available-model list via `modelIdsForProfileResolution` so token
+ * profiles do not hop to a cheaper provider (e.g. Gemini Flash) when the user
+ * is working on OpenAI or Anthropic. When the selected/session model is known,
+ * it is preferred for tiers it can satisfy. When the registry is unavailable
+ * (e.g., early startup), falls back to canonical Anthropic model IDs.
  *
  * @param profile           The token profile to resolve
  * @param availableModelIds Optional list of available model IDs for cross-provider resolution.
  *                          Undefined means the registry is unavailable.
  * @param routingConfig     Optional routing config for tier model pins.
+ * @param preferredModelId  Optional selected/session model ID to prefer.
  */
 export function resolveProfileDefaults(
   profile: TokenProfile,
   availableModelIds?: string[],
   routingConfig: DynamicRoutingConfig = defaultRoutingConfig(),
+  preferredModelId?: string,
 ): Partial<GSDPreferences> {
   // burn-max never writes model defaults — preserve user-selected models.
   // For the other three profiles, derive concrete model IDs from the tier map
   // against the available-model list when the registry is provided. If callers
   // omit the registry entirely, use canonical fallbacks explicitly.
   const tierMap = PROFILE_TIER_MAP[profile];
-  const resolveTierModel = (tier: ComplexityTier): string => Array.isArray(availableModelIds)
-    ? resolveModelForTier(tier, availableModelIds, routingConfig)
-    : canonicalModelForTier(tier);
+  const resolveTierModel = (tier: ComplexityTier): string =>
+    Array.isArray(availableModelIds) || preferredModelId
+      ? resolveModelForTier(tier, availableModelIds ?? [], routingConfig, undefined, preferredModelId)
+      : canonicalModelForTier(tier);
   const models: GSDModelConfigV2 | undefined = profile === "burn-max"
     ? undefined
     : {

package/src/resources/extensions/gsd/preferences.ts

@@ -10,7 +10,7 @@
  * 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";
 
@@ -20,7 +20,12 @@ import type { PostUnitHookConfig, PreDispatchHookConfig, TokenProfile } from "./
 import type { DynamicRoutingConfig } from "./model-router.js";
 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 {
@@ -142,6 +147,94 @@ export function getProjectGSDPreferencesPath(basePath?: string): string {
   return projectPreferencesPath(basePath);
 }
 
+/** Minimal model-registry surface for provider-aware preference resolution. */
+export type PreferencesModelRegistry = {
+  getAvailable: () => ReadonlyArray<{ provider: string; id: string }>;
+};
+
+/** Format registry models the same way tier resolution and prefs persistence use. */
+export function availableModelIdsFromRegistry(registry: PreferencesModelRegistry): string[] {
+  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: string[], provider: string): string[] {
+  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: PreferencesModelRegistry,
+  anchorProvider?: string,
+  disabledProviders?: string[],
+): string[] | undefined {
+  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?: string,
+  autoModeStartProvider?: string | null,
+): string | undefined {
+  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: PreferencesModelRegistry | undefined,
+  basePath?: string,
+  anchorProvider?: string,
+  preferredModelId?: string,
+): LoadedGSDPreferences | null {
+  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
@@ -174,32 +267,94 @@ export function normalizePreferencesShape(
 }
 // ─── Loading ────────────────────────────────────────────────────────────────
 
-export function loadGlobalGSDPreferences(): LoadedGSDPreferences | null {
-  return loadFirstUsablePreferencesFile([
+const EFFECTIVE_PREFERENCES_CACHE_MAX = 64;
+const effectivePreferencesCache = new Map<string, LoadedGSDPreferences | null>();
+
+export function clearGSDPreferencesCache(): void {
+  effectivePreferencesCache.clear();
+}
+
+function globalPreferencesCandidatePaths(): string[] {
+  return [
     globalPreferencesPath(),
     legacyGlobalPreferencesPathLowercase(),
     legacyGlobalPreferencesPath(),
-  ], "global");
+  ];
 }
 
-export function loadProjectGSDPreferences(basePath?: string): LoadedGSDPreferences | null {
-  return loadFirstUsablePreferencesFile([
+function projectPreferencesCandidatePaths(basePath?: string): string[] {
+  return [
     projectPreferencesPath(basePath),
     legacyProjectPreferencesPathLowercase(basePath),
-  ], "project");
+  ];
+}
+
+function preferencesFileSignature(path: string): string {
+  try {
+    const stats = statSync(path);
+    return `${path}:${stats.size}:${stats.mtimeMs}`;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code ?? "unknown";
+    return `${path}:missing:${code}`;
+  }
+}
+
+function effectivePreferencesCacheKey(
+  basePath?: string,
+  opts?: { availableModelIds?: string[]; preferredModelId?: string },
+): string {
+  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: LoadedGSDPreferences | null,
+): LoadedGSDPreferences | null {
+  return loaded ? structuredClone(loaded) : null;
+}
+
+function cacheEffectivePreferences(
+  key: string,
+  loaded: LoadedGSDPreferences | null,
+): void {
+  if (!effectivePreferencesCache.has(key) && effectivePreferencesCache.size >= EFFECTIVE_PREFERENCES_CACHE_MAX) {
+    effectivePreferencesCache.clear();
+  }
+  effectivePreferencesCache.set(key, cloneLoadedPreferences(loaded));
+}
+
+export function loadGlobalGSDPreferences(): LoadedGSDPreferences | null {
+  return loadFirstUsablePreferencesFile(globalPreferencesCandidatePaths(), "global");
+}
+
+export function loadProjectGSDPreferences(basePath?: string): LoadedGSDPreferences | null {
+  return loadFirstUsablePreferencesFile(projectPreferencesCandidatePaths(basePath), "project");
 }
 
 export function loadEffectiveGSDPreferences(
   basePath?: string,
-  opts?: { availableModelIds?: string[] },
+  opts?: { availableModelIds?: string[]; preferredModelId?: string },
 ): LoadedGSDPreferences | null {
+  const cacheKey = effectivePreferencesCacheKey(basePath, opts);
+  if (effectivePreferencesCache.has(cacheKey)) {
+    return cloneLoadedPreferences(effectivePreferencesCache.get(cacheKey)!);
+  }
+
   const globalPreferences = loadGlobalGSDPreferences();
   const projectPreferences = loadProjectGSDPreferences(basePath);
   const effectiveGlobalPreferences = globalPreferences?.ignored ? null : globalPreferences;
   const effectiveProjectPreferences = projectPreferences?.ignored ? null : projectPreferences;
   const projectHasPlanningDepth = effectiveProjectPreferences?.preferences.planning_depth !== undefined;
 
-  if (!effectiveGlobalPreferences && !effectiveProjectPreferences) return null;
+  if (!effectiveGlobalPreferences && !effectiveProjectPreferences) {
+    cacheEffectivePreferences(cacheKey, null);
+    return null;
+  }
 
   let result: LoadedGSDPreferences;
   if (!effectiveGlobalPreferences) {
@@ -220,16 +375,28 @@ export function loadEffectiveGSDPreferences(
   // 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 as TokenProfile | undefined;
-  if (profile) {
+  const explicitProfile = result.preferences.token_profile as TokenProfile | undefined;
+  let profileForDefaults: TokenProfile | undefined;
+  if (explicitProfile) {
+    if (VALID_TOKEN_PROFILES.has(explicitProfile)) {
+      profileForDefaults = explicitProfile;
+    }
+  } else {
+    profileForDefaults = DEFAULT_TOKEN_PROFILE;
+  }
+  if (profileForDefaults) {
     const profileDefaults = _resolveProfileDefaults(
-      profile,
+      profileForDefaults,
       opts?.availableModelIds,
       result.preferences.dynamic_routing,
+      opts?.preferredModelId,
     );
+    const defaultsToApply = explicitProfile
+      ? profileDefaults
+      : withoutProfilePhaseDefaults(profileDefaults);
     result = {
       ...result,
-      preferences: mergePreferences(profileDefaults as GSDPreferences, result.preferences),
+      preferences: mergePreferences(defaultsToApply as GSDPreferences, result.preferences),
     };
   }
 
@@ -243,9 +410,16 @@ export function loadEffectiveGSDPreferences(
 
   result = stripInheritedPlanningDepth(result, projectHasPlanningDepth);
 
+  cacheEffectivePreferences(cacheKey, result);
   return result;
 }
 
+function withoutProfilePhaseDefaults(defaults: Partial<GSDPreferences>): Partial<GSDPreferences> {
+  if (defaults.phases === undefined) return defaults;
+  const { phases: _phases, ...rest } = defaults;
+  return rest;
+}
+
 function mergePreferenceMetadata(
   primary: LoadedGSDPreferences,
   secondary: LoadedGSDPreferences | null,

package/src/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/src/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/src/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/src/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/src/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/src/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.