muonroi-cli 1.8.4 → 1.8.5

package/dist/src/router/decide.js

@@ -6,7 +6,7 @@
  * If cap breach detected, downgrade chain overrides classifier output (ROUTE-06).
  */
 import { getDefaultEEClient } from "../ee/intercept.js";
-import { getModelByTier, getModelInfo, getModelsForProvider } from "../models/registry.js";
+import { getModelInfo, getModelsForProvider } from "../models/registry.js";
 import { taskTypeToRole } from "../pil/task-tier-map.js";
 import { detectProviderForModel } from "../providers/runtime.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
@@ -14,9 +14,10 @@ import { downgradeChain, emitDowngrade, getDowngradeChain } from "../usage/downg
 import { release, reserve } from "../usage/ledger.js";
 import { midstreamPolicy } from "../usage/midstream.js";
 import { CapBreachError } from "../usage/types.js";
-import { getRoleModel, isCouncilMultiProviderPreferred, isProviderDisabled } from "../utils/settings.js";
+import { getRoleModel, getRoutingPromoteMax, isCouncilMultiProviderPreferred, isProviderDisabled, } from "../utils/settings.js";
 import { classify } from "./classifier/index.js";
 import { callColdRoute } from "./cold.js";
+import { adjustPeakHourModel, getRoutedModelByTier } from "./peak-hour.js";
 import { isInheritProvider } from "./provider-sentinel.js";
 import { routerStore } from "./store.js";
 import { callWarmRoute } from "./warm.js";
@@ -75,6 +76,16 @@ function buildRouteContext(cwd, pil) {
         ctx.filesTouched = pil.filesTouched;
     if (pil?.mode)
         ctx.mode = pil.mode;
+    if (pil?.turnIndex !== undefined)
+        ctx.turnIndex = pil.turnIndex;
+    if (pil?.messageCount !== undefined)
+        ctx.messageCount = pil.messageCount;
+    if (pil?.compactionCount !== undefined)
+        ctx.compactionCount = pil.compactionCount;
+    if (pil?.totalSavedTokens !== undefined)
+        ctx.totalSavedTokens = pil.totalSavedTokens;
+    if (pil?.compactionSummary)
+        ctx.compactionSummary = pil.compactionSummary;
     return ctx;
 }
 // ─── Disabled-provider guard: fallback providers ────────────────────────────
