@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-DBHOWDUH.js

@@ -0,0 +1,976 @@
+import {
+  computeHistoricalAdjustment
+} from "./chunk-EEUESN3T.js";
+import {
+  PROVIDER_CAPABILITY_MATRIX
+} from "./chunk-QX6LOMMH.js";
+import {
+  resolveVariantModel
+} from "./chunk-EUWIIDQ7.js";
+import {
+  registry
+} from "./chunk-7HYBSRPZ.js";
+import {
+  getProviderHealth
+} from "./chunk-CRPRVNQ4.js";
+import {
+  resolveDefaultProvider
+} from "./chunk-C3DH3NCY.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  formatReasoningEffortLevelForUser
+} from "./chunk-4BTDUT2S.js";
+import {
+  BUILD_PROVIDER_HEALTH_GUARDRAILS,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/shared/auth-probe-options.ts
+var PASSIVE_AUTH_PROBE = { mode: "passive" };
+async function readPassiveAuthState(auth) {
+  try {
+    if (auth.isAuthenticatedTriState) {
+      return await auth.isAuthenticatedTriState(PASSIVE_AUTH_PROBE);
+    }
+    return await auth.isAuthenticated(PASSIVE_AUTH_PROBE) === true ? "yes" : "no";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/routing/task-type-preferences.ts
+var DEFAULT_TASK_TYPE_PREFERENCES = {
+  bugfix: { traits: { code: true, reasoning: true }, preferredTier: "standard" },
+  feature: { traits: { code: true, reasoning: true }, preferredTier: "standard" },
+  refactor: {
+    traits: { code: true, reasoning: true, longContext: true },
+    preferredTier: "premium"
+  },
+  documentation: { traits: { fast: true }, preferredTier: "economy" },
+  testing: { traits: { code: true }, preferredTier: "standard" },
+  analysis: {
+    traits: { reasoning: true, longContext: true, thinking: true },
+    preferredTier: "premium"
+  },
+  configuration: { traits: { code: true, fast: true }, preferredTier: "economy" },
+  unknown: { traits: {} }
+};
+function resolveTaskTypePreference(intent, overrides) {
+  const defaults = DEFAULT_TASK_TYPE_PREFERENCES[intent] ?? DEFAULT_TASK_TYPE_PREFERENCES.unknown;
+  if (!overrides || !overrides[intent]) {
+    return {
+      traits: { ...defaults.traits },
+      ...defaults.preferredTier ? { preferredTier: defaults.preferredTier } : {}
+    };
+  }
+  const override = overrides[intent];
+  return {
+    traits: { ...defaults.traits, ...override.traits },
+    preferredTier: override.preferredTier ?? defaults.preferredTier
+  };
+}
+function scoreTraitMatchForProvider(preference, ratings, scale) {
+  const rationale = [];
+  let score = 0;
+  let matchedTraits = 0;
+  const desiredTraits = Object.entries(preference.traits).filter(([, wanted]) => wanted === true);
+  const semanticTraitBuckets = new Set(
+    desiredTraits.map(
+      ([trait]) => trait === "reasoning" || trait === "thinking" || trait === "longContext" ? "reasoningFamily" : trait
+    )
+  );
+  const totalDesiredTraits = semanticTraitBuckets.size;
+  if (totalDesiredTraits === 0) {
+    return { score: 0, rationale: [], matchedTraits: 0, totalDesiredTraits: 0 };
+  }
+  const s = scale === "consolidated" ? 10 : 1;
+  for (const trait of semanticTraitBuckets) {
+    switch (trait) {
+      case "reasoningFamily":
+        if (ratings.reasoningRating >= 4) {
+          matchedTraits++;
+          score += 0.3 * s;
+        } else if (ratings.reasoningRating >= 3) {
+          matchedTraits++;
+          score += 0.1 * s;
+        }
+        break;
+      case "fast":
+        if (ratings.speedRating >= 4) {
+          matchedTraits++;
+          score += 0.3 * s;
+        } else if (ratings.speedRating >= 3) {
+          matchedTraits++;
+          score += 0.1 * s;
+        }
+        break;
+      case "code":
+        if (ratings.reliabilityRating >= 4) {
+          matchedTraits++;
+          score += 0.2 * s;
+        } else {
+          matchedTraits++;
+          score += 0.1 * s;
+        }
+        break;
+    }
+  }
+  if (preference.preferredTier) {
+    if (preference.preferredTier === "economy" && ratings.costTier === "low") {
+      score += 0.2 * s;
+      rationale.push(`Cost tier match: ${ratings.costTier} (economy preferred)`);
+    } else if (preference.preferredTier === "premium" && ratings.costTier === "high") {
+      score += 0.2 * s;
+      rationale.push(`Cost tier match: ${ratings.costTier} (premium preferred)`);
+    }
+  }
+  if (matchedTraits > 0 || totalDesiredTraits > 0) {
+    rationale.push(
+      `Task-type preferences (${totalDesiredTraits} traits): ${score > 0 ? "+" : ""}${score.toFixed(1)}`
+    );
+  }
+  return { score, rationale, matchedTraits, totalDesiredTraits };
+}
+
+// src/orchestrator/routing-feedback.ts
+function getHistoricalAdjustment(providerId, domain, store, windowDays = 30, model) {
+  return computeHistoricalAdjustment(providerId, domain, store, windowDays, model);
+}
+var DEFAULT_FEEDBACK_OPTIONS = {
+  enabled: true,
+  minConfidence: 0.3,
+  // Confidence at which adjustment reaches full weight
+  windowDays: 30
+};
+function applyHistoricalFeedback(providerId, domain, currentScore, store, options = DEFAULT_FEEDBACK_OPTIONS, model) {
+  const rationale = [];
+  if (!options.enabled || !store) {
+    return { score: currentScore, rationale };
+  }
+  const adjustment = getHistoricalAdjustment(providerId, domain, store, options.windowDays, model);
+  if (adjustment.confidence === 0) {
+    rationale.push(
+      `Historical feedback skipped: insufficient samples (n=${adjustment.sampleSize})`
+    );
+    return { score: currentScore, rationale };
+  }
+  const fullConfidence = options.minConfidence > 0 ? options.minConfidence : 1;
+  const confidenceScale = Math.min(1, adjustment.confidence / fullConfidence);
+  const effectiveAdjustment = adjustment.adjustment * confidenceScale;
+  const adjustedScore = currentScore + effectiveAdjustment;
+  rationale.push(
+    `Historical feedback: ${effectiveAdjustment > 0 ? "+" : ""}${effectiveAdjustment.toFixed(1)} (${adjustment.reason}, n=${adjustment.sampleSize}, confidence=${(adjustment.confidence * 100).toFixed(0)}%)`
+  );
+  return { score: adjustedScore, rationale };
+}
+
+// src/orchestrator/routing-planner.ts
+var LEGACY_DOMAIN_PROVIDER_SCORES = {
+  frontend: {
+    cursor: 90,
+    claude: 70,
+    gemini: 65,
+    codex: 60,
+    copilot: 75,
+    opencode: 85
+    // Strong at UI/component patterns
+  },
+  backend: {
+    claude: 90,
+    codex: 85,
+    gemini: 75,
+    cursor: 60,
+    copilot: 70,
+    opencode: 80
+    // Good at API/service patterns
+  },
+  testing: {
+    claude: 85,
+    codex: 80,
+    cursor: 75,
+    gemini: 70,
+    copilot: 80,
+    opencode: 75
+    // Good at test patterns
+  },
+  docs: {
+    claude: 95,
+    gemini: 85,
+    copilot: 65,
+    cursor: 60,
+    codex: 70,
+    opencode: 70
+    // Good technical writing
+  },
+  infra: {
+    claude: 80,
+    codex: 85,
+    gemini: 75,
+    cursor: 60,
+    copilot: 70,
+    opencode: 75
+    // Good at IaC patterns
+  },
+  data: {
+    gemini: 90,
+    claude: 85,
+    codex: 75,
+    cursor: 55,
+    copilot: 65,
+    opencode: 70
+    // Good at data analysis patterns
+  },
+  general: {
+    claude: 85,
+    codex: 80,
+    gemini: 75,
+    cursor: 70,
+    copilot: 75,
+    opencode: 80
+    // Strong general-purpose
+  }
+};
+var HARNESS_FIT_SCORES = {
+  frontend: {
+    cursor: 80,
+    claude: 55,
+    gemini: 60,
+    codex: 60,
+    copilot: 70,
+    opencode: 70
+  },
+  backend: {
+    claude: 70,
+    codex: 75,
+    gemini: 60,
+    cursor: 60,
+    copilot: 55,
+    opencode: 68
+  },
+  testing: {
+    claude: 65,
+    codex: 78,
+    cursor: 65,
+    gemini: 58,
+    copilot: 60,
+    opencode: 68
+  },
+  docs: {
+    claude: 65,
+    gemini: 70,
+    copilot: 55,
+    cursor: 50,
+    codex: 58,
+    opencode: 55
+  },
+  infra: {
+    claude: 62,
+    codex: 76,
+    gemini: 58,
+    cursor: 52,
+    copilot: 50,
+    opencode: 70
+  },
+  data: {
+    gemini: 72,
+    claude: 58,
+    codex: 64,
+    cursor: 50,
+    copilot: 45,
+    opencode: 60
+  },
+  general: {
+    claude: 64,
+    codex: 68,
+    gemini: 62,
+    cursor: 58,
+    copilot: 55,
+    opencode: 65
+  }
+};
+var MODEL_QUALITY_SCORES = {
+  premium: {
+    frontend: 18,
+    backend: 24,
+    testing: 20,
+    docs: 24,
+    infra: 22,
+    data: 22,
+    general: 22
+  },
+  standard: {
+    frontend: 12,
+    backend: 16,
+    testing: 14,
+    docs: 16,
+    infra: 15,
+    data: 15,
+    general: 15
+  },
+  economy: {
+    frontend: 8,
+    backend: 6,
+    testing: 7,
+    docs: 8,
+    infra: 6,
+    data: 6,
+    general: 7
+  },
+  unknown: {
+    frontend: 0,
+    backend: 0,
+    testing: 0,
+    docs: 0,
+    infra: 0,
+    data: 0,
+    general: 0
+  }
+};
+var MODEL_COMPLEXITY_MODIFIERS = {
+  low: {
+    premium: -2,
+    standard: 1,
+    economy: 4,
+    unknown: 0
+  },
+  medium: {
+    premium: 0,
+    standard: 0,
+    economy: 0,
+    unknown: 0
+  },
+  high: {
+    premium: 8,
+    standard: 3,
+    economy: -8,
+    unknown: 0
+  }
+};
+var CONSOLIDATED_INTENT_MODIFIERS = {
+  compare: {
+    // compareIntent: true → reward high reasoning
+    claude: 15,
+    gemini: 10,
+    codex: 5,
+    cursor: -10,
+    copilot: 0,
+    opencode: 5
+  },
+  speed: {
+    // speedIntent: true → reward high throughput
+    cursor: 10,
+    copilot: 10,
+    codex: 5,
+    claude: 5,
+    gemini: 0,
+    opencode: 8
+  },
+  critical: {
+    // isCritical: true → reward high reliability
+    claude: 10,
+    codex: 8,
+    gemini: 5,
+    cursor: 5,
+    copilot: 5,
+    opencode: 7
+  }
+};
+var PROVIDER_EXECUTION_MODES_TABLE = {
+  claude: { local: true },
+  cursor: { local: true },
+  gemini: { local: true },
+  codex: { local: true },
+  copilot: { local: true },
+  opencode: { local: true }
+};
+var RoutingPlanner = class {
+  constructor(matrix = PROVIDER_CAPABILITY_MATRIX) {
+    this.matrix = matrix;
+  }
+  matrix;
+  historyStore = null;
+  /**
+   * Set the routing history store for historical feedback
+   */
+  setHistoryStore(store) {
+    this.historyStore = store;
+  }
+  /**
+   * Get the current history store (for testing)
+   */
+  getHistoryStore() {
+    return this.historyStore;
+  }
+  /**
+   * Plan routing based on domain analysis result.
+   * Note: DomainAnalysisResult is populated by DomainAnalyzer.analyze(),
+   * which internally consumes TaskAnalysis as the single source of truth
+   * for routing signals (compareIntent, speedIntent, isCritical, etc.).
+   */
+  plan(analysis, options = {}) {
+    const subTaskId = options.subTaskId ?? "root-task";
+    const excludedProviders = new Set(options.excludeProviders ?? []);
+    const enabledProviders = this.getEnabledProviderIds();
+    const allowed = options.allowedProviders && new Set(options.allowedProviders);
+    const candidateProviders = allowed ? new Set([...enabledProviders].filter((id) => allowed.has(id))) : enabledProviders;
+    if (options.manualProvider) {
+      if (excludedProviders.has(options.manualProvider)) {
+        throw new Error(`Manual provider override is excluded: ${options.manualProvider}`);
+      }
+      if (!enabledProviders.has(options.manualProvider)) {
+        throw new Error(`Manual provider override is disabled: ${options.manualProvider}`);
+      }
+      const manualCapability = this.matrix[options.manualProvider];
+      if (!manualCapability) {
+        throw new Error(
+          `Manual provider override refers to unknown provider: ${options.manualProvider}`
+        );
+      }
+      return {
+        subTaskId,
+        primary: {
+          provider: options.manualProvider,
+          confidence: 1,
+          rationale: ["Manual provider override supplied."],
+          setup: manualCapability.setup
+        },
+        alternates: this.buildAlternates(
+          options.manualProvider,
+          excludedProviders,
+          candidateProviders
+        ),
+        rationale: ["Manual override bypassed automated routing."],
+        modelRoleIntent: this.inferModelRoleIntent(analysis),
+        routingMode: options.routingMode ?? "balanced",
+        taskIntent: options.taskIntent
+      };
+    }
+    const candidateCapabilities = Object.values(this.matrix).filter(
+      (capability) => candidateProviders.has(capability.provider) && !excludedProviders.has(capability.provider)
+    );
+    if (candidateCapabilities.length === 0) {
+      throw new Error("No providers available for routing after exclusions");
+    }
+    const scoredProviders = candidateCapabilities.map((capability) => this.scoreProviderConsolidated(capability, analysis, options)).sort((a, b) => b.score - a.score);
+    const decision = this.buildDecisionFromScores(scoredProviders, analysis, subTaskId);
+    decision.routingMode = this.resolveEffectiveRoutingMode(options);
+    decision.taskIntent = options.taskIntent;
+    return decision;
+  }
+  /**
+   * Resolve the effective routing mode actually applied during scoring.
+   *
+   * A requested routing mode (e.g. `frugal`) only influences scoring when
+   * `routingBehavior === 'adaptive'`. When behavior is inactive, record
+   * `balanced` so the decision reflects what scoring actually did rather than
+   * what the caller requested.
+   */
+  resolveEffectiveRoutingMode(options) {
+    const requested = options.routingMode ?? "balanced";
+    if (options.routingBehavior === "adaptive") {
+      return requested;
+    }
+    return "balanced";
+  }
+  /**
+   * Apply routing mode adjustment to provider score.
+   *
+   * Uses provider capability ratings (1-5 scale) to produce a mode-specific
+   * score adjustment on the consolidated 0-100 scale. 'balanced' returns 0
+   * (no regression).
+   */
+  applyRoutingModeAdjustment(capability, mode, rationale) {
+    if (!mode || mode === "balanced") return 0;
+    const s = 10;
+    let adjustment = 0;
+    switch (mode) {
+      case "frugal":
+        adjustment = capability.speedRating * 0.3 * s - capability.reasoningRating * 0.15 * s;
+        adjustment += (capability.costTier === "low" ? 1 : capability.costTier === "high" ? -0.5 : 0) * s;
+        break;
+      case "quality":
+        adjustment = capability.reasoningRating * 0.3 * s - capability.speedRating * 0.1 * s;
+        break;
+      case "speed":
+        adjustment = capability.speedRating * 0.5 * s;
+        break;
+    }
+    if (adjustment !== 0) {
+      rationale.push(
+        `Routing mode '${mode}': ${adjustment > 0 ? "+" : ""}${adjustment.toFixed(1)}`
+      );
+    }
+    return adjustment;
+  }
+  resolveModelForProvider(provider, requestedModel) {
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(provider);
+      const available = providerConfig.models?.available ?? [];
+      const mappings = providerConfig.models?.mappings ?? {};
+      if (requestedModel && requestedModel.trim().length > 0) {
+        const direct = requestedModel.trim();
+        const mapped = mappings[direct] ?? direct;
+        const isKnown2 = available.some((model) => model.id === mapped || model.id === direct);
+        return isKnown2 ? mapped : void 0;
+      }
+      const resolved = resolveVariantModel(provider, void 0).model;
+      if (!resolved) return void 0;
+      const isKnown = available.some((model) => model.id === resolved);
+      return isKnown ? resolved : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  getModelQualityTier(provider, modelId) {
+    try {
+      const providerConfig = ProviderRegistry.getProviderConfig(provider);
+      const modelInfo = providerConfig.models?.available?.find((model) => model.id === modelId);
+      if (!modelInfo) return "unknown";
+      const capabilities = new Set(modelInfo.capabilities);
+      if (capabilities.has("advanced") || capabilities.has("adaptive_thinking") || capabilities.has("thinking")) {
+        return "premium";
+      }
+      if (capabilities.has("reasoning")) {
+        return "standard";
+      }
+      if (capabilities.has("fast")) {
+        return "economy";
+      }
+      return "standard";
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Score a provider using consolidated scoring tables (Phase 2A)
+   * Uses 0-100 scale from flywheel routing for fine-grained differentiation
+   */
+  scoreProviderConsolidated(capability, analysis, options) {
+    let score = 0;
+    const rationale = [];
+    const provider = capability.provider;
+    const breakdown = {
+      harnessScore: 0,
+      modelScore: 0,
+      providerHealthScore: 0
+    };
+    const resolvedModel = this.resolveModelForProvider(provider, options.model);
+    const modelTier = resolvedModel ? this.getModelQualityTier(provider, resolvedModel) : "unknown";
+    if (options.executionMode) {
+      const modes = PROVIDER_EXECUTION_MODES_TABLE[provider];
+      const modeSupported = modes?.[options.executionMode] ?? true;
+      if (!modeSupported) {
+        rationale.push(`Provider does not support ${options.executionMode} execution mode.`);
+        return { provider: capability, score: 0, rationale, breakdown, model: resolvedModel };
+      }
+    }
+    const harnessScore = (HARNESS_FIT_SCORES[analysis.domain] ?? HARNESS_FIT_SCORES.general)[provider] ?? 50;
+    score += harnessScore;
+    breakdown.harnessScore = harnessScore;
+    rationale.push(`Harness fit (${analysis.domain}): ${harnessScore}`);
+    let modelScore = 0;
+    if (resolvedModel && modelTier !== "unknown") {
+      const tierBase = MODEL_QUALITY_SCORES[modelTier][analysis.domain] ?? 0;
+      const complexityMod = MODEL_COMPLEXITY_MODIFIERS[analysis.complexity][modelTier] ?? 0;
+      modelScore = tierBase + complexityMod;
+      rationale.push(`Model quality (${resolvedModel}, tier=${modelTier}): ${modelScore}`);
+    } else {
+      const legacyDomainScore = (LEGACY_DOMAIN_PROVIDER_SCORES[analysis.domain] ?? LEGACY_DOMAIN_PROVIDER_SCORES.general)[provider] ?? 50;
+      modelScore = Math.max(0, legacyDomainScore - harnessScore);
+      rationale.push(`Model quality fallback (provider-level): ${modelScore}`);
+    }
+    score += modelScore;
+    breakdown.modelScore = modelScore;
+    let intentScore = 0;
+    if (analysis.compareIntent) {
+      const compareBonus = CONSOLIDATED_INTENT_MODIFIERS.compare[provider] ?? 0;
+      intentScore += compareBonus;
+      if (compareBonus !== 0) {
+        rationale.push(`Compare intent bonus: ${compareBonus > 0 ? "+" : ""}${compareBonus}`);
+      }
+    }
+    if (analysis.speedIntent) {
+      const speedBonus = CONSOLIDATED_INTENT_MODIFIERS.speed[provider] ?? 0;
+      intentScore += speedBonus;
+      if (speedBonus !== 0) {
+        rationale.push(`Speed intent bonus: ${speedBonus > 0 ? "+" : ""}${speedBonus}`);
+      }
+    }
+    if (analysis.isCritical) {
+      const criticalBonus = CONSOLIDATED_INTENT_MODIFIERS.critical[provider] ?? 0;
+      intentScore += criticalBonus;
+      if (criticalBonus !== 0) {
+        rationale.push(`Critical task bonus: ${criticalBonus > 0 ? "+" : ""}${criticalBonus}`);
+      }
+    }
+    score += intentScore;
+    const healthGuardrailsEnabled = readEnv(BUILD_PROVIDER_HEALTH_GUARDRAILS).value;
+    if (healthGuardrailsEnabled) {
+      const providerHealth = getProviderHealth(provider);
+      let providerHealthScore = 0;
+      if (providerHealth.score < 1) {
+        providerHealthScore -= (1 - providerHealth.score) * 20;
+      }
+      if (providerHealth.degraded) {
+        providerHealthScore -= 8;
+      }
+      if (providerHealthScore !== 0) {
+        score += providerHealthScore;
+        rationale.push(
+          `Provider health adjustment: ${providerHealthScore > 0 ? "+" : ""}${providerHealthScore.toFixed(1)} (health=${providerHealth.score.toFixed(2)}, failures=${providerHealth.consecutiveFailures})`
+        );
+      }
+      breakdown.providerHealthScore = providerHealthScore;
+    }
+    const confidenceBonus = (analysis.confidence ?? 0) * 15;
+    score += confidenceBonus;
+    if (options.requestedSetup && capability.setup !== options.requestedSetup && capability.setup !== "hybrid" && options.requestedSetup !== "hybrid") {
+      const setupPenalty = 15;
+      score -= setupPenalty;
+      rationale.push(
+        `Setup mismatch penalty: -${setupPenalty} (provider=${capability.setup}, requested=${options.requestedSetup})`
+      );
+    }
+    const isAdaptive = options.routingBehavior === "adaptive";
+    if (isAdaptive) {
+      score += this.applyRoutingModeAdjustment(capability, options.routingMode, rationale);
+    }
+    if (isAdaptive && options.taskIntent) {
+      const preference = resolveTaskTypePreference(
+        options.taskIntent,
+        options.taskTypePreferences
+      );
+      const traitResult = scoreTraitMatchForProvider(preference, capability, "consolidated");
+      if (traitResult.score !== 0) {
+        score += traitResult.score;
+        rationale.push(...traitResult.rationale);
+      }
+    }
+    if (score <= 0) {
+      score = 5;
+      rationale.push("Applied baseline score for fallback rotation.");
+    }
+    if (this.historyStore) {
+      const feedback = applyHistoricalFeedback(
+        provider,
+        analysis.domain,
+        score,
+        this.historyStore,
+        DEFAULT_FEEDBACK_OPTIONS,
+        resolvedModel
+      );
+      score = feedback.score;
+      rationale.push(...feedback.rationale);
+    }
+    return { provider: capability, score, rationale, breakdown, model: resolvedModel };
+  }
+  /**
+   * Build routing decision from scored providers
+   */
+  buildDecisionFromScores(scoredProviders, analysis, subTaskId) {
+    const [primaryScore, ...alternateScores] = scoredProviders;
+    if (!primaryScore) {
+      throw new Error("No providers available for routing");
+    }
+    const totalScore = scoredProviders.reduce((sum, item) => sum + item.score, 0) || 1;
+    const confidence = this.calculateConfidence(scoredProviders);
+    const primary = {
+      provider: primaryScore.provider.provider,
+      confidence,
+      rationale: primaryScore.rationale,
+      setup: primaryScore.provider.setup
+    };
+    const alternates = alternateScores.slice(0, 2).map((item) => ({
+      provider: item.provider.provider,
+      confidence: Math.min(1, item.score / totalScore),
+      rationale: item.rationale,
+      setup: item.provider.setup
+    }));
+    const rationale = [
+      `Domain classified as ${analysis.domain} with confidence ${(analysis.confidence * 100).toFixed(0)}%.`,
+      `Primary provider ${primary.provider} selected with score ${primaryScore.score.toFixed(2)}.`
+    ];
+    if (analysis.compareIntent) {
+      rationale.push(
+        "Comparison intent detected; prioritised providers with high reasoning rating."
+      );
+    }
+    if (analysis.speedIntent) {
+      rationale.push(
+        "Speed intent detected; ensured at least one high-throughput provider is available."
+      );
+    }
+    if (analysis.isCritical) {
+      rationale.push("Critical task detected; emphasised reliability in provider scoring.");
+    }
+    return {
+      subTaskId,
+      primary,
+      alternates,
+      rationale,
+      modelRoleIntent: this.inferModelRoleIntent(analysis)
+    };
+  }
+  inferModelRoleIntent(analysis) {
+    if (analysis.speedIntent || analysis.complexity === "low") {
+      return "fast";
+    }
+    if (analysis.compareIntent) {
+      return "reasoning";
+    }
+    if (analysis.isCritical || analysis.complexity === "high") {
+      return "quality";
+    }
+    return "default";
+  }
+  buildAlternates(primary, excludedProviders, enabledProviders) {
+    return Object.values(this.matrix).filter(
+      (capability) => capability.provider !== primary && enabledProviders.has(capability.provider) && !excludedProviders.has(capability.provider)
+    ).map((capability) => ({
+      provider: capability.provider,
+      confidence: 0.25,
+      rationale: ["Manual override fallback."],
+      setup: capability.setup
+    })).slice(0, 2);
+  }
+  getEnabledProviderIds() {
+    const matrixProviders = new Set(Object.keys(this.matrix));
+    return new Set(
+      ProviderRegistry.getEnabledProviders().map((provider) => provider.id).filter((providerId) => matrixProviders.has(providerId))
+    );
+  }
+  calculateConfidence(scoredProviders) {
+    if (scoredProviders.length === 0) return 0;
+    if (scoredProviders.length === 1) return 1;
+    const topScore = scoredProviders[0]?.score ?? 0;
+    const secondScore = scoredProviders[1]?.score ?? 0;
+    const margin = topScore - secondScore;
+    return Math.max(0.5, Math.min(1, 0.5 + margin / 50));
+  }
+};
+function matrixProviderIds(matrix = PROVIDER_CAPABILITY_MATRIX) {
+  return Object.keys(matrix);
+}
+function configuredDefaultProvider(matrix = PROVIDER_CAPABILITY_MATRIX, cwd = process.cwd()) {
+  const resolved = resolveDefaultProvider(void 0, cwd).value;
+  if (matrix[resolved]) return resolved;
+  return fastestProvider(matrix);
+}
+function alternateProvider(primary, matrix = PROVIDER_CAPABILITY_MATRIX, cwd = process.cwd()) {
+  const configured = configuredDefaultProvider(matrix, cwd);
+  if (configured !== primary) return configured;
+  const fastest = fastestProvider(matrix);
+  if (fastest !== primary) return fastest;
+  return matrixProviderIds(matrix).find((provider) => provider !== primary) ?? primary;
+}
+function fastestProvider(matrix = PROVIDER_CAPABILITY_MATRIX) {
+  const providers = matrixProviderIds(matrix);
+  const fastest = providers.reduce((best, provider) => {
+    if (!best) return provider;
+    const providerCapability = matrix[provider];
+    const bestCapability = matrix[best];
+    if (!providerCapability || !bestCapability) return best;
+    return providerCapability.speedRating > bestCapability.speedRating ? provider : best;
+  }, void 0);
+  if (fastest) return fastest;
+  throw new Error("No providers configured for routing");
+}
+function getIntentProviderMap(matrix = PROVIDER_CAPABILITY_MATRIX, cwd = process.cwd()) {
+  const defaultProvider = configuredDefaultProvider(matrix, cwd);
+  const fastProvider = fastestProvider(matrix);
+  const defaultFallback = alternateProvider(defaultProvider, matrix, cwd);
+  const fastFallback = fastProvider === defaultProvider ? defaultFallback : defaultProvider;
+  return {
+    fast: { primary: fastProvider, fallback: fastFallback },
+    best: { primary: defaultProvider, fallback: defaultFallback },
+    balanced: { primary: defaultProvider, fallback: defaultFallback }
+  };
+}
+var INTENT_EFFORT_MAP = {
+  fast: "low",
+  best: "high",
+  balanced: "medium"
+};
+async function checkProviderAvailability(provider) {
+  const providerModule = registry.get(provider);
+  if (!providerModule) {
+    return {
+      available: false,
+      reason: "provider not registered"
+    };
+  }
+  const authState = await readPassiveAuthState(providerModule.auth);
+  if (authState !== "yes") {
+    return {
+      available: true,
+      authVerified: false,
+      reason: "authentication not preverified"
+    };
+  }
+  return { available: true, authVerified: true };
+}
+async function createAvailabilitySnapshot(cwd = process.cwd()) {
+  const providers = /* @__PURE__ */ new Set();
+  const intentProviderMap = getIntentProviderMap(PROVIDER_CAPABILITY_MATRIX, cwd);
+  for (const { primary, fallback } of Object.values(intentProviderMap)) {
+    providers.add(primary);
+    providers.add(fallback);
+  }
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    Array.from(providers).map(async (provider) => {
+      const availability = await checkProviderAvailability(provider);
+      results.set(provider, availability);
+    })
+  );
+  return results;
+}
+function isAvailabilitySnapshot(value) {
+  return Boolean(value && typeof value.get === "function");
+}
+function resolveAuthPrecheck(snapshot, provider) {
+  if (!snapshot) {
+    return "not_run";
+  }
+  const availability = snapshot.get(provider);
+  if (!availability || availability.authVerified === void 0) {
+    return "not_run";
+  }
+  return availability.authVerified ? "verified" : "not_preverified";
+}
+function selectAutoProfile(options, matrixOrSnapshot = PROVIDER_CAPABILITY_MATRIX, availabilitySnapshot) {
+  const { intent, oneShot, manualProvider, allowExperimental } = options;
+  const effectiveMatrix = isAvailabilitySnapshot(matrixOrSnapshot) ? PROVIDER_CAPABILITY_MATRIX : matrixOrSnapshot;
+  const effectiveSnapshot = isAvailabilitySnapshot(matrixOrSnapshot) ? matrixOrSnapshot : availabilitySnapshot;
+  const rationale = [];
+  if (manualProvider) {
+    const capability = effectiveMatrix[manualProvider];
+    if (!capability) {
+      throw new Error(`Unknown provider: ${manualProvider}`);
+    }
+    const authPrecheck2 = resolveAuthPrecheck(effectiveSnapshot, manualProvider);
+    rationale.push(`Manual provider override: ${manualProvider}`);
+    rationale.push("Execution default: local quick-mode provider CLI");
+    if (authPrecheck2 === "not_preverified") {
+      rationale.push(
+        "Auth precheck: not preverified (passive; advisory \u2014 provider CLI verifies at execution)"
+      );
+    }
+    return {
+      harness: "quick",
+      preferredProvider: manualProvider,
+      provider: manualProvider,
+      fallbackProvider: void 0,
+      runtimeExecutionMode: "local",
+      executionMode: capability.setup,
+      recommendedEffort: INTENT_EFFORT_MAP[intent],
+      model: "provider-default",
+      maxTries: oneShot ? 1 : intent === "best" ? 3 : 2,
+      enableReview: intent !== "fast",
+      authPrecheck: authPrecheck2,
+      rationale
+    };
+  }
+  const intentProviderMap = getIntentProviderMap(effectiveMatrix, options.cwd);
+  const { primary, fallback } = intentProviderMap[intent];
+  const fallbackProvider = fallback !== primary ? fallback : void 0;
+  let selectedProvider = primary;
+  let selectedCapability = effectiveMatrix[primary];
+  if (!allowExperimental && selectedCapability?.experimental) {
+    rationale.push(`Primary provider ${primary} is experimental; selecting alternate ${fallback}`);
+    selectedProvider = fallback;
+    selectedCapability = effectiveMatrix[fallback];
+  }
+  if (effectiveSnapshot) {
+    const primaryAvailability = effectiveSnapshot.get(selectedProvider);
+    if (primaryAvailability && !primaryAvailability.available) {
+      rationale.push(
+        `Primary provider ${selectedProvider} unavailable (${primaryAvailability.reason}); selecting alternate ${fallback}`
+      );
+      selectedProvider = fallback;
+      selectedCapability = effectiveMatrix[fallback];
+      const alternateAvailability = effectiveSnapshot.get(selectedProvider);
+      if (alternateAvailability && !alternateAvailability.available) {
+        rationale.push(
+          `Alternate provider ${selectedProvider} also unavailable (${alternateAvailability.reason}); using configured default as last resort`
+        );
+        selectedProvider = configuredDefaultProvider(effectiveMatrix, options.cwd);
+        selectedCapability = effectiveMatrix[selectedProvider];
+      }
+    }
+  }
+  const authPrecheck = resolveAuthPrecheck(effectiveSnapshot, selectedProvider);
+  if (authPrecheck === "not_preverified") {
+    rationale.push(
+      "Auth precheck: not preverified (passive; advisory \u2014 provider CLI verifies at execution)"
+    );
+  }
+  if (!selectedCapability) {
+    throw new Error(`No capability found for provider: ${selectedProvider}`);
+  }
+  rationale.push(`Intent: ${intent}`);
+  rationale.push(`Selected provider: ${selectedProvider} (${selectedCapability.setup} setup)`);
+  rationale.push("Execution default: local quick-mode provider CLI");
+  const executionMode = selectedCapability.setup;
+  let maxTries;
+  if (oneShot) {
+    maxTries = 1;
+    rationale.push(
+      "One-shot mode: one provider/quality-gate iteration (no validation feedback re-prompt)"
+    );
+  } else if (intent === "best") {
+    maxTries = 3;
+    rationale.push(
+      "Best intent: up to 3 quality-gate iterations (re-prompt with validation feedback)"
+    );
+  } else {
+    maxTries = 2;
+    rationale.push("Up to 2 quality-gate iterations (re-prompt with validation feedback)");
+  }
+  const enableReview = intent !== "fast";
+  if (!enableReview) {
+    rationale.push("Fast intent: AI review disabled for speed");
+  }
+  return {
+    harness: "quick",
+    preferredProvider: primary,
+    provider: selectedProvider,
+    fallbackProvider,
+    runtimeExecutionMode: "local",
+    executionMode,
+    recommendedEffort: INTENT_EFFORT_MAP[intent],
+    model: "provider-default",
+    maxTries,
+    enableReview,
+    authPrecheck,
+    rationale
+  };
+}
+function formatAutoProfile(profile) {
+  const lines = [];
+  lines.push(`Provider: ${profile.provider}`);
+  if (profile.provider !== profile.preferredProvider) {
+    lines.push(`Preferred: ${profile.preferredProvider}`);
+  }
+  lines.push(`Execution mode: ${profile.runtimeExecutionMode}`);
+  lines.push(`Provider setup: ${profile.executionMode}`);
+  lines.push(`Reasoning effort: ${formatReasoningEffortLevelForUser(profile.recommendedEffort)}`);
+  lines.push("Model: provider-default");
+  lines.push(`Max quality-gate iterations: ${profile.maxTries}`);
+  lines.push(`Review: ${profile.enableReview ? "enabled" : "disabled"}`);
+  const authPrecheckLabel = profile.authPrecheck === "verified" ? "verified" : profile.authPrecheck === "not_preverified" ? "not preverified" : "not run";
+  lines.push(`Auth precheck: ${authPrecheckLabel}`);
+  return lines;
+}
+
+export {
+  readPassiveAuthState,
+  RoutingPlanner,
+  checkProviderAvailability,
+  createAvailabilitySnapshot,
+  selectAutoProfile,
+  formatAutoProfile
+};
+//# sourceMappingURL=chunk-DBHOWDUH.js.map