@wrongstack/core 0.313.1 → 0.316.2

package/dist/chunk-RTOTNK3P.js

@@ -0,0 +1,484 @@
+import {
+  AGENTS_BY_PHASE,
+  AGENT_CATALOG
+} from "./chunk-FCBTO76Z.js";
+import {
+  fallbackProfileChain
+} from "./chunk-U45AXT5D.js";
+import {
+  parseModelRef
+} from "./chunk-RJIZEJ42.js";
+
+// src/coordination/model-matrix.ts
+var MATRIX_PHASE_KEYS = Object.keys(AGENTS_BY_PHASE);
+var ROLE_TO_PHASE = (() => {
+  const map = {};
+  for (const [phase, defs] of Object.entries(AGENTS_BY_PHASE)) {
+    for (const def of defs) {
+      const role = def.config.role;
+      if (role) map[role] = phase;
+    }
+  }
+  return map;
+})();
+function phaseForRole(role) {
+  return role ? ROLE_TO_PHASE[role] : void 0;
+}
+function resolveModelMatrixResolution(matrix, role) {
+  if (!matrix) return void 0;
+  if (role && matrix[role]) return { entry: matrix[role], source: "role", key: role };
+  const phase = phaseForRole(role);
+  if (phase && matrix[phase]) return { entry: matrix[phase], source: "phase", key: phase };
+  if (matrix["*"]) return { entry: matrix["*"], source: "default", key: "*" };
+  return void 0;
+}
+function resolveModelMatrix(matrix, role) {
+  return resolveModelMatrixResolution(matrix, role)?.entry;
+}
+function resolveModelTargetFromEntry(config, entry) {
+  if (!entry) return void 0;
+  if (entry.model) {
+    return {
+      provider: entry.provider,
+      model: entry.model,
+      modelRuntime: entry.modelRuntime,
+      fallbackProfile: entry.fallbackProfile,
+      fallbackModels: fallbackProfileChain(config, entry.fallbackProfile)
+    };
+  }
+  const chain = fallbackProfileChain(config, entry.fallbackProfile);
+  const first = chain[0];
+  if (!first) {
+    return entry.modelRuntime ? { modelRuntime: entry.modelRuntime } : void 0;
+  }
+  const parsed = parseModelRef(first);
+  return {
+    provider: parsed.provider,
+    model: parsed.model,
+    modelRuntime: entry.modelRuntime,
+    fallbackProfile: entry.fallbackProfile,
+    fallbackModels: chain.slice(1)
+  };
+}
+function roleNeedsIndependentReviewModel(role) {
+  if (!role) return false;
+  return role === "reviewer" || phaseForRole(role) === "review";
+}
+function resolveSubagentModelTarget(config, role, opts = {}) {
+  const resolution = resolveModelMatrixResolution(config.modelMatrix, role);
+  const matrixTarget = resolveModelTargetFromEntry(config, resolution?.entry);
+  const implementationTarget = opts.implementationTarget ?? resolveImplementationModelTarget(config);
+  const isAvailable = (providerId, model) => {
+    if (!opts.statusTracker) return true;
+    if (!providerId || !model) return true;
+    return opts.statusTracker.isAvailable(providerId, model);
+  };
+  const matrixEffective = materializeTarget(config, matrixTarget);
+  const matrixIsAvailable = !matrixEffective || isAvailable(matrixEffective.provider, matrixEffective.model);
+  if (!roleNeedsIndependentReviewModel(role)) {
+    if (!matrixTarget) return void 0;
+    if (!matrixIsAvailable) return void 0;
+    return {
+      ...matrixTarget,
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const matrixRef = materializeTarget(config, matrixTarget);
+  if (resolution?.source === "role" || resolution?.source === "phase") {
+    if (!matrixTarget) return void 0;
+    if (!matrixIsAvailable) return void 0;
+    return {
+      ...matrixTarget,
+      source: "matrix",
+      matrixSource: resolution.source
+    };
+  }
+  if (matrixRef && !sameModelReference(matrixRef, implementationTarget)) {
+    if (!matrixIsAvailable) return void 0;
+    return {
+      ...matrixTarget ?? {},
+      source: "matrix",
+      matrixSource: resolution?.source
+    };
+  }
+  const diverse = chooseDiverseModelTargetWithTracker(
+    config,
+    implementationTarget,
+    opts.statusTracker
+  );
+  if (diverse) {
+    return {
+      provider: diverse.provider,
+      model: diverse.model,
+      modelRuntime: matrixTarget?.modelRuntime,
+      fallbackModels: matrixTarget?.fallbackModels,
+      fallbackProfile: matrixTarget?.fallbackProfile,
+      source: "diversity",
+      matrixSource: resolution?.source,
+      diversified: true
+    };
+  }
+  if (!matrixTarget) return void 0;
+  if (!matrixIsAvailable) return void 0;
+  return {
+    ...matrixTarget,
+    source: "matrix",
+    matrixSource: resolution?.source
+  };
+}
+function resolveImplementationModelTarget(config) {
+  const target = resolveModelTargetFromEntry(
+    config,
+    resolveModelMatrix(config.modelMatrix, "executor")
+  );
+  return materializeTarget(config, target) ?? {
+    provider: config.provider,
+    model: config.model
+  };
+}
+function sameModelReference(a, b) {
+  if (!a?.model || !b?.model) return false;
+  const providerA = a.provider ?? "";
+  const providerB = b.provider ?? "";
+  return providerA === providerB && a.model === b.model;
+}
+function materializeTarget(config, target) {
+  if (!target?.model) return void 0;
+  return {
+    provider: target.provider ?? config.provider,
+    model: target.model
+  };
+}
+function chooseDiverseModelTarget(config, avoid) {
+  const candidates = collectConfiguredModelTargets(config).filter(
+    (candidate) => !sameModelReference(candidate, avoid)
+  );
+  candidates.sort((a, b) => modelDiversityScore(b, avoid) - modelDiversityScore(a, avoid));
+  return candidates[0];
+}
+function chooseDiverseModelTargetWithTracker(config, avoid, tracker) {
+  if (!tracker) return chooseDiverseModelTarget(config, avoid);
+  const ranked = collectConfiguredModelTargets(config).filter((candidate) => !sameModelReference(candidate, avoid)).sort((a, b) => modelDiversityScore(b, avoid) - modelDiversityScore(a, avoid));
+  for (const candidate of ranked) {
+    if (tracker.isAvailable(candidate.provider, candidate.model)) return candidate;
+  }
+  return void 0;
+}
+function collectConfiguredModelTargets(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (provider, model) => {
+    if (!provider || !model) return;
+    const key = `${provider}\0${model}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ provider, model });
+  };
+  add(config.provider, config.model);
+  for (const [providerId, provider] of Object.entries(config.providers ?? {})) {
+    if (!isProviderAvailable(providerId, provider, config.provider)) continue;
+    for (const model of provider.models ?? []) add(providerId, model);
+    for (const model of Object.keys(provider.customModels ?? {})) add(providerId, model);
+  }
+  for (const model of Object.keys(config.models ?? {})) add(config.provider, model);
+  return out;
+}
+function isProviderAvailable(providerId, provider, leaderProvider) {
+  if (providerId === leaderProvider) return true;
+  if (typeof provider.apiKey === "string" && provider.apiKey.length > 0) return true;
+  if (Array.isArray(provider.apiKeys) && provider.apiKeys.some((key) => key?.apiKey)) return true;
+  if (typeof provider.baseUrl === "string" && provider.baseUrl.length > 0) return true;
+  return false;
+}
+function modelDiversityScore(candidate, avoid) {
+  let score = 0;
+  if (candidate.provider !== avoid.provider) score += 100;
+  if (candidate.model !== avoid.model) score += 20;
+  if (/opus|gpt-5|o3|o4|gemini.*pro|deepseek-r1/i.test(candidate.model)) score += 10;
+  if (/mini|haiku|flash/i.test(candidate.model)) score -= 5;
+  return score;
+}
+function matrixKeyKind(key) {
+  if (key === "*") return "default";
+  if (key in AGENT_CATALOG) return "role";
+  if (MATRIX_PHASE_KEYS.includes(key)) return "phase";
+  return "unknown";
+}
+function isValidMatrixKey(key) {
+  return matrixKeyKind(key) !== "unknown";
+}
+
+// src/coordination/model-tier.ts
+var DEFAULT_TIER_ID = "standard";
+function activeTierConfig(config) {
+  const tiers = config.modelTiers;
+  if (tiers?.enabled !== true) return void 0;
+  return tiers;
+}
+function listTierIds(config) {
+  const tiers = activeTierConfig(config);
+  return Object.keys(tiers?.levels ?? {});
+}
+function tierLevel(config, tier) {
+  if (!tier) return void 0;
+  const tiers = activeTierConfig(config);
+  return tiers?.levels?.[tier];
+}
+function isConfiguredTier(config, tier) {
+  return tierLevel(config, tier) !== void 0;
+}
+function classifyTier(config, input = {}) {
+  const tiers = activeTierConfig(config);
+  if (!tiers) return void 0;
+  if (input.tier) {
+    return {
+      tier: input.tier,
+      source: "explicit",
+      configured: isConfiguredTier(config, input.tier)
+    };
+  }
+  const routing = tiers.routing ?? {};
+  const role = input.role;
+  const roleTier = role ? routing[role] : void 0;
+  if (roleTier) {
+    return {
+      tier: roleTier,
+      source: "role",
+      key: role,
+      configured: isConfiguredTier(config, roleTier)
+    };
+  }
+  const phase = phaseForRole(role);
+  const phaseTier = phase ? routing[phase] : void 0;
+  if (phaseTier) {
+    return {
+      tier: phaseTier,
+      source: "phase",
+      key: phase,
+      configured: isConfiguredTier(config, phaseTier)
+    };
+  }
+  const starTier = routing["*"];
+  if (starTier) {
+    return {
+      tier: starTier,
+      source: "default",
+      key: "*",
+      configured: isConfiguredTier(config, starTier)
+    };
+  }
+  const fallbackTier = tiers.default ?? DEFAULT_TIER_ID;
+  return {
+    tier: fallbackTier,
+    source: "config-default",
+    configured: isConfiguredTier(config, fallbackTier)
+  };
+}
+function tierBudget(level) {
+  if (!level) return {};
+  return {
+    ...level.maxCostUsd !== void 0 ? { maxCostUsd: level.maxCostUsd } : {},
+    ...level.maxIterations !== void 0 ? { maxIterations: level.maxIterations } : {},
+    ...level.maxToolCalls !== void 0 ? { maxToolCalls: level.maxToolCalls } : {},
+    ...level.maxTokens !== void 0 ? { maxTokens: level.maxTokens } : {},
+    ...level.timeoutMs !== void 0 ? { timeoutMs: level.timeoutMs } : {}
+  };
+}
+function tierModelTarget(config, level) {
+  if (!level) return void 0;
+  const entry = {
+    ...level.provider !== void 0 ? { provider: level.provider } : {},
+    ...level.model !== void 0 ? { model: level.model } : {},
+    ...level.modelRuntime !== void 0 ? { modelRuntime: level.modelRuntime } : {},
+    ...level.fallbackProfile !== void 0 ? { fallbackProfile: level.fallbackProfile } : {}
+  };
+  return resolveModelTargetFromEntry(config, entry);
+}
+function resolveTier(config, input = {}) {
+  const decision = classifyTier(config, input);
+  if (!decision) return void 0;
+  const level = tierLevel(config, decision.tier);
+  if (!level) return void 0;
+  const target = tierModelTarget(config, level);
+  return {
+    ...target ?? {},
+    tier: decision.tier,
+    source: decision.source,
+    budget: tierBudget(level)
+  };
+}
+var TIGHTENABLE_BUDGETS = ["maxCostUsd", "maxIterations", "maxToolCalls", "maxTokens"];
+function applyTierToSubagentConfig(cfg, resolved) {
+  if (!resolved) return;
+  if (!cfg.model && resolved.model) cfg.model = resolved.model;
+  if (!cfg.provider && resolved.provider) cfg.provider = resolved.provider;
+  if (!cfg.fallbackProfile && resolved.fallbackProfile) {
+    cfg.fallbackProfile = resolved.fallbackProfile;
+  }
+  if (!cfg.fallbackModels?.length && resolved.fallbackModels?.length) {
+    cfg.fallbackModels = [...resolved.fallbackModels];
+  }
+  if (!cfg.modelRuntime && resolved.modelRuntime) cfg.modelRuntime = resolved.modelRuntime;
+  const budget = resolved.budget;
+  const pinned = new Set(cfg.budgetPins ?? []);
+  for (const field of TIGHTENABLE_BUDGETS) {
+    const tierValue = budget[field];
+    if (tierValue === void 0 || pinned.has(field)) continue;
+    const current = cfg[field];
+    cfg[field] = current === void 0 ? tierValue : Math.min(current, tierValue);
+  }
+  if (cfg.timeoutMs === void 0 && budget.timeoutMs !== void 0 && !pinned.has("timeoutMs")) {
+    cfg.timeoutMs = budget.timeoutMs;
+  }
+}
+
+// src/coordination/model-tier-leader.ts
+var DEFAULTS = {
+  mode: "propose",
+  dwellTurns: 6,
+  minSavingsUsd: 0.1,
+  maxContextFillForSwitch: 0.8
+};
+function leaderTierPolicy(config) {
+  const leader = config.modelTiers?.leader ?? {};
+  return {
+    mode: leader.mode ?? DEFAULTS.mode,
+    dwellTurns: leader.dwellTurns ?? DEFAULTS.dwellTurns,
+    minSavingsUsd: leader.minSavingsUsd ?? DEFAULTS.minSavingsUsd,
+    maxContextFillForSwitch: leader.maxContextFillForSwitch ?? DEFAULTS.maxContextFillForSwitch,
+    ...leader.maxTier !== void 0 ? { maxTier: leader.maxTier } : {}
+  };
+}
+function tierRank(config, tier) {
+  if (!tier) return -1;
+  return listTierIds(config).indexOf(tier);
+}
+function evaluateSwitchEconomics(request, projectedTurns) {
+  const mtok = request.contextTokens / 1e6;
+  const { from, to } = request.economics;
+  const fromInput = from.inputPerMTok ?? 0;
+  const toInput = to.inputPerMTok ?? 0;
+  const stayPerTurn = mtok * (from.cacheReadPerMTok ?? fromInput);
+  const switchPerTurn = mtok * (to.cacheReadPerMTok ?? toInput);
+  const reWarm = mtok * (to.cacheWritePerMTok ?? toInput);
+  return {
+    reWarmCostUsd: reWarm,
+    stayCostPerTurnUsd: stayPerTurn,
+    switchCostPerTurnUsd: switchPerTurn,
+    projectedSavingsUsd: (stayPerTurn - switchPerTurn) * projectedTurns - reWarm,
+    isDowngrade: toInput < fromInput
+  };
+}
+function evaluateLeaderTierSwitch(config, request) {
+  const tiers = activeTierConfig(config);
+  if (!tiers) {
+    return { allowed: false, code: "disabled", reason: "The model-tier layer is not enabled." };
+  }
+  const policy = leaderTierPolicy(config);
+  if (policy.mode === "off") {
+    return {
+      allowed: false,
+      code: "disabled",
+      reason: 'Leader tier switching is off (modelTiers.leader.mode = "off").'
+    };
+  }
+  if (request.toTier === request.fromTier) {
+    return {
+      allowed: false,
+      code: "same-tier",
+      reason: `Already running at tier "${request.toTier}".`
+    };
+  }
+  const targetRank = tierRank(config, request.toTier);
+  if (targetRank < 0) {
+    const available = listTierIds(config);
+    return {
+      allowed: false,
+      code: "unknown-tier",
+      reason: `"${request.toTier}" is not a configured tier${available.length ? ` (available: ${available.join(", ")})` : ""}.`
+    };
+  }
+  if (policy.maxTier !== void 0) {
+    const ceiling = tierRank(config, policy.maxTier);
+    if (ceiling >= 0 && targetRank > ceiling) {
+      return {
+        allowed: false,
+        code: "ceiling",
+        reason: `Tier "${request.toTier}" is above the configured ceiling "${policy.maxTier}". Raising spend past the ceiling is the user\u2019s call, not the leader\u2019s.`
+      };
+    }
+  }
+  if (request.turnsSinceSwitch < policy.dwellTurns) {
+    return {
+      allowed: false,
+      code: "dwell",
+      reason: `Only ${request.turnsSinceSwitch} turn(s) since the last tier switch; ${policy.dwellTurns} required. Switching more often than this busts the prompt cache faster than a new tier can pay for itself.`
+    };
+  }
+  const targetWindow = request.economics.to.maxContext;
+  if (targetWindow && targetWindow > 0) {
+    const fill = request.contextTokens / targetWindow;
+    if (fill > policy.maxContextFillForSwitch) {
+      return {
+        allowed: false,
+        code: "context-window",
+        reason: `Context is ${Math.round(fill * 100)}% of the target model's ${targetWindow}-token window (limit ${Math.round(policy.maxContextFillForSwitch * 100)}%). Compact first, then retry the switch.`
+      };
+    }
+  }
+  const projectedTurns = request.projectedTurns ?? policy.dwellTurns;
+  const economics = evaluateSwitchEconomics(request, projectedTurns);
+  const pricingKnown = request.economics.from.inputPerMTok !== void 0 || request.economics.to.inputPerMTok !== void 0;
+  if (pricingKnown && economics.isDowngrade && economics.projectedSavingsUsd < policy.minSavingsUsd) {
+    return {
+      allowed: false,
+      code: "not-worth-it",
+      economics,
+      reason: `Projected saving $${economics.projectedSavingsUsd.toFixed(4)} over ${projectedTurns} turn(s) is below the $${policy.minSavingsUsd.toFixed(4)} floor once the $${economics.reWarmCostUsd.toFixed(4)} cache re-warm is paid for.`
+    };
+  }
+  if (!pricingKnown) {
+    return {
+      allowed: true,
+      mode: policy.mode === "auto" ? "auto" : "propose",
+      economics,
+      reason: `No published pricing for either model, so the switch to "${request.toTier}" was judged on the structural guards alone (dwell, context window, ceiling).`
+    };
+  }
+  return {
+    allowed: true,
+    mode: policy.mode === "auto" ? "auto" : "propose",
+    economics,
+    reason: economics.isDowngrade ? `Downgrade to "${request.toTier}" saves about $${economics.projectedSavingsUsd.toFixed(4)} over ${projectedTurns} turn(s) after a $${economics.reWarmCostUsd.toFixed(4)} re-warm.` : `Upgrade to "${request.toTier}" costs about $${(-economics.projectedSavingsUsd).toFixed(4)} over ${projectedTurns} turn(s), including a $${economics.reWarmCostUsd.toFixed(4)} re-warm.`
+  };
+}
+
+export {
+  MATRIX_PHASE_KEYS,
+  phaseForRole,
+  resolveModelMatrixResolution,
+  resolveModelMatrix,
+  resolveModelTargetFromEntry,
+  roleNeedsIndependentReviewModel,
+  resolveSubagentModelTarget,
+  resolveImplementationModelTarget,
+  sameModelReference,
+  matrixKeyKind,
+  isValidMatrixKey,
+  DEFAULT_TIER_ID,
+  activeTierConfig,
+  listTierIds,
+  tierLevel,
+  isConfiguredTier,
+  classifyTier,
+  tierBudget,
+  tierModelTarget,
+  resolveTier,
+  applyTierToSubagentConfig,
+  leaderTierPolicy,
+  tierRank,
+  evaluateSwitchEconomics,
+  evaluateLeaderTierSwitch
+};
+//# sourceMappingURL=chunk-RTOTNK3P.js.map

package/dist/{chunk-SN2DQRL6.js → chunk-RXKSDUAU.js}

@@ -6,25 +6,25 @@ import {
 } from "./chunk-XEBHSJLT.js";
 import {
   atomicWrite
-} from "./chunk-7ZHZE5EO.js";
+} from "./chunk-OSGLYW5J.js";
 import {
   isValidSkillNameFormat,
   parseSkillFrontmatter,
   validateSkillName
-} from "./chunk-WEBMSQP2.js";
+} from "./chunk-FC2ZGRF3.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
 import {
   ERROR_CODES,
   FetchError,
   FsError,
   ParseError,
   WrongStackError
-} from "./chunk-WOEZV3Q4.js";
+} from "./chunk-25LSLC3G.js";
 import {
   toErrorMessage
 } from "./chunk-TBRL2RCC.js";
-import {
-  expectDefined
-} from "./chunk-PFZO3C6H.js";
 
 // src/skills/registry/github-direct-adapter.ts
 var githubDirectAdapter = {
@@ -1169,4 +1169,4 @@ export {
   SkillManifestStore,
   SkillInstaller
 };
-//# sourceMappingURL=chunk-SN2DQRL6.js.map
+//# sourceMappingURL=chunk-RXKSDUAU.js.map