@wrongstack/core 0.306.3 → 0.306.4

package/dist/tools/index.js

@@ -2024,6 +2024,12 @@ function normalizeModelRef(ref, defaultProvider) {
 function hasText(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
+function asRefList(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function asProfileName(value) {
+  return hasText(value) ? value : void 0;
+}
 function providerHasKey(entry) {
   if (!entry) return false;
   if (hasText(entry.apiKey)) return true;
@@ -2034,7 +2040,7 @@ function providerHasKey(entry) {
 }
 function visibleProviderModels(config, providerId, providerModels) {
   const entry = config.providers?.[providerId];
-  return entry?.models !== void 0 ? [...entry.models] : providerModels;
+  return Array.isArray(entry?.models) ? [...entry.models] : providerModels;
 }
 function buildProfiles(config) {
   const entries = /* @__PURE__ */ new Map();
@@ -2071,13 +2077,34 @@ var FallbackProfileManager = class {
   listProfiles() {
     return Object.freeze([...this.profiles.keys()]);
   }
+  /**
+   * The profile the session has selected (`config.fallbackProfile`, set by
+   * `/fallback profile use <name>`), or undefined when none is selected or the
+   * name no longer resolves to a defined profile.
+   *
+   * Consulted by every resolution entry point when the caller does not name a
+   * profile itself. Without this the leader — which passes no profile — could
+   * never use a named profile at all: `config.fallbackProfiles` was reachable
+   * only by copying a chain into `fallbackModels`.
+   */
+  activeProfileName() {
+    const name = asProfileName(this.config.fallbackProfile);
+    return name && this.profiles.has(name) ? name : void 0;
+  }
   // ── Resolution ─────────────────────────────────────────────────────────
   /**
    * Resolve a named fallback profile to a validated, provider-filtered chain.
    *
-   * Returns an empty chain when:
-   * - The profile doesn't exist.
-   * - Every entry's provider is missing, has no key, or has no matching model.
+   * Returns an empty chain when the profile doesn't exist, or when every entry
+   * is excluded, quarantined, or blacked out.
+   *
+   * Filtering is intentionally identical to {@link resolveRefs} (the explicit
+   * `fallbackModels` path): the self-exclusion, the runtime status tracker,
+   * and the availability calendar — nothing else. Anything a named profile
+   * drops, an explicit chain drops too, and vice versa. Profiles used to apply
+   * two extra filters (provider "usability" and the `providers[].models`
+   * snapshot) that the explicit path did not, which silently rerouted roles
+   * pinned to a profile onto a different model than the one configured.
    *
    * @param name - Profile name from config.fallbackProfiles.
    * @param defaultProvider - Used when an entry has no explicit provider.
@@ -2098,13 +2125,9 @@ var FallbackProfileManager = class {
       if (seen.has(key)) continue;
       seen.add(key);
       if (excludeKey && key === excludeKey) continue;
-      const health = this.checkProvider(providerId);
-      if (!health.usable) continue;
       if (this.statusTracker && !this.statusTracker.isAvailable(providerId, parsed.model)) continue;
       if (!evaluateModelCalendar(this.config.modelAvailabilitySchedule, providerId, parsed.model).allowed)
         continue;
-      const allowedModels = this.config.providers?.[providerId]?.models;
-      if (allowedModels && !allowedModels.includes(parsed.model)) continue;
       resolved.push({
         providerId,
         model: parsed.model,
@@ -2122,12 +2145,14 @@ var FallbackProfileManager = class {
   resolveEffective(opts = {}) {
     const bridge = this.resolveBridge(opts.exclude);
     let selected = FREEZER_EMPTY;
-    if (opts.fallbackModels && opts.fallbackModels.length > 0) {
-      const resolved = this.resolveRefs(opts.fallbackModels, opts.exclude);
+    const explicitRefs = asRefList(opts.fallbackModels);
+    const profileName = asProfileName(opts.fallbackProfile) ?? this.activeProfileName();
+    if (explicitRefs && explicitRefs.length > 0) {
+      const resolved = this.resolveRefs(explicitRefs, opts.exclude);
       if (resolved.length > 0) selected = resolved;
     }
-    if (selected.length === 0 && opts.fallbackProfile) {
-      const resolved = this.resolve(opts.fallbackProfile, { exclude: opts.exclude });
+    if (selected.length === 0 && profileName) {
+      const resolved = this.resolve(profileName, { exclude: opts.exclude });
       if (resolved.length > 0) selected = resolved;
     }
     if (selected.length === 0 && opts.fallbackAuto !== false) {
@@ -2203,13 +2228,14 @@ var FallbackProfileManager = class {
     };
     const configFallbackAuto = this.config.fallbackAuto;
     const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
-    const explicitRefs = opts.fallbackModels ?? this.config.fallbackModels;
+    const explicitRefs = asRefList(opts.fallbackModels) ?? asRefList(this.config.fallbackModels);
+    const profileName = asProfileName(opts.fallbackProfile) ?? this.activeProfileName();
     const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && this.resolveRefs(explicitRefs, current).length > 0;
-    const profileUsable = opts.fallbackProfile !== void 0 && this.hasProfile(opts.fallbackProfile) && this.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
+    const profileUsable = profileName !== void 0 && this.hasProfile(profileName) && this.resolve(profileName, { exclude: current }).length > 0;
     const fromExplicitSource = explicitUsable || profileUsable;
-    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? this.resolve(opts.fallbackProfile, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
+    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : profileName ? this.resolve(profileName, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
       fallbackModels: explicitRefs,
-      fallbackProfile: opts.fallbackProfile,
+      fallbackProfile: profileName,
       fallbackAuto: effectiveFallbackAuto,
       exclude: current
     });
@@ -2226,7 +2252,7 @@ var FallbackProfileManager = class {
         });
       }
       candidates.push(...selectedChain);
-      if (!fromExplicitSource && effectiveFallbackAuto && opts.fallbackProfile !== "default") {
+      if (!fromExplicitSource && effectiveFallbackAuto && profileName !== "default") {
         candidates.push(...this.resolve("default", { exclude: current }));
       }
       if (!fromExplicitSource && effectiveFallbackAuto) {
@@ -2304,7 +2330,7 @@ var FallbackProfileManager = class {
     const leaderModel = this.config.model;
     const providers = this.config.providers ?? {};
     const favoriteSet = new Set(
-      (this.config.favoriteModels ?? []).map((ref) => {
+      (asRefList(this.config.favoriteModels) ?? []).map((ref) => {
         const p = parseModelRef(ref);
         return `${p.provider ?? leaderProvider}/${p.model}`;
       })
@@ -7478,6 +7504,30 @@ var PROVIDER_MANAGE_SCHEMA = {
   required: ["action"],
   additionalProperties: false
 };
+var CREDENTIAL_SELECTOR_FIELDS = ["apiKey", "apiKeys", "activeKey", "envVars"];
+function envVarsClaimedByOtherProviders(providers, exceptProvider) {
+  const claimed = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(providers)) {
+    if (id === exceptProvider) continue;
+    const names = entry?.["envVars"];
+    if (!Array.isArray(names)) continue;
+    for (const name of names) {
+      if (typeof name === "string" && !claimed.has(name)) claimed.set(name, id);
+    }
+  }
+  return claimed;
+}
+function rejectBorrowedEnvVars(providers, provider, requested) {
+  if (!requested) return null;
+  const claimed = envVarsClaimedByOtherProviders(providers, provider);
+  for (const name of requested) {
+    const owner = typeof name === "string" ? claimed.get(name) : void 0;
+    if (owner !== void 0) {
+      return `Environment variable "${String(name)}" already supplies the key for provider "${owner}". Reading another provider's credential from "${provider}" is not allowed; use provider_key_set to give "${provider}" its own key.`;
+    }
+  }
+  return null;
+}
 function validateProviderBaseUrl(raw) {
   let url;
   try {
@@ -7548,6 +7598,8 @@ ${msg}`,
           const invalid = validateProviderBaseUrl(input.baseUrl);
           if (invalid) return { status: "error", message: invalid };
         }
+        const borrowed = rejectBorrowedEnvVars(providers, input.provider, input.envVars);
+        if (borrowed) return { status: "error", message: borrowed };
         const entry = { type: input.type };
         if (input.models) entry.models = input.models;
         if (input.baseUrl) entry.baseUrl = input.baseUrl;
@@ -7581,14 +7633,22 @@ ${msg}`,
         if (input.autoDiscoverModels !== void 0) entry.autoDiscoverModels = input.autoDiscoverModels;
         if (input.apiKey !== void 0) entry.apiKey = input.apiKey || void 0;
         const endpointChanged = input.baseUrl !== void 0 && (entry.baseUrl ?? void 0) !== (previous.baseUrl ?? void 0);
-        const keyDropped = endpointChanged && input.apiKey === void 0 && previous.apiKey !== void 0;
-        if (keyDropped) entry.apiKey = void 0;
+        const explicitlySupplied = /* @__PURE__ */ new Set([
+          ...input.apiKey !== void 0 ? ["apiKey"] : [],
+          ...input.envVars !== void 0 ? ["envVars"] : []
+        ]);
+        const droppedFields = endpointChanged ? CREDENTIAL_SELECTOR_FIELDS.filter(
+          (field) => !explicitlySupplied.has(field) && previous[field] !== void 0
+        ) : [];
+        for (const field of droppedFields) entry[field] = void 0;
+        const borrowed = rejectBorrowedEnvVars(providers, input.provider, input.envVars);
+        if (borrowed) return { status: "error", message: borrowed };
         providers[input.provider] = entry;
         await opts.updateConfig((cfg) => {
           cfg.providers = providers;
         });
         const updated = Object.keys({ ...entry }).filter((k) => k !== "apiKey").join(", ");
-        const keyNote = keyDropped ? " \u2014 stored API key cleared because the base URL changed; set it again with provider_key_set" : "";
+        const keyNote = droppedFields.length > 0 ? ` \u2014 cleared ${droppedFields.join(", ")} because the base URL changed; set the key again with provider_key_set` : "";
         return { status: "ok", message: `\u2713 Updated ${input.provider}: ${updated}${keyNote}` };
       }
       if (input.action === "remove") {
@@ -9494,6 +9554,7 @@ export {
   createMcpControlTool,
   createMcpUseTool,
   createOneShotLLMTool,
-  createPluginManagerTool
+  createPluginManagerTool,
+  validateProviderBaseUrl
 };
 //# sourceMappingURL=index.js.map

package/dist/types/config/root.d.ts

@@ -115,6 +115,20 @@ export interface Config {
      * model by `/setmodel`, while the whole ordered list is used for failover.
      */
     fallbackProfiles?: Record<string, string[]> | undefined;
+    /**
+     * The named profile from {@link Config.fallbackProfiles} currently selected
+     * for failover, set by `/fallback profile use <name>` and cleared by
+     * `/fallback profile none`.
+     *
+     * Resolution order is `fallbackModels` → this profile → smart default, so an
+     * explicit chain still wins. Selecting a profile does NOT overwrite
+     * `fallbackModels`: before this field existed, `profile use` was implemented
+     * by copying the profile's entries over the explicit chain, which destroyed
+     * whatever the user had configured and left no way back.
+     *
+     * A name that no longer matches a defined profile is ignored.
+     */
+    fallbackProfile?: string | undefined;
     /**
      * When `true` (the default) and `fallbackModels` is empty, a fallback chain
      * is derived automatically from the other keyed providers/models so 429s

package/dist/types/session.d.ts

@@ -594,6 +594,13 @@ export interface SessionStore {
      * Returns the refreshed summary. Throws if the session does not exist.
      */
     rename(id: string, name: string): Promise<SessionSummary>;
+    /**
+     * Return true only when the persisted journal is strictly readable and
+     * contains lifecycle envelope events but no messages or other session content.
+     * Implementations should fail closed (false) for malformed or unknown events.
+     * Optional stores that cannot make this guarantee must omit the method.
+     */
+    isEmpty?(id: string): Promise<boolean>;
     delete(id: string): Promise<void>;
     /**
      * Rewrite the session JSONL file to contain only a fresh session_start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/core",
-  "version": "0.306.3",
+  "version": "0.306.4",
   "license": "MIT",
   "description": "WrongStack core: kernel, types, defaults, and shared utilities for the WrongStack CLI agent.",
   "repository": {
@@ -177,8 +177,8 @@
   "wrongstackApiVersion": "0.1.10",
   "dependencies": {
     "zod": "4.4.3",
-    "@wrongstack/persistence": "0.306.3",
-    "@wrongstack/kanban": "0.306.3"
+    "@wrongstack/kanban": "0.306.4",
+    "@wrongstack/persistence": "0.306.4"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",