@wrongstack/core 0.306.3 → 0.306.4

package/dist/coordination/index.js

@@ -8328,6 +8328,24 @@ import { dirname as dirname5 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 
 // src/security/secret-scrubber.ts
+var JSON_CREDENTIAL_KEY_ANCHORS = [
+  'Key"',
+  'key"',
+  'KEY"',
+  'token"',
+  'Token"',
+  'TOKEN"',
+  'secret"',
+  'Secret"',
+  'SECRET"',
+  'password"',
+  'Password"',
+  'PASSWORD"',
+  'authorization"',
+  'Authorization"',
+  'bearer"',
+  'Bearer"'
+];
 var PATTERNS = [
   // Anchored at the start where possible so partial matches inside larger
   // strings don't trigger false positives.
@@ -8430,6 +8448,30 @@ var PATTERNS = [
     regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
     anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD"]
   },
+  {
+    type: "json_credential_key",
+    // The JSON counterpart to `high_entropy_env`, and the pattern that the
+    // now-deleted `JSON_KEY_ANCHORS` list was written for. Without it those
+    // anchors only widened the cheap pre-scan — `hasCredentialAnchors` said
+    // "this text may hold a secret", every pattern then declined to match, and
+    // the value went out verbatim. `high_entropy_env` cannot cover these: it
+    // requires an UPPERCASE unquoted key (`API_KEY=…`), so `{"apiKey":"…"}`
+    // never matched.
+    //
+    // Tool results are routinely serialised as JSON, and a credential with no
+    // recognisable prefix (Azure, self-hosted gateways, Anthropic/Codex OAuth)
+    // has no other pattern that can catch it — this is the only thing standing
+    // between such a value and the session JSONL, chronicle, HQ broadcast and
+    // the model's own context.
+    //
+    // The key may carry a prefix (`"anthropicApiKey"`), but the credential word
+    // must END the key: `"tokenCount"` and `"maxTokens"` do not match, because
+    // the closing quote has to follow the word immediately.
+    // Value floor of 8 chars keeps enum-ish values (`"authorization":"none"`)
+    // out. Capture groups: 1=key + punctuation, 2=value, 3=closing quote.
+    regex: /("[A-Za-z0-9_]*(?:apiKey|api_key|token|secret|password|authorization|bearer|private_key|access_token|refresh_token|client_secret)"\s*:\s*")([^"\\]{8,512})(")/gi,
+    anchor: JSON_CREDENTIAL_KEY_ANCHORS
+  },
   // ── Ported from packages/plugins credential-patterns.ts (WS-034) ─────────
   // The plugin runtime carried 37 patterns while this scrubber — the one that
   // guards session JSONL, chronicle, HQ broadcast, WebUI events and the auth
@@ -8512,9 +8554,12 @@ var PATTERNS = [
     anchor: "GOCSPX-"
   }
 ];
-var SIMPLE_PATTERNS = PATTERNS.filter((p) => p.type !== "high_entropy_env");
+var SIMPLE_PATTERNS = PATTERNS.filter(
+  (p) => p.type !== "high_entropy_env" && p.type !== "json_credential_key"
+);
 var COMBINED_REGEX = new RegExp(SIMPLE_PATTERNS.map((p) => `(${p.regex.source})`).join("|"), "g");
 var HIGH_ENTROPY_REGEX = PATTERNS.find((p) => p.type === "high_entropy_env").regex;
+var JSON_CREDENTIAL_REGEX = PATTERNS.find((p) => p.type === "json_credential_key").regex;
 var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 var SCRUB_OVERLAP_BYTES = 1024;
@@ -8525,20 +8570,7 @@ var PATTERN_ANCHORS = [
     )
   )
 ];
