gsd-pi 2.68.0 → 2.68.1-dev.58193fa

package/src/resources/extensions/gsd/guided-flow.ts

@@ -53,25 +53,8 @@ import {
   runPreparation,
   formatCodebaseBrief,
   formatPriorContextBrief,
-  formatEcosystemBrief,
-  type PreparationResult,
 } from "./preparation.js";
 
-// ─── Preparation result storage ─────────────────────────────────────────────
-// Stores the most recent preparation result for injection into discuss prompts.
-// S02 will consume this when building the prepared discussion prompt.
-let lastPreparationResult: PreparationResult | null = null;
-
-/** Get the most recent preparation result (for S02 prompt building). */
-export function getLastPreparationResult(): PreparationResult | null {
-  return lastPreparationResult;
-}
-
-/** Clear the preparation result (called after discussion completes). */
-export function clearPreparationResult(): void {
-  lastPreparationResult = null;
-}
-
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export {
   MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId,
@@ -427,7 +410,7 @@ function resolveAvailableModel<T extends { id: string; provider: string }>(
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
  */
-function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string): string {
+function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string, preparationContext?: string): string {
   const milestoneRel = `.gsd/milestones/${nextId}`;
   const inlinedTemplates = [
     inlineTemplate("project", "Project"),
@@ -439,6 +422,7 @@ function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string)
   return loadPrompt("discuss", {
     milestoneId: nextId,
     preamble,
+    preparationContext: preparationContext ?? "",
     contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
     roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
     inlinedTemplates,
@@ -471,59 +455,12 @@ function buildHeadlessDiscussPrompt(nextId: string, seedContext: string, _basePa
   });
 }
 
-/**
- * Build the prepared discuss prompt with brief injection.
- * Uses the discuss-prepared template which encodes the 4-layer discussion protocol.
- *
- * @param nextId - The milestone ID being discussed
- * @param preamble - Preamble text for the discuss prompt
- * @param _basePath - Root directory of the project (unused, kept for signature consistency)
- * @param prepResult - Preparation result containing briefs to inject
- * @returns The prepared discuss prompt string
- */
-function buildPreparedPrompt(
-  nextId: string,
-  preamble: string,
-  _basePath: string,
-  prepResult: PreparationResult,
-): string {
-  const milestoneRel = `.gsd/milestones/${nextId}`;
-
-  // Use context-enhanced instead of context for prepared discussions
-  const inlinedTemplates = [
-    inlineTemplate("project", "Project"),
-    inlineTemplate("requirements", "Requirements"),
-    inlineTemplate("context-enhanced", "Context Enhanced"),
-    inlineTemplate("roadmap", "Roadmap"),
-    inlineTemplate("decisions", "Decisions"),
-  ].join("\n\n---\n\n");
-
-  // Format the briefs from the preparation result
-  const codebaseBrief = prepResult.codebaseBrief || formatCodebaseBrief(prepResult.codebase);
-  const priorContextBrief = prepResult.priorContextBrief || formatPriorContextBrief(prepResult.priorContext);
-  const ecosystemBrief = prepResult.ecosystemBrief || formatEcosystemBrief(prepResult.ecosystem);
-
-  return loadPrompt("discuss-prepared", {
-    milestoneId: nextId,
-    preamble,
-    codebaseBrief,
-    priorContextBrief,
-    ecosystemBrief,
-    contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
-    roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
-    inlinedTemplates,
-    commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): context, requirements, and roadmap`),
-    multiMilestoneCommitInstruction: buildDocsCommitInstruction("docs: project plan — N milestones"),
-  });
-}
-
 /**
  * Run preparation phase if enabled, then build the discuss prompt.
- * This is the main entry point for new milestone discussions with preparation.
- * Stores the preparation result for S02 to inject into the discuss prompt.
- *
- * When preparation succeeds, uses the discuss-prepared template with brief injection.
- * Falls back to the standard discuss template when preparation is disabled or fails.
+ * Preparation analyzes the codebase and prior context, injecting the results
+ * as supplementary context into the standard discuss template. The discuss
+ * template drives the conversation (asks "What's the vision?" first), while
+ * the preparation briefs give the agent grounding in the existing codebase.
  *
  * @param ctx - Extension command context with UI for progress notifications
  * @param nextId - The milestone ID being discussed
@@ -537,14 +474,13 @@ async function prepareAndBuildDiscussPrompt(
   preamble: string,
   basePath: string,
 ): Promise<string> {
-  // Clear stale preparation result immediately to prevent cross-session/project
-  // state leaks. This ensures data from a prior milestone/project never leaks
-  // into subsequent discussions (adversarial review fix #3602).
-  lastPreparationResult = null;
-
   const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
 
-  // Run preparation if enabled (default: true)
+  // Run preparation if enabled (default: true) — results are injected as
+  // supplementary context into the standard discuss prompt, NOT as a
+  // replacement template. The discuss prompt always leads with "What's the
+  // vision?" so the user defines the scope, not the codebase analysis.
+  let preparationContext = "";
   if (prefs.discuss_preparation !== false) {
     try {
       const prepResult = await runPreparation(basePath, ctx.ui, {
@@ -552,21 +488,23 @@ async function prepareAndBuildDiscussPrompt(
         discuss_web_research: prefs.discuss_web_research,
         discuss_depth: prefs.discuss_depth,
       });
-      lastPreparationResult = prepResult;
 
-      // Use prepared prompt if preparation was enabled and produced results
       if (prepResult.enabled) {
-        return buildPreparedPrompt(nextId, preamble, basePath, prepResult);
+        const codebaseBrief = prepResult.codebaseBrief || formatCodebaseBrief(prepResult.codebase);
+        const priorContextBrief = prepResult.priorContextBrief || formatPriorContextBrief(prepResult.priorContext);
+        const parts: string[] = [];
+        if (codebaseBrief) parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
+        if (priorContextBrief) parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
+        if (parts.length > 0) {
+          preparationContext = `\n\n## Preparation Context\n\nThe system analyzed the codebase before this discussion. Use these findings as background context — they describe what already exists, NOT what the user wants to build. Always ask the user what they want to build first.\n\n${parts.join("\n\n")}`;
+        }
       }
-    } catch {
-      // If preparation throws, ensure stale data doesn't persist
-      lastPreparationResult = null;
+    } catch (err) {
+      logWarning("guided", `preparation failed, proceeding without context: ${(err as Error).message}`);
     }
   }
 
