claude-autorouter 0.3.7 → 0.5.0

package/src/session-log.mjs

@@ -2,64 +2,14 @@ import { constants } from 'node:fs';
 import fs from 'node:fs/promises';
 import { createHash, randomBytes } from 'node:crypto';
 import { join, resolve } from 'node:path';
+import { normalizeSessionRecord } from './telemetry-event.mjs';
 
 const MAX_PENDING_BYTES = 1024 * 1024;
 const MAX_SESSIONS = 128;
 const WARNING = 'AutoRouter session logging disabled.';
-const SOURCES = new Set(['jev', 'ollama', 'cache', 'fallback', 'passthrough']);
-const ERRORS = new Set(['timeout', 'http_error', 'invalid_response', 'network_error']);
-const identifier = value => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,200}$/.test(value) ? value : undefined;
-const model = value => typeof value === 'string' && /^[A-Za-z0-9_.:/-]{1,120}$/.test(value) ? value : undefined;
-const code = value => typeof value === 'string' && /^[a-z][a-z0-9_]{0,79}$/.test(value) ? value : undefined;
-
-function excerpt(value) {
-  if (typeof value !== 'string') return { text: '', truncated: false };
-  let text = '', count = 0;
-  for (const character of value) {
-    if (count++ === 500) return { text: text.toWellFormed(), truncated: true };
-    text += character;
-  }
-  return { text: text.toWellFormed(), truncated: false };
-}
-
-function normalize(entry) {
-  if (!entry || typeof entry !== 'object' || Array.isArray(entry) || entry.event !== 'decision') return;
-  const requestId = identifier(entry.request_id);
-  const selectedModel = model(entry.selected_model);
-  const requestedModel = model(entry.requested_model);
-  if (!requestId || !selectedModel || !requestedModel) return;
-  const anonymous = entry.session_id === undefined || entry.session_id === null || entry.session_id === '';
-  const sessionId = anonymous ? undefined : identifier(entry.session_id);
-  // An invalid explicit identity must not mix records into an anonymous file.
-  if (!anonymous && !sessionId) return;
-  const requestClass = code(entry.request_class);
-  const foreground = entry.request_class === undefined || entry.request_class === null || entry.request_class === '' || entry.request_class === 'main';
-  const prompt = foreground ? excerpt(entry.prompt_excerpt) : { text: '', truncated: false };
-  const timestamp = typeof entry.timestamp === 'string' && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(entry.timestamp)
-    && Number.isFinite(Date.parse(entry.timestamp)) ? entry.timestamp : new Date().toISOString();
-  const row = { schema_version: 1, event: 'decision', timestamp, request_id: requestId,
-    ...(sessionId ? { session_id: sessionId } : {}),
-    prompt_excerpt: prompt.text, prompt_truncated: prompt.truncated || (foreground && entry.prompt_truncated === true),
-    requested_model: requestedModel, selected_model: selectedModel };
-  for (const field of ['agent_id', 'prompt_id']) {
-    const value = identifier(entry[field]);
-    if (value) row[field] = value;
-  }
-  if (requestClass) row.request_class = requestClass;
-  if (typeof entry.decision_latency_ms === 'number' && Number.isFinite(entry.decision_latency_ms)
-    && entry.decision_latency_ms >= 0) row.decision_latency_ms = entry.decision_latency_ms;
-  if (SOURCES.has(entry.source)) row.source = entry.source;
-  const reason = code(entry.reason);
-  if (reason) row.reason = reason;
-  if (['jev', 'ollama'].includes(entry.evaluator)) row.evaluator = entry.evaluator;
-  if (['haiku', 'sonnet', 'opus'].includes(entry.classified_tier)) row.classified_tier = entry.classified_tier;
-  if (ERRORS.has(entry.classifier_error)) row.classifier_error = entry.classifier_error;
-  return { sessionKey: sessionId ? `session:${sessionId}` : 'anonymous', row };
-}
-
 // Inference never waits on this writer. Each launch creates new files; only
 // accepted, bounded JSON lines are retained until the serialized writer drains.