-var JSON_KEY_ANCHORS = [
-  '"apiKey"',
-  '"api_key"',
-  '"token"',
-  '"secret"',
-  '"password"',
-  '"authorization"',
-  '"bearer"',
-  '"private_key"',
-  '"access_token"',
-  '"refresh_token"',
-  '"client_secret"'
-];
-var ALL_ANCHORS = [...PATTERN_ANCHORS, ...JSON_KEY_ANCHORS];
+var ALL_ANCHORS = PATTERN_ANCHORS;
 function hasCredentialAnchors(text) {
   for (const anchor of ALL_ANCHORS) {
     if (text.includes(anchor)) return true;
@@ -8587,6 +8619,9 @@ var DefaultSecretScrubber = class {
     out = out.replace(HIGH_ENTROPY_REGEX, (_match, lead, key, _value) => {
       return `${lead}${key}=[REDACTED:high_entropy_env]`;
     });
+    out = out.replace(JSON_CREDENTIAL_REGEX, (_match, keyPrefix, _value, closingQuote) => {
+      return `${keyPrefix}[REDACTED:json_credential_key]${closingQuote}`;
+    });
     return out;
   }
   /**
@@ -17102,9 +17137,40 @@ async function readOrBuildShardManifestEntry(opts) {
   return entry;
 }
 
-// src/storage/session-store/summary-builder.ts
+// src/storage/session-store/strict-empty-check.ts
 import { createReadStream as createReadStream4 } from "node:fs";
 import { createInterface as createInterface4 } from "node:readline";
+var EMPTY_SESSION_EVENT_TYPES = /* @__PURE__ */ new Set(["session_start", "session_resumed", "session_end"]);
+async function isStrictlyEmptySessionFile(file) {
+  const input = createReadStream4(file, { encoding: "utf8" });
+  const lines = createInterface4({ input, crlfDelay: Infinity });
+  let sawSessionStart = false;
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return false;
+      }
+      if (event === null || typeof event !== "object" || Array.isArray(event)) return false;
+      const type = event.type;
+      if (typeof type !== "string" || !EMPTY_SESSION_EVENT_TYPES.has(type)) return false;
+      if (type === "session_start") sawSessionStart = true;
+    }
+  } catch {
+    return false;
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+  return sawSessionStart;
+}
+
+// src/storage/session-store/summary-builder.ts
+import { createReadStream as createReadStream5 } from "node:fs";
+import { createInterface as createInterface5 } from "node:readline";
 async function summarizeSessionFile(opts) {
   return summarizeSessionEventSequence({
     id: opts.id,
@@ -17221,8 +17287,8 @@ async function summarizeSessionEventSequence(opts) {
   }
 }
 async function* iterateSessionEvents(file, secretScrubber) {
-  const stream = createReadStream4(file, { encoding: "utf8" });
-  const lines = createInterface4({ input: stream, crlfDelay: Infinity });
+  const stream = createReadStream5(file, { encoding: "utf8" });
+  const lines = createInterface5({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of lines) {
       if (!line.trim()) continue;
@@ -18118,6 +18184,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     await deleteSessionArtifacts({ rootDir: this.dir, id, jsonlPath });
     await this.writeTombstone(id);
   }
+  async isEmpty(id) {
+    const canonicalId = await this.resolveId(id);
+    return isStrictlyEmptySessionFile(this.sessionPath(canonicalId, ".jsonl"));
+  }
   async delete(id) {
     if (this.catalogClient) {
       const canonical = await this.resolveId(id);
@@ -18681,6 +18751,12 @@ function parseModelRef(ref) {
 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;
@@ -18691,7 +18767,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();
@@ -18728,13 +18804,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.
@@ -18755,13 +18852,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,
@@ -18779,12 +18872,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) {
@@ -18860,13 +18955,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
     });
@@ -18883,7 +18979,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) {
@@ -18961,7 +19057,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}`;
       })
@@ -27720,10 +27816,10 @@ var AdaptiveConcurrencyController = class {
 };
 
 // src/coordination/agent-monitor.ts
-import { createReadStream as createReadStream5 } from "node:fs";
+import { createReadStream as createReadStream6 } from "node:fs";
 import * as fs6 from "node:fs/promises";
 import * as path38 from "node:path";
-import { createInterface as createInterface5 } from "node:readline";
+import { createInterface as createInterface6 } from "node:readline";
 var AgentMonitorService = class _AgentMonitorService {
   _fleetBus;
   _events;
@@ -27830,8 +27926,8 @@ var AgentMonitorService = class _AgentMonitorService {
     const accessible = await fs6.access(file).then(() => true).catch(() => false);
     if (!accessible) return [];
     const out = [];
-    const input = createReadStream5(file, { encoding: "utf8" });
-    const lines = createInterface5({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    const input = createReadStream6(file, { encoding: "utf8" });
+    const lines = createInterface6({ input, crlfDelay: Number.POSITIVE_INFINITY });
     try {
       for await (const line of lines) {
         const trimmed = line.trim();

package/dist/coordination/mail-tools.d.ts

@@ -75,12 +75,12 @@ export declare function makeMailSendTool(opts?: MailToolsOptions): {
         required: string[];
     };
     execute(input: unknown, ctx: Context): Promise<{
+        summary?: never;
         ok: boolean;
         error: string;
         messageId?: never;
         from?: never;
         to?: never;
-        summary?: never;
     } | {
         error?: never;
         ok: boolean;

package/dist/core/conversation-state.d.ts

@@ -1,7 +1,6 @@
 import type { ContentBlock } from '../types/blocks.js';
 import type { Message } from '../types/messages.js';
-import type { TodoItem } from './context.js';
-import { Context } from './context.js';
+import type { Context, TodoItem } from './context.js';
 /**
  * Observable wrapper for mutable conversation state. Production code should
  * mutate messages, todos, and meta through this API so subscribers see a

package/dist/core/fallback-model.d.ts

@@ -143,9 +143,27 @@ export declare function fallbackProfileChain(config: Config, profileName: string
 export declare function smartDefaultFallbackChain(config: Config): string[];
 /**
  * The effective fallback chain for a turn: the explicit `fallbackModels` list
- * when non-empty, otherwise the smart default (unless `fallbackAuto` is off).
+ * when non-empty, otherwise the selected profile, otherwise the smart default
+ * (unless `fallbackAuto` is off).
+ *
+ * NOTE: this is the SELECTED chain, not the full runtime order — it omits the
+ * bridge, the primary re-insertion, the extra `default`-profile depth and the
+ * last-resort sweep that {@link runtimeFallbackChain} adds. Use
+ * `runtimeFallbackChain` for anything shown to a user as "what will be tried".
  */
 export declare function effectiveFallbackChain(config: Config): string[];
+/**
+ * The chain the agent loop will ACTUALLY rotate through, in order, if the
+ * current primary fails right now — the same `resolveCandidates` call the
+ * fallback extension makes, including bridge, primary re-insertion, the
+ * `default`-profile depth and the last-resort sweep.
+ *
+ * `/fallback` used to render `effectiveFallbackChain` instead, so the
+ * displayed chain could be four entries while the runtime rotated through
+ * seventeen — the view was structurally unable to match the behavior it
+ * claimed to describe.
+ */
+export declare function runtimeFallbackChain(config: Config): string[];
 /**
  * Build the cross-provider fallback extension. Always returns an extension —
  * the effective chain (`effectiveFallbackChain`) is recomputed every turn from

package/dist/core/fallback-profile-manager.d.ts

@@ -59,12 +59,30 @@ export declare class FallbackProfileManager {
     setStatusTracker(tracker: ProviderModelStatusTracker | undefined): void;
     hasProfile(name: string): boolean;
     listProfiles(): readonly string[];
+    /**
+     * 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(): string | undefined;
     /**
      * 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.

package/dist/core/index.d.ts

@@ -4,7 +4,7 @@ export { buildBtwBlock, consumeBtwNotes, pendingBtwCount, setBtwNote, } from './
 export { Context, type ContextInit, type ProviderMemoryEvidence, type RunOptions, type TodoItem, } from './context.js';
 export { type ContinuationInput, type ContinuationSource, detectContinueIntent, type ResolvedContinuation, resolveContinuation, } from './continue-intent.js';
 export { ConversationState, type ReadonlyConversationState, type StateChange, type StateChangeHandler, wrapAsState, } from './conversation-state.js';
-export { createFallbackModelExtension, effectiveFallbackChain, type FallbackGateFn, type FallbackModelDeps, fallbackProfileChain, smartDefaultFallbackChain, } from './fallback-model.js';
+export { createFallbackModelExtension, effectiveFallbackChain, type FallbackGateFn, type FallbackModelDeps, fallbackProfileChain, runtimeFallbackChain, smartDefaultFallbackChain, } from './fallback-model.js';
 export { FallbackProfileManager } from './fallback-profile-manager.js';
 export { InputBuilder, type InputBuilderEvent, type InputBuilderOptions, } from './input-builder.js';
 export { type InstructionBundle, type InstructionBundlePaths, loadInstructionBundle, type SystemInstructionVariant, } from './instruction-bundle.js';