-  // Fall back to standard discuss prompt for backward compatibility
-  // lastPreparationResult is already null (cleared at entry or on error)
-  return buildDiscussPrompt(nextId, preamble, basePath);
+  return buildDiscussPrompt(nextId, preamble, basePath, preparationContext);
 }
 
 /**

package/src/resources/extensions/gsd/model-router.ts

@@ -5,6 +5,9 @@
 import type { ComplexityTier, ClassificationResult, TaskMetadata } from "./complexity-classifier.js";
 import { tierOrdinal } from "./complexity-classifier.js";
 import type { ResolvedModelConfig } from "./preferences.js";
+import { getProviderCapabilities, type ProviderCapabilities } from "@gsd/pi-ai";
+import { getToolCompatibility, getAllToolCompatibility } from "@gsd/pi-coding-agent";
+import type { ToolCompatibility } from "@gsd/pi-coding-agent";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -37,6 +40,8 @@ export interface RoutingDecision {
   selectionMethod: "tier-only" | "capability-scored";
   /** Capability scores per eligible model (capability-scored path only) */
   capabilityScores?: Record<string, number>;
+  /** Tools filtered out due to provider incompatibility (ADR-005) */
+  filteredTools?: string[];
   /** Task requirement vector used for scoring */
   taskRequirements?: Partial<Record<string, number>>;
 }
