chati-dev 3.3.2 → 4.0.1

package/src/autonomy/surface-criteria.js

@@ -0,0 +1,226 @@
+/**
+ * Surface Criteria — 7 codified checkpoints for autonomous execution pause.
+ *
+ * Defines WHEN the system should surface a decision to the user instead
+ * of proceeding autonomously. Each criterion has a severity level:
+ *   critical — always pause, cannot be batch-confirmed
+ *   warning  — pause unless already confirmed, batchable
+ *
+ * Short-circuit: critical criteria (C003, C006, C007) are checked first.
+ * Batch confirm: C001 + C002 can be grouped into a single user prompt.
+ * Session memory: once confirmed, a criterion can be skipped for the session.
+ */
+
+/**
+ * The 7 surface criteria.
+ */
+export const CRITERIA = {
+  C001: {
+    id: 'C001',
+    name: 'ambiguous_requirement',
+    severity: 'warning',
+    description: 'Requirement is ambiguous and can be interpreted multiple ways.',
+  },
+  C002: {
+    id: 'C002',
+    name: 'multiple_approaches',
+    severity: 'warning',
+    description: 'Multiple valid implementation approaches exist.',
+  },
+  C003: {
+    id: 'C003',
+    name: 'destructive_operation',
+    severity: 'critical',
+    description: 'Action would delete, overwrite, or irreversibly modify existing data or code.',
+  },
+  C004: {
+    id: 'C004',
+    name: 'external_interaction',
+    severity: 'warning',
+    description: 'Action involves external systems (APIs, deployments, notifications).',
+  },
+  C005: {
+    id: 'C005',
+    name: 'cost_threshold',
+    severity: 'warning',
+    description: 'Estimated cost exceeds defined threshold for the session.',
+  },
+  C006: {
+    id: 'C006',
+    name: 'scope_creep',
+    severity: 'critical',
+    description: 'Proposed changes extend beyond the original scope or task definition.',
+  },
+  C007: {
+    id: 'C007',
+    name: 'security_sensitive',
+    severity: 'critical',
+    description: 'Action involves credentials, secrets, permissions, or security-sensitive operations.',
+  },
+};
+
+/**
+ * Check if a criterion has already been confirmed in this session.
+ *
+ * @param {string} criterionId - e.g., 'C001'
+ * @param {Set<string>|string[]} sessionDecisions - Previously confirmed criteria
+ * @returns {boolean}
+ */
+export function isAlreadyConfirmed(criterionId, sessionDecisions) {
+  if (!sessionDecisions) return false;
+  if (sessionDecisions instanceof Set) return sessionDecisions.has(criterionId);
+  if (Array.isArray(sessionDecisions)) return sessionDecisions.includes(criterionId);
+  return false;
+}
+
+/**
+ * Evaluate surface criteria for a given action context.
+ *
+ * @param {object} action - The action being evaluated
+ * @param {string} [action.type] - Action type (e.g., 'write', 'delete', 'deploy', 'create')
+ * @param {string} [action.target] - Target of the action (e.g., file path, resource name)
+ * @param {string} [action.description] - Human-readable action description
+ * @param {string[]} [action.tags] - Semantic tags (e.g., ['destructive', 'external', 'security'])
+ * @param {number} [action.estimatedCost] - Estimated cost in dollars
+ * @param {object} context - Evaluation context
+ * @param {Set<string>|string[]} [context.sessionDecisions] - Previously confirmed criteria
+ * @param {number} [context.costThreshold] - Cost threshold for C005 (default: 1.0)
+ * @param {string[]} [context.taskScope] - Original task scope keywords
+ * @returns {{ shouldPause: boolean, triggers: Array<{ id: string, name: string, severity: string, reason: string }>, batchable: boolean }}
+ */
+export function evaluateSurfaceCriteria(action, context = {}) {
+  if (!action) {
+    return { shouldPause: false, triggers: [], batchable: false };
+  }
+
+  const triggers = [];
+  const sessionDecisions = context.sessionDecisions || new Set();
+  const tags = new Set((action.tags || []).map(t => t.toLowerCase()));
+  const actionType = (action.type || '').toLowerCase();
+
+  // --- Critical criteria first (short-circuit) ---
+
+  // C003: Destructive operation
+  if (isDestructive(actionType, tags) && !isAlreadyConfirmed('C003', sessionDecisions)) {
+    triggers.push({
+      id: 'C003',
+      name: CRITERIA.C003.name,
+      severity: 'critical',
+      reason: `Destructive operation: ${action.description || action.type || 'unknown'}`,
+    });
+  }
+
+  // C006: Scope creep
+  if (isScopeCreep(action, context) && !isAlreadyConfirmed('C006', sessionDecisions)) {
+    triggers.push({
+      id: 'C006',
+      name: CRITERIA.C006.name,
+      severity: 'critical',
+      reason: `Changes extend beyond original task scope.`,
+    });
+  }
+
+  // C007: Security sensitive
+  if (isSecuritySensitive(actionType, tags, action.target) && !isAlreadyConfirmed('C007', sessionDecisions)) {
+    triggers.push({
+      id: 'C007',
+      name: CRITERIA.C007.name,
+      severity: 'critical',
+      reason: `Security-sensitive operation: ${action.description || action.target || 'unknown'}`,
+    });
+  }
+
+  // --- Warning criteria ---
+
+  // C001: Ambiguous requirement
+  if (tags.has('ambiguous') && !isAlreadyConfirmed('C001', sessionDecisions)) {
+    triggers.push({
+      id: 'C001',
+      name: CRITERIA.C001.name,
+      severity: 'warning',
+      reason: 'Requirement is ambiguous.',
+    });
+  }
+
+  // C002: Multiple approaches
+  if (tags.has('multiple_approaches') && !isAlreadyConfirmed('C002', sessionDecisions)) {
+    triggers.push({
+      id: 'C002',
+      name: CRITERIA.C002.name,
+      severity: 'warning',
+      reason: 'Multiple valid approaches exist.',
+    });
+  }
+
+  // C004: External interaction
+  if (isExternal(actionType, tags) && !isAlreadyConfirmed('C004', sessionDecisions)) {
+    triggers.push({
+      id: 'C004',
+      name: CRITERIA.C004.name,
+      severity: 'warning',
+      reason: `External interaction: ${action.description || action.type || 'unknown'}`,
+    });
+  }
+
+  // C005: Cost threshold
+  const costThreshold = context.costThreshold ?? 1.0;
+  if (action.estimatedCost && action.estimatedCost > costThreshold && !isAlreadyConfirmed('C005', sessionDecisions)) {
+    triggers.push({
+      id: 'C005',
+      name: CRITERIA.C005.name,
+      severity: 'warning',
+      reason: `Estimated cost $${action.estimatedCost.toFixed(2)} exceeds threshold $${costThreshold.toFixed(2)}.`,
+    });
+  }
+
+  // Determine if batchable (only if ALL triggers are warnings, no critical)
+  const hasCritical = triggers.some(t => t.severity === 'critical');
+  const warningOnly = triggers.length > 0 && !hasCritical;
+  const batchable = warningOnly && triggers.length > 1;
+
+  return {
+    shouldPause: triggers.length > 0,
+    triggers,
+    batchable,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Internal detection helpers
+// ---------------------------------------------------------------------------
+
+function isDestructive(actionType, tags) {
+  return (
+    tags.has('destructive') ||
+    ['delete', 'remove', 'drop', 'reset', 'force-push', 'overwrite'].includes(actionType)
+  );
+}
+
+function isSecuritySensitive(actionType, tags, target) {
+  if (tags.has('security') || tags.has('credentials') || tags.has('secrets')) return true;
+  if (target && /\.(env|pem|key|secret|credentials|password)/i.test(target)) return true;
+  if (['chmod', 'chown'].includes(actionType)) return true;
+  return false;
+}
+
+function isExternal(actionType, tags) {
+  return (
+    tags.has('external') ||
+    ['deploy', 'publish', 'push', 'send', 'notify'].includes(actionType)
+  );
+}
+
+function isScopeCreep(action, context) {
+  if (!context.taskScope || context.taskScope.length === 0) return false;
+  if (!action.tags || action.tags.length === 0) return false;
+
+  const scopeSet = new Set(context.taskScope.map(s => s.toLowerCase()));
+  const actionTags = action.tags.map(t => t.toLowerCase());
+
+  // If action has 'scope_creep' tag explicitly
+  if (actionTags.includes('scope_creep')) return true;
+
+  // If none of the action tags overlap with task scope, it may be scope creep
+  const hasOverlap = actionTags.some(t => scopeSet.has(t));
+  return !hasOverlap && actionTags.length > 0;
+}

package/src/context/bracket-tracker.js

@@ -2,32 +2,58 @@
  * Bracket Tracker — Pure arithmetic for context window management.
  *
  * Brackets determine how much context to inject:
- *   FRESH    (60-100%) → All 5 layers active
- *   MODERATE (40-60%)  → L0 + L1 + L2 + L3 (skip L4 task detail)
+ *   FRESH    (60-100%) → All 6 layers active (L0-L5)
+ *   MODERATE (40-60%)  → L0 + L1 + L2 + L3 + L5 (skip L4 task detail)
  *   DEPLETED (25-40%)  → L0 + L1 + L2 only
  *   CRITICAL (<25%)    → L0 + L1 only (handoff mandatory)
+ *
+ * Progressive Reinforcement Model (v4.0):
+ *   As context window depletes, the model forgets initial instructions
+ *   and needs MORE reinforcement, not less. Budget expressed as percentage
+ *   of the provider's total context window — proportional across providers.
+ *
+ *   FRESH    = 1.5% → minimal reinforcement (context is plentiful)
+ *   MODERATE = 2.5% → growing reinforcement (model starting to forget)
+ *   DEPLETED = 4.0% → heavy reinforcement (significant context loss)
+ *   CRITICAL = 5.0% → maximum reinforcement (last interactions before handoff)
  */
 
+/** Provider context window limits (tokens). */
+const PROVIDER_LIMITS = {
+  claude: 200_000,
+  gemini: 1_000_000,
+  codex: 128_000,
+};
+
 const BRACKETS = {
-  FRESH:    { min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], tokenBudget: 8000 },
-  MODERATE: { min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3'],       tokenBudget: 5000 },
-  DEPLETED: { min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             tokenBudget: 3000 },
-  CRITICAL: { min: 0,  max: 25,  layers: ['L0', 'L1'],                   tokenBudget: 1500 },
+  FRESH:    { min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4', 'L5'], budgetRatio: 0.015 },
+  MODERATE: { min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3', 'L5'],       budgetRatio: 0.025 },
+  DEPLETED: { min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],                   budgetRatio: 0.040 },
+  CRITICAL: { min: 0,  max: 25,  layers: ['L0', 'L1'],                         budgetRatio: 0.050 },
 };
 
+/**
+ * Memory injection level per bracket.
+ * As context degrades, memory becomes MORE important:
+ *   FRESH    = none     (context abundant, no memory needed)
+ *   MODERATE = metadata (light reminders of relevant memories)
+ *   DEPLETED = chunks   (recovery via memory summaries)
+ *   CRITICAL = full     (full memory dump for handoff continuity)
+ */
 const MEMORY_LEVELS = {
-  FRESH:    'full',
-  MODERATE: 'chunks',
-  DEPLETED: 'metadata',
-  CRITICAL: 'none',
+  FRESH:    'none',
+  MODERATE: 'metadata',
+  DEPLETED: 'chunks',
+  CRITICAL: 'full',
 };
 
 /**
  * Calculate bracket from remaining context percentage.
  * @param {number} remainingPercent - 0 to 100
- * @returns {{ bracket: string, activeLayers: string[], tokenBudget: number, memoryLevel: string, handoffRequired: boolean }}
+ * @param {string} [provider='claude'] - Provider name for context window scaling
+ * @returns {{ bracket: string, activeLayers: string[], tokenBudget: number, budgetRatio: number, memoryLevel: string, handoffRequired: boolean, provider: string }}
  */
-export function calculateBracket(remainingPercent) {
+export function calculateBracket(remainingPercent, provider = 'claude') {
   const pct = Math.max(0, Math.min(100, remainingPercent));
 
   let name = 'CRITICAL';
@@ -36,13 +62,18 @@ export function calculateBracket(remainingPercent) {
   else if (pct >= 25) name = 'DEPLETED';
 
   const def = BRACKETS[name];
+  const providerLimit = PROVIDER_LIMITS[provider] || PROVIDER_LIMITS.claude;
+  const tokenBudget = Math.round(def.budgetRatio * providerLimit);
+
   return {
     bracket: name,
     activeLayers: [...def.layers],
-    tokenBudget: def.tokenBudget,
+    tokenBudget,
+    budgetRatio: def.budgetRatio,
     memoryLevel: MEMORY_LEVELS[name],
     handoffRequired: pct < 15,
     remainingPercent: pct,
+    provider,
   };
 }
 

package/src/context/domain-loader.js

@@ -91,6 +91,28 @@ export function loadGlobalDomain(domainsDir) {
   return result.loaded ? result.data : null;
 }
 
+/**
+ * Load all keyword domain files from chati.dev/domains/keywords/.
+ * @param {string} domainsDir - Path to chati.dev/domains/
+ * @returns {Map<string, object>} Map of topicName → domain data (keywords + rules)
+ */
+export function loadKeywordDomains(domainsDir) {
+  const keywordsDir = join(domainsDir, 'keywords');
+  const domains = new Map();
+
+  if (!existsSync(keywordsDir)) return domains;
+
+  const files = readdirSync(keywordsDir).filter(f => f.endsWith('.yaml'));
+  for (const file of files) {
+    const name = basename(file, '.yaml');
+    const result = loadDomainFile(join(keywordsDir, file));
+    if (result.loaded) {
+      domains.set(name, result.data);
+    }
+  }
+  return domains;
+}
+
 /**
  * Extract rules array from a domain object.
  * Domain files have a `rules` key with an array of rule objects.

package/src/context/engine.js

@@ -1,7 +1,7 @@
 /**
- * PRISM Context Engine — 5-layer context injection pipeline.
+ * PRISM Context Engine — 6-layer context injection pipeline.
  *
- * Orchestrates L0-L4 layers, respects bracket constraints,
+ * Orchestrates L0-L5 layers, respects bracket constraints,
  * and produces formatted XML context for agent prompts.
  *
  * Pipeline: bracket calculation → layer processing → formatting → output
@@ -13,6 +13,7 @@ import { processL1 } from './layers/l1-global.js';
 import { processL2 } from './layers/l2-agent.js';
 import { processL3 } from './layers/l3-workflow.js';
 import { processL4 } from './layers/l4-task.js';
+import { processL5 } from './layers/l5-keywords.js';
 import { formatContext } from './formatter.js';
 
 const LAYER_TIMEOUT_MS = 100;
@@ -31,14 +32,16 @@ const LAYER_TIMEOUT_MS = 100;
  * @param {object} [input.handoff] - Handoff data from previous agent
  * @param {string[]} [input.artifacts] - Relevant artifact paths
  * @param {string[]} [input.taskCriteria] - Active task criteria
+ * @param {string} [input.userPrompt] - User prompt text for L5 keyword matching
+ * @param {string} [input.provider] - CLI provider for context window scaling (claude, gemini, codex)
  * @returns {{ xml: string, bracket: object, layers: object[], errors: string[] }}
  */
 export function runPrism(input) {
   const errors = [];
   const layers = [];
 
-  // 1. Calculate bracket
-  const bracket = calculateBracket(input.remainingPercent);
+  // 1. Calculate bracket (provider-aware for proportional budgets)
+  const bracket = calculateBracket(input.remainingPercent, input.provider || 'claude');
 
   // 2. Build context for layer processors
   const ctx = {
@@ -52,6 +55,7 @@ export function runPrism(input) {
     handoff: input.handoff || {},
     artifacts: input.artifacts || [],
     taskCriteria: input.taskCriteria || [],
+    userPrompt: input.userPrompt || null,
   };
 
   // 3. Process each active layer with timeout protection
@@ -85,6 +89,12 @@ export function runPrism(input) {
     if (l4) { layers.push(l4); layerResults.l4 = l4; }
   }
 
+  // L5 — Keyword recall layer (dynamic rules based on user prompt)
+  if (isLayerActive(bracket.bracket, 'L5') && ctx.userPrompt) {
+    const l5 = safeProcess('L5', () => processL5(ctx), errors);
+    if (l5 && l5.matchCount > 0) { layers.push(l5); layerResults.l5 = l5; }
+  }
+
   // 4. Format output
   const xml = formatContext({
     bracket: bracket.bracket,
@@ -129,9 +139,9 @@ function safeProcess(layerName, processFn, errors) {
 export function getPrismInfo() {
   return {
     name: 'PRISM',
-    version: '1.0.0',
-    layers: 5,
-    layerNames: ['L0 Constitution', 'L1 Global', 'L2 Agent', 'L3 Workflow', 'L4 Task'],
+    version: '1.1.0',
+    layers: 6,
+    layerNames: ['L0 Constitution', 'L1 Global', 'L2 Agent', 'L3 Workflow', 'L4 Task', 'L5 Keywords'],
     brackets: ['FRESH', 'MODERATE', 'DEPLETED', 'CRITICAL'],
     features: [
       'Priority-based context truncation',
@@ -139,6 +149,7 @@ export function getPrismInfo() {
       'Graceful degradation on layer failure',
       'XML structured output',
       'Bracket-aware layer activation',
+      'Provider-aware proportional budgets',
     ],
   };
 }

package/src/context/formatter.js

@@ -15,10 +15,11 @@
  * @param {object} [options.l2] - L2 Agent result
  * @param {object} [options.l3] - L3 Workflow result
  * @param {object} [options.l4] - L4 Task result
+ * @param {object} [options.l5] - L5 Keywords result
  * @returns {string} XML context block
  */
 export function formatContext(options) {
-  const { bracket, tokenBudget, l0, l1, l2, l3, l4 } = options;
+  const { bracket, tokenBudget, l0, l1, l2, l3, l4, l5 } = options;
   const sections = [];
 
   // L0 — Constitution (always present)
@@ -46,6 +47,11 @@ export function formatContext(options) {
     sections.push(formatTask(l4));
   }
 
+  // L5 — Keywords
+  if (l5 && l5.matchCount > 0) {
+    sections.push(formatKeywords(l5));
+  }
+
   let body = sections.join('\n\n');
 
   // Truncate if over budget (rough estimate: 1 token ≈ 4 chars)
@@ -154,6 +160,20 @@ function formatTask(l4) {
   return lines.join('\n');
 }
 
+function formatKeywords(l5) {
+  const lines = [];
+  lines.push(`  <keyword-rules matches="${l5.matchCount}">`);
+  for (const match of l5.matches) {
+    lines.push(`    <topic name="${esc(match.topic)}">`);
+    for (const r of match.rules) {
+      lines.push(`      <rule id="${esc(r.id)}" priority="${esc(r.priority)}">${esc(r.text)}</rule>`);
+    }
+    lines.push(`    </topic>`);
+  }
+  lines.push(`  </keyword-rules>`);
+  return lines.join('\n');
+}
+
 /**
  * Truncate sections by removing lower-priority layers first (L4 → L3 → L2).
  * L0 and L1 are never truncated.

package/src/context/layers/l5-keywords.js

@@ -0,0 +1,53 @@
+/**
+ * L5 Keyword Recall Layer — Dynamic rule injection based on user prompt content.
+ *
+ * Scans the user prompt for topic keywords and loads matching rules from
+ * domains/keywords/*.yaml. This adds the WHAT dimension to PRISM context:
+ *   L0-L4 handle WHO (agent) and WHERE (workflow/task)
+ *   L5 handles WHAT (topic detection from user prompt)
+ *
+ * Only active in FRESH and MODERATE brackets (expensive layer).
+ */
+
+import { loadKeywordDomains } from '../domain-loader.js';
+
+/**
+ * Process L5: scan user prompt for keywords, return matching rules.
+ *
+ * @param {object} ctx - Pipeline context
+ * @param {string} ctx.domainsDir - Path to chati.dev/domains/
+ * @param {string} [ctx.userPrompt] - The user's prompt text to scan for keywords
+ * @returns {{ layer: string, matches: Array<{ topic: string, rules: object[] }>, matchCount: number }}
+ */
+export function processL5(ctx) {
+  const result = {
+    layer: 'L5',
+    matches: [],
+    matchCount: 0,
+  };
+
+  if (!ctx.userPrompt || !ctx.domainsDir) {
+    return result;
+  }
+
+  const promptLower = ctx.userPrompt.toLowerCase();
+  const keywordDomains = loadKeywordDomains(ctx.domainsDir);
+
+  for (const [topic, domain] of keywordDomains) {
+    const keywords = domain.keywords || [];
+    const matched = keywords.some(kw => promptLower.includes(kw.toLowerCase()));
+
+    if (matched) {
+      const rules = (domain.rules || []).map(r => ({
+        id: r.id || `${topic}-unknown`,
+        text: r.text || '',
+        priority: r.priority || 'normal',
+      }));
+
+      result.matches.push({ topic, rules });
+      result.matchCount += rules.length;
+    }
+  }
+
+  return result;
+}

package/src/intelligence/context-status.js

@@ -1,16 +1,23 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
+/** Provider context window limits (tokens). */
+const PROVIDER_LIMITS = {
+  claude: 200_000,
+  gemini: 1_000_000,
+  codex: 128_000,
+};
+
 const BRACKETS = [
-  { name: 'FRESH',    min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], budget: 8000 },
-  { name: 'MODERATE', min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3'],       budget: 5000 },
-  { name: 'DEPLETED', min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             budget: 3000 },
-  { name: 'CRITICAL', min: 0,  max: 25,  layers: ['L0', 'L1'],                   budget: 1500 },
+  { name: 'FRESH',    min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4', 'L5'], budgetRatio: 0.015 },
+  { name: 'MODERATE', min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3', 'L5'],       budgetRatio: 0.025 },
+  { name: 'DEPLETED', min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],                   budgetRatio: 0.040 },
+  { name: 'CRITICAL', min: 0,  max: 25,  layers: ['L0', 'L1'],                         budgetRatio: 0.050 },
 ];
 // NOTE: This BRACKETS array is intentionally duplicated from src/context/bracket-tracker.js
 // for module isolation. bracket-tracker.js is the canonical source of truth.
-// If bracket ranges or budgets change, update BOTH files.
-// Format differs: here = array with `budget`, there = object with `tokenBudget`.
+// Progressive Reinforcement Model (v4.0): budgets as ratio of provider context window.
+// If bracket ranges or ratios change, update BOTH files.
 
 /**
  * Get context status based on session state
@@ -19,10 +26,12 @@ const BRACKETS = [
 export function getContextStatus(targetDir) {
   const sessionPath = join(targetDir, '.chati', 'session.yaml');
   if (!existsSync(sessionPath)) {
+    const providerLimit = PROVIDER_LIMITS.claude;
     return {
       bracket: 'FRESH',
       activeLayers: BRACKETS[0].layers,
-      tokenBudget: BRACKETS[0].budget,
+      tokenBudget: Math.round(BRACKETS[0].budgetRatio * providerLimit),
+      budgetRatio: BRACKETS[0].budgetRatio,
       memoryLevel: 'none',
       advisory: 'No active session — default FRESH bracket',
     };
@@ -44,12 +53,14 @@ export function getContextStatus(targetDir) {
 
   const bracket = BRACKETS.find(b => remainingPercent >= b.min && remainingPercent <= b.max) || BRACKETS[0];
 
-  const memoryLevels = { FRESH: 'full', MODERATE: 'chunks', DEPLETED: 'metadata', CRITICAL: 'none' };
+  const memoryLevels = { FRESH: 'none', MODERATE: 'metadata', DEPLETED: 'chunks', CRITICAL: 'full' };
+  const providerLimit = PROVIDER_LIMITS.claude;
 
   return {
     bracket: bracket.name,
     activeLayers: bracket.layers,
-    tokenBudget: bracket.budget,
+    tokenBudget: Math.round(bracket.budgetRatio * providerLimit),
+    budgetRatio: bracket.budgetRatio,
     memoryLevel: memoryLevels[bracket.name],
     remainingPercent,
     estimatedUsage,