synabun 2.0.5 → 2.0.9

package/neural-interface/lib/assistant-budget.js

@@ -1,19 +1,22 @@
 // ═══════════════════════════════════════════
-// SynaBun — Assistant budgets (caps · list prices · Codex usage)
+// SynaBun — Assistant budget (the one setting · list prices · Codex usage)
 // ═══════════════════════════════════════════
 //
-// The money rails of the central assistant, in one place:
+// One setting for every Assistant session: { unlimited, amountUsd, version }.
+// It lives in assistant-config.json under `budget` and is read live. Every new
+// session starts with it; a change applies to the open sessions at once.
 //
-//   defaultRunUsd   per-run cap a dispatch gets when the brain names none
-//   maxRunUsd       largest per-run cap a brain may ask for (budget_usd)
-//   sessionWarnUsd  one warning to the brain and the user at this session spend
-//   sessionHardUsd  session spend (brain + every run) that stops everything
-//   brainUsd        the central brain's own spend in one session
+//   unlimited false  the session may spend `amountUsd` (brain + every run, at
+//                    list price). The warning is fixed at 80 %; at 100 % the
+//                    session stops. assistant-budget-split.js divides what is
+//                    left across the providers (Jev or a fixed heuristic).
+//   unlimited true   No limit: no caps, no shares, no Jev call. Spend is still
+//                    metered.
 //
-// They live where the dispatcher and the runtime always read them, so a hand
-// edit keeps working: `limits.defaultBudgetUsd`, `limits.maxBudgetUsd`,
-// `limits.sessionWarnUsd` (older files: 80 % of `limits.sessionSoftBudgetUsd`),
-// `limits.sessionHardBudgetUsd`, `brains.claude.maxBudgetUsd`.
+// Older files kept five caps in `limits` (default/largest per run, session
+// warning, session hard cap) and `brains.claude.maxBudgetUsd`. They are read
+// once (migrateBudget): the session hard cap becomes the amount, the rest is
+// dropped.
 //
 // Prices: Claude and OpenCode report what a turn cost. Codex reports tokens
 // only, so its runs are priced from the list-price table (assistant-pricing.js,
@@ -28,17 +31,15 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { PRICING_SOURCES, PRICING_VERIFIED, listPrice, pricingRows } from './assistant-pricing.js';
 
-export const BUDGET_FIELDS = Object.freeze(['defaultRunUsd', 'maxRunUsd', 'sessionWarnUsd', 'sessionHardUsd', 'brainUsd']);
-export const BUDGET_DEFAULTS = Object.freeze({ defaultRunUsd: 5, maxRunUsd: 25, sessionWarnUsd: 8, sessionHardUsd: 25, brainUsd: 10 });
 export const BUDGET_MIN_USD = 0.1;
 export const BUDGET_MAX_USD = 1000;