@@ -58,7 +63,7 @@ export interface ModelCapabilities {
 // Maps known model IDs to their capability tier. Used when tier_models is not
 // explicitly configured to pick the best available model for each tier.
 
-const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
+export const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
   // Light-tier models (cheapest)
   "claude-haiku-4-5": "light",
   "claude-3-5-haiku-latest": "light",
@@ -139,15 +144,49 @@ const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
 // model selection within an eligible tier set.
 
 export const MODEL_CAPABILITY_PROFILES: Record<string, ModelCapabilities> = {
-  "claude-opus-4-6":   { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
-  "claude-sonnet-4-6": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
-  "claude-haiku-4-5":  { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
-  "gpt-4o":            { coding: 80, debugging: 75, research: 70, reasoning: 75, speed: 65, longContext: 70, instruction: 80 },
-  "gpt-4o-mini":       { coding: 55, debugging: 45, research: 40, reasoning: 45, speed: 90, longContext: 45, instruction: 70 },
-  "gemini-2.5-pro":    { coding: 75, debugging: 70, research: 85, reasoning: 75, speed: 55, longContext: 90, instruction: 75 },
-  "gemini-2.0-flash":  { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
-  "deepseek-chat":     { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
-  "o3":                { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
+  // ── Anthropic ──────────────────────────────────────────────────────────────
+  "claude-opus-4-6":              { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
+  "claude-sonnet-4-6":            { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
+  "claude-sonnet-4-5-20250514":   { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
+  "claude-3-5-sonnet-latest":     { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 70, instruction: 82 },
+  "claude-haiku-4-5":             { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
+  "claude-3-5-haiku-latest":      { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
+  "claude-3-haiku-20240307":      { coding: 50, debugging: 40, research: 35, reasoning: 40, speed: 95, longContext: 40, instruction: 65 },
+  "claude-3-opus-latest":         { coding: 90, debugging: 85, research: 82, reasoning: 90, speed: 35, longContext: 75, instruction: 88 },
+
+  // ── OpenAI GPT ─────────────────────────────────────────────────────────────
+  "gpt-4o":                       { coding: 80, debugging: 75, research: 70, reasoning: 75, speed: 65, longContext: 70, instruction: 80 },
+  "gpt-4o-mini":                  { coding: 55, debugging: 45, research: 40, reasoning: 45, speed: 90, longContext: 45, instruction: 70 },
+  "gpt-4-turbo":                  { coding: 78, debugging: 72, research: 68, reasoning: 72, speed: 50, longContext: 65, instruction: 78 },
+  "gpt-4.1":                      { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 72, instruction: 82 },
+  "gpt-4.1-mini":                 { coding: 58, debugging: 48, research: 42, reasoning: 48, speed: 88, longContext: 48, instruction: 72 },
+  "gpt-4.1-nano":                 { coding: 40, debugging: 30, research: 25, reasoning: 30, speed: 95, longContext: 30, instruction: 60 },
+  "gpt-5":                        { coding: 92, debugging: 88, research: 85, reasoning: 92, speed: 40, longContext: 85, instruction: 90 },
+  "gpt-5-mini":                   { coding: 62, debugging: 52, research: 48, reasoning: 52, speed: 88, longContext: 52, instruction: 74 },
+  "gpt-5-nano":                   { coding: 42, debugging: 32, research: 28, reasoning: 32, speed: 95, longContext: 32, instruction: 62 },
+  "gpt-5-pro":                    { coding: 94, debugging: 90, research: 88, reasoning: 94, speed: 35, longContext: 88, instruction: 92 },
+  "gpt-5.1":                      { coding: 93, debugging: 89, research: 86, reasoning: 93, speed: 42, longContext: 86, instruction: 91 },
+  "gpt-5.1-codex-max":            { coding: 90, debugging: 85, research: 70, reasoning: 85, speed: 55, longContext: 75, instruction: 85 },
+  "gpt-5.1-codex-mini":           { coding: 65, debugging: 55, research: 40, reasoning: 50, speed: 88, longContext: 48, instruction: 72 },
+  "gpt-5.2":                      { coding: 93, debugging: 90, research: 87, reasoning: 93, speed: 42, longContext: 87, instruction: 91 },
+  "gpt-5.2-codex":                { coding: 93, debugging: 90, research: 72, reasoning: 88, speed: 50, longContext: 78, instruction: 88 },
+  "gpt-5.3-codex":                { coding: 94, debugging: 91, research: 74, reasoning: 89, speed: 50, longContext: 80, instruction: 89 },
+  "gpt-5.3-codex-spark":          { coding: 68, debugging: 58, research: 42, reasoning: 52, speed: 90, longContext: 50, instruction: 74 },
+  "gpt-5.4":                      { coding: 95, debugging: 92, research: 88, reasoning: 94, speed: 42, longContext: 88, instruction: 92 },
+
+  // ── OpenAI o-series (reasoning-first) ──────────────────────────────────────
+  "o1":                           { coding: 78, debugging: 82, research: 78, reasoning: 90, speed: 20, longContext: 65, instruction: 82 },
+  "o3":                           { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
+  "o4-mini":                      { coding: 75, debugging: 80, research: 72, reasoning: 88, speed: 60, longContext: 65, instruction: 80 },
+  "o4-mini-deep-research":        { coding: 75, debugging: 80, research: 85, reasoning: 88, speed: 30, longContext: 80, instruction: 80 },
+
+  // ── Google ─────────────────────────────────────────────────────────────────
+  "gemini-2.5-pro":               { coding: 75, debugging: 70, research: 85, reasoning: 75, speed: 55, longContext: 90, instruction: 75 },
+  "gemini-2.0-flash":             { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
+  "gemini-flash-2.0":             { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
+
+  // ── DeepSeek ───────────────────────────────────────────────────────────────
+  "deepseek-chat":                { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
 };
 
 // ─── Base Task Requirements Data Table ───────────────────────────────────────
@@ -502,3 +541,71 @@ function getModelCost(modelId: string): number {
   // Unknown cost — assume expensive to avoid routing to unknown cheap models
   return 999;
 }
+
+// ─── Tool Compatibility Filter (ADR-005 Phase 3) ───────────────────────────
+
+/**
+ * Check if a tool is compatible with a provider's capabilities.
+ * Returns true if the tool can be used with the provider.
+ */
+export function isToolCompatibleWithProvider(
+  toolName: string,
+  providerCaps: ProviderCapabilities,
+): boolean {
+  const compat = getToolCompatibility(toolName);
+  if (!compat) return true;  // no metadata = always compatible
+
+  // Hard filter: provider doesn't support image tool results
+  if (compat.producesImages && !providerCaps.imageToolResults) return false;
+
+  // Hard filter: tool uses schema features provider doesn't support
+  if (compat.schemaFeatures?.some(f => providerCaps.unsupportedSchemaFeatures.includes(f))) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Filter a list of tool names to only those compatible with a provider.
+ * Used by the routing pipeline to adjust tool sets when switching providers.
+ */
+export function filterToolsForProvider(
+  toolNames: string[],
+  providerApi: string,
+): { compatible: string[]; filtered: string[] } {
+  const providerCaps = getProviderCapabilities(providerApi);
+
+  // Provider doesn't support tool calling at all
+  if (!providerCaps.toolCalling) {
+    return { compatible: [], filtered: toolNames };
+  }
+
+  const compatible: string[] = [];
+  const filtered: string[] = [];
+
+  for (const name of toolNames) {
+    if (isToolCompatibleWithProvider(name, providerCaps)) {
+      compatible.push(name);
+    } else {
+      filtered.push(name);
+    }
+  }
+
+  return { compatible, filtered };
+}
+
+/**
+ * Adjust the active tool set for a selected model's provider capabilities.
+ * Returns tool names that should be active — removes incompatible tools.
+ *
+ * This is a hard filter only — it removes tools that would fail at the
+ * provider level. It does NOT remove tools based on soft heuristics.
+ */
+export function adjustToolSet(
+  activeToolNames: string[],
+  selectedModelApi: string,
+): { toolNames: string[]; removedTools: string[] } {
+  const { compatible, filtered } = filterToolsForProvider(activeToolNames, selectedModelApi);
+  return { toolNames: compatible, removedTools: filtered };
+}

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

@@ -20,7 +20,7 @@ import type {
   ReactiveExecutionConfig,
   GateEvaluationConfig,
 } from "./types.js";
-import type { DynamicRoutingConfig } from "./model-router.js";
+import type { DynamicRoutingConfig, ModelCapabilities } from "./model-router.js";
 
 export interface ContextManagementConfig {
   observation_masking?: boolean;          // default: true
@@ -255,6 +255,8 @@ export interface GSDPreferences {
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
   dynamic_routing?: DynamicRoutingConfig;
+  /** Per-model capability overrides. Deep-merged with built-in profiles for capability-aware routing (ADR-004). */
+  modelOverrides?: Record<string, { capabilities?: Partial<ModelCapabilities> }>;
   context_management?: ContextManagementConfig;
   token_profile?: TokenProfile;
   phases?: PhaseSkipPreferences;

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

@@ -28,6 +28,8 @@ After reflection is confirmed, decide the approach based on the actual scope —
 
 **Anti-reduction rule:** If the user describes a big vision, plan the big vision. Do not ask "what's the minimum viable version?" or try to reduce scope unless the user explicitly asks for an MVP or minimal version. When something is complex or risky, phase it into a later milestone — do not cut it. The user's ambition is the target, and your job is to sequence it intelligently, not shrink it.
 
+{{preparationContext}}
+
 ## Mandatory Investigation Before First Question Round
 
 Before asking your first question, do a mandatory investigation pass. This is not optional.

package/src/resources/extensions/gsd/templates/context.md

@@ -38,6 +38,28 @@ To call this milestone complete, we must prove:
 - {{one real end-to-end scenario}}
 - {{what cannot be simulated if this milestone is to be considered truly done}}
 
+## Architectural Decisions
+
+### {{decisionTitle}}
+
+**Decision:** {{decisionStatement}}
+
+**Rationale:** {{rationale}}
+
+**Alternatives Considered:**
+- {{alternative}} — {{whyNotChosen}}
+
+---
+
+> Add additional decisions as separate `### Decision Title` blocks following the same structure above.
+> See `.gsd/DECISIONS.md` for the full append-only register of all project decisions.
+
+## Error Handling Strategy
+
+{{errorHandlingStrategy}}
+
+> Describe the approach for handling failures, edge cases, and error propagation. Include retry policies, fallback behaviors, and user-facing error messages where relevant.
+
 ## Risks and Unknowns
 
 - {{riskOrUnknown}} — {{whyItMatters}}
@@ -47,8 +69,6 @@ To call this milestone complete, we must prove:
 - `{{fileOrModule}}` — {{howItRelates}}
 - `{{fileOrModule}}` — {{howItRelates}}
 
-> See `.gsd/DECISIONS.md` for all architectural and pattern decisions — it is an append-only register; read it during planning, append to it during execution.
-
 ## Relevant Requirements
 
 - {{requirementId}} — {{howThisMilestoneAdvancesIt}}
@@ -71,6 +91,18 @@ To call this milestone complete, we must prove:
 
 - {{systemOrService}} — {{howThisMilestoneInteractsWithIt}}
 
+## Testing Requirements
+
+{{testingRequirements}}
+
+> Specify test types (unit, integration, e2e), coverage expectations, and specific test scenarios that must pass.
+
+## Acceptance Criteria
+
+{{acceptanceCriteria}}
+
+> Per-slice acceptance criteria gathered during discussion. Each slice should have clear, testable criteria.
+
 ## Open Questions
 
 - {{question}} — {{currentThinking}}

package/src/resources/extensions/gsd/tests/capability-router.test.ts

@@ -11,6 +11,7 @@ import {
   getEligibleModels,
   resolveModelForComplexity,
   MODEL_CAPABILITY_PROFILES,
+  MODEL_CAPABILITY_TIER,
   BASE_REQUIREMENTS,
   defaultRoutingConfig,
 } from "../model-router.js";
@@ -125,13 +126,9 @@ describe("computeTaskRequirements", () => {
 // ─── MODEL_CAPABILITY_PROFILES ───────────────────────────────────────────────
 
 describe("MODEL_CAPABILITY_PROFILES", () => {
-  test("contains all 9 required models", () => {
-    const required = [
-      "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5",
-      "gpt-4o", "gpt-4o-mini", "gemini-2.5-pro", "gemini-2.0-flash",
-      "deepseek-chat", "o3",
-    ];
-    for (const model of required) {
+  test("contains profiles for all tier-mapped models", () => {
+    const tierModels = Object.keys(MODEL_CAPABILITY_TIER);
+    for (const model of tierModels) {
       assert.ok(MODEL_CAPABILITY_PROFILES[model], `Missing profile for ${model}`);
     }
   });
@@ -345,3 +342,30 @@ describe("RoutingDecision.selectionMethod", () => {
     assert.equal(result.selectionMethod, "tier-only");
   });
 });
+
+// ─── ADR-004: Profile Completeness Lint ─────────────────────────────────────
+// Every model in MODEL_CAPABILITY_TIER must have an entry in
+// MODEL_CAPABILITY_PROFILES. This prevents profile staleness as new models
+// are added to the tier map without corresponding capability data.
+
+describe("profile completeness (ADR-004 lint)", () => {
+  test("every model in MODEL_CAPABILITY_TIER has a MODEL_CAPABILITY_PROFILES entry", () => {
+    const tierModels = Object.keys(MODEL_CAPABILITY_TIER);
+    const missing = tierModels.filter(id => !MODEL_CAPABILITY_PROFILES[id]);
+    assert.equal(
+      missing.length,
+      0,
+      `Models in MODEL_CAPABILITY_TIER but missing from MODEL_CAPABILITY_PROFILES:\n  ${missing.join("\n  ")}\n\nAdd capability profiles for these models in model-router.ts.`,
+    );
+  });
+
+  test("MODEL_CAPABILITY_PROFILES does not contain models absent from MODEL_CAPABILITY_TIER", () => {
+    const profileModels = Object.keys(MODEL_CAPABILITY_PROFILES);
+    const orphaned = profileModels.filter(id => !MODEL_CAPABILITY_TIER[id]);
+    assert.equal(
+      orphaned.length,
+      0,
+      `Models in MODEL_CAPABILITY_PROFILES but not in MODEL_CAPABILITY_TIER:\n  ${orphaned.join("\n  ")}\n\nEither add these to MODEL_CAPABILITY_TIER or remove stale profiles.`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/codebase-generator.test.ts

@@ -162,6 +162,34 @@ test("generateCodebaseMap: excludes .claude/ and other tool directories", () =>
   }
 });
 
+test("generateCodebaseMap: excludes .agents/ and other tooling directories", () => {
+  const base = makeTmpRepo();
+  try {
+    addFile(base, "src/main.ts");
+    addFile(base, ".agents/skills/pdf/SKILL.md");
+    addFile(base, ".agents/skills/find-skills/SKILL.md");
+    addFile(base, ".bg-shell/session.json");
+    addFile(base, ".idea/workspace.xml");
+    addFile(base, ".cache/data.bin");
+    addFile(base, "tmp/scratch.ts");
+    addFile(base, "target/debug/build.rs");
+    addFile(base, "venv/lib/site.py");
+
+    const result = generateCodebaseMap(base);
+    assert.ok(result.content.includes("`src/main.ts`"), "should include src/main.ts");
+    assert.ok(!result.content.includes("SKILL.md"), "should exclude .agents/ files");
+    assert.ok(!result.content.includes(".bg-shell"), "should exclude .bg-shell/ files");
+    assert.ok(!result.content.includes(".idea"), "should exclude .idea/ files");
+    assert.ok(!result.content.includes(".cache"), "should exclude .cache/ files");
+    assert.ok(!result.content.includes("tmp/"), "should exclude tmp/ files");
+    assert.ok(!result.content.includes("target"), "should exclude target/ files");
+    assert.ok(!result.content.includes("venv"), "should exclude venv/ files");
+    assert.equal(result.fileCount, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("generateCodebaseMap: excludes binary and lock files", () => {
   const base = makeTmpRepo();
   try {

package/src/resources/extensions/gsd/tests/discord-invite-links.test.ts

@@ -18,7 +18,7 @@ const VALID_INVITE = "https://discord.com/invite/nKXTsAcmbT";
 /** Files that contain user-facing Discord invite links. */
 const FILES_WITH_INVITE_LINKS: string[] = [
   "README.md",
-  "docs/what-is-pi/15-pi-packages-the-ecosystem.md",
+  "docs/dev/what-is-pi/15-pi-packages-the-ecosystem.md",
 ];
 
 describe("Discord invite links (#2699)", () => {

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -287,9 +287,9 @@ test("resolveModelForComplexity falls back to tier-only when capability_routing
   assert.ok(!result.selectionMethod || result.selectionMethod === "tier-only");
 });
 
-test("MODEL_CAPABILITY_PROFILES has entries for core models", () => {
+test("MODEL_CAPABILITY_PROFILES has entries for all tier-mapped models", () => {
   const profiledModels = Object.keys(MODEL_CAPABILITY_PROFILES);
-  assert.ok(profiledModels.length >= 9, `Expected ≥9 profiles, got ${profiledModels.length}`);
+  assert.ok(profiledModels.length >= 30, `Expected ≥30 profiles, got ${profiledModels.length}`);
   assert.ok(MODEL_CAPABILITY_PROFILES["claude-opus-4-6"]);
   assert.ok(MODEL_CAPABILITY_PROFILES["claude-haiku-4-5"]);
 });

package/src/resources/extensions/gsd/tests/resource-loader-import-path.test.ts

@@ -0,0 +1,37 @@
+// GSD2 — Regression test for broken resource-loader import path
+// Ensures auto.ts imports resource-loader via package resolution, not a
+// relative path that breaks when deployed to ~/.gsd/agent/extensions/gsd/.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const autoSrc = readFileSync(join(import.meta.dirname, "..", "auto.ts"), "utf-8");
+
+describe("resource-loader import path", () => {
+  test("must not use relative import reaching above extensions/", () => {
+    // The old broken pattern: import("../../../" + "resource-loader.js")
+    // This resolves to ~/.gsd/resource-loader.js from deployed location, which
+    // doesn't exist. Regression introduced in #3899.
+    const brokenPattern = /import\(\s*["']\.\.\/\.\.\/\.\..*resource-loader/;
+    assert.ok(
+      !brokenPattern.test(autoSrc),
+      "auto.ts must not import resource-loader via relative path above extensions/ — " +
+      "breaks when deployed to ~/.gsd/agent/extensions/gsd/ (see #3899)",
+    );
+  });
+
+  test("uses createRequire to resolve resource-loader from package root", () => {
+    // The fix uses createRequire to find gsd-pi/package.json, then imports
+    // dist/resource-loader.js from there — works in both source and deployed.
+    assert.ok(
+      autoSrc.includes('createRequire(import.meta.url)'),
+      "auto.ts should use createRequire to resolve resource-loader",
+    );
+    assert.ok(
+      autoSrc.includes('resolve("gsd-pi/package.json")'),
+      "auto.ts should resolve gsd-pi package root via package.json",
+    );
+  });
+});