@@ -90,7 +101,7 @@ function resolveEffectiveDefaults(opts) {
     }
     for (const p of FALLBACK_PROVIDERS) {
         if (!isProviderDisabled(p)) {
-            const m = getModelByTier("balanced", p);
+            const m = getRoutedModelByTier("balanced", p);
             // Guard: getModelByTier may return a model from a different provider
             // when the preferred provider has no model for the requested tier.
             if (m && m.provider === p)
@@ -114,7 +125,7 @@ function resolveTierModel(tier, defaultProvider) {
     }
     for (const p of FALLBACK_PROVIDERS) {
         if (!isProviderDisabled(p)) {
-            const m = getModelByTier(tier, p);
+            const m = getRoutedModelByTier(tier, p);
             // Guard: getModelByTier may return a model from a different provider
             // when the preferred provider has no model for the requested tier.
             if (m && m.provider === p)
@@ -126,6 +137,17 @@ function resolveTierModel(tier, defaultProvider) {
     }
     return undefined;
 }
+function applyPeakHourRoute(dec) {
+    const adj = adjustPeakHourModel(dec.model);
+    if (!adj.adjusted)
+        return dec;
+    return {
+        ...dec,
+        model: adj.modelId,
+        provider: adj.provider,
+        reason: `${dec.reason}|${adj.reason}`,
+    };
+}
 // ─── Provider constraint: never route to a provider the user lacks a key for ─
 function constrainToProvider(decision, opts) {
     // Inherit-sentinel: warm path may emit an empty provider to signal
@@ -134,11 +156,11 @@ function constrainToProvider(decision, opts) {
     if (isInheritProvider(decision.provider)) {
         const resolved = detectProviderForModel(decision.model);
         if (resolved && !isProviderDisabled(resolved))
-            return decision;
+            return applyPeakHourRoute(decision);
         if (resolved && isProviderDisabled(resolved)) {
             return constrainToProvider({ ...decision, provider: resolved }, opts);
         }
-        return decision;
+        return applyPeakHourRoute(decision);
     }
     // Provider-only UX: the user enables N providers and pins one as default.
     // Routing rules:
@@ -150,7 +172,7 @@ function constrainToProvider(decision, opts) {
     //     surface a config error elsewhere).
     const decisionDisabled = isProviderDisabled(decision.provider);
     if (!decisionDisabled) {
-        return decision;
+        return applyPeakHourRoute(decision);
     }
     if (isProviderDisabled(opts.defaultProvider)) {
         return {
@@ -158,7 +180,7 @@ function constrainToProvider(decision, opts) {
             reason: `${decision.reason}|provider-not-constrained(default-also-disabled)`,
         };
     }
-    const sameProviderModel = getModelByTier(decision.tier === "hot" ? "fast" : decision.tier === "cold" ? "premium" : "balanced", opts.defaultProvider);
+    const sameProviderModel = getRoutedModelByTier(decision.tier === "hot" ? "fast" : decision.tier === "cold" ? "premium" : "balanced", opts.defaultProvider);
     if (sameProviderModel && sameProviderModel.provider !== opts.defaultProvider) {
         return {
             ...decision,
@@ -167,12 +189,12 @@ function constrainToProvider(decision, opts) {
             reason: `${decision.reason}|provider-constrained(forced-default)`,
         };
     }
-    return {
+    return applyPeakHourRoute({
         ...decision,
         model: sameProviderModel?.id ?? opts.defaultModel,
         provider: sameProviderModel?.provider ?? opts.defaultProvider,
         reason: `${decision.reason}|provider-constrained`,
-    };
+    });
 }
 // ─── Route feedback (HTTP path) ─────────────────────────────────────────────
 /**
@@ -194,12 +216,78 @@ export function reportRouteOutcome(taskHash, outcome, duration) {
         duration: duration ?? null,
     });
 }
+// ─── Tier-promotion cap (cost-ceiling guard) ───────────────────────────────
+const TIER_RANK = {
+    fast: 0,
+    balanced: 1,
+    premium: 2,
+};
+/**
+ * Enforce the user's tier-promotion ceiling. The session default model is the
+ * cost ceiling: the router may downgrade per turn but may not silently promote
+ * beyond `routingPromoteMax` (default "balanced"). See settings.ts.
+ *
+ * When the decision would promote, clamp down to the max allowed tier on the
+ * SAME provider. If no same-provider model exists at the ceiling tier, fall
+ * back to the session default model (the user's explicit pick). The clamp is
+ * skipped for: the `"any"` opt-in, the role path (explicit user roleModels
+ * config is itself the opt-in), cap-halt decisions, and provider-constrained
+ * disabled-provider recoveries (those already move toward the default).
+ */
+function applyPromotionCap(dec, defaultModel) {
+    if (dec.model === "HALT" || dec.model === defaultModel)
+        return dec;
+    const cap = getRoutingPromoteMax();
+    if (cap === "any")
+        return dec;
+    const capRank = cap === "off" ? null : TIER_RANK[cap]; // "balanced" → 1
+    const defaultTier = getModelInfo(defaultModel)?.tier;
+    // "off" means ceiling = the default model's own tier.
+    const maxAllowedRank = capRank === null ? (defaultTier ? TIER_RANK[defaultTier] : 0) : capRank;
+    const decInfo = getModelInfo(dec.model);
+    const decTier = decInfo?.tier;
+    if (!decTier || TIER_RANK[decTier] <= maxAllowedRank)
+        return dec;
+    // Promotion exceeds the ceiling — clamp DOWN to the max allowed tier on the
+    // same provider. Walk down from the ceiling so we pick the highest permitted.
+    const provider = decInfo?.provider ?? detectProviderForModel(dec.model);
+    const targetTiers = capRank === null
+        ? defaultTier
+            ? [defaultTier]
+            : ["fast"]
+        : maxAllowedRank >= 1
+            ? ["balanced", "fast"]
+            : ["fast"];
+    for (const t of targetTiers) {
+        if (TIER_RANK[t] > maxAllowedRank)
+            continue;
+        const m = getRoutedModelByTier(t, provider);
+        if (m && m.provider === provider) {
+            return {
+                ...dec,
+                model: m.id,
+                reason: `${dec.reason} | promo-cap(${decTier}→${t})`,
+            };
+        }
+    }
+    // No cheaper model on the same provider — fall back to the session default.
+    return {
+        ...dec,
+        model: defaultModel,
+        reason: `${dec.reason} | promo-cap(${decTier}→default:${defaultModel})`,
+    };
+}
 /**
  * Apply cap-check to a RouteDecision. Walks the downgrade chain if
  * the reservation would breach the cap. Returns the (possibly downgraded) decision.
+ *
+ * `opts` carries both the ledger homeOverride and the session defaultModel used
+ * by the promotion cap. `exempt` skips the promotion cap — used only for the
+ * role path, where the user's explicit roleModels config is itself the opt-in.
  */
-async function capCheck(dec, homeOverride) {
-    let current = { ...dec };
+async function capCheck(dec, opts, exempt) {
+    let current = exempt ? { ...dec } : applyPromotionCap({ ...dec }, opts.defaultModel);
+    const homeOverride = opts.homeOverride;
     let attempts = 0;
     while (attempts++ < getDowngradeChain().length) {
         // If midstream policy already refuses, halt immediately
@@ -305,14 +393,15 @@ export async function decide(prompt, opts) {
                 providerDisabled: isProviderDisabled(provider),
                 multiProviderPreferred: isCouncilMultiProviderPreferred(),
             })) {
+                const peak = adjustPeakHourModel(roleModelId);
                 const d = {
                     tier: "hot",
-                    model: roleModelId,
-                    provider,
-                    reason: `role:${role}→${roleModelId}`,
+                    model: peak.modelId,
+                    provider: peak.provider,
+                    reason: peak.adjusted ? `role:${role}→${peak.modelId}|${peak.reason}` : `role:${role}→${roleModelId}`,
                     source: "role",
                 };
-                const checked = await capCheck(d, opts.homeOverride);
+                const checked = await capCheck(d, opts, /* exempt */ true);
                 routerStore.setState({ tier: checked.tier, lastDecision: checked, taskHash: null, source: "role" });
                 if (cacheKey && !checked.cap_overridden)
                     setCachedRoute(cacheKey, checked);
@@ -328,7 +417,7 @@ export async function decide(prompt, opts) {
     if (pilTier && pilConf >= 0.6) {
         // Use effective (non-disabled) provider when default is disabled
         const effective = resolveTierModel(pilTier, opts.defaultProvider);
-        let tierModel = effective ?? getModelByTier(pilTier, opts.defaultProvider);
+        let tierModel = effective ?? getRoutedModelByTier(pilTier, opts.defaultProvider);
         // Guard: getModelByTier may cross to another provider when defaultProvider
         // has no model for the requested tier. If that cross-provider is disabled,
         // pin to the default model on the default provider instead.
@@ -338,17 +427,21 @@ export async function decide(prompt, opts) {
             isProviderDisabled(tierModel.provider)) {
             tierModel = undefined;
         }
+        const pilModel = tierModel?.id ?? opts.defaultModel;
+        const peak = adjustPeakHourModel(pilModel);
         const d = {
             tier: "hot",
-            model: tierModel?.id ?? opts.defaultModel,
-            provider: tierModel?.provider ?? opts.defaultProvider,
-            reason: effective
-                ? `pil:${pilTier}(${pilConf.toFixed(2)})-rerouted(disabled-default)`
-                : `pil:${pilTier}(${pilConf.toFixed(2)})`,
+            model: peak.modelId,
+            provider: tierModel?.provider ?? peak.provider,
+            reason: peak.adjusted
+                ? `${effective ? `pil:${pilTier}(${pilConf.toFixed(2)})-rerouted(disabled-default)` : `pil:${pilTier}(${pilConf.toFixed(2)})`}|${peak.reason}`
+                : effective
+                    ? `pil:${pilTier}(${pilConf.toFixed(2)})-rerouted(disabled-default)`
+                    : `pil:${pilTier}(${pilConf.toFixed(2)})`,
             confidence: pilConf,
             source: "pil",
         };
-        const checked = await capCheck(d, opts.homeOverride);
+        const checked = await capCheck(d, opts);
         routerStore.setState({
             tier: checked.tier,
             lastDecision: checked,
@@ -364,7 +457,7 @@ export async function decide(prompt, opts) {
     if (c.tier === "hot") {
         // Use effective (non-disabled) provider when default is disabled
         const effective = c.tierHint ? resolveTierModel(c.tierHint, opts.defaultProvider) : undefined;
-        let tierModel = effective ?? (c.tierHint ? getModelByTier(c.tierHint, opts.defaultProvider) : undefined);
+        let tierModel = effective ?? (c.tierHint ? getRoutedModelByTier(c.tierHint, opts.defaultProvider) : undefined);
         // Same guard as the PIL branch above: drop cross-provider fallback when
         // the cross-provider is disabled, so we don't switch to a provider the
         // user has turned off in the splash modal.
@@ -374,14 +467,20 @@ export async function decide(prompt, opts) {
             isProviderDisabled(tierModel.provider)) {
             tierModel = undefined;
         }
+        const hotModel = tierModel?.id ?? opts.defaultModel;
+        const peak = adjustPeakHourModel(hotModel);
         const d = {
             tier: "hot",
-            model: tierModel?.id ?? opts.defaultModel,
-            provider: tierModel?.provider ?? opts.defaultProvider,
-            reason: effective ? `${c.reason}-rerouted(disabled-default)` : c.reason,
+            model: peak.modelId,
+            provider: tierModel?.provider ?? peak.provider,
+            reason: peak.adjusted
+                ? `${effective ? `${c.reason}-rerouted(disabled-default)` : c.reason}|${peak.reason}`
+                : effective
+                    ? `${c.reason}-rerouted(disabled-default)`
+                    : c.reason,
             confidence: c.confidence,
         };
-        const checked = await capCheck(d, opts.homeOverride);
+        const checked = await capCheck(d, opts);
         routerStore.setState({
             tier: checked.tier,
             lastDecision: checked,
@@ -395,7 +494,7 @@ export async function decide(prompt, opts) {
     // Step 2: Warm path (EE /api/route-model, 250ms timeout)
     const w = await callWarmRoute(prompt, { ...opts, context: routeCtx });
     if (w) {
-        const checked = await capCheck(constrainToProvider(w, opts), opts.homeOverride);
+        const checked = await capCheck(constrainToProvider(w, opts), opts);
         routerStore.setState({
             tier: checked.tier,
             lastDecision: checked,
@@ -409,7 +508,7 @@ export async function decide(prompt, opts) {
     // Step 3: Cold path (EE /api/cold-route, 1s timeout)
     const cd = await callColdRoute(prompt, { ...opts, context: routeCtx });
     if (cd) {
-        const checked = await capCheck(constrainToProvider(cd, opts), opts.homeOverride);
+        const checked = await capCheck(constrainToProvider(cd, opts), opts);
         routerStore.setState({
             tier: "cold",
             lastDecision: checked,
@@ -422,15 +521,18 @@ export async function decide(prompt, opts) {
     }
     // Step 4: Final fallback when EE entirely unreachable
     const effective = resolveEffectiveDefaults(opts);
+    const peak = adjustPeakHourModel(effective.model);
     const fallback = {
         tier: routerStore.getState().degraded ? "degraded" : "hot",
-        model: effective.model,
-        provider: effective.provider,
-        reason: effective.provider !== opts.defaultProvider
-            ? "fallback:ee-unreachable+rerouted(disabled-default)"
-            : "fallback:ee-unreachable",
+        model: peak.modelId,
+        provider: peak.provider,
+        reason: peak.adjusted
+            ? `${effective.provider !== opts.defaultProvider ? "fallback:ee-unreachable+rerouted(disabled-default)" : "fallback:ee-unreachable"}|${peak.reason}`
+            : effective.provider !== opts.defaultProvider
+                ? "fallback:ee-unreachable+rerouted(disabled-default)"
+                : "fallback:ee-unreachable",
     };
-    const checked = await capCheck(fallback, opts.homeOverride);
+    const checked = await capCheck(fallback, opts);
     routerStore.setState({
         lastDecision: checked,
         taskHash: null,

package/dist/src/router/peak-hour.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Peak-hour routing — rules loaded from catalog API `provider_policies.peak_hour`
+ * (vendor-sourced metadata). User settings only toggle enabled + switch/downgrade mode.
+ */
+import type { CatalogProviderPeakHour } from "../models/catalog-client.js";
+import type { ProviderId } from "../providers/types.js";
+import type { ModelInfo } from "../types/index.js";
+import { type PeakHourPolicy } from "../utils/settings.js";
+export type PeakHourMode = "downgrade" | "switch";
+export interface PeakHourAdjustment {
+    modelId: string;
+    provider: ProviderId;
+    adjusted: boolean;
+    reason?: string;
+}
+export declare function hourInTimezone(now: Date, timezone: string): number;
+/** @deprecated Use hourInTimezone — kept for tests referencing UTC+8. */
+export declare function hourUtc8(now: Date): number;
+export declare function peakHourWindows(rule: CatalogProviderPeakHour): Array<{
+    start_hour: number;
+    end_hour: number;
+}>;
+export declare function isPeakHourForProvider(provider: ProviderId, now: Date, userPolicy?: PeakHourPolicy): boolean;
+/** @deprecated Use isPeakHourForProvider(provider, ...) — window is per-provider from catalog. */
+export declare function isPeakHourUtc8(now: Date, userPolicy: PeakHourPolicy): boolean;
+/**
+ * Adjust a concrete model id for peak-hour policy. No-op outside the provider's
+ * catalog-defined window or when user policy is disabled.
+ */
+export declare function adjustPeakHourModel(modelId: string, opts?: {
+    now?: Date;
+    policy?: PeakHourPolicy;
+}): PeakHourAdjustment;
+/** Tier lookup with peak-hour adjustment applied to the resolved model. */
+export declare function getRoutedModelByTier(tier: "fast" | "balanced" | "premium", preferProvider?: string, opts?: {
+    now?: Date;
+    policy?: PeakHourPolicy;
+}): ModelInfo | undefined;

package/dist/src/router/peak-hour.js

@@ -0,0 +1,107 @@
+import { getModelByTier, getModelInfo, getProviderPeakHourRule, SWITCH_PROVIDER_ORDER } from "../models/registry.js";
+import { detectProviderForModel } from "../providers/runtime.js";
+import { getPeakHourPolicy, isProviderDisabled } from "../utils/settings.js";
+export function hourInTimezone(now, timezone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        hour: "numeric",
+        hour12: false,
+    }).formatToParts(now);
+    const hour = parts.find((p) => p.type === "hour")?.value;
+    return hour ? Number(hour) : 0;
+}
+/** @deprecated Use hourInTimezone — kept for tests referencing UTC+8. */
+export function hourUtc8(now) {
+    return hourInTimezone(now, "Asia/Shanghai");
+}
+export function peakHourWindows(rule) {
+    if (rule.windows?.length)
+        return rule.windows;
+    if (rule.start_hour != null && rule.end_hour != null) {
+        return [{ start_hour: rule.start_hour, end_hour: rule.end_hour }];
+    }
+    return [];
+}
+export function isPeakHourForProvider(provider, now, userPolicy = getPeakHourPolicy()) {
+    if (userPolicy.enabled === false)
+        return false;
+    const rule = getProviderPeakHourRule(provider);
+    if (!rule)
+        return false;
+    const h = hourInTimezone(now, rule.timezone);
+    return peakHourWindows(rule).some((w) => h >= w.start_hour && h < w.end_hour);
+}
+/** @deprecated Use isPeakHourForProvider(provider, ...) — window is per-provider from catalog. */
+export function isPeakHourUtc8(now, userPolicy) {
+    return isPeakHourForProvider("zai", now, userPolicy) || isPeakHourForProvider("deepseek", now, userPolicy);
+}
+function sameProviderDowngrade(modelId, provider) {
+    const rule = getProviderPeakHourRule(provider);
+    if (!rule)
+        return null;
+    if (!rule.sensitive_model_ids.includes(modelId))
+        return null;
+    return rule.fallback_model_id;
+}
+function pickSwitchFallback(excludeProvider) {
+    const rule = getProviderPeakHourRule(excludeProvider);
+    const order = rule?.switch_fallback_providers ?? SWITCH_PROVIDER_ORDER;
+    for (const p of order) {
+        if (p === excludeProvider)
+            continue;
+        if (isProviderDisabled(p))
+            continue;
+        const m = getModelByTier("fast", p) ?? getModelByTier("balanced", p);
+        if (m && m.provider === p)
+            return m;
+    }
+    return undefined;
+}
+/**
+ * Adjust a concrete model id for peak-hour policy. No-op outside the provider's
+ * catalog-defined window or when user policy is disabled.
+ */
+export function adjustPeakHourModel(modelId, opts) {
+    const userPolicy = opts?.policy ?? getPeakHourPolicy();
+    const now = opts?.now ?? new Date();
+    const provider = detectProviderForModel(modelId);
+    if (!isPeakHourForProvider(provider, now, userPolicy)) {
+        return { modelId, provider, adjusted: false };
+    }
+    const downgraded = sameProviderDowngrade(modelId, provider);
+    if (downgraded) {
+        if (userPolicy.mode === "switch") {
+            const alt = pickSwitchFallback(provider);
+            if (alt && alt.id !== modelId) {
+                return {
+                    modelId: alt.id,
+                    provider: alt.provider,
+                    adjusted: true,
+                    reason: `peak-hour(${provider}→${alt.provider}:${alt.id})`,
+                };
+            }
+        }
+        const info = getModelInfo(downgraded);
+        if (info?.provider === provider) {
+            return {
+                modelId: downgraded,
+                provider,
+                adjusted: true,
+                reason: `peak-hour(${modelId}→${downgraded})`,
+            };
+        }
+    }
+    return { modelId, provider, adjusted: false };
+}
+/** Tier lookup with peak-hour adjustment applied to the resolved model. */
+export function getRoutedModelByTier(tier, preferProvider, opts) {
+    const base = getModelByTier(tier, preferProvider);
+    if (!base)
+        return undefined;
+    const adj = adjustPeakHourModel(base.id, opts);
+    if (!adj.adjusted)
+        return base;
+    const info = getModelInfo(adj.modelId);
+    return info ?? base;
+}
+//# sourceMappingURL=peak-hour.js.map

package/dist/src/router/step-router.js

@@ -28,6 +28,7 @@ import { getModelByTier } from "../models/registry.js";
 import { detectProviderForModel } from "../providers/runtime.js";
 import { readTimeoutEnv } from "../utils/ee-logger.js";
 import { isModelDisabled, isProviderDisabled, loadUserSettings } from "../utils/settings.js";
+import { getRoutedModelByTier } from "./peak-hour.js";
 // ─── EE-guided SAMR override ─────────────────────────────────────────────────
 // EE_SAMR_TIMEOUT: per-call budget for consulting the EE brain about SAMR.
 // Default 2s, range 500ms..5s. Falls back to heuristics on timeout/error.
@@ -187,7 +188,7 @@ export function decideStepRouting(phase1ModelId, defaultProvider, config) {
 // ─── Internal helpers ────────────────────────────────────────────────────────
 function resolveExecutionModel(provider, tier, excludeModelId) {
     // Try same provider first
-    const sameProvider = getModelByTier(tier, provider);
+    const sameProvider = getRoutedModelByTier(tier, provider);
     if (sameProvider && sameProvider.id !== excludeModelId) {
         // Guard: check provider-disabled and model-disabled (mirrors cross-provider branch)
         if (!isProviderDisabled(sameProvider.provider) && !isModelDisabled(sameProvider.id)) {
@@ -195,7 +196,7 @@ function resolveExecutionModel(provider, tier, excludeModelId) {
         }
     }
     // If no same-provider model in this tier, try any provider
-    const anyProvider = getModelByTier(tier);
+    const anyProvider = getRoutedModelByTier(tier);
     if (anyProvider && anyProvider.id !== excludeModelId) {
         // Only use cross-provider if the provider and model aren't disabled
         if (!isProviderDisabled(anyProvider.provider) && !isModelDisabled(anyProvider.id)) {

package/dist/src/router/warm.js

@@ -6,13 +6,13 @@
  */
 import { routeModel as bridgeRouteModel } from "../ee/bridge.js";
 import { getDefaultEEClient } from "../ee/intercept.js";
-import { getModelByTier } from "../models/registry.js";
+import { getRoutedModelByTier } from "./peak-hour.js";
 import { PROVIDER_INHERIT } from "./provider-sentinel.js";
 /**
  * Map the session's provider to the EE runtime whose tier ladder the EE serves.
  * EE keys its `getModelTiers()` ladders by agent runtime, not provider, and only
- * the catalog-backed runtimes (claude/codex/gemini) resolve to a non-null model.
- * Providers without an EE runtime (deepseek/siliconflow/xai) map to "" — EE then
+ * the catalog-backed runtimes (claude/codex) resolve to a non-null model.
+ * Providers without an EE runtime (deepseek/xai) map to "" — EE then
  * returns the routing TIER with a null model and we resolve the concrete model
  * from the shared catalog for the session provider. This removes the old
  * hardcoded `runtime:"claude"`, which leaked EE's stale `claude-*` ids into the
@@ -21,7 +21,6 @@ import { PROVIDER_INHERIT } from "./provider-sentinel.js";
 const PROVIDER_TO_EE_RUNTIME = Object.freeze({
     anthropic: "claude",
     openai: "codex",
-    google: "gemini",
 });
 function eeRuntimeForProvider(provider) {
     return (provider && PROVIDER_TO_EE_RUNTIME[provider]) || "";
@@ -36,7 +35,7 @@ export async function callWarmRoute(prompt, opts) {
         // EE returns a model only for catalog-backed runtimes; otherwise resolve the
         // concrete model from the catalog for the session provider + decided tier.
         const catalogTier = TIER_TO_CATALOG_TIER[bridgeResult.tier] ?? "balanced";
-        const model = bridgeResult.model || getModelByTier(catalogTier, opts.defaultProvider)?.id;
+        const model = bridgeResult.model || getRoutedModelByTier(catalogTier, opts.defaultProvider)?.id;
         if (model) {
             return {
                 tier: bridgeResult.tier === "fast" ? "hot" : bridgeResult.tier === "premium" ? "cold" : "warm",

package/dist/src/scaffold/continuation-prompt.d.ts

@@ -10,3 +10,14 @@ export interface ContinuationPromptInput {
     installedPackages?: readonly string[];
 }
 export declare function buildIdealContinuationPrompt(input: ContinuationPromptInput): string;
+export interface AdoptExistingPromptInput {
+    originalPrompt: string;
+    projectDir: string;
+}
+/**
+ * Build the continuation prompt fed to the LLM after the user adopts an EXISTING
+ * project via the CB-3 "Point to existing" recovery option. Unlike the init_new
+ * variant this makes no template/BB assumptions — the target is an arbitrary
+ * repo the user already has, with a verify recipe already detected there.
+ */
+export declare function buildAdoptExistingContinuationPrompt(input: AdoptExistingPromptInput): string;

package/dist/src/scaffold/continuation-prompt.js

@@ -63,4 +63,30 @@ Constraints:
 - Don't ask "do you want me to continue?" — proceed end-to-end.
 - If you hit a blocker that genuinely needs the user, state EXACTLY which decision is blocking and stop.`;
 }
+/**
+ * Build the continuation prompt fed to the LLM after the user adopts an EXISTING
+ * project via the CB-3 "Point to existing" recovery option. Unlike the init_new
+ * variant this makes no template/BB assumptions — the target is an arbitrary
+ * repo the user already has, with a verify recipe already detected there.
+ */
+export function buildAdoptExistingContinuationPrompt(input) {
+    const { originalPrompt, projectDir } = input;
+    return `You are continuing a /ideal product loop in an EXISTING project the user pointed to at ${projectDir}. A verify recipe was detected there, so the project already has a runnable test/build setup — adopt it, do NOT re-scaffold.
+
+User's original request:
+"${originalPrompt}"
+
+Implement this now against the existing codebase. Do NOT ask the user to restate the request.
+
+1. Discover structure (1-2 tool calls max): list the project directory, then read the manifest that exists (package.json / pyproject.toml / go.mod / Cargo.toml / *.csproj) and any README/AGENTS.md to learn the stack, entry point, and conventions. Do NOT assume files — skip whatever is absent.
+2. Design briefly (5-10 lines): the entities/modules/endpoints to add, matching the conventions you observed (naming, error-handling, DI, folder layout).
+3. Implement: create/edit files in the EXISTING layout; mirror the surrounding patterns. Never hardcode secrets or URLs — read config from the project's existing mechanism.
+4. Verify: run the project's OWN detected test/build command; it must pass. Report the exact command + an output excerpt as evidence.
+5. Summarize in 3-5 bullets: what was added, where, and how to run/test it.
+
+Constraints:
+- Your working directory is already ${projectDir}; do NOT cd into it and do NOT re-scaffold.
+- Don't ask "do you want me to continue?" — proceed end-to-end.
+- If a genuine blocker needs the user (missing API key, ambiguous requirement), state EXACTLY which decision is blocking and stop.`;
+}
 //# sourceMappingURL=continuation-prompt.js.map

package/dist/src/scaffold/point-to-existing.d.ts

@@ -5,6 +5,7 @@
  * Designed for testability: callers inject detectVerifyRecipe so unit tests
  * never hit the real orchestrator.
  */
+import type { VerifyRecipe } from "../types/index.js";
 import { detectBBFramework } from "./init-new.js";
 export interface PointToExistingOptions {
     /** Raw path string entered by the user. May be relative or absolute. */
@@ -26,6 +27,26 @@ export interface PointToExistingResult {
     targetFramework?: "muonroi-building-block" | string;
 }
 export { detectBBFramework };
+/**
+ * Deterministic, filesystem-only verify-recipe detection for an existing project
+ * the user pointed to via the CB-3 recovery card.
+ *
+ * WHY NOT the orchestrator's detectVerifyRecipe: that path runs an LLM
+ * verify-detect sub-agent against the orchestrator's OWN (session) cwd via
+ * `this.bash.getCwd()` — it cannot inspect an arbitrary pointed-to directory, so
+ * wiring it here was deferred and the handler stubbed to `null` (point-to-existing
+ * therefore ALWAYS reported "no recipe", making the recovery option inert).
+ * `inferVerifyProjectProfile` reads the target dir's manifest/build files
+ * directly (package.json test/check/lint, Makefile, pyproject, go.mod, cargo,
+ * maven/gradle, *.csproj) — the correct detector for adopting an existing repo.
+ *
+ * Returns the recipe only when it is actually RUNNABLE (has a test/build/start
+ * command). The bare "unknown" fallback that `inferVerifyProjectProfile` emits
+ * for a directory with no recognizable project files carries empty commands →
+ * we return null so point-to-existing correctly reports `no_recipe` instead of
+ * falsely adopting an empty directory.
+ */
+export declare function detectExistingProjectRecipe(cwd: string): VerifyRecipe | null;
 /**
  * Resolve and validate a user-provided path for sprint re-entry.
  *

package/dist/src/scaffold/point-to-existing.js

@@ -7,8 +7,33 @@
  */
 import { realpathSync, statSync } from "node:fs";
 import * as path from "node:path";
+import { inferVerifyProjectProfile } from "../verify/recipes.js";
 import { detectBBFramework } from "./init-new.js";
 export { detectBBFramework };
+/**
+ * Deterministic, filesystem-only verify-recipe detection for an existing project
+ * the user pointed to via the CB-3 recovery card.
+ *
+ * WHY NOT the orchestrator's detectVerifyRecipe: that path runs an LLM
+ * verify-detect sub-agent against the orchestrator's OWN (session) cwd via
+ * `this.bash.getCwd()` — it cannot inspect an arbitrary pointed-to directory, so
+ * wiring it here was deferred and the handler stubbed to `null` (point-to-existing
+ * therefore ALWAYS reported "no recipe", making the recovery option inert).
+ * `inferVerifyProjectProfile` reads the target dir's manifest/build files
+ * directly (package.json test/check/lint, Makefile, pyproject, go.mod, cargo,
+ * maven/gradle, *.csproj) — the correct detector for adopting an existing repo.
+ *
+ * Returns the recipe only when it is actually RUNNABLE (has a test/build/start
+ * command). The bare "unknown" fallback that `inferVerifyProjectProfile` emits
+ * for a directory with no recognizable project files carries empty commands →
+ * we return null so point-to-existing correctly reports `no_recipe` instead of
+ * falsely adopting an empty directory.
+ */
+export function detectExistingProjectRecipe(cwd) {
+    const { recipe } = inferVerifyProjectProfile(cwd);
+    const runnable = recipe.testCommands.length > 0 || recipe.buildCommands.length > 0 || Boolean(recipe.startCommand);
+    return runnable ? recipe : null;
+}
 // ---------------------------------------------------------------------------
 // Implementation
 // ---------------------------------------------------------------------------