-export const BUDGET_LABELS = Object.freeze({
-  defaultRunUsd: 'Default per-run cap',
-  maxRunUsd: 'Largest per-run cap',
-  sessionWarnUsd: 'Session warning',
-  sessionHardUsd: 'Session hard cap',
-  brainUsd: 'Brain cap',
-});
+export const BUDGET_DEFAULT_USD = 25;
+/** The one warning comes at this share of the budget. */
+export const BUDGET_WARN_RATIO = 0.8;
+export const BUDGET_FIELDS = Object.freeze(['unlimited', 'amountUsd']);
+export const BUDGET_DEFAULTS = Object.freeze({ unlimited: false, amountUsd: BUDGET_DEFAULT_USD });
+/** The keys of the old five-cap budget (`limits.*`, `brains.claude.maxBudgetUsd`), dropped by the migration. */
+export const LEGACY_LIMIT_KEYS = Object.freeze(['defaultBudgetUsd', 'maxBudgetUsd', 'sessionWarnUsd', 'sessionSoftBudgetUsd', 'sessionHardBudgetUsd', 'budgetVersion', 'budgetUpdatedAt']);
 
 function num(value) {
   if (value === null || value === undefined || value === '' || typeof value === 'boolean') return null;
@@ -47,6 +48,8 @@ function num(value) {
 }
 function obj(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
 export function roundUsd(value) { return Math.round(Number(value) * 100) / 100; }
+/** Whole cents, never more than `value` (a budget never rounds up). */
+export function floorCents(value) { return Math.max(0, Math.floor(Number(value) * 100 + 1e-6)); }
 
 function budgetError(field, message) {
   const error = new Error(message);
@@ -55,109 +58,105 @@ function budgetError(field, message) {
   error.status = 400;
   return error;
 }
+const inRange = (n) => n !== null && n >= BUDGET_MIN_USD && n <= BUDGET_MAX_USD;
 
-/** The raw values a config file holds (null = not set). */
-export function storedBudget(raw = {}) {
+/** Whether a config file still carries the old five-cap budget and no `budget` of its own. */
+export function needsBudgetMigration(raw = {}) {
+  if (raw?.budget && typeof raw.budget === 'object' && !Array.isArray(raw.budget)) return false;
   const limits = obj(raw?.limits);
-  const soft = num(limits.sessionSoftBudgetUsd);
-  const warn = num(limits.sessionWarnUsd);
-  return {
-    defaultRunUsd: num(limits.defaultBudgetUsd),
-    maxRunUsd: num(limits.maxBudgetUsd),
-    sessionWarnUsd: warn ?? (soft !== null ? roundUsd(soft * 0.8) : null),
-    sessionHardUsd: num(limits.sessionHardBudgetUsd),
-    brainUsd: num(obj(obj(raw?.brains).claude).maxBudgetUsd),
-  };
+  return LEGACY_LIMIT_KEYS.some((key) => Object.hasOwn(limits, key)) || Object.hasOwn(obj(obj(raw?.brains).claude), 'maxBudgetUsd');
 }
 
 /**
- * The invariant that fails first, or null: default ≤ largest ≤ hard,
- * warning < hard, brain ≤ hard.
+ * The budget a config file holds: its `budget` when it has one, else what an
+ * older file says (the saved session hard cap, else the default).
+ * → { unlimited, amountUsd, version, updatedAt, source: 'saved' | 'migrated' | 'default' }
  */
-export function budgetInvariantError(b) {
-  if (b.maxRunUsd > b.sessionHardUsd) return { field: 'maxRunUsd', message: `${BUDGET_LABELS.maxRunUsd} ($${b.maxRunUsd}) cannot exceed the ${BUDGET_LABELS.sessionHardUsd.toLowerCase()} ($${b.sessionHardUsd}).` };
-  if (b.defaultRunUsd > b.maxRunUsd) return { field: 'defaultRunUsd', message: `${BUDGET_LABELS.defaultRunUsd} ($${b.defaultRunUsd}) cannot exceed the ${BUDGET_LABELS.maxRunUsd.toLowerCase()} ($${b.maxRunUsd}).` };
-  if (b.sessionWarnUsd >= b.sessionHardUsd) return { field: 'sessionWarnUsd', message: `${BUDGET_LABELS.sessionWarnUsd} ($${b.sessionWarnUsd}) must be below the ${BUDGET_LABELS.sessionHardUsd.toLowerCase()} ($${b.sessionHardUsd}).` };
-  if (b.brainUsd > b.sessionHardUsd) return { field: 'brainUsd', message: `${BUDGET_LABELS.brainUsd} ($${b.brainUsd}) cannot exceed the ${BUDGET_LABELS.sessionHardUsd.toLowerCase()} ($${b.sessionHardUsd}).` };
-  return null;
+export function effectiveBudget(raw = {}) {
+  const stored = raw?.budget && typeof raw.budget === 'object' && !Array.isArray(raw.budget) ? raw.budget : null;
+  if (stored) {
+    const amount = num(stored.amountUsd);
+    return {
+      unlimited: stored.unlimited === true,
+      amountUsd: inRange(amount) ? roundUsd(amount) : BUDGET_DEFAULT_USD,
+      version: Math.max(0, Math.floor(num(stored.version) || 0)),
+      updatedAt: typeof stored.updatedAt === 'string' ? stored.updatedAt : null,
+      source: 'saved',
+    };
+  }
+  const limits = obj(raw?.limits);
+  const hard = num(limits.sessionHardBudgetUsd);
+  const migrated = needsBudgetMigration(raw);
+  return {
+    unlimited: false,
+    // The saved session hard cap is the amount (a hand edit outside the bounds is brought inside them).
+    amountUsd: hard !== null && hard > 0 ? roundUsd(Math.min(BUDGET_MAX_USD, Math.max(BUDGET_MIN_USD, hard))) : BUDGET_DEFAULT_USD,
+    version: Math.max(0, Math.floor(num(limits.budgetVersion) || 0)),
+    updatedAt: typeof limits.budgetUpdatedAt === 'string' ? limits.budgetUpdatedAt : null,
+    source: migrated ? 'migrated' : 'default',
+  };
 }
 
-/**
- * What applies now: each saved value in range, else its default; a hand edit
- * that breaks an invariant is repaired (and listed in `repairs`), never trusted.
- */
-export function effectiveBudget(raw = {}) {
-  const stored = storedBudget(raw);
-  const out = {};
-  const sources = {};
-  for (const field of BUDGET_FIELDS) {
-    const value = stored[field];
-    const ok = value !== null && value >= BUDGET_MIN_USD && value <= BUDGET_MAX_USD;
-    out[field] = ok ? roundUsd(value) : BUDGET_DEFAULTS[field];
-    sources[field] = !ok ? 'default' : (field === 'sessionWarnUsd' && num(obj(raw?.limits).sessionWarnUsd) === null ? 'legacy' : 'saved');
+/** A config object without the old five-cap keys (every other key kept). */
+export function withoutLegacyBudget(raw = {}) {
+  const base = { ...obj(raw) };
+  if (base.limits && typeof base.limits === 'object') {
+    const limits = { ...base.limits };
+    for (const key of LEGACY_LIMIT_KEYS) delete limits[key];
+    base.limits = limits;
   }
-  const repairs = [];
-  for (let guard = 0; guard < BUDGET_FIELDS.length; guard += 1) {
-    const broken = budgetInvariantError(out);
-    if (!broken) break;
-    repairs.push(broken.field);
-    if (broken.field === 'maxRunUsd') out.maxRunUsd = out.sessionHardUsd;
-    else if (broken.field === 'defaultRunUsd') out.defaultRunUsd = out.maxRunUsd;
-    else if (broken.field === 'sessionWarnUsd') out.sessionWarnUsd = roundUsd(out.sessionHardUsd * 0.8);
-    else if (broken.field === 'brainUsd') out.brainUsd = out.sessionHardUsd;
+  const brains = obj(base.brains);
+  if (brains.claude && typeof brains.claude === 'object' && Object.hasOwn(brains.claude, 'maxBudgetUsd')) {
+    const { maxBudgetUsd: _cap, ...claude } = brains.claude;
+    base.brains = { ...brains, claude };
   }
-  return { ...out, sources, repairs };
+  return base;
 }
 
 /**
- * Validate a patch against the current values and return the full next set.
- * `null` resets a field to its default. Throws BUDGET_INVALID (status 400,
- * `field`) on a bad value or a broken invariant.
+ * Validate a patch ({ unlimited?, amountUsd? }) against the current budget and
+ * return the full next one. Throws BUDGET_INVALID (status 400, `field`) on an
+ * unknown field, a bad value or an empty patch. Amounts are kept in cents.
  */
 export function validateBudgetPatch(patch = {}, current = BUDGET_DEFAULTS) {
   if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw budgetError('budget', 'budget must be an object');
-  const next = {};
-  for (const field of BUDGET_FIELDS) next[field] = num(current?.[field]) ?? BUDGET_DEFAULTS[field];
+  const next = { unlimited: current?.unlimited === true, amountUsd: inRange(num(current?.amountUsd)) ? roundUsd(current.amountUsd) : BUDGET_DEFAULT_USD };
+  let changed = 0;
   for (const [field, value] of Object.entries(patch)) {
-    if (!BUDGET_FIELDS.includes(field)) throw budgetError(field, `Unknown budget field "${field}"`);
-    if (value === null) { next[field] = BUDGET_DEFAULTS[field]; continue; }
+    if (!BUDGET_FIELDS.includes(field)) throw budgetError(field, `Unknown budget field "${field}". Send unlimited and/or amountUsd.`);
+    changed += 1;
+    if (field === 'unlimited') {
+      if (typeof value !== 'boolean') throw budgetError('unlimited', 'unlimited must be true or false');
+      next.unlimited = value;
+      continue;
+    }
     const n = typeof value === 'number' || (typeof value === 'string' && value.trim() !== '') ? Number(value) : NaN;
-    if (!Number.isFinite(n)) throw budgetError(field, `${BUDGET_LABELS[field]} must be an amount in US dollars`);
-    if (n < BUDGET_MIN_USD || n > BUDGET_MAX_USD) throw budgetError(field, `${BUDGET_LABELS[field]} must be between $${BUDGET_MIN_USD.toFixed(2)} and $${BUDGET_MAX_USD}`);
-    next[field] = roundUsd(n);
+    if (!Number.isFinite(n)) throw budgetError('amountUsd', 'The budget must be an amount in US dollars');
+    if (n < BUDGET_MIN_USD || n > BUDGET_MAX_USD) throw budgetError('amountUsd', `The budget must be between $${BUDGET_MIN_USD.toFixed(2)} and $${BUDGET_MAX_USD}`);
+    next.amountUsd = roundUsd(n);
   }
-  const broken = budgetInvariantError(next);
-  if (broken) throw budgetError(broken.field, broken.message);
+  if (!changed) throw budgetError('budget', 'Nothing to change: send unlimited and/or amountUsd');
   return next;
 }
 
-/** A config object with `budget` written into the keys its readers use (every other key kept). */
+/** A config object with `budget` written (the old caps dropped, every other key kept). */
 export function writeBudgetInto(raw = {}, budget, { version = 0, at = new Date().toISOString() } = {}) {
-  const base = obj(raw);
-  const brains = obj(base.brains);
   return {
-    ...base,
-    limits: {
-      ...obj(base.limits),
-      defaultBudgetUsd: budget.defaultRunUsd,
-      maxBudgetUsd: budget.maxRunUsd,
-      sessionWarnUsd: budget.sessionWarnUsd,
-      sessionHardBudgetUsd: budget.sessionHardUsd,
-      budgetVersion: version,
-      budgetUpdatedAt: at,
-    },
-    brains: { ...brains, claude: { ...obj(brains.claude), maxBudgetUsd: budget.brainUsd } },
+    ...withoutLegacyBudget(raw),
+    budget: { unlimited: budget.unlimited === true, amountUsd: roundUsd(budget.amountUsd), version, updatedAt: at },
   };
 }
 
-/** The dispatcher's limit keys for a budget. */
-export function budgetLimits(budget) {
+/** What the Assistant's budget limits at `spentUsd` (null amounts under No limit). */
+export function budgetLimitsAt(budget, spentUsd = 0) {
+  if (!budget || budget.unlimited) return { unlimited: true, amountUsd: null, warnAtUsd: null, leftUsd: null, warned: false, exceeded: false };
+  const amount = Number(budget.amountUsd) || 0;
+  const spent = Math.max(0, Number(spentUsd) || 0);
+  const warnAt = roundUsd(amount * BUDGET_WARN_RATIO);
   return {
-    defaultBudgetUsd: budget.defaultRunUsd,
-    maxBudgetUsd: budget.maxRunUsd,
-    sessionWarnUsd: budget.sessionWarnUsd,
-    sessionHardBudgetUsd: budget.sessionHardUsd,
-    brainBudgetUsd: budget.brainUsd,
+    unlimited: false, amountUsd: amount, warnAtUsd: warnAt,
+    leftUsd: Math.max(0, Number((amount - spent).toFixed(8))),
+    warned: spent >= warnAt, exceeded: spent >= amount,
   };
 }
 

package/neural-interface/lib/assistant-config.js

@@ -4,7 +4,7 @@
 //
 // The assistant's user-editable knobs live in one JSON file: `defaultBrain`,
 // `persona`, `limits`, `memory` (read by the other assistant modules),
-// `routing`, the budget caps (owned here; see assistant-budget.js) and
+// `routing`, `budget` (owned here; see assistant-budget.js) and
 // `userContext` (the three layers of assistant-user-context.js). Knobs
 // are data: the file is re-read when its mtime changes, so a PUT from the
 // routes or budget editor, or a hand edit, applies without a restart. Writes
@@ -12,7 +12,7 @@
 
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { effectiveBudget, validateBudgetPatch, writeBudgetInto } from './assistant-budget.js';
+import { effectiveBudget, needsBudgetMigration, validateBudgetPatch, writeBudgetInto } from './assistant-budget.js';
 import { normalizeUserContext, USER_CONTEXT_DEFAULTS } from './assistant-user-context-budgets.js';
 
 export const ROUTE_MODES = ['always-ask', 'ask-unsure', 'never'];
@@ -55,6 +55,10 @@ function cleanTarget(field, target) {
   const provider = String(target.provider || '').trim();
   if (!ROUTE_PROVIDERS.includes(provider)) throw routingError(`${field}.provider`, `routing.${field}.provider must be one of ${ROUTE_PROVIDERS.join(', ')}`);
   const out = { kind, provider, model: target.model ? String(target.model).slice(0, 200) : null, effort: target.effort ? String(target.effort).slice(0, 40) : null };
+  if (target.accountId != null && target.accountId !== '') {
+    if (typeof target.accountId !== 'string' || !/^[a-z0-9-]{1,64}$/.test(target.accountId)) throw routingError(`${field}.accountId`, 'Invalid route account id');
+    if (provider !== 'opencode') out.accountId = target.accountId;
+  }
   if (target.label) out.label = String(target.label).slice(0, 120);
   if (target.at) out.at = String(target.at).slice(0, 40);
   if (target.by) out.by = String(target.by).slice(0, 20);
@@ -210,30 +214,46 @@ export function createAssistantConfigStore({ path, log = () => {}, now = Date.no
     return { routing: effectiveRouting(nextRouting), version: nextRouting.version };
   }
 
-  /** Effective budget caps (assistant-budget.js effectiveBudget) + the file's budget version. */
+  /**
+   * The budget every session runs under (assistant-budget.js effectiveBudget):
+   * { unlimited, amountUsd, version, updatedAt, source }. A file that still
+   * holds the old five caps is migrated the first time it is read here: the
+   * session hard cap becomes the amount (else the default), the old keys go,
+   * and the version moves on so a client holding the old shape gets a 409.
+   * A file that cannot be written keeps working on the migrated values.
+   */
   function budget() {
     const raw = read();
-    return { ...effectiveBudget(raw), version: Number(raw.limits?.budgetVersion) || 0 };
+    if (!needsBudgetMigration(raw)) return effectiveBudget(raw);
+    const migrated = effectiveBudget(raw);
+    try {
+      const version = migrated.version + 1;
+      write(writeBudgetInto(raw, migrated, { version, at: new Date(now()).toISOString() }));
+      log('config:budget-migrated', `amountUsd ${migrated.amountUsd} (from the session hard cap) · version ${version}`);
+      return { ...effectiveBudget(read()), source: 'migrated' };
+    } catch (error) {
+      log('config:budget-migration-failed', error?.message || String(error));
+      return migrated;
+    }
   }
-  function budgetVersion() { return Number(read().limits?.budgetVersion) || 0; }
+  function budgetVersion() { return budget().version; }
 
   /**
-   * Validate and save budget caps (a partial patch; `null` resets a field).
+   * Validate and save the budget (a partial patch: unlimited, amountUsd).
    * `expectedVersion` (when given) must match. Readers pick it up on their next
-   * read: the dispatcher per dispatch / turn, the runtime per brain turn.
+   * read: the dispatcher per dispatch / turn / metered step, the runtime per brain turn.
    */
   function patchBudget(patch = {}, { expectedVersion = null } = {}) {
-    const current = read();
-    const currentVersion = Number(current.limits?.budgetVersion) || 0;
-    if (expectedVersion !== null && expectedVersion !== undefined && Number(expectedVersion) !== currentVersion) {
+    const current = budget();
+    if (expectedVersion !== null && expectedVersion !== undefined && Number(expectedVersion) !== current.version) {
       const error = new Error('Budget settings changed elsewhere; reload and try again.');
       error.code = 'VERSION_CONFLICT';
       error.status = 409;
-      error.version = currentVersion;
+      error.version = current.version;
       throw error;
     }
-    const next = validateBudgetPatch(patch, effectiveBudget(current));
-    write(writeBudgetInto(current, next, { version: currentVersion + 1, at: new Date(now()).toISOString() }));
+    const next = validateBudgetPatch(patch, current);
+    write(writeBudgetInto(read(), next, { version: current.version + 1, at: new Date(now()).toISOString() }));
     return budget();
   }
 
@@ -253,9 +273,37 @@ export function createAssistantConfigStore({ path, log = () => {}, now = Date.no
     return userContext();
   }
 
+  /**
+   * Defaults for dispatched workers, read live. `claudeAccount` / `codexAccount`:
+   * the account a Claude Code / Codex worker runs under when its dispatch names
+   * none (null = Default).
+   */
+  const WORKER_ACCOUNT_KEYS = { claudeAccount: 'Claude', codexAccount: 'Codex' };
+  const accountIdOf = (id) => (typeof id === 'string' && /^[a-z0-9-]{1,64}$/.test(id) && id !== 'default' ? id : null);
+  function workers() {
+    const raw = read().workers;
+    const stored = raw && typeof raw === 'object' ? raw : {};
+    return { claudeAccount: accountIdOf(stored.claudeAccount), codexAccount: accountIdOf(stored.codexAccount) };
+  }
+  /** Save worker defaults (a partial patch; null or 'default' for an account is Default). Unknown keys stay. */
+  function patchWorkers(patch = {}) {
+    const current = read();
+    const stored = current.workers && typeof current.workers === 'object' && !Array.isArray(current.workers) ? current.workers : {};
+    const next = { ...stored };
+    for (const [key, provider] of Object.entries(WORKER_ACCOUNT_KEYS)) {
+      if (!Object.prototype.hasOwnProperty.call(patch || {}, key)) continue;
+      const id = patch[key];
+      if (id === null || id === '' || id === 'default') delete next[key];
+      else if (typeof id === 'string' && /^[a-z0-9-]{1,64}$/.test(id)) next[key] = id;
+      else throw Object.assign(new Error(`That is not a ${provider} account id.`), { code: 'INVALID_ACCOUNT', status: 400 });
+    }
+    write({ ...current, workers: { ...next, updatedAt: new Date(now()).toISOString() } });
+    return workers();
+  }
+
   function onChange(fn) { listeners.add(fn); return () => listeners.delete(fn); }
 
-  return { read, routing, version, patchRouting, setPreference, budget, budgetVersion, patchBudget, userContext, patchUserContext, onChange, path };
+  return { read, routing, version, patchRouting, setPreference, budget, budgetVersion, patchBudget, userContext, patchUserContext, workers, patchWorkers, onChange, path };
 }
 
 export function fileExists(path) { try { return existsSync(path); } catch { return false; } }