-export async function createSessionLog(directory, { warn = () => {} } = {}) {
+export async function createSessionLog(directory, { includePrompts = true, warn = () => {} } = {}) {
   let accepting = true, failed = false, warned = false, pendingBytes = 0;
   let root, directoryIdentity, pump, closePromise;
   const sessions = new Map(), queue = [];
@@ -133,19 +83,20 @@ export async function createSessionLog(directory, { warn = () => {} } = {}) {
   function record(entry) {
     if (!accepting) return false;
     try {
-      const normalized = normalize(entry);
-      if (!normalized) return false;
-      const line = `${JSON.stringify(normalized.row)}\n`;
+      const row = normalizeSessionRecord(entry, { includePrompts });
+      if (!row) return false;
+      const sessionKey = row.session_id ? `session:${row.session_id}` : 'anonymous';
+      const line = `${JSON.stringify(row)}\n`;
       const bytes = Buffer.byteLength(line);
-      let session = sessions.get(normalized.sessionKey);
+      let session = sessions.get(sessionKey);
       if (pendingBytes + bytes > MAX_PENDING_BYTES || (!session && sessions.size >= MAX_SESSIONS)) {
         disable();
         return false;
       }
       if (!session) {
-        const sessionHash = createHash('sha256').update(normalized.sessionKey).digest('hex');
+        const sessionHash = createHash('sha256').update(sessionKey).digest('hex');
         session = { path: join(root, `autorouter-session-${launch}-${sessionHash}.jsonl`) };
-        sessions.set(normalized.sessionKey, session);
+        sessions.set(sessionKey, session);
       }
       queue.push({ session, line, bytes });
       pendingBytes += bytes;

package/src/status-state.mjs

@@ -1,18 +1,12 @@
-import { closeSync, chmodSync, fchmodSync, mkdtempSync, openSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import * as fileSystem from 'node:fs/promises';
 import { randomBytes } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createSavingsTracker } from './savings.mjs';
+import { normalizeTelemetryEvent } from './telemetry-event.mjs';
 
-const EVENTS = new Set(['request_start', 'route', 'upstream_response', 'upstream_model', 'upstream_usage', 'upstream_error', 'request_complete', 'request_error', 'request_cancelled']);
-const CLASSIFIER_ERRORS = new Set(['timeout', 'http_error', 'invalid_response', 'network_error']);
-const UPSTREAM_ERRORS = new Set(['invalid_request_error', 'authentication_error', 'billing_error', 'permission_error', 'not_found_error', 'request_too_large', 'rate_limit_error', 'api_error', 'overloaded_error', 'timeout_error', 'unknown_error', 'http_error', 'request_error']);
-const identifier = value => typeof value === 'string' && /^[\w.:-]{1,200}$/.test(value) ? value : undefined;
-const modelName = value => typeof value === 'string' && /^[\w.:/-]{1,120}$/.test(value) ? value : undefined;
-const code = value => typeof value === 'string' && /^[a-z][a-z0-9_]{0,63}$/.test(value) ? value : undefined;
-const httpStatus = value => Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
-const latency = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 3600000 ? value : undefined;
 const tokenCount = value => Number.isSafeInteger(value) && value >= 0;
+const TIMING_FIELDS = ['evaluation_latency_ms', 'routing_latency_ms', 'decision_latency_ms', 'latency_ms', 'first_response_ms', 'total_latency_ms'];
 
 function contextUsage(usage, model) {
   if (!model || !usage || typeof usage !== 'object' || Array.isArray(usage) || usage.pricing_unsupported === true) return;
@@ -32,48 +26,82 @@ function contextUsage(usage, model) {
 // All telemetry is best-effort. Never let filesystem or malformed-event
 // failures interrupt routing, and never persist request bodies or raw errors.
 export function createStatusState(options = {}) {
-  let privateDirectory, path = null, pending, heartbeat, closed = false;
+  let privateDirectory, snapshotPath, path = null, pending, heartbeat, closing = false, disabled = false;
+  let initialized = false, dirty = false, writing, closingPromise;
   const sessions = new Map();
   const savings = createSavingsTracker({ baselineModel: options?.baselineModel });
+  let io = fileSystem;
 
-  function flush() {
-    if (closed) return;
-    if (pending) { clearImmediate(pending); pending = undefined; }
-    if (!path) return;
-    let temporary, fd;
+  async function writeSnapshot() {
+    let temporary, handle;
     try {
       const snapshot = { version: 1, pid: process.pid, heartbeat_at: Date.now(), sessions: Object.fromEntries(sessions), savings: savings.snapshot() };
+      // Capture only one bounded snapshot. Events arriving during I/O merely
+      // mark the latest in-memory state dirty; they never queue more copies.
+      const serialized = JSON.stringify(snapshot);
       temporary = join(privateDirectory, `.state-${randomBytes(8).toString('hex')}.tmp`);
-      fd = openSync(temporary, 'wx', 0o600);
-      fchmodSync(fd, 0o600);
-      writeFileSync(fd, JSON.stringify(snapshot));
-      closeSync(fd); fd = undefined;
-      renameSync(temporary, path);
+      handle = await io.open(temporary, 'wx', 0o600);
+      await handle.chmod(0o600);
+      await handle.writeFile(serialized);
+      await handle.close(); handle = undefined;
+      if (disabled) return false;
+      await io.rename(temporary, snapshotPath);
+      temporary = undefined;
+      return true;
     } catch {
-      if (fd !== undefined) { try { closeSync(fd); } catch {} }
-      if (temporary) { try { rmSync(temporary, { force: true }); } catch {} }
+      return false;
+    } finally {
+      if (handle) { try { await handle.close(); } catch {} }
+      if (temporary) { try { await io.rm(temporary, { force: true }); } catch {} }
     }
   }
 
+  function drain() {
+    if (writing) return writing;
+    if (!initialized || disabled || !dirty) return Promise.resolve();
+    writing = (async () => {
+      while (dirty && !disabled) {
+        dirty = false;
+        await writeSnapshot();
+      }
+    })().finally(() => { writing = undefined; });
+    return writing;
+  }
+
+  function flush() {
+    if (closing) return closingPromise ?? Promise.resolve();
+    if (disabled) return Promise.resolve();
+    dirty = true;
+    if (pending) { clearImmediate(pending); pending = undefined; }
+    // A caller may await durability, but update() never waits for this work.
+    return initialization.then(drain).catch(() => {});
+  }
+
   function schedule() {
-    if (closed || pending || !path) return;
-    try { pending = setImmediate(flush); pending.unref?.(); } catch {}
+    if (closing || disabled) return;
+    dirty = true;
+    if (pending || !initialized) return;
+    try {
+      pending = setImmediate(() => { pending = undefined; void drain(); });
+      pending.unref?.();
+    } catch {}
   }
 
   function update(event) {
-    if (closed) return;
+    if (closing || disabled) return;
     try {
-      if (!event || !EVENTS.has(event.event)) return;
+      event = normalizeTelemetryEvent(event);
+      if (!event) return;
       // Account for all session calls, including parallel agents and auxiliary
       // requests, independently of which foreground request owns the model UI.
       savings.update(event);
       schedule();
       if ((event.agent_id != null && event.agent_id !== '')
         || (event.request_class != null && event.request_class !== '' && event.request_class !== 'main')) return;
-      const sessionId = event.session_id == null || event.session_id === '' ? '' : identifier(event.session_id);
-      const requestId = identifier(event.request_id);
-      // Invalid IDs must never collapse into an unrelated/anonymous session.
-      if (sessionId === undefined || !requestId) return;
+      // The normalizer rejects invalid explicit identities; absent IDs remain
+      // the anonymous session, and future non-main classes stay isolated.
+      const sessionId = event.session_id ?? '';
+      const requestId = event.request_id;
       const previous = sessions.get(sessionId);
       if (event.event === 'request_start') {
         const state = {
@@ -84,8 +112,8 @@ export function createStatusState(options = {}) {
           ...((previous?.context_usage ?? previous?.last_context_usage)
             ? { last_context_usage: previous.context_usage ?? previous.last_context_usage } : {}),
         };
-        const requested = modelName(event.requested_model);
-        const promptId = identifier(event.prompt_id);
+        const requested = event.requested_model;
+        const promptId = event.prompt_id;
         if (requested) state.requested_model = requested;
         if (promptId) state.prompt_id = promptId;
         sessions.delete(sessionId);
@@ -97,29 +125,26 @@ export function createStatusState(options = {}) {
       if (!previous || previous.request_id !== requestId) return;
       const state = previous;
       state.updated_at = Date.now();
-      const status = httpStatus(event.status);
+      const status = event.status;
       const terminal = ['error', 'cancelled', 'ready'].includes(state.phase);
+      for (const key of TIMING_FIELDS) if (event[key] !== undefined) state[key] = event[key];
+      if (event.completion_confirmed !== undefined) state.completion_confirmed = event.completion_confirmed;
       switch (event.event) {
         case 'route': {
-          const fields = { requested_model: modelName(event.requested_model), selected_model: modelName(event.model),
-            source: ['jev', 'ollama', 'cache', 'fallback', 'passthrough'].includes(event.source) ? event.source : undefined,
-            evaluator: ['jev', 'ollama'].includes(event.evaluator) ? event.evaluator : undefined,
-            reason: code(event.reason), latency_ms: latency(event.latency_ms),
-            classified_tier: ['haiku', 'sonnet', 'opus'].includes(event.classified_tier) ? event.classified_tier : undefined,
-            context_check: ['within_budget', 'over_budget', 'count_unavailable'].includes(event.context_check) ? event.context_check : undefined,
-            counted_input_tokens: tokenCount(event.counted_input_tokens) ? event.counted_input_tokens : undefined,
-            classifier_error: CLASSIFIER_ERRORS.has(event.classifier_error) ? event.classifier_error : undefined, classifier_status: httpStatus(event.classifier_status) };
+          const fields = { requested_model: event.requested_model, selected_model: event.selected_model ?? event.model };
+          for (const key of ['source', 'evaluator', 'reason', 'compatibility_reason', 'continuity_state',
+            'classified_tier', 'context_check', 'counted_input_tokens', 'classifier_error', 'classifier_status']) fields[key] = event[key];
           for (const [key, value] of Object.entries(fields)) if (value !== undefined) state[key] = value;
           if (!terminal) state.phase = 'connecting';
           break;
         }
         case 'upstream_response':
           if (status !== undefined) state.status = status;
-          if (status >= 400) { delete state.context_usage; state.phase = 'error'; state.error_type = UPSTREAM_ERRORS.has(event.error_type) ? event.error_type : 'http_error'; }
+          if (status >= 400) { delete state.context_usage; state.phase = 'error'; state.error_type = event.error_type ?? 'http_error'; }
           else if (!terminal) state.phase = 'streaming';
           break;
         case 'upstream_model': {
-          const model = modelName(event.model);
+          const model = event.confirmed_model ?? event.model;
           if (model) { state.actual_model = model; state.last_model = model; }
           if (!terminal) state.phase = 'streaming';
           break;
@@ -134,7 +159,7 @@ export function createStatusState(options = {}) {
         case 'request_error':
           delete state.context_usage;
           state.phase = 'error';
-          state.error_type = UPSTREAM_ERRORS.has(event.error_type) ? event.error_type : (event.event === 'upstream_error' ? 'unknown_error' : 'request_error');
+          state.error_type = event.error_type ?? (event.event === 'upstream_error' ? 'unknown_error' : 'request_error');
           if (status !== undefined) state.status = status;
           break;
         case 'request_complete':
@@ -150,25 +175,48 @@ export function createStatusState(options = {}) {
   }
 
   function close() {
-    if (closed) return;
-    closed = true;
+    if (closingPromise) return closingPromise;
+    closing = true;
     try { clearImmediate(pending); clearInterval(heartbeat); } catch {}
-    sessions.clear();
-    savings.clear();
-    if (privateDirectory) { try { rmSync(privateDirectory, { recursive: true, force: true }); } catch {} }
+    closingPromise = (async () => {
+      // An accepted write must finish before removing its directory. No
+      // detached filesystem promise may recreate a file after shutdown.
+      await initialization;
+      await drain();
+      if (privateDirectory) { try { await io.rm(privateDirectory, { recursive: true, force: true }); } catch {} }
+      sessions.clear();
+      savings.clear();
+    })().catch(() => {});
+    return closingPromise;
   }
 
-  try {
-    const directory = options?.directory ?? tmpdir();
-    privateDirectory = mkdtempSync(join(directory, 'autorouter-status-'));
-    chmodSync(privateDirectory, 0o700);
-    path = join(privateDirectory, 'state.json');
-    flush();
-    heartbeat = setInterval(schedule, 5000);
-    heartbeat.unref();
-  } catch {
-    if (privateDirectory) { try { rmSync(privateDirectory, { recursive: true, force: true }); } catch {} }
-    path = null;
-  }
-  return { path, update, flush, close };
+  const initialization = (async () => {
+    try {
+      io = options?.fileSystem ?? fileSystem;
+      const directory = options?.directory ?? tmpdir();
+      privateDirectory = await io.mkdtemp(join(directory, 'autorouter-status-'));
+      await io.chmod(privateDirectory, 0o700);
+      if (disabled) return;
+      snapshotPath = join(privateDirectory, 'state.json');
+      dirty = false;
+      if (!await writeSnapshot() || disabled) { disabled = true; return; }
+      initialized = true;
+      path = snapshotPath;
+      if (!closing) {
+        heartbeat = setInterval(schedule, 5000);
+        heartbeat.unref();
+        if (dirty) schedule();
+      }
+    } catch { disabled = true; }
+    finally {
+      if (disabled && privateDirectory) { try { await io.rm(privateDirectory, { recursive: true, force: true }); } catch {} }
+    }
+  })();
+  // Optional UI storage must not hold up Claude startup indefinitely. The
+  // underlying operation still belongs to close(), even after this deadline.
+  let readinessTimer;
+  const ready = Promise.race([initialization, new Promise(resolve => {
+    readinessTimer = setTimeout(() => { disabled = true; path = null; resolve(); }, 1000);
+  })]).finally(() => clearTimeout(readinessTimer));
+  return { get path() { return path; }, ready, update, flush, close };
 }

package/src/statusline.mjs

@@ -1,15 +1,26 @@
+import { modelContextWindow } from './model-catalog.mjs';
 const PHASES = new Set(['routing', 'connecting', 'streaming', 'ready', 'error', 'cancelled']);
 const REASONS = {
   tool_turn_pinned: 'turn pinned', prompt_turn_pinned: 'prompt pinned', goal_turn_pinned: 'goal pinned',
-  thinking_history: 'thinking pinned', unknown_continuation: 'continuation pinned',
+  thinking_history: 'thinking pinned', unknown_continuation: 'continuity unknown',
   mid_conversation_system: 'system features', requires_sonnet_capabilities: 'capability guard',
-  model_specific_features: 'model features', large_or_multimodal_request: 'large request',
+  model_specific_features: 'model features', model_incompatible: 'model guard', large_or_multimodal_request: 'large request',
   context_capacity: 'large context',
   internal_request: 'internal request', unknown_model: 'custom model', low_confidence: 'low confidence',
-  auto_mode_floor: 'Auto mode floor', auto_mode_safeguards: 'Auto safety', auto_mode_incompatible: 'Auto model guard',
+  auto_mode_floor: 'Auto floor from Haiku', auto_mode_safeguards: 'Auto safety', auto_mode_incompatible: 'Auto model guard',
+};
+const COMPATIBILITY_REASONS = {
+  unknown_model: 'unknown model', invalid_request_shape: 'request shape', auto_model: 'Auto support',
+  request_extension: 'request extension', safeguards: 'safety review', output_limit: 'output limit', speed: 'speed',
+  execution_facility: 'execution features', tool_type: 'tool type', system_message: 'system messages',
+  message_effort: 'message effort', inline_tool: 'inline tools', content_extension: 'content extension',
+  assistant_prefill: 'prefill', tool_choice: 'tool choice', forced_tool_choice: 'tool choice',
+  context_management: 'context edits', thinking_mode: 'thinking mode', thinking_extension: 'thinking fields',
+  thinking_effort: 'thinking effort', output_extension: 'output fields', effort: 'effort', task_budget: 'task budget', sampling: 'sampling',
 };
 const CLASSIFIER_ERRORS = {
   timeout: 'timeout', http_error: 'HTTP error', invalid_response: 'invalid response', network_error: 'network error',
+  capacity_exhausted: 'evaluator busy',
 };
 const clean = (value, limit = 64) => typeof value === 'string' ? value
   .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, '')
@@ -30,14 +41,6 @@ function modelName(value) {
   return match ? `${match[1][0].toUpperCase()}${match[1].slice(1).toLowerCase()} ${match[2]}${match[3] ? '.' + match[3] : ''}` : name;
 }
 
-// Only unambiguous native windows are listed. Custom IDs and models whose
-// subscription window depends on an opt-in cannot safely imply a capacity.
-const CONTEXT_WINDOWS = new Map([
-  ...['claude-haiku-4-5', 'claude-haiku-4-5-20251001', 'claude-sonnet-4-5', 'claude-sonnet-4-5-20250929',
-    'claude-opus-4-5', 'claude-opus-4-5-20251101'].map(model => [model, 200000]),
-  ...['claude-sonnet-5', 'claude-sonnet-5-5', 'claude-opus-4-7', 'claude-opus-4-8',
-    'claude-opus-5', 'claude-opus-5-5'].map(model => [model, 1000000]),
-]);
 const capacityLabel = value => value % 1000000 === 0 ? `${value / 1000000}M` : value % 1000 === 0 ? `${value / 1000}K` : String(value);
 
 function contextLabel(input, state) {
@@ -55,7 +58,7 @@ function contextLabel(input, state) {
   const historical = !current && ['routing', 'connecting', 'streaming', 'error', 'cancelled'].includes(state?.phase)
     && object(state.last_context_usage) ? state.last_context_usage : undefined;
   const usage = current ?? historical;
-  const capacity = CONTEXT_WINDOWS.get(usage?.model);
+  const capacity = modelContextWindow(usage?.model);
   if (!capacity || !Number.isSafeInteger(usage.input_tokens) || usage.input_tokens < 0) return cli;
   const api = `${historical ? 'last ' : ''}API ctx ${Math.round(usage.input_tokens * 100 / capacity)}%/${capacityLabel(capacity)}`;
   // Keep the client limit visible when it differs: the API window does not
@@ -67,7 +70,8 @@ function savingsLabels(entry) {
   if (!object(entry)) return;
   const count = value => Number.isSafeInteger(value) && value >= 0;
   const dollars = value => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-  const unavailable = { full: 'savings unavailable', compact: 'savings unavailable', color: '33' };
+  const unpriced = count(entry.unpriced_requests) && entry.unpriced_requests > 0 ? ` · unpriced ${entry.unpriced_requests}` : '';
+  const unavailable = { full: `savings unavailable${unpriced}`, compact: 'savings unavailable', color: '33' };
   if (!count(entry.requests) || !count(entry.unpriced_requests)) return unavailable;
   if (entry.requests === 0) return entry.unpriced_requests > 0 ? unavailable : undefined;
   if (!dollars(entry.actual_usd) || !dollars(entry.baseline_usd)
@@ -81,7 +85,7 @@ function savingsLabels(entry) {
   const label = `est ${extra ? 'extra' : 'saved'}`;
   const ending = ` vs Opus${partial ? ' partial' : ''}`;
   return {
-    full: `${label} ${money}${percent ? ` (${percent})` : ''}${ending}`,
+    full: `${label} ${money}${percent ? ` (${percent})` : ''}${ending}${unpriced}`,
     compact: percent ? `${label} ${percent}${ending}` : `${label} ${money}${ending}`,
     color: extra || partial ? '33' : '32',
   };
@@ -108,7 +112,10 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
   const savings = savingsLabels(savingsEntry);
   const state = object(candidate) && PHASES.has(candidate.phase) ? candidate : undefined;
   const phase = state?.phase;
-  let status = phase ?? 'awaiting request';
+  // Receiving a model identifier proves who served some output, not that the
+  // protocol completed. Observation limits can also leave completion unknown.
+  const completionUnknown = phase === 'ready' && state?.completion_confirmed === false;
+  let status = completionUnknown ? 'completion unknown' : phase ?? 'awaiting request';
   let model = '';
   let prefix = '';
   let suffix = '';
@@ -121,9 +128,11 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
   else if (phase === 'streaming' && selected) { model = selected; suffix = ' unconfirmed'; }
   else if (phase === 'ready' && actual) { model = actual; prefix = 'last '; confirmed = true; }
   else if (phase === 'ready' && selected) { model = selected; suffix = ' unconfirmed'; }
-  else if (['ready', 'error', 'cancelled'].includes(phase) && (last || actual)) { model = last || actual; prefix = 'last '; confirmed = true; }
+  else if (['error', 'cancelled'].includes(phase) && actual) { model = actual; prefix = 'last '; confirmed = true; }
+  else if (['error', 'cancelled'].includes(phase) && selected) { model = selected; suffix = ' selected'; }
+  else if (['ready', 'error', 'cancelled'].includes(phase) && last) { model = last; prefix = 'last '; confirmed = true; }
   else if (last) { model = last; prefix = 'last '; confirmed = true; }
-  if (phase === 'ready' && !model) status = 'awaiting request';
+  if (phase === 'ready' && !model && !completionUnknown) status = 'awaiting request';
   const errorType = clean(state?.error_type, 32);
   if (phase === 'error') status = Number.isInteger(state.status) && state.status >= 400 && state.status <= 599
     ? `error ${state.status}` : errorType ? `error ${errorType}` : 'error';
@@ -135,15 +144,19 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
   let fallbackCause = '';
   let fallbackPhase = '';
   let compactFallback = false;
+  let compactGuard = false;
   if (source) {
     const sourceLabel = source === 'passthrough' ? 'pass-through' : source === 'jev' ? 'Jev' : source === 'ollama' ? 'Ollama'
       : evaluatorLabel ? `${evaluatorLabel} ${source}` : source;
-    const timing = Number.isFinite(state.latency_ms) && state.latency_ms >= 0 ? ` ${Math.round(Math.min(state.latency_ms, 999999))}ms` : '';
+    const evaluationLatency = state.evaluation_latency_ms ?? state.latency_ms;
+    const timing = Number.isFinite(evaluationLatency) && evaluationLatency >= 0 ? ` ${Math.round(Math.min(evaluationLatency, 999999))}ms` : '';
     const classified = ['haiku', 'sonnet', 'opus'].includes(state.classified_tier) ? state.classified_tier : undefined;
     const chosenFamily = /^claude-(haiku|sonnet|opus)-/.exec(state.selected_model ?? '')?.[1];
     const override = source !== 'fallback' && classified && chosenFamily && classified !== chosenFamily
       ? `→${classified[0].toUpperCase()}${classified.slice(1)}` : '';
     details.push(`${sourceLabel}${override}${timing}`);
+    if (Number.isFinite(state.routing_latency_ms) && state.routing_latency_ms >= 0
+      && state.evaluation_latency_ms !== undefined) details.push(`route ${Math.round(Math.min(state.routing_latency_ms, 999999))}ms`);
   }
   if (source === 'fallback') {
     // Snapshots normally contain allowlisted categories, but the renderer also
@@ -153,8 +166,16 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
       && state.classifier_status >= 100 && state.classifier_status <= 599) fallbackCause = `HTTP ${state.classifier_status}`;
     if (fallbackCause) details.push(fallbackCause);
   }
-  if (Object.hasOwn(REASONS, state?.reason)) details.push(state.reason === 'context_capacity' && state.context_check === 'count_unavailable'
-    ? 'size unverified' : REASONS[state.reason]);
+  let guard = Object.hasOwn(REASONS, state?.reason) ? state.reason === 'context_capacity' && state.context_check === 'count_unavailable'
+    ? 'size unverified' : REASONS[state.reason] : '';
+  if (state?.continuity_state === 'unknown') guard = 'continuity unknown';
+  else if (state?.continuity_state === 'capacity_exhausted') guard = 'continuity capacity full';
+  else if (['model_incompatible', 'auto_mode_incompatible'].includes(state?.reason)
+    && Object.hasOwn(COMPATIBILITY_REASONS, state.compatibility_reason)) guard = `${guard}: ${COMPATIBILITY_REASONS[state.compatibility_reason]}`;
+  const shortGuard = state?.continuity_state === 'capacity_exhausted' ? 'state full'
+    : guard === 'Auto floor from Haiku' ? 'Auto floor'
+      : guard.includes(': ') ? REASONS[state.reason] : guard;
+  if (guard) details.push(guard);
   if (phase === 'error' && errorType && !status.includes(errorType)) details.push(errorType);
   let context = contextLabel(input, state);
   let detail = details.join(' · ');
@@ -163,10 +184,9 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
   const modelLabel = () => model ? prefix + model + suffix : '';
   const plain = () => [brand, modelLabel(), status, detail, saving, context].filter(Boolean).join(' · ');
   if (width(plain()) > available) context = '';
-  // Routine routing details can yield to the estimate, while errors and
-  // fallback explanations have priority over savings. Never shorten away
-  // "est" or "partial": hide the whole metric when its qualifiers cannot fit.
-  if (width(plain()) > available && source !== 'fallback' && phase !== 'error') detail = '';
+  // Preserve why this model was chosen before estimates, timing, or context.
+  // Never shorten away "est" or "partial": hide an estimate as one unit.
+  if (width(plain()) > available && source !== 'fallback' && phase !== 'error') detail = guard;
   if (width(plain()) > available && saving) saving = savings.compact;
   if (width(plain()) > available) saving = '';
   if (width(plain()) > available && source === 'fallback') {
@@ -174,18 +194,28 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
     // space is tight, retain that cause instead of an ordinary "ready" phase,
     // evaluator timing, or the guard details that followed the fallback.
     compactFallback = true;
-    fallbackPhase = ['error', 'cancelled'].includes(phase) ? status : '';
+    fallbackPhase = completionUnknown || ['error', 'cancelled'].includes(phase) ? status : '';
     status = [fallbackPhase, `${evaluatorLabel ? `${evaluatorLabel} ` : ''}fallback${fallbackCause ? `: ${fallbackCause}` : ''}`].filter(Boolean).join(' · ');
     detail = '';
   }
+  if (width(plain()) > available && source !== 'fallback' && guard) {
+    compactGuard = true;
+    status = [completionUnknown || ['error', 'cancelled'].includes(phase) ? status : '', shortGuard].filter(Boolean).join(' · ');
+    detail = '';
+  }
   if (width(plain()) > available) detail = '';
   if (width(plain()) > available) brand = '● AR';
   if (width(plain()) > available) brand = '';
+  if (width(plain()) > available && completionUnknown) {
+    // The response qualifier takes priority over an earlier routing decision.
+    // Keep the observed/selected model when both it and the qualifier can fit.
+    status = 'completion unknown'; detail = ''; compactFallback = false;
+  }
   if (width(plain()) > available && compactFallback) {
     status = [fallbackPhase, `fallback${fallbackCause ? `: ${fallbackCause}` : ''}`].filter(Boolean).join(' · ');
   }
   if (width(plain()) > available && model) {
-    if (phase === 'streaming' && !compactFallback) status = 'stream';
+    if (phase === 'streaming' && !compactFallback && !compactGuard) status = 'stream';
     const room = available - width(prefix + suffix + status) - 3;
     if (room >= 1) model = shorten(model, room);
     else {
@@ -199,7 +229,7 @@ export function renderStatusLine(input, snapshot, { now = Date.now(), color = tr
   if (width(plain()) > available && compactFallback && !fallbackPhase && available >= width('fallback')
     && available < width('fallback: ') + 2) status = 'fallback';
   if (width(plain()) > available) status = shorten(status, Math.max(1, available - width(modelLabel()) - (model ? 3 : 0)));
-  const attention = phase === 'error' ? '31' : source === 'fallback' ? '33' : phase === 'cancelled' ? '2' : phase === 'streaming' || phase === 'ready' ? '32' : '36';
+  const attention = phase === 'error' ? '31' : completionUnknown || source === 'fallback' ? '33' : phase === 'cancelled' ? '2' : phase === 'streaming' || phase === 'ready' ? '32' : '36';
   const chunks = [];
   if (brand) chunks.push(`${paint('●', attention)} ${paint(brand.slice(2), '1')}`);
   if (model) chunks.push(paint(modelLabel(), confirmed ? '37' : '33'));