create-walle 0.9.30 → 0.9.32

package/template/wall-e/chat.js

@@ -520,7 +520,10 @@ function _getCommandRegistry() {
   if (_commandRegistry) return _commandRegistry;
   const { CommandRegistry } = require('./tools/command-registry');
   _commandRegistry = new CommandRegistry();
-  _commandRegistry.registerBuiltins();
+  // getProvider lets the /compact builtin summarize via the active default client.
+  _commandRegistry.registerBuiltins({
+    getProvider: () => { try { return getDefaultClient(); } catch { return null; } },
+  });
   try {
     const {
       filterSkillsForAgent,
@@ -918,7 +921,7 @@ function _providerRowHasRuntimeAccess(row = {}) {
 }
 
 function _fallbackErrorType(providerError = {}) {
-  return new Set(['rate_limited', 'network', 'provider_unavailable', 'timeout']).has(providerError.type);
+  return new Set(['rate_limited', 'network', 'provider_unavailable', 'timeout', 'model_unavailable', 'model_circuit_open']).has(providerError.type);
 }
 
 function _routingPolicySettings() {
@@ -929,6 +932,80 @@ function _routingPolicySettings() {
   }
 }
 
+function _uniqueChatProviders(values = []) {
+  const out = [];
+  const seen = new Set();
+  for (const value of values) {
+    const text = String(value || '').trim();
+    const key = text.toLowerCase();
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(text);
+  }
+  return out;
+}
+
+function _chatProviderModelCircuit(providers, model, options = {}) {
+  try {
+    const healthState = require('./llm/provider-health-state');
+    const circuit = healthState.getFirstProviderModelCircuit(_uniqueChatProviders(providers), model, { brain });
+    if (!circuit) return null;
+    if (options.allowProbe && circuit.probe_due) {
+      healthState.reserveProviderModelCircuitProbe(circuit.provider, circuit.model, { brain });
+      return null;
+    }
+    return circuit;
+  } catch {
+    return null;
+  }
+}
+
+function _recordChatCircuitRoutingNotice(circuit, fallback) {
+  try {
+    const failures = Number(circuit?.failures || 0);
+    const total = Number(circuit?.total || 0);
+    const rate = Number(circuit?.failure_rate_pct || Math.round(Number(circuit?.failure_rate || 0) * 100));
+    const windowMs = Number(circuit?.window_ms || 0);
+    const windowLabel = windowMs >= 60 * 60 * 1000
+      ? `${Math.round(windowMs / (60 * 60 * 1000))}h`
+      : 'rolling window';
+    const fromLabel = `${circuit?.provider || 'provider'}${circuit?.model ? ' / ' + circuit.model : ''}`;
+    const hasFallback = !!fallback;
+    const toLabel = hasFallback
+      ? `${fallback?.providerType || fallback?.provider?.type || 'fallback'}${fallback?.model ? ' / ' + fallback.model : ''}`
+      : 'no eligible fallback';
+    require('./llm/health').default.recordRoutingNotice({
+      kind: 'model_circuit_open',
+      severity: 'warning',
+      message: hasFallback
+        ? `Auto-fallback active for ${fromLabel}; answering via ${toLabel} while recovery probes run periodically.`
+        : `Auto-fallback active for ${fromLabel}, but this turn has no eligible fallback route. Waiting for recovery probes or Setup changes.`,
+      detail: total ? `${rate}% errors over ${windowLabel} (${failures}/${total}).` : '',
+      from: { type: circuit?.provider || null, model: circuit?.model || null },
+      to: hasFallback ? { type: fallback?.providerType || fallback?.provider?.type || null, model: fallback?.model || null } : null,
+    });
+  } catch {}
+}
+
+function _chatCircuitOpenError(circuit) {
+  const failures = Number(circuit?.failures || 0);
+  const total = Number(circuit?.total || 0);
+  const rate = Number(circuit?.failure_rate_pct || Math.round(Number(circuit?.failure_rate || 0) * 100));
+  const probe = circuit?.probe_due
+    ? 'a recovery probe is due now'
+    : `next recovery probe in ${Math.max(1, Math.ceil(Number(circuit?.next_probe_in_ms || 0) / 60000))}m`;
+  const sample = total ? `${rate}% errors (${failures}/${total})` : 'recent failures';
+  const err = new Error(`Auto-fallback is active for ${circuit?.provider || 'provider'}${circuit?.model ? ' / ' + circuit.model : ''}: ${sample}; ${probe}.`);
+  err.status = 503;
+  const decorated = decorateProviderError(err, {
+    type: 'provider_unavailable_local',
+    provider: circuit?.provider || null,
+    model: circuit?.model || null,
+  });
+  decorated.suppressProviderHealthRecord = true;
+  return decorated;
+}
+
 function _allowChatProviderFallback(opts = {}) {
   if (_clientOverride) return false;
   if (opts.modelPinned === true || opts.providerPinned === true) return false;
@@ -1328,7 +1405,7 @@ function _selectFallbackModel(providerId, runtimeType, taskType) {
   return getDefaultModelForProvider(runtimeType);
 }
 
-function _listChatFallbackRows({ attemptedProviderTypes, providerAvailability }) {
+function _listChatFallbackRows({ attemptedProviderTypes, providerAvailability, taskType = 'chat' }) {
   let rows = [];
   try {
     rows = (brain.listModelProviders?.() || [])
@@ -1352,7 +1429,13 @@ function _listChatFallbackRows({ attemptedProviderTypes, providerAvailability })
     if (providerAvailability?.isProviderUsable) {
       if (!providerAvailability.isProviderUsable(row.id) || !providerAvailability.isProviderUsable(runtimeType)) continue;
     }
-    candidates.push({ row, runtimeType, modelCount });
+    const model = resolveCompatibleModel(
+      _selectFallbackModel(row.id, runtimeType, taskType),
+      runtimeType,
+    );
+    const circuit = _chatProviderModelCircuit([runtimeType, row.type, row.id], model, { allowProbe: false });
+    if (circuit) continue;
+    candidates.push({ row, runtimeType, modelCount, model });
   }
   const rank = {
     openai: 10,
@@ -1377,8 +1460,8 @@ function _listChatProviderFallbacks({ attemptedProviderTypes, providerError, tas
   if (!_allowChatProviderFallback(opts)) return null;
   if (!_fallbackErrorType(providerError)) return null;
   const fallbacks = [];
-  for (const { row, runtimeType } of _listChatFallbackRows({ attemptedProviderTypes, providerAvailability })) {
-    const model = resolveCompatibleModel(
+  for (const { row, runtimeType, model: fallbackModel } of _listChatFallbackRows({ attemptedProviderTypes, providerAvailability, taskType })) {
+    const model = fallbackModel || resolveCompatibleModel(
       _selectFallbackModel(row.id, runtimeType, taskType),
       runtimeType,
     );
@@ -1407,8 +1490,8 @@ function _allowFinalizationProviderFallback(opts = {}) {
 function _listChatFinalizationFallbacks({ attemptedProviderTypes, taskType, opts, providerAvailability }) {
   if (!_allowFinalizationProviderFallback(opts)) return [];
   const fallbacks = [];
-  for (const { row, runtimeType } of _listChatFallbackRows({ attemptedProviderTypes, providerAvailability })) {
-    const model = resolveCompatibleModel(
+  for (const { row, runtimeType, model: fallbackModel } of _listChatFallbackRows({ attemptedProviderTypes, providerAvailability, taskType })) {
+    const model = fallbackModel || resolveCompatibleModel(
       _selectFallbackModel(row.id, runtimeType, taskType),
       runtimeType,
     );
@@ -3690,6 +3773,49 @@ async function chat(message, opts = {}) {
 
     const chatStart = Date.now();
     const attemptedProviderTypes = new Set([targetProviderType, provider.type].filter(Boolean));
+    const primaryCircuit = !_clientOverride
+      ? _chatProviderModelCircuit([provider.type, targetProviderType, selectedRoute.provider], selectedModel, { allowProbe: true })
+      : null;
+    if (primaryCircuit) {
+      let fallback = null;
+      if (_allowCrossProviderFallbackForTurn({
+        opts,
+        wallECodingMode,
+        provider,
+        model: selectedModel,
+      })) {
+        const fallbacks = _listChatProviderFallbacks({
+          attemptedProviderTypes,
+          providerError: { type: 'model_circuit_open' },
+          taskType: opts.taskType || 'chat',
+          opts,
+          providerAvailability,
+        }) || [];
+        fallback = fallbacks[0] || null;
+      }
+      if (fallback) {
+        const fromProvider = primaryCircuit.provider || targetProviderType;
+        const fromModel = primaryCircuit.model || selectedModel;
+        provider = withProviderMessageGuard(fallback.provider);
+        selectedModel = fallback.model;
+        usedProvider = fallback.provider.type || fallback.providerType;
+        attemptedProviderTypes.add(fallback.providerType);
+        attemptedProviderTypes.add(fallback.provider?.type);
+        _recordChatCircuitRoutingNotice(primaryCircuit, fallback);
+        try {
+          _telemetry.track('chat_provider_failover', {
+            from_provider: fromProvider,
+            from_model: fromModel,
+            to_provider: fallback.providerType,
+            to_model: fallback.model,
+            reason: 'model_circuit_open',
+          });
+        } catch {}
+      } else {
+        _recordChatCircuitRoutingNotice(primaryCircuit, null);
+        throw _chatCircuitOpenError(primaryCircuit);
+      }
+    }
     for (let turn = 0; turn < allowedTurns; turn++) {
       if (opts.abortSignal?.aborted) {
         clearTimeout(timeout);
@@ -3802,7 +3928,7 @@ async function chat(message, opts = {}) {
           provider,
           model: selectedModel,
         })
-        && _listChatFallbackRows({ attemptedProviderTypes, providerAvailability }).length > 0)
+        && _listChatFallbackRows({ attemptedProviderTypes, providerAvailability, taskType: opts.taskType || 'chat' }).length > 0)
         ? 0
         : 2;
       // Unified with coding mode: chat gets the 8k floor so longer
@@ -3853,6 +3979,7 @@ async function chat(message, opts = {}) {
           }) || [])
           : [];
         if (fallbacks.length > 0) {
+          recordProviderFailureAlert(decorated.providerError, brain);
           let fallbackSucceeded = false;
           let lastFallbackDecorated = null;
           for (const fallback of fallbacks) {
@@ -3872,6 +3999,7 @@ async function chat(message, opts = {}) {
               });
             } catch {}
             try {
+              resetTurnTimeout(Math.min(FINALIZATION_TIMEOUT_MS, MESSAGE_TIMEOUT_MS));
               const fallbackReasoningOptions = resolveCurrentReasoningOptions(provider, selectedModel);
               response = await withRetry(() => provider.chat({
                 model: selectedModel,

package/template/wall-e/coding/action-memory-policy.js

@@ -3,7 +3,20 @@
 const DEFAULT_MIN_SCORE = 120;
 const DEFAULT_MIN_MARGIN = 15;
 const DEFAULT_LIMIT = 8;
-const MODES = new Set(['off', 'audit', 'assist', 'apply']);
+// Modes, from most honest to most invasive:
+//   off       — disabled.
+//   audit     — observe candidates, never touch the call.
+//   exemplar  — HONEST RAG (recommended): never mutate the call; surface
+//               retrieved verified examples for prompt injection so the model
+//               writes its OWN call (adapts params → generalizes).
+//   assist    — fill ONLY missing fields from memory (model still drives).
+//   apply     — replace the whole input with a remembered action. This is
+//               deterministic replay, NOT model capability: passes produced
+//               this way are flagged memory-mutated and excluded from
+//               capability metrics (see eval-splits.hasSyntheticPass).
+const MODES = new Set(['off', 'audit', 'exemplar', 'assist', 'apply']);
+// Modes where memory substitutes the action rather than the model deciding it.
+const MUTATING_MODES = new Set(['assist', 'apply']);
 const SELECTORS = new Set(['store', 'replay', 'auto']);
 const REPLAY_SELECTOR_TOOLS = new Set(['run_shell', 'apply_patch', 'edit_file', 'write_file']);
 
@@ -71,19 +84,30 @@ class ActionMemoryPolicy {
     };
 
     let preparedCall = clonedCall;
+    decision.mutatedByMemory = false;
     if (this.mode === 'audit') {
       decision.action = 'observe';
       decision.accepted = false;
       decision.reason = selection?.id ? 'audit_only' : 'no_candidate';
+    } else if (this.mode === 'exemplar') {
+      // Honest RAG: never touch the call. Candidates are returned for the
+      // caller to inject into the prompt as worked examples; the model still
+      // emits its own tool call.
+      decision.action = 'exemplar';
+      decision.accepted = false;
+      decision.exemplarCount = candidates.length;
+      decision.reason = candidates.length ? 'exemplars_available' : 'no_candidate';
     } else if (canUseSelection && this.mode === 'assist') {
       const mergedInput = fillMissingFields(clonedCall.input || {}, selectedInput);
       preparedCall = { ...clonedCall, input: mergedInput };
       decision.action = 'assist';
       decision.accepted = true;
+      decision.mutatedByMemory = true;
     } else if (canUseSelection && this.mode === 'apply') {
       preparedCall = { ...clonedCall, input: cloneJson(selectedInput) };
       decision.action = 'apply';
       decision.accepted = true;
+      decision.mutatedByMemory = true;
     }
 
     this.recordAudit({
@@ -149,6 +173,38 @@ class ActionMemoryPolicy {
     }
   }
 
+  /**
+   * Honest RAG retrieval: return verified past actions as worked exemplars for
+   * prompt injection. Does NOT mutate anything. Optionally re-ranks by embedding
+   * similarity of the task text when an embedder is provided.
+   * @returns {{ exemplars: object[], text: string }}
+   */
+  async retrieveExemplars({ context = {}, toolName = '', limit = 3, embedder = null } = {}) {
+    if (!this.store?.searchActionMemoryCandidates) return { exemplars: [], text: '' };
+    let candidates = [];
+    try {
+      candidates = this.store.searchActionMemoryCandidates({
+        context,
+        prediction: toolName ? { name: toolName, input: {} } : null,
+        toolName,
+        limit: Math.max(limit, this.limit),
+        positiveOnly: true,
+      }) || [];
+    } catch (err) {
+      this.logger?.warn?.(`[action-memory] exemplar retrieval failed: ${err.message}`);
+      return { exemplars: [], text: '' };
+    }
+    const ranked = await rerankByEmbedding(candidates, context, embedder, this.logger);
+    const exemplars = ranked.slice(0, Math.max(1, limit)).map((candidate) => ({
+      tool: candidate.tool || candidate.toolName || toolName,
+      input: safeObject(candidate.input),
+      outcome: candidate.outcomeStatus || candidate.outcome_status || 'verified',
+      score: Number.isFinite(Number(candidate.score)) ? Number(candidate.score) : null,
+      source: candidate.sourceKind || candidate.source_kind || 'memory',
+    }));
+    return { exemplars, text: formatExemplars(exemplars) };
+  }
+
   recordAudit(row) {
     if (!this.store?.recordSelectionAudit) return null;
     try {
@@ -175,14 +231,73 @@ async function executeToolCallWithActionMemoryPolicy({
     : { call: cloneToolCall(call), decision: { mode: 'off', action: 'skip', accepted: false }, candidates: [] };
   const execution = await execute(evaluated.call, evaluated.decision);
   if (execution && typeof execution === 'object') {
+    const action = evaluated.decision?.action || 'skip';
     execution.actionMemory = {
       decision: evaluated.decision,
       candidateCount: evaluated.candidates.length,
+      action,
+      mutated: Boolean(evaluated.decision?.mutatedByMemory),
     };
+    // A pass where memory replaced the model's whole action ('apply') is
+    // deterministic replay, not model capability — tag it so honest eval
+    // (eval-splits.hasSyntheticPass) excludes it from capability metrics.
+    if (action === 'apply') {
+      execution.memoryMutatedToolResults = Number(execution.memoryMutatedToolResults || 0) + 1;
+    }
   }
   return execution;
 }
 
+function formatExemplars(exemplars = []) {
+  if (!exemplars.length) return '';
+  const lines = ['[MEMORY] Similar verified actions from past work (for reference — adapt to the current task, do not copy blindly):'];
+  exemplars.forEach((ex, index) => {
+    lines.push(`${index + 1}. ${ex.tool}(${compactJson(ex.input)})  → ${ex.outcome}`);
+  });
+  return lines.join('\n');
+}
+
+function compactJson(value) {
+  try {
+    const text = JSON.stringify(value ?? {});
+    return text.length > 300 ? `${text.slice(0, 297)}...` : text;
+  } catch {
+    return '{}';
+  }
+}
+
+function cosineSimilarity(a = [], b = []) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length === 0 || a.length !== b.length) return 0;
+  let dot = 0; let na = 0; let nb = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+async function rerankByEmbedding(candidates = [], context = {}, embedder = null, logger = console) {
+  const taskText = String(context.taskText || context.task || context.taskPreview || '').trim();
+  if (!embedder || typeof embedder.embed !== 'function' || !taskText || candidates.length <= 1) {
+    return candidates;
+  }
+  try {
+    const texts = [taskText, ...candidates.map((c) => String(c.taskPreview || c.task_preview || '').trim())];
+    const vectors = await embedder.embed(texts);
+    if (!Array.isArray(vectors) || vectors.length !== texts.length) return candidates;
+    const queryVec = vectors[0];
+    return candidates
+      .map((candidate, index) => ({ candidate, sim: cosineSimilarity(queryVec, vectors[index + 1]) }))
+      .sort((left, right) => (right.sim - left.sim) || ((Number(right.candidate.score) || 0) - (Number(left.candidate.score) || 0)))
+      .map((entry) => entry.candidate);
+  } catch (err) {
+    logger?.warn?.(`[action-memory] embedding rerank failed: ${err.message}`);
+    return candidates;
+  }
+}
+
 function cloneToolCall(call = {}) {
   return {
     ...call,
@@ -347,7 +462,11 @@ module.exports = {
   DEFAULT_LIMIT,
   DEFAULT_MIN_MARGIN,
   DEFAULT_MIN_SCORE,
+  MODES,
+  MUTATING_MODES,
   executeToolCallWithActionMemoryPolicy,
   fillMissingFields,
+  formatExemplars,
+  cosineSimilarity,
   replayExampleFromRuntimeContext,
 };

package/template/wall-e/coding/compaction-service.js

@@ -56,9 +56,16 @@ class CompactionService {
     const actualInput = Number.isFinite(usage?.input) ? usage.input
       : Number.isFinite(usage?.inputTokens) ? usage.inputTokens
         : null;
-    return actualInput == null
-      ? systemTokens + estimateMessagesTokens(messages)
-      : actualInput;
+    const estimated = systemTokens + estimateMessagesTokens(messages);
+    // Use the LARGER of the provider's real last-turn occupancy and our text
+    // estimate. estimateMessagesTokens is a chars/4 heuristic — image-blind and
+    // it undercounts code/diff/JSON-heavy history, so on its own it let the live
+    // window silently run past 100% (e.g. real 234k while the estimate read
+    // <150k). The real occupancy is authoritative but can be slightly stale (it
+    // predates messages appended since that turn). max() defeats both blind
+    // spots: compaction fires when EITHER signal crosses the threshold.
+    if (actualInput == null) return estimated;
+    return Math.max(actualInput, estimated);
   }
 
   shouldCompact({ messages = [], systemTokens = 0, usage = null, contextWindow = this.contextWindow } = {}) {

package/template/wall-e/coding/model-router.js

@@ -0,0 +1,116 @@
+'use strict';
+
+/**
+ * Difficulty / confidence model routing.
+ *
+ * A 4B local model is fast and good enough for seen/simple repeated workflows,
+ * but has a real capability ceiling on hard/unseen work (the session's own
+ * research: Gemma A4B ~77 vs E4B ~52 on LiveCodeBench). Rather than pretend the
+ * small model learned everything, route by difficulty:
+ *   - simple/seen  → local model (cheap, fast, retrieval-grounded);
+ *   - hard/unseen  → a stronger model (or cloud).
+ *
+ * Routing uses only cheap, pre-run signals (retrieval hit, prompt shape, file
+ * count, explicit difficulty), and a runtime escalation check that promotes to
+ * the strong model when the local model is provably failing (read-loops, no
+ * decisive action, invalid tool calls) past a turn budget.
+ *
+ * Pure + provider-agnostic: callers pass a { local, strong } model map.
+ */
+
+const DIFFICULTY = Object.freeze({ SIMPLE: 'simple', HARD: 'hard' });
+
+const MULTI_STEP_RE = /\b(refactor|migrate|migration|across|end[- ]?to[- ]?end|rewrite|redesign|architecture|all callers|every|multiple files|orchestrat|concurren|race condition|distributed)\b/i;
+const HARD_PROMPT_CHARS = 1200;
+const HARD_FILE_COUNT = 3;
+
+function normalizeDifficultyHint(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (['easy', 'simple', 'trivial', 'low'].includes(text)) return DIFFICULTY.SIMPLE;
+  if (['hard', 'complex', 'difficult', 'high', 'medium'].includes(text)) {
+    // 'medium' leans hard for routing — better to use the strong model than to
+    // fail on a small one.
+    return text === 'medium' ? DIFFICULTY.HARD : DIFFICULTY.HARD;
+  }
+  return null;
+}
+
+/**
+ * @returns {{ difficulty: string, score: number, reasons: string[] }}
+ */
+function assessDifficulty({ prompt = '', fileHints = [], retrievalHit = null, explicitDifficulty = null } = {}) {
+  const reasons = [];
+
+  const hint = normalizeDifficultyHint(explicitDifficulty);
+  if (hint) {
+    return { difficulty: hint, score: hint === DIFFICULTY.HARD ? 1 : 0, reasons: [`explicit difficulty: ${explicitDifficulty}`] };
+  }
+
+  let score = 0;
+  const text = String(prompt || '');
+  const files = Array.isArray(fileHints) ? fileHints.filter(Boolean) : [];
+
+  if (retrievalHit === false) { score += 2; reasons.push('unseen: no retrieval/memory match'); }
+  else if (retrievalHit === true) { score -= 1; reasons.push('seen: retrieval match available'); }
+
+  if (text.length >= HARD_PROMPT_CHARS) { score += 1; reasons.push(`long prompt (${text.length} chars)`); }
+  if (files.length >= HARD_FILE_COUNT) { score += 1; reasons.push(`multi-file (${files.length} hints)`); }
+  if (MULTI_STEP_RE.test(text)) { score += 2; reasons.push('multi-step / cross-cutting keywords'); }
+
+  const difficulty = score >= 2 ? DIFFICULTY.HARD : DIFFICULTY.SIMPLE;
+  return { difficulty, score, reasons };
+}
+
+/** Pick a model spec for a difficulty; falls back to local when no strong model. */
+function routeModel({ difficulty = DIFFICULTY.SIMPLE, models = {} } = {}) {
+  const local = models.local || models.base || null;
+  const strong = models.strong || models.large || null;
+  if (difficulty === DIFFICULTY.HARD && strong) return strong;
+  return local || strong || null;
+}
+
+/**
+ * One-shot pre-run routing decision.
+ * @returns {{ model: object|null, difficulty: string, score: number, reasons: string[] }}
+ */
+function decideRoute({ prompt = '', fileHints = [], retrievalHit = null, explicitDifficulty = null, models = {} } = {}) {
+  const assessment = assessDifficulty({ prompt, fileHints, retrievalHit, explicitDifficulty });
+  const model = routeModel({ difficulty: assessment.difficulty, models });
+  const usedStrong = model && models.strong && model === models.strong;
+  return {
+    ...assessment,
+    model,
+    routedTo: usedStrong ? 'strong' : 'local',
+  };
+}
+
+/**
+ * Runtime confidence escalation: should we abandon the local model mid-run for
+ * the strong one? Only past a turn budget, only when behavior is clearly failing,
+ * and only when a strong model exists.
+ * @returns {{ escalate: boolean, reason: string }}
+ */
+function shouldEscalate({ behavioral = {}, turn = 0, maxLocalTurns = 5, hasStrongModel = true } = {}) {
+  if (!hasStrongModel) return { escalate: false, reason: 'no_strong_model' };
+  if (turn < maxLocalTurns) return { escalate: false, reason: 'within_local_budget' };
+
+  const readLoop = Number(behavioral.readLoopRate || 0);
+  const decisive = Number(behavioral.decisiveActionRate || 0);
+  const valid = behavioral.validToolCallRate == null ? 1 : Number(behavioral.validToolCallRate);
+
+  const failing = [];
+  if (readLoop >= 0.5) failing.push('read-loop');
+  if (decisive <= 0.1) failing.push('no decisive action');
+  if (valid <= 0.5) failing.push('invalid tool calls');
+
+  if (failing.length) return { escalate: true, reason: `local model failing past budget: ${failing.join(', ')}` };
+  return { escalate: false, reason: 'making_progress' };
+}
+
+module.exports = {
+  DIFFICULTY,
+  assessDifficulty,
+  routeModel,
+  decideRoute,
+  shouldEscalate,
+};