gsd-pi 2.68.1-dev.362687a → 2.68.1-dev.abc8f2b

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/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/tool-compatibility.test.ts

@@ -0,0 +1,199 @@
+// GSD-2 — Tool Compatibility + Model Router Tool Filtering Tests (ADR-005 Phases 2-3)
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  registerToolCompatibility,
+  getToolCompatibility,
+  getAllToolCompatibility,
+  registerMcpToolCompatibility,
+  resetToolCompatibilityRegistry,
+} from "@gsd/pi-coding-agent";
+
+import {
+  isToolCompatibleWithProvider,
+  filterToolsForProvider,
+  adjustToolSet,
+} from "../model-router.js";
+
+import {
+  getProviderCapabilities,
+} from "@gsd/pi-ai";
+
+// ─── Tool Compatibility Registry ────────────────────────────────────────────
+
+describe("tool compatibility registry", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("built-in tools are pre-registered", () => {
+    const builtins = ["bash", "read", "write", "edit", "grep", "find", "ls", "lsp"];
+    for (const name of builtins) {
+      const compat = getToolCompatibility(name);
+      assert.ok(compat !== undefined, `${name} should be pre-registered`);
+    }
+  });
+
+  test("unknown tool returns undefined", () => {
+    assert.equal(getToolCompatibility("nonexistent_tool_xyz"), undefined);
+  });
+
+  test("registerToolCompatibility stores and retrieves metadata", () => {
+    registerToolCompatibility("screenshot_tool", {
+      producesImages: true,
+      minCapabilityTier: "standard",
+    });
+    const compat = getToolCompatibility("screenshot_tool");
+    assert.ok(compat);
+    assert.equal(compat.producesImages, true);
+    assert.equal(compat.minCapabilityTier, "standard");
+  });
+
+  test("registerMcpToolCompatibility sets default schema features", () => {
+    registerMcpToolCompatibility("mcp__test__tool");
+    const compat = getToolCompatibility("mcp__test__tool");
+    assert.ok(compat);
+    assert.ok(compat.schemaFeatures?.includes("patternProperties"));
+  });
+
+  test("registerMcpToolCompatibility allows overrides", () => {
+    registerMcpToolCompatibility("mcp__test__override", { producesImages: true });
+    const compat = getToolCompatibility("mcp__test__override");
+    assert.ok(compat);
+    assert.equal(compat.producesImages, true);
+    assert.ok(compat.schemaFeatures?.includes("patternProperties"));
+  });
+
+  test("getAllToolCompatibility returns all entries", () => {
+    const all = getAllToolCompatibility();
+    assert.ok(all.size >= 10); // at least built-in tools
+    assert.ok(all.has("bash"));
+    assert.ok(all.has("read"));
+  });
+
+  test("resetToolCompatibilityRegistry clears custom entries but keeps builtins", () => {
+    registerToolCompatibility("custom_tool", { producesImages: true });
+    assert.ok(getToolCompatibility("custom_tool"));
+    resetToolCompatibilityRegistry();
+    assert.equal(getToolCompatibility("custom_tool"), undefined);
+    assert.ok(getToolCompatibility("bash")); // built-in preserved
+  });
+});
+
+// ─── isToolCompatibleWithProvider ───────────────────────────────────────────
+
+describe("isToolCompatibleWithProvider", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("tool without compatibility metadata is always compatible", () => {
+    const caps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("unknown_tool", caps), true);
+  });
+
+  test("built-in tools are compatible with all providers", () => {
+    const providers = ["anthropic-messages", "openai-responses", "google-generative-ai", "mistral-conversations"];
+    const tools = ["bash", "read", "write", "edit"];
+    for (const api of providers) {
+      const caps = getProviderCapabilities(api);
+      for (const tool of tools) {
+        assert.equal(
+          isToolCompatibleWithProvider(tool, caps),
+          true,
+          `${tool} should be compatible with ${api}`,
+        );
+      }
+    }
+  });
+
+  test("image-producing tool filtered for providers without image support", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    const openaiCaps = getProviderCapabilities("openai-responses");
+    assert.equal(isToolCompatibleWithProvider("screenshot", openaiCaps), false);
+
+    const anthropicCaps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("screenshot", anthropicCaps), true);
+  });
+
+  test("tool with unsupported schema features filtered for Google", () => {
+    registerToolCompatibility("complex_schema_tool", {
+      schemaFeatures: ["patternProperties"],
+    });
+    const googleCaps = getProviderCapabilities("google-generative-ai");
+    assert.equal(isToolCompatibleWithProvider("complex_schema_tool", googleCaps), false);
+
+    const anthropicCaps = getProviderCapabilities("anthropic-messages");
+    assert.equal(isToolCompatibleWithProvider("complex_schema_tool", anthropicCaps), true);
+  });
+});
+
+// ─── filterToolsForProvider ─────────────────────────────────────────────────
+
+describe("filterToolsForProvider", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("all built-in tools pass for any provider", () => {
+    const toolNames = ["bash", "read", "write", "edit", "grep", "find", "ls"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "mistral-conversations");
+    assert.deepEqual(compatible, toolNames);
+    assert.deepEqual(filtered, []);
+  });
+
+  test("image tool filtered for OpenAI Responses", () => {
+    registerToolCompatibility("browser_screenshot", { producesImages: true });
+    const toolNames = ["bash", "read", "browser_screenshot"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "openai-responses");
+    assert.deepEqual(compatible, ["bash", "read"]);
+    assert.deepEqual(filtered, ["browser_screenshot"]);
+  });
+
+  test("MCP tool with patternProperties filtered for Google", () => {
+    registerMcpToolCompatibility("mcp__repowise__search");
+    const toolNames = ["bash", "read", "mcp__repowise__search"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "google-generative-ai");
+    assert.deepEqual(compatible, ["bash", "read"]);
+    assert.deepEqual(filtered, ["mcp__repowise__search"]);
+  });
+
+  test("unknown provider passes all tools (permissive default)", () => {
+    registerToolCompatibility("image_tool", { producesImages: true });
+    registerMcpToolCompatibility("mcp_tool");
+    const toolNames = ["bash", "image_tool", "mcp_tool"];
+    const { compatible, filtered } = filterToolsForProvider(toolNames, "unknown-provider-xyz");
+    assert.deepEqual(compatible, toolNames);
+    assert.deepEqual(filtered, []);
+  });
+});
+
+// ─── adjustToolSet ──────────────────────────────────────────────────────────
+
+describe("adjustToolSet", () => {
+  beforeEach(() => {
+    resetToolCompatibilityRegistry();
+  });
+
+  test("returns all tools for Anthropic (most permissive)", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    const toolNames = ["bash", "read", "screenshot"];
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "anthropic-messages");
+    assert.deepEqual(result, toolNames);
+    assert.deepEqual(removedTools, []);
+  });
+
+  test("removes incompatible tools and reports them", () => {
+    registerToolCompatibility("screenshot", { producesImages: true });
+    registerMcpToolCompatibility("mcp_complex");
+    const toolNames = ["bash", "read", "screenshot", "mcp_complex"];
+    const { toolNames: result, removedTools } = adjustToolSet(toolNames, "google-generative-ai");
+    // Google supports images but not patternProperties
+    assert.ok(result.includes("bash"));
+    assert.ok(result.includes("read"));
+    assert.ok(result.includes("screenshot")); // Google supports images
+    assert.ok(!result.includes("mcp_complex")); // patternProperties not supported
+    assert.deepEqual(removedTools, ["mcp_complex"]);
+  });
+});

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -230,16 +230,13 @@ import {
 // ─── Scenario 19: isGateQuestionId recognizes all gate patterns ──
 
 test('write-gate: isGateQuestionId recognizes all gate patterns', () => {
-  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer2_architecture_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer3_error_gate'), true);
-  assert.strictEqual(isGateQuestionId('layer4_quality_gate'), true);
   assert.strictEqual(isGateQuestionId('depth_verification'), true);
   assert.strictEqual(isGateQuestionId('depth_verification_M002'), true);
-  assert.strictEqual(isGateQuestionId('my_layer1_scope_gate_question'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification_confirm'), true);
   // Non-gate question IDs
   assert.strictEqual(isGateQuestionId('project_intent'), false);
   assert.strictEqual(isGateQuestionId('feature_priority'), false);
+  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), false);
   assert.strictEqual(isGateQuestionId(''), false);
 });
 
@@ -249,14 +246,14 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   clearDiscussionFlowState();
   assert.strictEqual(getPendingGate(), null, 'starts null');
 
-  setPendingGate('layer1_scope_gate');
-  assert.strictEqual(getPendingGate(), 'layer1_scope_gate', 'set correctly');
+  setPendingGate('depth_verification');
+  assert.strictEqual(getPendingGate(), 'depth_verification', 'set correctly');
 
   clearPendingGate();
   assert.strictEqual(getPendingGate(), null, 'cleared correctly');
 
   // clearDiscussionFlowState also clears pending gate
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification_M002');
   clearDiscussionFlowState();
   assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
 });
