gsd-pi 2.18.0 → 2.20.0

package/src/resources/extensions/gsd/model-cost-table.ts

@@ -0,0 +1,65 @@
+// GSD Extension — Model Cost Table
+// Static cost reference for known models, used by the dynamic router
+// for cross-provider cost comparison.
+//
+// Costs are approximate per-1K-token rates in USD (input tokens).
+// Updated with GSD releases. Users can override via preferences.
+
+export interface ModelCostEntry {
+  /** Model ID (bare, without provider prefix) */
+  id: string;
+  /** Approximate cost per 1K input tokens in USD */
+  inputPer1k: number;
+  /** Approximate cost per 1K output tokens in USD */
+  outputPer1k: number;
+  /** Last updated date */
+  updatedAt: string;
+}
+
+/**
+ * Bundled cost table for known models.
+ * Updated periodically with GSD releases.
+ */
+export const BUNDLED_COST_TABLE: ModelCostEntry[] = [
+  // Anthropic
+  { id: "claude-opus-4-6", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
+  { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
+  { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
+  { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
+  { id: "claude-3-5-sonnet-latest", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
+  { id: "claude-3-5-haiku-latest", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
+  { id: "claude-3-opus-latest", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
+
+  // OpenAI
+  { id: "gpt-4o", inputPer1k: 0.0025, outputPer1k: 0.01, updatedAt: "2025-03-15" },
+  { id: "gpt-4o-mini", inputPer1k: 0.00015, outputPer1k: 0.0006, updatedAt: "2025-03-15" },
+  { id: "o1", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
+  { id: "o3", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
+  { id: "gpt-4-turbo", inputPer1k: 0.01, outputPer1k: 0.03, updatedAt: "2025-03-15" },
+
+  // Google
+  { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
+  { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
+  { id: "gemini-2.5-pro", inputPer1k: 0.00125, outputPer1k: 0.005, updatedAt: "2025-03-15" },
+
+  // DeepSeek
+  { id: "deepseek-chat", inputPer1k: 0.00014, outputPer1k: 0.00028, updatedAt: "2025-03-15" },
+];
+
+/**
+ * Lookup cost for a model ID. Returns undefined if not found.
+ */
+export function lookupModelCost(modelId: string): ModelCostEntry | undefined {
+  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+  return BUNDLED_COST_TABLE.find(e => e.id === bareId)
+    ?? BUNDLED_COST_TABLE.find(e => bareId.includes(e.id) || e.id.includes(bareId));
+}
+
+/**
+ * Compare two models by input cost. Returns negative if a is cheaper.
+ */
+export function compareModelCost(modelIdA: string, modelIdB: string): number {
+  const costA = lookupModelCost(modelIdA)?.inputPer1k ?? 999;
+  const costB = lookupModelCost(modelIdB)?.inputPer1k ?? 999;
+  return costA - costB;
+}

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

@@ -0,0 +1,256 @@
+// GSD Extension — Dynamic Model Router
+// Maps complexity tiers to models, enforcing downgrade-only semantics.
+// The user's configured model is always the ceiling.
+
+import type { ComplexityTier, ClassificationResult } from "./complexity-classifier.js";
+import { tierOrdinal } from "./complexity-classifier.js";
+import type { ResolvedModelConfig } from "./preferences.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface DynamicRoutingConfig {
+  enabled?: boolean;
+  tier_models?: {
+    light?: string;
+    standard?: string;
+    heavy?: string;
+  };
+  escalate_on_failure?: boolean;   // default: true
+  budget_pressure?: boolean;       // default: true
+  cross_provider?: boolean;        // default: true
+  hooks?: boolean;                 // default: true
+}
+
+export interface RoutingDecision {
+  /** The model ID to use (may be downgraded from configured) */
+  modelId: string;
+  /** Fallback chain: [selected_model, ...configured_fallbacks, configured_primary] */
+  fallbacks: string[];
+  /** The complexity tier that drove this decision */
+  tier: ComplexityTier;
+  /** True if the model was downgraded from the configured primary */
+  wasDowngraded: boolean;
+  /** Human-readable reason for this decision */
+  reason: string;
+}
+
+// ─── Known Model Tiers ───────────────────────────────────────────────────────
+// 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> = {
+  // Light-tier models (cheapest)
+  "claude-haiku-4-5": "light",
+  "claude-3-5-haiku-latest": "light",
+  "claude-3-haiku-20240307": "light",
+  "gpt-4o-mini": "light",
+  "gemini-2.0-flash": "light",
+  "gemini-flash-2.0": "light",
+
+  // Standard-tier models
+  "claude-sonnet-4-6": "standard",
+  "claude-sonnet-4-5-20250514": "standard",
+  "claude-3-5-sonnet-latest": "standard",
+  "gpt-4o": "standard",
+  "gemini-2.5-pro": "standard",
+  "deepseek-chat": "standard",
+
+  // Heavy-tier models (most capable)
+  "claude-opus-4-6": "heavy",
+  "claude-3-opus-latest": "heavy",
+  "gpt-4-turbo": "heavy",
+  "o1": "heavy",
+  "o3": "heavy",
+};
+
+// ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
+// Used for cross-provider cost comparison when multiple providers offer
+// the same capability tier.
+
+const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
+  "claude-haiku-4-5": 0.0008,
+  "claude-3-5-haiku-latest": 0.0008,
+  "claude-sonnet-4-6": 0.003,
+  "claude-sonnet-4-5-20250514": 0.003,
+  "claude-opus-4-6": 0.015,
+  "gpt-4o-mini": 0.00015,
+  "gpt-4o": 0.0025,
+  "gemini-2.0-flash": 0.0001,
+  "gemini-2.5-pro": 0.00125,
+  "deepseek-chat": 0.00014,
+};
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Resolve the model to use for a given complexity tier.
+ *
+ * Downgrade-only: the returned model is always equal to or cheaper than
+ * the user's configured primary model. Never upgrades beyond configuration.
+ *
+ * @param classification  The complexity classification result
+ * @param phaseConfig     The user's configured model for this phase (ceiling)
+ * @param routingConfig   Dynamic routing configuration
+ * @param availableModelIds  List of available model IDs (from registry)
+ */
+export function resolveModelForComplexity(
+  classification: ClassificationResult,
+  phaseConfig: ResolvedModelConfig | undefined,
+  routingConfig: DynamicRoutingConfig,
+  availableModelIds: string[],
+): RoutingDecision {
+  // If no phase config or routing disabled, pass through
+  if (!phaseConfig || !routingConfig.enabled) {
+    return {
+      modelId: phaseConfig?.primary ?? "",
+      fallbacks: phaseConfig?.fallbacks ?? [],
+      tier: classification.tier,
+      wasDowngraded: false,
+      reason: "dynamic routing disabled or no phase config",
+    };
+  }
+
+  const configuredPrimary = phaseConfig.primary;
+  const configuredTier = getModelTier(configuredPrimary);
+  const requestedTier = classification.tier;
+
+  // Downgrade-only: if requested tier >= configured tier, no change
+  if (tierOrdinal(requestedTier) >= tierOrdinal(configuredTier)) {
+    return {
+      modelId: configuredPrimary,
+      fallbacks: phaseConfig.fallbacks,
+      tier: requestedTier,
+      wasDowngraded: false,
+      reason: `tier ${requestedTier} >= configured ${configuredTier}`,
+    };
+  }
+
+  // Find the best model for the requested tier
+  const targetModelId = findModelForTier(
+    requestedTier,
+    routingConfig,
+    availableModelIds,
+    routingConfig.cross_provider !== false,
+  );
+
+  if (!targetModelId) {
+    // No suitable model found — use configured primary
+    return {
+      modelId: configuredPrimary,
+      fallbacks: phaseConfig.fallbacks,
+      tier: requestedTier,
+      wasDowngraded: false,
+      reason: `no ${requestedTier}-tier model available`,
+    };
+  }
+
+  // Build fallback chain: [downgraded_model, ...configured_fallbacks, configured_primary]
+  const fallbacks = [
+    ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
+    configuredPrimary,
+  ].filter(f => f !== targetModelId);
+
+  return {
+    modelId: targetModelId,
+    fallbacks,
+    tier: requestedTier,
+    wasDowngraded: true,
+    reason: classification.reason,
+  };
+}
+
+/**
+ * Escalate to the next tier after a failure.
+ * Returns the new tier, or null if already at heavy (max).
+ */
+export function escalateTier(currentTier: ComplexityTier): ComplexityTier | null {
+  switch (currentTier) {
+    case "light": return "standard";
+    case "standard": return "heavy";
+    case "heavy": return null;
+  }
+}
+
+/**
+ * Get the default routing config (all features enabled).
+ */
+export function defaultRoutingConfig(): DynamicRoutingConfig {
+  return {
+    enabled: false,
+    escalate_on_failure: true,
+    budget_pressure: true,
+    cross_provider: true,
+    hooks: true,
+  };
+}
+
+// ─── Internal ────────────────────────────────────────────────────────────────
+
+function getModelTier(modelId: string): ComplexityTier {
+  // Strip provider prefix if present
+  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+
+  // Check exact match first
+  if (MODEL_CAPABILITY_TIER[bareId]) return MODEL_CAPABILITY_TIER[bareId];
+
+  // Check if any known model ID is a prefix/suffix match
+  for (const [knownId, tier] of Object.entries(MODEL_CAPABILITY_TIER)) {
+    if (bareId.includes(knownId) || knownId.includes(bareId)) return tier;
+  }
+
+  // Unknown models are assumed heavy (safest assumption)
+  return "heavy";
+}
+
+function findModelForTier(
+  tier: ComplexityTier,
+  config: DynamicRoutingConfig,
+  availableModelIds: string[],
+  crossProvider: boolean,
+): string | null {
+  // 1. Check explicit tier_models config
+  const explicitModel = config.tier_models?.[tier];
+  if (explicitModel && availableModelIds.includes(explicitModel)) {
+    return explicitModel;
+  }
+  // Also check with provider prefix stripped
+  if (explicitModel) {
+    const match = availableModelIds.find(id => {
+      const bareAvail = id.includes("/") ? id.split("/").pop()! : id;
+      const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop()! : explicitModel;
+      return bareAvail === bareExplicit;
+    });
+    if (match) return match;
+  }
+
+  // 2. Auto-detect: find the cheapest available model in the requested tier
+  const candidates = availableModelIds
+    .filter(id => {
+      const modelTier = getModelTier(id);
+      return modelTier === tier;
+    })
+    .sort((a, b) => {
+      if (!crossProvider) return 0;
+      const costA = getModelCost(a);
+      const costB = getModelCost(b);
+      return costA - costB;
+    });
+
+  return candidates[0] ?? null;
+}
+
+function getModelCost(modelId: string): number {
+  const bareId = modelId.includes("/") ? modelId.split("/").pop()! : modelId;
+
+  if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {
+    return MODEL_COST_PER_1K_INPUT[bareId];
+  }
+
+  // Check partial matches
+  for (const [knownId, cost] of Object.entries(MODEL_COST_PER_1K_INPUT)) {
+    if (bareId.includes(knownId) || knownId.includes(bareId)) return cost;
+  }
+
+  // Unknown cost — assume expensive to avoid routing to unknown cheap models
+  return 999;
+}

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

@@ -1,6 +1,5 @@
 // GSD Extension — Desktop Notification Helper
 // Cross-platform desktop notifications for auto-mode events.
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import { execFileSync } from "node:child_process";
 import type { NotificationPreferences } from "./types.js";

package/src/resources/extensions/gsd/post-unit-hooks.ts

@@ -1,7 +1,6 @@
 // GSD Extension — Hook Engine (Post-Unit, Pre-Dispatch, State Persistence)
 // Manages hook queue, cycle tracking, artifact verification, pre-dispatch
 // interception, and durable hook state for user-configured extensibility.
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import type {
   PostUnitHookConfig,
@@ -60,7 +59,8 @@ export function checkPostUnitHooks(
   }
 
   // Don't trigger hooks for other hook units (prevent hook-on-hook chains)
-  if (completedUnitType.startsWith("hook/")) return null;
+  // Don't trigger hooks for triage units (prevent hook-on-triage chains)
+  if (completedUnitType.startsWith("hook/") || completedUnitType === "triage-captures") return null;
 
   // Check if any hooks are configured for this unit type
   const hooks = resolvePostUnitHooks().filter(h =>
@@ -411,6 +411,76 @@ export function getHookStatus(): HookStatusEntry[] {
   return entries;
 }
 
+/**
+ * Manually trigger a specific hook for a unit.
+ * This bypasses the normal flow and forces the hook to run even if its artifact exists.
+ * 
+ * @param hookName - The name of the hook to trigger (e.g., "code-review")
+ * @param unitType - The type of unit that triggered the hook (e.g., "execute-task")
+ * @param unitId - The unit ID (e.g., "M001/S01/T01")
+ * @param basePath - The project base path
+ * @returns The hook dispatch result or null if hook not found
+ */
+export function triggerHookManually(
+  hookName: string,
+  unitType: string,
+  unitId: string,
+  basePath: string,
+): HookDispatchResult | null {
+  // Find the hook configuration
+  const hook = resolvePostUnitHooks().find(h => h.name === hookName);
+  if (!hook) {
+    console.error(`[triggerHookManually] Hook "${hookName}" not found in post_unit_hooks`);
+    return null;
+  }
+
+  if (!hook.prompt || typeof hook.prompt !== 'string' || hook.prompt.trim().length === 0) {
+    console.error(`[triggerHookManually] Hook "${hookName}" has empty prompt`);
+    return null;
+  }
+
+  // Reset any active hook state to allow manual triggering
+  activeHook = {
+    hookName: hook.name,
+    triggerUnitType: unitType,
+    triggerUnitId: unitId,
+    cycle: 1,
+    pendingRetry: false,
+  };
+
+  // Build the hook queue with just this hook
+  hookQueue = [{
+    config: hook,
+    triggerUnitType: unitType,
+    triggerUnitId: unitId,
+  }];
+
+  // Set the cycle count for this specific hook+trigger
+  const cycleKey = `${hook.name}/${unitType}/${unitId}`;
+  const currentCycle = (cycleCounts.get(cycleKey) ?? 0) + 1;
+  cycleCounts.set(cycleKey, currentCycle);
+
+  // Update active hook with the cycle count
+  activeHook.cycle = currentCycle;
+
+  // Build the prompt with variable substitution
+  const [mid, sid, tid] = unitId.split("/");
+  const prompt = hook.prompt
+    .replace(/\{milestoneId\}/g, mid ?? "")
+    .replace(/\{sliceId\}/g, sid ?? "")
+    .replace(/\{taskId\}/g, tid ?? "");
+
+  console.log(`[triggerHookManually] Built prompt for ${hookName}, length: ${prompt.length}`);
+
+  return {
+    hookName: hook.name,
+    prompt,
+    model: hook.model,
+    unitType: `hook/${hook.name}`,
+    unitId,
+  };
+}
+
 /**
  * Format hook status for terminal display.
  */