@cohortapp/agent-sdk 2.3.0

package/lib/model-router/economics.mjs

@@ -0,0 +1,564 @@
+/**
+ * lib/model-router/economics.mjs — the router ECONOMICS layer (SPEC §8 + §6.4/§6.5).
+ *
+ * Five pure, role-agnostic cost levers that bolt onto the resolveChain substrate
+ * (resolve.mjs + catalog.mjs + ledger.mjs) WITHOUT re-routing a live session —
+ * routing happens at dispatch/spawn time only, never mid-session (cache prefixes
+ * are model-scoped; a mid-session switch silently re-bills the entire prefix, G8).
+ *
+ *   1. budgetLadder(spentUSD, capUSD) -> { band:0|75|90|100, degrade }
+ *      A LADDER, not a cliff (§6.4):
+ *        <75%  → policy as written
+ *        ≥75%  → prefer cheaper tiers (downgrade one rung)
+ *        ≥90%  → cheap-only + batch deferrable
+ *        100%  → essential-only (still answers inbox DMs)
+ *
+ *   2. degradeChain(chain, band) — a resolveChain `opts` hook that TIGHTENS a
+ *      candidate chain per band (drops/reorders refs). Subordinate to the gates
+ *      that resolve.mjs already applies; this only narrows the candidate set.
+ *
+ *   3. batchLaneFor(request) -> bool — deferrable task_classes (learning.*,
+ *      digests, indexing, curation) route to the batch API (-50%).
+ *
+ *   4. cacheAffinity — pin(sessionKey, ref, ttl) / lookupPin(sessionKey),
+ *      keyed on the conversation-resolver `session_key`, TTL = lane cache_ttl.
+ *      Subordinate to governance/breakers: a pin that a breaker or band-100 state
+ *      forces off emits a `pin_overridden` audit event (§4.9 / graft #16).
+ *
+ *   5. spawnKnobsFor(task_class) -> { maxTurns, effort, agentsJson } — defaults;
+ *      `agentsJson` is the cheap-subagent map (Haiku-Explore), the SANCTIONED
+ *      intra-session cost lever (§6.5 rule 2 / graft #13).
+ *
+ * House style (lib/cadence-bus.mjs, lib/model-router/ledger.mjs, lib/rate-guard.mjs):
+ * ESM .mjs, Node 20, near-zero-dep. Everything injectable (`deps.now`,
+ * `deps.store`, `deps.affinityFile`, `deps.audit`). The pure levers NEVER throw;
+ * the affinity store's write path degrades silently rather than crashing a spawn.
+ * The band/degrade levers are pure functions of their inputs.
+ *
+ * @module lib/model-router/economics
+ */
+
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve as resolvePath } from "node:path";
+
+import { writeJsonAtomic, appendJsonl } from "../fs-atomic.mjs";
+
+// ---------------------------------------------------------------------------
+// Budget ladder — a ladder, not a cliff (§6.4)
+// ---------------------------------------------------------------------------
+
+/**
+ * The economics bands. Note these are the ladder's ECONOMIC bands (0/75/90/100),
+ * deliberately coarser than budget-guard's notification bands ([50,75,90,100]):
+ * 50% is a "you're halfway" notice, not a routing change — the first DEGRADATION
+ * happens at 75% (§4.2 budget_ladder). budgetLadder collapses 50% back to band 0
+ * so a caller cannot accidentally degrade routing on a mere halfway notice.
+ */
+export const LADDER_BANDS = Object.freeze([0, 75, 90, 100]);
+
+/** Map a spend percentage onto an economics band. */
+function ladderBandForPct(pct) {
+  if (pct >= 100) return 100;
+  if (pct >= 90) return 90;
+  if (pct >= 75) return 75;
+  return 0;
+}
+
+/**
+ * Compute the budget degradation for the day's spend. PURE. NEVER throws.
+ *
+ * `degrade` is the structured instruction the resolver / dispatcher consume:
+ *   - band 0   → { preferCheaper:false, cheapOnly:false, batchDeferrable:false,
+ *                  essentialOnly:false, downgradeTiers:0 }
+ *   - band 75  → preferCheaper (downgrade one tier)
+ *   - band 90  → cheapOnly + batchDeferrable (defer batch-eligible work)
+ *   - band 100 → essentialOnly (inbox DMs answered on the cheapest qualifying
+ *                row; everything else DEFER)
+ *
+ * @param {number} spentUSD  today's spend (>= 0)
+ * @param {number} capUSD    the daily cap (> 0; <= 0 ⇒ no cap ⇒ band 0)
+ * @returns {{ band:0|75|90|100, pct:number, spentUSD:number, capUSD:number,
+ *             degrade:{ preferCheaper:boolean, cheapOnly:boolean,
+ *                       batchDeferrable:boolean, essentialOnly:boolean,
+ *                       downgradeTiers:number } }}
+ */
+export function budgetLadder(spentUSD, capUSD) {
+  const spent = numOr0(spentUSD);
+  const cap = Number(capUSD);
+  const hasCap = Number.isFinite(cap) && cap > 0;
+  const pct = hasCap ? round2((spent / cap) * 100) : 0;
+  const band = hasCap ? ladderBandForPct(pct) : 0;
+
+  const degrade = {
+    preferCheaper: band >= 75,
+    cheapOnly: band >= 90,
+    batchDeferrable: band >= 90,
+    essentialOnly: band >= 100,
+    // band 75 downgrades one tier; band 90+ collapses to cheap/fast directly
+    // (degradeChain drops the frontier/default head), so the tier count is the
+    // explain-string figure rather than a second knob.
+    downgradeTiers: band >= 90 ? 99 : band >= 75 ? 1 : 0,
+  };
+
+  return { band, pct, spentUSD: round6(spent), capUSD: hasCap ? cap : 0, degrade };
+}
+
+// ---------------------------------------------------------------------------
+// degradeChain — the resolveChain opts hook (tighten a chain per band)
+// ---------------------------------------------------------------------------
+
+// Tier order, cheapest last. A chain member is recognised as a tier by its alias
+// (the resolveChain alias vocabulary) OR by a literal ref whose model id contains
+// a tier hint. The hook is alias-first: resolveChain tags each chain member with
+// the alias it came from.
+const TIER_ORDER = ["frontier", "default", "fast", "cheap"];
+const TIER_RANK = Object.freeze({ frontier: 0, default: 1, fast: 2, cheap: 3 });
+
+// Heuristic tier inference from a literal ref when no alias tag is present. Keeps
+// degradeChain useful for chains built from raw "provider/model" refs.
+function inferTier(member) {
+  const alias = typeof member === "object" && member ? member.alias : null;
+  if (alias && TIER_RANK[alias] != null) return alias;
+  const ref = String((member && member.ref) || member || "").toLowerCase();
+  if (ref.includes("opus")) return "frontier";
+  if (ref.includes("sonnet")) return "default";
+  if (ref.includes("haiku") || ref.includes("flash") || ref.includes("mini")) return "fast";
+  if (ref.includes("cheap") || ref.includes("deepseek") || ref.includes("kimi") || ref.includes("glm") || ref.includes("qwen")) return "cheap";
+  return null;
+}
+
+/**
+ * Tighten a resolved candidate chain for a budget band. PURE. NEVER throws.
+ *
+ * Contract (the `band` argument is the economics band from budgetLadder):
+ *   - band  < 75 → the chain is returned unchanged.
+ *   - band ≥ 75  → each tier-tagged member is downgraded ONE rung toward cheap
+ *                  (frontier→default→fast→cheap); the rest pass through. The
+ *                  resulting chain is de-duplicated, preserving order.
+ *   - band ≥ 90  → frontier+default head members are DROPPED entirely (cheap/fast
+ *                  only); a chain that would empty out keeps its cheapest member
+ *                  so the caller always has at least one candidate.
+ *   - `exempt` (pin or critical) → unchanged at any band below 100.
+ *
+ * Members are `{ ref, alias?, ... }` (resolveChain's chain shape) or bare ref
+ * strings. The returned members keep their original shape, only `ref`/`alias`
+ * shift on a downgrade. A `rules`/sentinel member is always preserved as a tail.
+ *
+ * @param {Array<object|string>} chain   resolved chain (alias-tagged members)
+ * @param {0|75|90|100} band
+ * @param {object} [opts]
+ *   @param {boolean} [opts.exempt]   pin / critical — bypass degradation
+ *   @param {Record<string,string>} [opts.aliases]  alias → ref, for retargeting a
+ *                                    downgraded member to the cheaper alias's ref
+ * @returns {Array<object|string>} the tightened chain
+ */
+export function degradeChain(chain, band, opts = {}) {
+  const members = Array.isArray(chain) ? chain : [];
+  if (!members.length) return members;
+  const b = Number(band) || 0;
+  if (b < 75 || opts.exempt) return members.slice();
+
+  const aliases = (opts && opts.aliases && typeof opts.aliases === "object") ? opts.aliases : {};
+
+  const isSentinel = (m) =>
+    (typeof m === "object" && m && (m.isRules || m.ref === "rules")) ||
+    m === "rules";
+
+  if (b >= 90) {
+    // cheap/fast only — drop the frontier/default head.
+    const kept = members.filter((m) => {
+      if (isSentinel(m)) return true;
+      const tier = inferTier(m);
+      return tier == null || TIER_RANK[tier] >= TIER_RANK.fast;
+    });
+    if (kept.length) return dedupeByRef(kept);
+    // Everything was frontier/default: keep the single cheapest as a safety net.
+    const cheapest = members
+      .filter((m) => !isSentinel(m))
+      .sort((a, z) => (TIER_RANK[inferTier(z)] ?? -1) - (TIER_RANK[inferTier(a)] ?? -1))[0];
+    return cheapest ? [cheapest] : members.slice();
+  }
+
+  // band >= 75: downgrade each tier-tagged member one rung.
+  const next = members.map((m) => {
+    if (isSentinel(m)) return m;
+    const tier = inferTier(m);
+    if (tier == null) return m;
+    const i = TIER_RANK[tier];
+    const downAlias = TIER_ORDER[Math.min(TIER_ORDER.length - 1, i + 1)];
+    if (downAlias === tier) return m; // already cheapest
+    // Retarget to the cheaper alias's ref when the caller supplied the alias map.
+    if (typeof m === "object" && m) {
+      const ref = aliases[downAlias] || m.ref;
+      return { ...m, ref, alias: downAlias };
+    }
+    return aliases[downAlias] || m;
+  });
+  return dedupeByRef(next);
+}
+
+function dedupeByRef(members) {
+  const seen = new Set();
+  const out = [];
+  for (const m of members) {
+    const ref = typeof m === "object" && m ? m.ref : m;
+    const key = String(ref);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(m);
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// batchLaneFor — deferrable task classes → batch API (-50%)
+// ---------------------------------------------------------------------------
+
+// Deferrable task-class prefixes: nothing a human is waiting on in real time.
+// learning.* (reflect/curate), digests, indexing, curation, capture, enrich.
+const DEFERRABLE_PREFIXES = Object.freeze([
+  "learning",          // learning.reflect / learning.curate
+  "digest",            // cost-rollup / fleet digests
+  "index",             // session indexing
+  "curate",            // skill / knowledge curation
+  "capture",           // collective capture
+  "enrich",            // setup enrichment
+  "rollup",            // org rollups
+]);
+
+// Explicitly NON-deferrable task classes even if a prefix matched: anything in
+// the live conversational / inbox path.
+const REALTIME_TASK_CLASSES = Object.freeze(new Set([
+  "session.responder",
+  "classify.inbox",
+  "huddle",
+  "voice.brief",
+]));
+
+/**
+ * Decide whether a request is BATCH-deferrable (eligible for the -50% batch API).
+ * PURE. NEVER throws.
+ *
+ * Rules, in order:
+ *   1. an explicit `lane` wins — `lane:"batch"` ⇒ true, `lane:"realtime"` ⇒ false.
+ *   2. a realtime-class task (inbox, session, huddle, voice) ⇒ false regardless.
+ *   3. a deferrable prefix (learning/digest/index/curate/capture/enrich/rollup)
+ *      AND not high priority ⇒ true.
+ *   4. otherwise ⇒ false (default to realtime; never silently defer user work).
+ *
+ * @param {object} request  RouteRequest (task_class, lane, priority)
+ * @returns {boolean}
+ */
+export function batchLaneFor(request = {}) {
+  const lane = request.lane;
+  if (lane === "batch") return true;
+  if (lane === "realtime") return false;
+
+  const tc = typeof request.task_class === "string" ? request.task_class : "";
+  if (REALTIME_TASK_CLASSES.has(tc)) return false;
+
+  // critical/high priority never defers, even a learning task escalated by hand.
+  const prio = request.priority;
+  if (prio === "critical" || prio === "high") return false;
+
+  const head = tc.split(".")[0];
+  return DEFERRABLE_PREFIXES.includes(head);
+}
+
+// ---------------------------------------------------------------------------
+// cacheAffinity — session_key → pinned ref, TTL = lane cache_ttl (§4.9, graft #16)
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a lane cache_ttl string ("1h", "5m", "30s", "0") to milliseconds.
+ * Unknown / falsy → the 1h default; "0" / "none" → 0 (no pin). PURE.
+ */
+export function ttlMs(ttl) {
+  if (ttl == null) return 3600_000;
+  if (typeof ttl === "number") return ttl > 0 ? ttl : 0;
+  const s = String(ttl).trim().toLowerCase();
+  if (s === "0" || s === "none" || s === "") return 0;
+  const m = s.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?$/);
+  if (!m) return 3600_000;
+  const n = Number(m[1]);
+  const unit = m[2] || "ms";
+  const mult = { ms: 1, s: 1000, m: 60_000, h: 3600_000, d: 86_400_000 }[unit];
+  return Math.round(n * mult);
+}
+
+function affinityFile(deps = {}) {
+  if (deps.affinityFile) return resolvePath(deps.affinityFile);
+  const root =
+    deps.agentRoot || process.env.AGENT_ROOT || process.env.AGENT_DIR || process.cwd();
+  return join(resolvePath(root), "state", "model-router", "affinity.json");
+}
+
+function auditFile(deps = {}) {
+  if (deps.auditFile) return resolvePath(deps.auditFile);
+  const root =
+    deps.agentRoot || process.env.AGENT_ROOT || process.env.AGENT_DIR || process.cwd();
+  return join(resolvePath(root), "logs", "audit", "routing.jsonl");
+}
+
+/**
+ * Hash a session_key so the on-disk affinity map carries no raw conversation
+ * identifiers (no PII; §4.9 keys on `sha256(session_key)`). PURE.
+ */
+export function hashSessionKey(sessionKey) {
+  return createHash("sha256").update(String(sessionKey || "")).digest("hex");
+}
+
+function readStore(deps) {
+  // An injected in-memory store (deps.store: a plain object) bypasses the FS so
+  // tests are hermetic and the daemon can keep one map hot.
+  if (deps && deps.store && typeof deps.store === "object") return deps.store;
+  const file = affinityFile(deps);
+  if (!existsSync(file)) return {};
+  try {
+    const obj = JSON.parse(readFileSync(file, "utf-8"));
+    return obj && typeof obj === "object" ? obj : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeStore(store, deps) {
+  if (deps && deps.store && typeof deps.store === "object") {
+    // Mutate the injected store in place (the caller owns persistence).
+    return true;
+  }
+  try {
+    writeJsonAtomic(affinityFile(deps), store);
+    return true;
+  } catch {
+    return false; // best-effort: a pin we can't persist degrades to no-pin
+  }
+}
+
+function nowMs(deps) {
+  return (deps && typeof deps.now === "function" ? deps.now : Date.now)();
+}
+
+/**
+ * Pin a session_key to a catalog ref for `ttl`. Subsequent threaded follow-ups
+ * resolve sticky to the same model so the conversation's cache survives. NEVER
+ * throws; a write failure returns `{ pinned:false }`.
+ *
+ * @param {string} sessionKey   conversation-resolver session_key
+ * @param {string} ref          "provider/model" the decision chose
+ * @param {string|number} ttl   lane cache_ttl ("1h"/"5m") or ms
+ * @param {object} [deps]  { now, store, affinityFile, agentRoot, decisionId }
+ * @returns {{ pinned:boolean, expires_at:number, key:string }}
+ */
+export function pin(sessionKey, ref, ttl, deps = {}) {
+  const key = hashSessionKey(sessionKey);
+  const span = ttlMs(ttl);
+  if (!sessionKey || !ref || span <= 0) {
+    return { pinned: false, expires_at: 0, key };
+  }
+  const now = nowMs(deps);
+  const store = readStore(deps);
+  store[key] = {
+    ref: String(ref),
+    decision_id: deps.decisionId || null,
+    expires_at: now + span,
+  };
+  const ok = writeStore(store, deps);
+  return { pinned: ok, expires_at: store[key].expires_at, key };
+}
+
+/**
+ * Look up a live (non-expired) pin for a session_key. NEVER throws. An expired
+ * entry is treated as absent (and pruned on the next write). Returns null when
+ * there is no live pin.
+ *
+ * @param {string} sessionKey
+ * @param {object} [deps]  { now, store, affinityFile, agentRoot }
+ * @returns {{ ref:string, decision_id:string|null, expires_at:number }|null}
+ */
+export function lookupPin(sessionKey, deps = {}) {
+  if (!sessionKey) return null;
+  const key = hashSessionKey(sessionKey);
+  const store = readStore(deps);
+  const entry = store[key];
+  if (!entry || typeof entry !== "object") return null;
+  const now = nowMs(deps);
+  if (!(entry.expires_at > now)) return null; // expired or malformed
+  return { ref: entry.ref, decision_id: entry.decision_id ?? null, expires_at: entry.expires_at };
+}
+
+/**
+ * Resolve a pin against governance: a live pin is honored ONLY when it still
+ * passes the caller-supplied gate (breaker closed, data-class ok, band < 100).
+ * A pin a breaker / governance / band-100 state forces off is DROPPED and a
+ * `pin_overridden` audit event is emitted (§4.9 / graft #16). NEVER throws.
+ *
+ * The gate is injected so this stays decoupled from resolve.mjs's internals: the
+ * caller passes `gate(ref) -> { ok:boolean, reason?:string }` (e.g. wrapping the
+ * breaker probe + band check).
+ *
+ * @param {string} sessionKey
+ * @param {(ref:string)=>{ok:boolean, reason?:string}} gate
+ * @param {object} [deps]  { now, store, affinityFile, agentRoot, auditFile,
+ *                           audit (injected sink fn), decisionId }
+ * @returns {{ ref:string|null, overridden:boolean, reason:string|null }}
+ */
+export function resolvePin(sessionKey, gate, deps = {}) {
+  const live = lookupPin(sessionKey, deps);
+  if (!live) return { ref: null, overridden: false, reason: null };
+
+  let verdict = { ok: true };
+  if (typeof gate === "function") {
+    try {
+      verdict = gate(live.ref) || { ok: true };
+    } catch {
+      verdict = { ok: false, reason: "gate_error" };
+    }
+  }
+
+  if (verdict.ok) {
+    return { ref: live.ref, overridden: false, reason: null };
+  }
+
+  // Pin forced off — emit the audit event and report the override.
+  emitPinOverridden(sessionKey, live, verdict.reason || "governance", deps);
+  return { ref: null, overridden: true, reason: verdict.reason || "governance" };
+}
+
+function emitPinOverridden(sessionKey, live, reason, deps) {
+  const row = {
+    kind: "pin_overridden",
+    ts: new Date(nowMs(deps)).toISOString(),
+    session_key_hash: hashSessionKey(sessionKey),
+    ref: live.ref,
+    decision_id: live.decision_id ?? deps.decisionId ?? null,
+    reason,
+  };
+  // An injected audit sink wins (the daemon owns logs/audit/routing.jsonl);
+  // otherwise append to the on-disk audit log, best-effort.
+  if (deps && typeof deps.audit === "function") {
+    try {
+      deps.audit(row);
+    } catch {
+      /* audit is best-effort */
+    }
+    return;
+  }
+  appendJsonl(auditFile(deps), row);
+}
+
+// ---------------------------------------------------------------------------
+// spawnKnobsFor — per-task-class spawn defaults incl. the cheap-subagent map
+// ---------------------------------------------------------------------------
+
+// The cheap-subagent map (`--agents <json>`): the SANCTIONED intra-session cost
+// lever (§6.5 rule 2 / graft #13). A heavy session keeps its own (cached) main
+// loop on the resolved model but farms cheap fan-out work (file exploration,
+// grep, summarisation) to a Haiku-Explore subagent so the main loop's cache
+// survives. The shape mirrors Claude Code's `--agents` JSON (name → { model,
+// description }).
+const HAIKU_EXPLORE = Object.freeze({
+  "Haiku-Explore": {
+    model: "claude-haiku-4-5",
+    description:
+      "Cheap fan-out: file exploration, grep/search, bulk read + summarise. Returns findings, never takes actions.",
+  },
+});
+
+// Per-task-class spawn knob defaults. maxTurns mirrors resolve.mjs's ceilings;
+// `effort` is null unless a task class genuinely wants deep thinking; `agentsJson`
+// attaches the cheap-subagent map to the EXPENSIVE, tool-heavy session classes
+// (the ones that benefit from offloading fan-out), and stays null for one-shot /
+// cheap classes where a subagent would only add overhead.
+const SPAWN_KNOBS = Object.freeze({
+  "session.responder": { maxTurns: 40, effort: null, agentsJson: HAIKU_EXPLORE },
+  "classify.inbox":    { maxTurns: 1,  effort: null, agentsJson: null },
+  lookup:              { maxTurns: 2,  effort: null, agentsJson: null },
+  enrich:              { maxTurns: 3,  effort: null, agentsJson: null },
+  "voice.brief":       { maxTurns: 4,  effort: null, agentsJson: null },
+  huddle:              { maxTurns: 8,  effort: null, agentsJson: HAIKU_EXPLORE },
+  "learning.reflect":  { maxTurns: 6,  effort: "medium", agentsJson: null },
+  "learning.curate":   { maxTurns: 6,  effort: null, agentsJson: null },
+  capture:             { maxTurns: 2,  effort: null, agentsJson: null },
+  "cadence":           { maxTurns: 20, effort: null, agentsJson: HAIKU_EXPLORE },
+});
+
+const DEFAULT_KNOBS = Object.freeze({ maxTurns: 40, effort: null, agentsJson: null });
+
+/**
+ * Default spawn knobs for a task class. PURE. NEVER throws. Resolves an exact
+ * task_class match first, then the dotted prefix (e.g. "lookup.gmail" → "lookup",
+ * "cadence.daily-digest" → "cadence"), then a generic ceiling. The returned
+ * `agentsJson` is a fresh shallow clone so a caller can mutate it safely.
+ *
+ * @param {string} taskClass
+ * @returns {{ maxTurns:number, effort:string|null, agentsJson:object|null }}
+ */
+export function spawnKnobsFor(taskClass) {
+  const tc = typeof taskClass === "string" ? taskClass : "";
+  let knobs = SPAWN_KNOBS[tc];
+  if (!knobs) {
+    const head = tc.split(".")[0];
+    knobs = SPAWN_KNOBS[head];
+  }
+  knobs = knobs || DEFAULT_KNOBS;
+  return {
+    maxTurns: knobs.maxTurns,
+    effort: knobs.effort,
+    // Deep clone the cheap-subagent map so a caller can mutate it (e.g. swap the
+    // explore model) without corrupting the shared module constant.
+    agentsJson: knobs.agentsJson ? cloneAgents(knobs.agentsJson) : null,
+  };
+}
+
+function cloneAgents(map) {
+  const out = {};
+  for (const [name, def] of Object.entries(map)) {
+    out[name] = def && typeof def === "object" ? { ...def } : def;
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Small numeric helpers (mirror ledger.mjs)
+// ---------------------------------------------------------------------------
+
+function numOr0(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+function round2(n) {
+  return Number(Number(n).toFixed(2));
+}
+function round6(n) {
+  return Number(Number(n).toFixed(6));
+}
+
+export const _internals = {
+  ladderBandForPct,
+  inferTier,
+  dedupeByRef,
+  TIER_ORDER,
+  TIER_RANK,
+  DEFERRABLE_PREFIXES,
+  REALTIME_TASK_CLASSES,
+  HAIKU_EXPLORE,
+  SPAWN_KNOBS,
+  affinityFile,
+  auditFile,
+  readStore,
+};
+
+export default {
+  budgetLadder,
+  degradeChain,
+  batchLaneFor,
+  pin,
+  lookupPin,
+  resolvePin,
+  spawnKnobsFor,
+  ttlMs,
+  hashSessionKey,
+  LADDER_BANDS,
+};