@@ -265,12 +262,12 @@ test('write-gate: pending gate lifecycle (set, get, clear)', () => {
 
 test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // write should be blocked during discussion
   const writeResult = shouldBlockPendingGate('write', 'M001', false);
   assert.strictEqual(writeResult.block, true, 'write should be blocked');
-  assert.ok(writeResult.reason!.includes('layer1_scope_gate'), 'reason mentions the gate');
+  assert.ok(writeResult.reason!.includes('depth_verification'), 'reason mentions the gate');
 
   // edit should be blocked
   const editResult = shouldBlockPendingGate('edit', 'M001', false);
@@ -287,7 +284,7 @@ test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate',
 
 test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // ask_user_questions is always safe (model needs to re-ask)
   assert.strictEqual(shouldBlockPendingGate('ask_user_questions', 'M001').block, false);
@@ -304,7 +301,7 @@ test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions
 
 test('write-gate: shouldBlockPendingGate blocks outside discussion when a gate is pending', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer1_scope_gate');
+  setPendingGate('depth_verification');
 
   // No milestoneId and no queue phase — still block because the gate is pending
   const result = shouldBlockPendingGate('write', null, false);
@@ -330,7 +327,7 @@ test('write-gate: shouldBlockPendingGate blocks in queue mode when gate is pendi
 
 test('write-gate: shouldBlockPendingGateBash allows read-only commands during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification');
 
   assert.strictEqual(shouldBlockPendingGateBash('cat file.txt', 'M001').block, false);
   assert.strictEqual(shouldBlockPendingGateBash('git log --oneline', 'M001').block, false);
@@ -344,11 +341,11 @@ test('write-gate: shouldBlockPendingGateBash allows read-only commands during pe
 
 test('write-gate: shouldBlockPendingGateBash blocks mutating commands during pending gate', () => {
   clearDiscussionFlowState();
-  setPendingGate('layer2_architecture_gate');
+  setPendingGate('depth_verification');
 
   const result = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(result.block, true, 'mutating bash should be blocked');
-  assert.ok(result.reason!.includes('layer2_architecture_gate'));
+  assert.ok(result.reason!.includes('depth_verification'));
 
   clearDiscussionFlowState();
 });
@@ -365,7 +362,7 @@ test('write-gate: no pending gate means no blocking', () => {
 // ─── Scenario 28: resetWriteGateState clears pending gate ──
 
 test('write-gate: resetWriteGateState clears pending gate', () => {
-  setPendingGate('layer3_error_gate');
+  setPendingGate('depth_verification');
   resetWriteGateState();
   assert.strictEqual(getPendingGate(), null);
 });