@pensar/apex 2.4.0 → 2.5.0-canary.2bbb0f6f

package/build/{index-6d22pyxt.js → index-3gavwzay.js}

@@ -7,23 +7,36 @@ import {
   buildThreatModelPrompt,
   createSkillsRegistry,
   runOffensiveSecurityAgent
-} from "./cli-vq52kp7j.js";
+} from "./cli-a8n64cef.js";
+import {
+  EMPTY_SESSION_TOKEN_USAGE,
+  accumulateSessionTokens,
+  contextPercentage
+} from "./cli-9pbk8m32.js";
 import {
   convertModelMessagesToUI,
   loadSubagents,
   readExecutionMetrics,
   writeExecutionMetrics
-} from "./cli-5k33webc.js";
-import"./cli-gq40s5b3.js";
+} from "./cli-7sqb16dd.js";
+import"./cli-fw7sp0fp.js";
+import"./cli-14j00zfh.js";
+import"./cli-3ew5fs3f.js";
 import {
   REPORT_FILENAME_MD
-} from "./cli-b1adytsy.js";
-import"./cli-mavved45.js";
-import"./cli-xshasbwe.js";
-import"./cli-32z0017y.js";
-import"./cli-k8kc47pq.js";
+} from "./cli-yge44bmk.js";
+import {
+  createWeaveTracer,
+  resolveConfig
+} from "./cli-t7rhyqx5.js";
+import {
+  AVAILABLE_PROVIDERS,
+  init_types
+} from "./cli-ee3axgts.js";
+import"./cli-4mgj070h.js";
+import"./cli-g3cb8pj5.js";
 import"./cli-9fsre5pt.js";
-import"./cli-qqt4gj1w.js";
+import"./cli-a9vq54sx.js";
 import {
   ALL_TOOL_NAMES,
   ASK_USER_QUESTIONS_TOOL_NAME,
@@ -39,10 +52,19 @@ import {
   hasPlan,
   planFilePath,
   readPlan
-} from "./cli-repbyhkk.js";
+} from "./cli-4vwnsyep.js";
 import {
   detectOSAndEnhancePrompt
-} from "./cli-tznv8pf1.js";
+} from "./cli-gbch9xmy.js";
+import {
+  require_index_node_http,
+  require_index_shim,
+  require_src as require_src2,
+  require_src1 as require_src3,
+  require_src2 as require_src4,
+  require_src3 as require_src5,
+  require_src4 as require_src6
+} from "./cli-68260ckj.js";
 import {
   formatParseError,
   parseHeaderLine
@@ -55,20 +77,18 @@ import {
   getAutoPopulatedPorts,
   parseTargetUrl
 } from "./cli-c8131c4q.js";
-import {
-  createWeaveTracer,
-  resolveConfig
-} from "./cli-2cbwdk78.js";
-import {
-  AVAILABLE_PROVIDERS,
-  init_types
-} from "./cli-ee3axgts.js";
 import {
   AVAILABLE_MODELS,
   DEFAULT_OPENAI_REASONING_EFFORT,
+  addRecentModelId,
   buildAuthConfig,
+  endAllActiveRootSpans,
+  getContextWindow,
   getOpenAIReasoningEfforts,
+  getRecentModels,
+  getResumeMessages,
   hasToolCall,
+  init_active_root_spans,
   init_ai,
   init_dist,
   init_logger,
@@ -85,7 +105,7 @@ import {
   stepCountIs,
   write,
   writeErrorLog
-} from "./cli-tkc598ey.js";
+} from "./cli-f47dgye3.js";
 import {
   disconnect,
   ensureValidToken,
@@ -100,21 +120,23 @@ import {
   selectWorkspace,
   startDeviceFlow,
   validateGateway
-} from "./cli-0n4r54hq.js";
-import"./cli-swpbx60z.js";
+} from "./cli-08fcc6d8.js";
+import"./cli-avmhkjtv.js";
 import"./cli-j54qa6tm.js";
 import {
   config,
-  init_config as init_config2
-} from "./cli-72cvcqhg.js";
-import {
-  init_config,
-  update
-} from "./cli-9rhzhgx2.js";
+  init_config
+} from "./cli-9ya3yktn.js";
+import"./cli-8pk8znhw.js";
 import {
   checkForUpdate,
-  init_installation
-} from "./cli-vnynf0js.js";
+  init_installation,
+  init_package,
+  version
+} from "./cli-3bmqdcfh.js";
+import {
+  require_src
+} from "./cli-knd276ed.js";
 import {
   __commonJS,
   __esm,
@@ -752,11 +774,11 @@ var require_core = __commonJS(function(exports, module) {
   var warn = (message, ...args) => {
     console.log(`WARN: ${message}`, ...args);
   };
-  var deprecated = (version2, message) => {
-    if (seenDeprecations[`${version2}/${message}`])
+  var deprecated = (version3, message) => {
+    if (seenDeprecations[`${version3}/${message}`])
       return;
-    console.log(`Deprecated as of ${version2}. ${message}`);
-    seenDeprecations[`${version2}/${message}`] = true;
+    console.log(`Deprecated as of ${version3}. ${message}`);
+    seenDeprecations[`${version3}/${message}`] = true;
   };
   var MultiClassError = new Error;
   function remapScopeNames(mode, regexes, { key }) {
@@ -1006,7 +1028,7 @@ var require_core = __commonJS(function(exports, module) {
     }
     return mode;
   }
-  var version = "11.11.1";
+  var version2 = "11.11.1";
 
   class HTMLInjectionError extends Error {
     constructor(reason, html) {
@@ -1070,13 +1092,13 @@ https://github.com/highlightjs/highlight.js/issues/2277`);
       if (ignoreIllegals === undefined) {
         ignoreIllegals = true;
       }
-      const context = {
+      const context2 = {
         code,
         language: languageName
       };
-      fire("before:highlight", context);
-      const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals);
-      result.code = context.code;
+      fire("before:highlight", context2);
+      const result = context2.result ? context2.result : _highlight(context2.language, context2.code, ignoreIllegals);
+      result.code = context2.code;
       fire("after:highlight", result);
       return result;
     }
@@ -1628,7 +1650,7 @@ https://github.com/highlightjs/highlight.js/issues/2277`);
     hljs.safeMode = function() {
       SAFE_MODE = true;
     };
-    hljs.versionString = version;
+    hljs.versionString = version2;
     hljs.regex = {
       concat,
       lookahead,
@@ -49370,13 +49392,186 @@ var require_lib = __commonJS(function(exports, module) {
 });
 
 // src/tui/index.tsx
-init_config2();
+init_config();
 init_installation();
 init_logger();
 import { createCliRenderer, FrameBufferRenderable, RGBA as RGBA25 } from "@opentui/core";
 import { createRoot, extend } from "@opentui/react";
 import { useEffect as useEffect27, useState as useState40 } from "react";
 
+// src/core/observability/runtime.ts
+init_package();
+init_active_root_spans();
+var import_api = __toESM(require_src(), 1);
+var import_context_async_hooks = __toESM(require_src2(), 1);
+var import_exporter_trace_otlp_http = __toESM(require_src6(), 1);
+var import_otlp_exporter_base = __toESM(require_src3(), 1);
+var import_node_http = __toESM(require_index_node_http(), 1);
+var import_otlp_transformer = __toESM(require_src5(), 1);
+var import_resources = __toESM(require_src4(), 1);
+var import_sdk_trace_base = __toESM(require_index_shim(), 1);
+import { randomUUID } from "node:crypto";
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
+function withTimeout(promise, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => settle("timed-out"), timeoutMs);
+    promise.then(() => settle("completed"), () => settle("completed"));
+  });
+}
+var NOOP_RUNTIME = {
+  async forceFlush() {},
+  async shutdown() {
+    return "completed";
+  }
+};
+function isOtelSdkDisabled(env) {
+  return env.OTEL_SDK_DISABLED === "true";
+}
+function resolveTracesEndpoint(env) {
+  const specific = env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim();
+  if (specific)
+    return specific;
+  const generic = env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+  if (!generic)
+    return null;
+  return `${generic.endsWith("/") ? generic : `${generic}/`}v1/traces`;
+}
+function resolveTracesProtocol(env) {
+  const raw = (env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL ?? env.OTEL_EXPORTER_OTLP_PROTOCOL ?? "").trim();
+  return raw === "http/protobuf" ? "http/protobuf" : "http/json";
+}
+function parseResourceAttributes(env) {
+  const raw = env.OTEL_RESOURCE_ATTRIBUTES;
+  if (!raw)
+    return {};
+  const attrs = {};
+  for (const pair of raw.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0)
+      continue;
+    const key = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1).trim();
+    if (key && value)
+      attrs[key] = value;
+  }
+  return attrs;
+}
+function buildResource(env) {
+  const resourceAttributes = parseResourceAttributes(env);
+  return import_resources.resourceFromAttributes({
+    "service.version": version,
+    "service.instance.id": randomUUID(),
+    ...resourceAttributes,
+    "service.name": env.OTEL_SERVICE_NAME?.trim() || resourceAttributes["service.name"] || "apex"
+  });
+}
+function createTraceExporter(protocol) {
+  if (protocol === "http/json") {
+    return new import_exporter_trace_otlp_http.OTLPTraceExporter;
+  }
+  return new import_otlp_exporter_base.OTLPExporterBase(import_node_http.createOtlpHttpExportDelegate(import_node_http.convertLegacyHttpOptions({}, "TRACES", "v1/traces", {
+    "Content-Type": "application/x-protobuf"
+  }), import_otlp_transformer.ProtobufTraceSerializer, "otlp_http_span_exporter", import_otlp_transformer.TraceExporterMetricsHelper, undefined));
+}
+var activeRuntime = null;
+function startObservabilityRuntime(env = process.env, opts) {
+  if (activeRuntime)
+    return activeRuntime;
+  if (isOtelSdkDisabled(env))
+    return NOOP_RUNTIME;
+  if (!resolveTracesEndpoint(env))
+    return NOOP_RUNTIME;
+  const shutdownTimeoutMs = opts?.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+  const exporter = createTraceExporter(resolveTracesProtocol(env));
+  const provider = new import_sdk_trace_base.BasicTracerProvider({
+    resource: buildResource(env),
+    spanProcessors: opts?.spanProcessors ?? [new import_sdk_trace_base.BatchSpanProcessor(exporter)]
+  });
+  const contextManager = new import_context_async_hooks.AsyncLocalStorageContextManager;
+  contextManager.enable();
+  import_api.trace.setGlobalTracerProvider(provider);
+  import_api.context.setGlobalContextManager(contextManager);
+  let shutdownPromise = null;
+  const runtime = {
+    async forceFlush() {
+      await provider.forceFlush();
+    },
+    shutdown() {
+      if (!shutdownPromise) {
+        const shutdownWork = (async () => {
+          endAllActiveRootSpans();
+          try {
+            await provider.forceFlush();
+          } finally {
+            await provider.shutdown();
+          }
+        })();
+        shutdownPromise = withTimeout(shutdownWork, shutdownTimeoutMs).then((result) => {
+          contextManager.disable();
+          import_api.trace.disable();
+          import_api.context.disable();
+          return result;
+        }).finally(() => {
+          activeRuntime = null;
+        });
+      }
+      return shutdownPromise;
+    }
+  };
+  activeRuntime = runtime;
+  return runtime;
+}
+function installObservabilityExitHandlers(runtime, opts) {
+  let exitPromise = null;
+  let exitCode = 0;
+  let fatalSeen = false;
+  const reportError = (error, source) => {
+    try {
+      opts?.onError?.(error, source);
+    } catch {}
+  };
+  const exitWith = (code, error, source) => {
+    let pendingReport = null;
+    if (error !== undefined && !fatalSeen) {
+      fatalSeen = true;
+      exitCode = 1;
+      const fatalSource = source ?? "uncaughtException";
+      pendingReport = () => reportError(error, fatalSource);
+    } else if (!fatalSeen && exitCode === 0) {
+      exitCode = code;
+    }
+    if (exitPromise) {
+      pendingReport?.();
+      return exitPromise;
+    }
+    try {
+      opts?.cleanup?.(code);
+    } catch (cleanupError) {
+      if (!fatalSeen) {
+        fatalSeen = true;
+        exitCode = 1;
+        pendingReport = () => reportError(cleanupError, "uncaughtException");
+      }
+    }
+    pendingReport?.();
+    exitPromise = runtime.shutdown().catch(() => {}).then(() => process.exit(exitCode));
+    return exitPromise;
+  };
+  process.on("SIGINT", () => void exitWith(130));
+  process.on("SIGTERM", () => void exitWith(143));
+  process.on("uncaughtException", (error) => void exitWith(1, error, "uncaughtException"));
+  process.on("unhandledRejection", (reason) => void exitWith(1, reason, "unhandledRejection"));
+  return exitWith;
+}
+
 // src/core/providers/index.ts
 init_types();
 init_utils();
@@ -52796,16 +52991,15 @@ function createClipboardManager(renderer) {
 
 // src/tui/components/chat/index.tsx
 init_session();
-import { useCallback as useCallback12, useEffect as useEffect12, useState as useState19 } from "react";
+import { useCallback as useCallback14, useEffect as useEffect12, useState as useState19 } from "react";
 
 // src/tui/context/agent.tsx
 init_ai();
-init_config();
 init_logger();
 init_utils();
 import {
   createContext as createContext3,
-  useCallback as useCallback2,
+  useCallback as useCallback4,
   useContext as useContext3,
   useEffect as useEffect2,
   useMemo as useMemo3,
@@ -52814,9 +53008,10 @@ import {
 } from "react";
 
 // src/tui/context/config.tsx
-init_config2();
+init_config();
 import {
   createContext as createContext2,
+  useCallback as useCallback2,
   useContext as useContext2,
   useMemo as useMemo2,
   useState as useState2
@@ -52825,20 +53020,22 @@ import { jsxDEV as jsxDEV2 } from "@opentui/react/jsx-dev-runtime";
 var ctx = createContext2(null);
 function ConfigProvider({ children, config: config2 }) {
   const [appConfig, setAppConfig] = useState2(config2);
+  const update = useCallback2(async (newConfig) => {
+    await config.update(newConfig);
+    setAppConfig((current) => ({
+      ...current,
+      ...newConfig
+    }));
+  }, []);
+  const reload = useCallback2(async () => {
+    const freshConfig = await config.get();
+    setAppConfig(freshConfig);
+  }, []);
   const value = useMemo2(() => ({
     data: appConfig,
-    update: async (newConfig) => {
-      await config.update(newConfig);
-      setAppConfig({
-        ...appConfig,
-        ...newConfig
-      });
-    },
-    reload: async () => {
-      const freshConfig = await config.get();
-      setAppConfig(freshConfig);
-    }
-  }), [appConfig]);
+    update,
+    reload
+  }), [appConfig, reload, update]);
   return /* @__PURE__ */ jsxDEV2(ctx.Provider, {
     value,
     children
@@ -52852,15 +53049,133 @@ var useConfig = () => {
   return config2;
 };
 
+// src/tui/context/session-usage.ts
+import { useCallback as useCallback3, useSyncExternalStore } from "react";
+var EMPTY_STATE = {
+  tokenUsage: EMPTY_SESSION_TOKEN_USAGE,
+  contextUsage: null
+};
+
+class SessionUsageStore {
+  sessions = new Map;
+  listeners = new Map;
+  activeListeners = new Set;
+  activeId = null;
+  provisionalState = EMPTY_STATE;
+  get activeSessionId() {
+    return this.activeId;
+  }
+  beginNewSession() {
+    const changed = this.activeId !== null || this.provisionalState !== EMPTY_STATE;
+    this.activeId = null;
+    this.provisionalState = EMPTY_STATE;
+    if (changed)
+      this.emitActive();
+  }
+  enterSession(sessionId, seed) {
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, {
+        tokenUsage: seed?.tokenUsage ?? this.provisionalState.tokenUsage,
+        contextUsage: seed?.contextUsage ?? null
+      });
+      this.provisionalState = EMPTY_STATE;
+    }
+    if (this.activeId !== sessionId) {
+      this.activeId = sessionId;
+      this.emit(sessionId);
+    }
+  }
+  forgetSession(sessionId) {
+    this.sessions.delete(sessionId);
+    this.listeners.delete(sessionId);
+    if (this.activeId === sessionId)
+      this.activeId = null;
+  }
+  getSnapshot(sessionId) {
+    if (sessionId === null)
+      return EMPTY_STATE;
+    return this.sessions.get(sessionId) ?? EMPTY_STATE;
+  }
+  subscribe(sessionId, listener) {
+    let set = this.listeners.get(sessionId);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(sessionId, set);
+    }
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+    };
+  }
+  addSessionTokens(sessionId, step) {
+    if (sessionId === null) {
+      const next = accumulateSessionTokens(this.provisionalState.tokenUsage, step);
+      if (next !== this.provisionalState.tokenUsage) {
+        this.provisionalState = { tokenUsage: next, contextUsage: null };
+        if (this.activeId === null)
+          this.emitActive();
+      }
+      return;
+    }
+    this.update(sessionId, (state) => ({
+      ...state,
+      tokenUsage: accumulateSessionTokens(state.tokenUsage, step)
+    }));
+  }
+  setRootContext(sessionId, sample) {
+    if (sessionId === null)
+      return;
+    this.update(sessionId, (state) => ({
+      ...state,
+      contextUsage: sample
+    }));
+  }
+  update(sessionId, updater) {
+    const current = this.sessions.get(sessionId);
+    if (!current)
+      return;
+    const next = updater(current);
+    if (next === current || next.tokenUsage === current.tokenUsage && next.contextUsage === current.contextUsage) {
+      return;
+    }
+    this.sessions.set(sessionId, next);
+    this.emit(sessionId);
+  }
+  getActiveSnapshot() {
+    return this.activeId === null ? this.provisionalState : this.getSnapshot(this.activeId);
+  }
+  subscribeActive(listener) {
+    this.activeListeners.add(listener);
+    return () => {
+      this.activeListeners.delete(listener);
+    };
+  }
+  emit(sessionId) {
+    for (const listener of this.listeners.get(sessionId) ?? [])
+      listener();
+    if (sessionId === this.activeId)
+      this.emitActive();
+  }
+  emitActive() {
+    for (const listener of this.activeListeners)
+      listener();
+  }
+}
+function useActiveSessionUsage(store) {
+  const subscribe = useCallback3((listener) => store.subscribeActive(listener), [store]);
+  const getSnapshot = useCallback3(() => store.getActiveSnapshot(), [store]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
 // src/tui/context/agent.tsx
 import { jsxDEV as jsxDEV3 } from "@opentui/react/jsx-dev-runtime";
 var AgentContext = createContext3(null);
 function useAgent() {
-  const context = useContext3(AgentContext);
-  if (!context) {
+  const context2 = useContext3(AgentContext);
+  if (!context2) {
     throw new Error("useAgent must be used within AgentProvider");
   }
-  return context;
+  return context2;
 }
 function AgentProvider({ children }) {
   const appConfig = useConfig();
@@ -52868,13 +53183,7 @@ function AgentProvider({ children }) {
     return getDefaultModelForConfig(appConfig.data) ?? AVAILABLE_MODELS[0];
   });
   const [isModelUserSelected, setIsModelUserSelected] = useState3(false);
-  const [tokenUsage, setTokenUsage] = useState3({
-    inputTokens: 0,
-    outputTokens: 0,
-    totalTokens: 0,
-    cachedTokens: 0,
-    cacheWriteTokens: 0
-  });
+  const usageStore = useMemo3(() => new SessionUsageStore, []);
   const [hasExecuted, setHasExecuted] = useState3(false);
   const [thinking, setThinking] = useState3(false);
   const [reasoningEnabled, setReasoningEnabledInternal] = useState3(() => appConfig.data?.reasoningEnabled ?? false);
@@ -52885,12 +53194,17 @@ function AgentProvider({ children }) {
   reasoningEnabledRef.current = reasoningEnabled;
   const openAIReasoningEffortRef = useRef(openAIReasoningEffort);
   openAIReasoningEffortRef.current = openAIReasoningEffort;
-  const setModel = useCallback2((newModel, persist = true) => {
+  const recentModelIdsRef = useRef(appConfig.data.recentModelIds ?? []);
+  const updateConfig = appConfig.update;
+  const setModel = useCallback4((newModel, persist = true) => {
     setModelInternal(newModel);
     if (persist) {
       setIsModelUserSelected(true);
+      const nextRecentModelIds = addRecentModelId(recentModelIdsRef.current, newModel.id);
+      recentModelIdsRef.current = nextRecentModelIds;
       const configUpdate = {
-        selectedModelId: newModel.id
+        selectedModelId: newModel.id,
+        recentModelIds: nextRecentModelIds
       };
       if (reasoningEnabledRef.current && !modelSupportsThinking(newModel.id)) {
         configUpdate.reasoningEnabled = false;
@@ -52901,23 +53215,26 @@ function AgentProvider({ children }) {
         configUpdate.openAIReasoningEffort = DEFAULT_OPENAI_REASONING_EFFORT;
         setOpenAIReasoningEffortInternal(DEFAULT_OPENAI_REASONING_EFFORT);
       }
-      update(configUpdate).catch((err) => {
+      updateConfig(configUpdate).catch((err) => {
         writeErrorLog(err, "AGENT_CONTEXT");
       });
     }
-  }, []);
-  const setReasoningEnabled = useCallback2((enabled) => {
+  }, [updateConfig]);
+  const setReasoningEnabled = useCallback4((enabled) => {
     setReasoningEnabledInternal(enabled);
-    update({ reasoningEnabled: enabled }).catch((err) => {
+    updateConfig({ reasoningEnabled: enabled }).catch((err) => {
       writeErrorLog(err, "AGENT_CONTEXT");
     });
-  }, []);
-  const setOpenAIReasoningEffort = useCallback2((effort) => {
+  }, [updateConfig]);
+  const setOpenAIReasoningEffort = useCallback4((effort) => {
     setOpenAIReasoningEffortInternal(effort);
-    update({ openAIReasoningEffort: effort }).catch((err) => {
+    updateConfig({ openAIReasoningEffort: effort }).catch((err) => {
       writeErrorLog(err, "AGENT_CONTEXT");
     });
-  }, []);
+  }, [updateConfig]);
+  useEffect2(() => {
+    recentModelIdsRef.current = appConfig.data.recentModelIds ?? [];
+  }, [appConfig.data.recentModelIds]);
   useEffect2(() => {
     if (appConfig.data?.reasoningEnabled != null) {
       setReasoningEnabledInternal(appConfig.data.reasoningEnabled);
@@ -52948,40 +53265,13 @@ function AgentProvider({ children }) {
       setModelInternal(defaultModel);
     }
   }, [appConfig.data, isModelUserSelected]);
-  const addTokenUsage = useCallback2((input, output) => {
-    setHasExecuted(true);
-    setTokenUsage((prev) => ({
-      ...prev,
-      inputTokens: prev.inputTokens + input,
-      outputTokens: prev.outputTokens + output,
-      totalTokens: prev.totalTokens + input + output
-    }));
-  }, []);
-  const addCacheUsage = useCallback2((cacheRead, cacheWrite) => {
-    setTokenUsage((prev) => ({
-      ...prev,
-      cachedTokens: prev.cachedTokens + cacheRead,
-      cacheWriteTokens: prev.cacheWriteTokens + cacheWrite
-    }));
-  }, []);
-  const resetTokenUsage = useCallback2(() => {
-    setHasExecuted(false);
-    setTokenUsage({
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-      cachedTokens: 0,
-      cacheWriteTokens: 0
-    });
-  }, []);
+  const markExecuted = useCallback4(() => setHasExecuted(true), []);
   const contextValue = useMemo3(() => ({
     model,
     setModel,
     isModelUserSelected,
-    tokenUsage,
-    addTokenUsage,
-    addCacheUsage,
-    resetTokenUsage,
+    usageStore,
+    markExecuted,
     hasExecuted,
     thinking,
     setThinking,
@@ -52997,7 +53287,6 @@ function AgentProvider({ children }) {
     model,
     setModel,
     isModelUserSelected,
-    tokenUsage,
     hasExecuted,
     thinking,
     reasoningEnabled,
@@ -53005,9 +53294,8 @@ function AgentProvider({ children }) {
     openAIReasoningEffort,
     isExecuting,
     sessionCwd,
-    addTokenUsage,
-    addCacheUsage,
-    resetTokenUsage,
+    usageStore,
+    markExecuted,
     setOpenAIReasoningEffort
   ]);
   return /* @__PURE__ */ jsxDEV3(AgentContext.Provider, {
@@ -53019,14 +53307,14 @@ function AgentProvider({ children }) {
 // src/tui/components/chat/config-view.tsx
 init_utils();
 import { useKeyboard as useKeyboard2 } from "@opentui/react";
-import { useCallback as useCallback4, useEffect as useEffect4, useState as useState5 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect4, useState as useState5 } from "react";
 
 // src/tui/components/model-picker/ModelPicker.tsx
 init_ai();
 init_utils();
 import { useKeyboard } from "@opentui/react";
 import {
-  useCallback as useCallback3,
+  useCallback as useCallback5,
   useEffect as useEffect3,
   useMemo as useMemo4,
   useRef as useRef2,
@@ -53094,18 +53382,105 @@ function findChildById(scrollBox, id) {
   return;
 }
 
-// src/tui/components/model-picker/ModelPicker.tsx
-import { jsxDEV as jsxDEV4 } from "@opentui/react/jsx-dev-runtime";
-var providerNames = {
-  anthropic: "Claude",
+// src/tui/components/model-picker/model-navigation.ts
+function findSelectedModelIndex(navigationItems, selectedModelId) {
+  return navigationItems.findIndex((item) => (item.type === "model" || item.type === "recent-model") && item.model?.id === selectedModelId);
+}
+function retainAvailableProviders(expandedProviders, availableProviders) {
+  const retainedProviders = new Set([...expandedProviders].filter((provider) => availableProviders.has(provider)));
+  return retainedProviders.size === expandedProviders.size ? expandedProviders : retainedProviders;
+}
+function getSelectedModelRevealKey({
+  availableModels,
+  selectedModel,
+  lastRevealedSelectedModelKey
+}) {
+  const selectedModelKey = `${selectedModel.provider}:${selectedModel.id}`;
+  if (lastRevealedSelectedModelKey === selectedModelKey)
+    return null;
+  const selectedModelIsAvailable = availableModels.some((model) => model.id === selectedModel.id && model.provider === selectedModel.provider);
+  return selectedModelIsAvailable ? selectedModelKey : null;
+}
+
+// src/tui/components/model-picker/model-search.ts
+var PROVIDER_DISPLAY_NAMES = {
+  anthropic: "Anthropic",
   openai: "OpenAI",
-  google: "Gemini",
+  google: "Google",
   openrouter: "OpenRouter",
   concentrate: "Concentrate",
-  bedrock: "Bedrock",
+  bedrock: "AWS Bedrock",
+  "bedrock-mantle": "Bedrock Mantle",
   pensar: "Pensar",
+  inception: "Inception",
   local: "Local LLM"
 };
+function getProviderDisplayName(provider) {
+  return PROVIDER_DISPLAY_NAMES[provider];
+}
+function normalizeSearchText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function filterModels(models, searchQuery) {
+  const terms = normalizeSearchText(searchQuery).split(/\s+/).filter(Boolean);
+  if (terms.length === 0)
+    return models;
+  return models.filter((model) => {
+    const searchableText = normalizeSearchText(`${model.name} ${model.id} ${model.provider} ${getProviderDisplayName(model.provider)}`);
+    return terms.every((term) => searchableText.includes(term));
+  });
+}
+
+// src/tui/components/model-picker/model-visibility.ts
+var HIDDEN_MODEL_IDS = {
+  anthropic: new Set([
+    "claude-3-haiku-20240307",
+    "claude-opus-4-0",
+    "claude-opus-4-20250514",
+    "claude-opus-4-1",
+    "claude-opus-4-1-20250805",
+    "claude-sonnet-4-0",
+    "claude-sonnet-4-20250514"
+  ]),
+  openai: new Set([
+    "gpt-5.3-chat-latest",
+    "gpt-5.2-chat-latest",
+    "gpt-5.2-codex",
+    "gpt-5.1-chat-latest",
+    "gpt-5.1-codex-mini",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5-chat-latest",
+    "gpt-5-codex",
+    "gpt-4.1-nano",
+    "gpt-4.1-nano-2025-04-14",
+    "gpt-4o-2024-05-13",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-0125",
+    "gpt-3.5-turbo-1106",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+    "o3-mini",
+    "o3-mini-2025-01-31",
+    "o1",
+    "o1-2024-12-17"
+  ]),
+  google: new Set([
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-001",
+    "gemini-2.0-flash-lite",
+    "gemini-2.0-flash-lite-001",
+    "gemini-3-pro-preview",
+    "gemini-3.1-flash-lite-preview",
+    "gemini-robotics-er-1.5-preview"
+  ])
+};
+function getVisiblePickerModels(models, selectedModel) {
+  return models.filter((model) => !HIDDEN_MODEL_IDS[model.provider]?.has(model.id) || model.id === selectedModel?.id && model.provider === selectedModel.provider);
+}
+
+// src/tui/components/model-picker/ModelPicker.tsx
+import { jsxDEV as jsxDEV4, Fragment } from "@opentui/react/jsx-dev-runtime";
 var providerOrder = [
   "pensar",
   "anthropic",
@@ -53114,11 +53489,10 @@ var providerOrder = [
   "openrouter",
   "concentrate",
   "bedrock",
+  "bedrock-mantle",
+  "inception",
   "local"
 ];
-function setsAreEqual(a, b) {
-  return a.size === b.size && [...a].every((value) => b.has(value));
-}
 function PickerRow({
   children,
   id,
@@ -53145,6 +53519,8 @@ function getNavItemId(item) {
     return `provider-${item.provider}`;
   if (item.type === "model")
     return `model-${item.model.id}`;
+  if (item.type === "recent-model")
+    return `recent-model-${item.model.id}`;
   if (item.type === "reasoning")
     return "reasoning-toggle";
   if (item.type === "openai-reasoning")
@@ -53169,8 +53545,10 @@ function ModelPicker({
   const scrollBoxRef = useRef2(null);
   const [availableModels, setAvailableModels] = useState4([]);
   const [searchQuery, setSearchQuery] = useState4("");
-  const [expandedProviders, setExpandedProviders] = useState4(new Set(["anthropic"]));
+  const [expandedProviders, setExpandedProviders] = useState4(new Set([selectedModel.provider]));
   const [focusedIndex, setFocusedIndex] = useState4(0);
+  const lastRevealedSelectedModelRef = useRef2(null);
+  const lastFocusedSelectedModelIdRef = useRef2(null);
   const [localUrl, setLocalUrl] = useState4(config2?.localModelUrl ?? "");
   const [localModelName, setLocalModelName] = useState4(config2?.localModelName ?? "");
   const [editingLocalField, setEditingLocalField] = useState4(null);
@@ -53183,86 +53561,105 @@ function ModelPicker({
       setAvailableModels([]);
       return;
     }
-    setAvailableModels(getAvailableModels(config2));
-  }, [config2]);
+    setAvailableModels(getVisiblePickerModels(getAvailableModels(config2), {
+      id: selectedModel.id,
+      provider: selectedModel.provider
+    }));
+  }, [config2, selectedModel.id, selectedModel.provider]);
   useEffect3(() => {
     const availableProviders = new Set(availableModels.map((model) => model.provider));
-    setExpandedProviders((prev) => {
-      if (availableProviders.size === 0) {
-        return prev.size === 0 ? prev : new Set;
-      }
-      const preservedProviders = new Set([...prev].filter((provider) => availableProviders.has(provider)));
-      if (preservedProviders.size > 0) {
-        return setsAreEqual(prev, preservedProviders) ? prev : preservedProviders;
-      }
-      const fallbackProvider = availableProviders.has(selectedModel.provider) ? selectedModel.provider : availableModels[0]?.provider;
-      if (!fallbackProvider) {
-        return prev.size === 0 ? prev : new Set;
-      }
-      return prev.size === 1 && prev.has(fallbackProvider) ? prev : new Set([fallbackProvider]);
+    setExpandedProviders((prev) => retainAvailableProviders(prev, availableProviders));
+  }, [availableModels]);
+  useEffect3(() => {
+    const selectedModelKey = getSelectedModelRevealKey({
+      availableModels,
+      selectedModel: {
+        id: selectedModel.id,
+        provider: selectedModel.provider
+      },
+      lastRevealedSelectedModelKey: lastRevealedSelectedModelRef.current
     });
-  }, [availableModels, selectedModel.provider]);
+    if (!selectedModelKey)
+      return;
+    lastRevealedSelectedModelRef.current = selectedModelKey;
+    setExpandedProviders((prev) => prev.has(selectedModel.provider) ? prev : new Set([...prev, selectedModel.provider]));
+  }, [availableModels, selectedModel.id, selectedModel.provider]);
+  const filteredModels = useMemo4(() => filterModels(availableModels, searchQuery), [availableModels, searchQuery]);
+  const isSearching = searchQuery.trim().length > 0;
+  const recentModels = useMemo4(() => getRecentModels(availableModels, config2?.recentModelIds ?? []), [availableModels, config2?.recentModelIds]);
   const groupedModels = useMemo4(() => {
     const groups = {};
-    const query = searchQuery.toLowerCase().trim();
     for (const m of availableModels) {
-      if (query && !m.name.toLowerCase().includes(query) && !m.id.toLowerCase().includes(query)) {
-        continue;
-      }
       if (!groups[m.provider]) {
         groups[m.provider] = [];
       }
       groups[m.provider].push(m);
     }
     return groups;
-  }, [availableModels, searchQuery]);
+  }, [availableModels]);
   const navigationItems = useMemo4(() => {
     const items = [];
-    for (const provider of providerOrder) {
-      if (provider === "local") {
-        items.push({ type: "provider", provider: "local" });
-        if (expandedProviders.has("local")) {
-          items.push({ type: "local-input", field: "url" });
-          items.push({ type: "local-input", field: "model" });
-          const localModels = groupedModels.local;
-          if (localModels) {
-            for (const m of localModels) {
-              items.push({ type: "model", model: m });
+    if (isSearching) {
+      for (const model of filteredModels) {
+        items.push({ type: "model", model });
+      }
+    } else {
+      for (const model of recentModels) {
+        items.push({ type: "recent-model", model });
+      }
+      for (const provider of providerOrder) {
+        if (provider === "local") {
+          items.push({ type: "provider", provider: "local" });
+          if (expandedProviders.has("local")) {
+            items.push({ type: "local-input", field: "url" });
+            items.push({ type: "local-input", field: "model" });
+            const localModels = groupedModels.local;
+            if (localModels) {
+              for (const m of localModels) {
+                items.push({ type: "model", model: m });
+              }
             }
           }
+          continue;
         }
-        continue;
-      }
-      const models = groupedModels[provider];
-      if (!models || models.length === 0)
-        continue;
-      items.push({ type: "provider", provider });
-      if (expandedProviders.has(provider)) {
-        for (const m of models) {
-          items.push({ type: "model", model: m });
+        const models = groupedModels[provider];
+        if (!models || models.length === 0)
+          continue;
+        items.push({ type: "provider", provider });
+        if (expandedProviders.has(provider)) {
+          for (const m of models) {
+            items.push({ type: "model", model: m });
+          }
         }
       }
     }
-    if (onReasoningToggle && modelSupportsThinking(selectedModel.id)) {
+    if (!isSearching && onReasoningToggle && modelSupportsThinking(selectedModel.id)) {
       items.push({ type: "reasoning" });
     }
-    if (onOpenAIReasoningEffortChange && modelSupportsOpenAIReasoning(selectedModel.id)) {
+    if (!isSearching && onOpenAIReasoningEffortChange && modelSupportsOpenAIReasoning(selectedModel.id)) {
       items.push({ type: "openai-reasoning" });
     }
     return items;
   }, [
     groupedModels,
+    filteredModels,
+    recentModels,
+    isSearching,
     expandedProviders,
     onReasoningToggle,
     onOpenAIReasoningEffortChange,
     selectedModel.id
   ]);
   useEffect3(() => {
-    const idx = navigationItems.findIndex((item) => item.type === "model" && item.model.id === selectedModel.id);
-    if (idx !== -1) {
-      setFocusedIndex(idx);
+    if (isSearching || lastFocusedSelectedModelIdRef.current === selectedModel.id) {
+      return;
     }
-  }, [selectedModel.id, navigationItems]);
+    const index = findSelectedModelIndex(navigationItems, selectedModel.id);
+    if (index === -1)
+      return;
+    lastFocusedSelectedModelIdRef.current = selectedModel.id;
+    setFocusedIndex(index);
+  }, [isSearching, navigationItems, selectedModel.id]);
   useEffect3(() => {
     setFocusedIndex((prev) => Math.min(prev, Math.max(0, navigationItems.length - 1)));
   }, [navigationItems.length]);
@@ -53272,16 +53669,16 @@ function ModelPicker({
       return;
     scrollToChild(scrollBoxRef.current, getNavItemId(item));
   }, [focusedIndex, navigationItems]);
-  const commitLocalConfig = useCallback3((url, modelName) => {
+  const commitLocalConfig = useCallback5((url, modelName) => {
     if (!onConfigUpdate)
       return;
-    const update2 = {
+    const update = {
       localModelUrl: url || null,
       localModelName: modelName || null
     };
-    onConfigUpdate(update2);
+    onConfigUpdate(update);
   }, [onConfigUpdate]);
-  const finishEditing = useCallback3(() => {
+  const finishEditing = useCallback5(() => {
     setEditingLocalField(null);
     commitLocalConfig(localUrl, localModelName);
   }, [localUrl, localModelName, commitLocalConfig]);
@@ -53290,7 +53687,7 @@ function ModelPicker({
   const openAIReasoningEfforts = getOpenAIReasoningEfforts(selectedModel.id);
   const isReasoningFocused = navigationItems[focusedIndex]?.type === "reasoning";
   const isOpenAIReasoningFocused = navigationItems[focusedIndex]?.type === "openai-reasoning";
-  const cycleOpenAIReasoningEffort = useCallback3(() => {
+  const cycleOpenAIReasoningEffort = useCallback5(() => {
     if (!onOpenAIReasoningEffortChange || openAIReasoningEfforts.length === 0) {
       return;
     }
@@ -53302,7 +53699,7 @@ function ModelPicker({
     openAIReasoningEffort,
     openAIReasoningEfforts
   ]);
-  const handleKeyboard = useCallback3((key) => {
+  const handleKeyboard = useCallback5((key) => {
     if (!focused)
       return false;
     if (editingLocalField) {
@@ -53312,24 +53709,18 @@ function ModelPicker({
       }
       return false;
     }
-    if (navigationItems.length === 0)
-      return false;
     if (key.name === "up" || key.name === "down") {
-      const newIndex = key.name === "up" ? Math.max(0, focusedIndex - 1) : Math.min(navigationItems.length - 1, focusedIndex + 1);
+      if (navigationItems.length === 0)
+        return false;
+      const direction = key.name === "up" ? -1 : 1;
+      const newIndex = (focusedIndex + direction + navigationItems.length) % navigationItems.length;
       setFocusedIndex(newIndex);
-      const item = navigationItems[newIndex];
-      if (item && item.type === "model") {
-        onSelectModel(item.model);
-      }
-      return true;
-    }
-    if (key.name === "backspace") {
-      setSearchQuery((prev) => prev.slice(0, -1));
       return true;
     }
     if (key.name === "escape") {
       if (searchQuery) {
         setSearchQuery("");
+        setFocusedIndex(0);
         return true;
       }
       if (onCancel) {
@@ -53338,16 +53729,16 @@ function ModelPicker({
       }
       return false;
     }
-    if (key.name === "space" && onReasoningToggle && thinkingSupported) {
+    const currentItem = navigationItems[focusedIndex];
+    if (key.name === "space" && currentItem?.type === "reasoning" && onReasoningToggle && thinkingSupported) {
       onReasoningToggle(!reasoningEnabled);
       return true;
     }
-    if (key.name === "space" && onOpenAIReasoningEffortChange && openAIReasoningSupported) {
+    if (key.name === "space" && currentItem?.type === "openai-reasoning" && onOpenAIReasoningEffortChange && openAIReasoningSupported) {
       cycleOpenAIReasoningEffort();
       return true;
     }
     if (key.name === "return") {
-      const currentItem = navigationItems[focusedIndex];
       if (!currentItem)
         return false;
       if (currentItem.type === "local-input") {
@@ -53369,17 +53760,20 @@ function ModelPicker({
           }
           return next;
         });
-      } else {
+      } else if (currentItem.type === "model" || currentItem.type === "recent-model") {
+        onSelectModel(currentItem.model);
         onConfirm?.();
       }
       return true;
     }
     if (key.name === "left" || key.name === "right") {
-      const currentItem = navigationItems[focusedIndex];
-      if (!currentItem || currentItem.type === "reasoning" || currentItem.type === "openai-reasoning") {
+      if (isSearching)
+        return false;
+      const currentItem2 = navigationItems[focusedIndex];
+      if (!currentItem2 || currentItem2.type === "recent-model" || currentItem2.type === "reasoning" || currentItem2.type === "openai-reasoning") {
         return false;
       }
-      const targetProvider = currentItem.type === "provider" ? currentItem.provider : currentItem.type === "model" ? currentItem.model.provider : "local";
+      const targetProvider = currentItem2.type === "provider" ? currentItem2.provider : currentItem2.type === "model" ? currentItem2.model.provider : "local";
       if (key.name === "left") {
         setExpandedProviders((prev) => {
           const next = new Set(prev);
@@ -53395,13 +53789,6 @@ function ModelPicker({
       }
       return true;
     }
-    if (key.sequence && key.sequence.length === 1 && /[a-zA-Z0-9\-_.]/.test(key.sequence)) {
-      setSearchQuery((prev) => prev + key.sequence);
-      if (!searchQuery) {
-        setExpandedProviders(new Set(providerOrder));
-      }
-      return true;
-    }
     return false;
   }, [
     focused,
@@ -53418,7 +53805,8 @@ function ModelPicker({
     thinkingSupported,
     onOpenAIReasoningEffortChange,
     openAIReasoningSupported,
-    cycleOpenAIReasoningEffort
+    cycleOpenAIReasoningEffort,
+    isSearching
   ]);
   useKeyboard((key) => {
     const handled = handleKeyboard(key);
@@ -53427,7 +53815,11 @@ function ModelPicker({
     }
   });
   const isProviderFocused = (provider) => navigationItems[focusedIndex]?.type === "provider" && navigationItems[focusedIndex].provider === provider;
-  const isModelFocused = (modelId) => navigationItems[focusedIndex]?.type === "model" && navigationItems[focusedIndex].model.id === modelId;
+  const isModelFocused = (modelId, recent = false) => {
+    const item = navigationItems[focusedIndex];
+    const expectedType = recent ? "recent-model" : "model";
+    return item?.type === expectedType && item.model.id === modelId;
+  };
   const isLocalFieldFocused = (field) => navigationItems[focusedIndex]?.type === "local-input" && navigationItems[focusedIndex].field === field;
   return /* @__PURE__ */ jsxDEV4("box", {
     flexDirection: "column",
@@ -53438,21 +53830,42 @@ function ModelPicker({
     children: [
       /* @__PURE__ */ jsxDEV4("box", {
         flexShrink: 0,
-        children: searchQuery ? /* @__PURE__ */ jsxDEV4(PickerRow, {
-          children: /* @__PURE__ */ jsxDEV4("text", {
-            fg: colors2.text,
+        marginBottom: 1,
+        children: [
+          /* @__PURE__ */ jsxDEV4(PickerRow, {
             children: [
-              "Search: ",
-              searchQuery
+              /* @__PURE__ */ jsxDEV4("text", {
+                fg: colors2.primary,
+                children: "Search "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV4("input", {
+                flexGrow: 1,
+                value: searchQuery,
+                onInput: (value) => {
+                  setSearchQuery(value);
+                  setFocusedIndex(0);
+                },
+                focused: focused && editingLocalField === null,
+                placeholder: "family, model name, or provider...",
+                textColor: colors2.text,
+                focusedTextColor: colors2.text,
+                backgroundColor: "transparent",
+                cursorColor: colors2.textMuted
+              }, undefined, false, undefined, this)
             ]
-          }, undefined, true, undefined, this)
-        }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV4(PickerRow, {
-          children: /* @__PURE__ */ jsxDEV4("text", {
-            fg: colors2.textMuted,
-            children: "Type to search models..."
+          }, undefined, true, undefined, this),
+          isSearching && /* @__PURE__ */ jsxDEV4(PickerRow, {
+            children: /* @__PURE__ */ jsxDEV4("text", {
+              fg: colors2.primary,
+              children: [
+                "Results (",
+                filteredModels.length,
+                ")"
+              ]
+            }, undefined, true, undefined, this)
           }, undefined, false, undefined, this)
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this),
+        ]
+      }, undefined, true, undefined, this),
       /* @__PURE__ */ jsxDEV4("scrollbox", {
         ref: scrollBoxRef,
         style: {
@@ -53460,170 +53873,240 @@ function ModelPicker({
             flexShrink: 1,
             width: "100%",
             overflow: "hidden",
-            maxHeight: navigationItems.length
+            maxHeight: Math.max(1, navigationItems.length + (!isSearching && recentModels.length > 0 ? 1 : 0))
           },
           contentOptions: {
             flexDirection: "column"
           },
           scrollbarOptions: {
-            visible: false
+            trackOptions: {
+              foregroundColor: colors2.textMuted,
+              backgroundColor: colors2.backgroundElement
+            }
           }
         },
         stickyScroll: false,
-        children: providerOrder.flatMap((provider) => {
-          const isExpanded = expandedProviders.has(provider);
-          const providerName = providerNames[provider] || provider;
-          const isFocused = isProviderFocused(provider);
-          if (provider === "local") {
-            const localModels = groupedModels.local;
-            const modelCount = localModels?.length ?? 0;
-            const elements2 = [];
-            elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-              id: "provider-local",
+        children: [
+          !isSearching && recentModels.length > 0 && /* @__PURE__ */ jsxDEV4(Fragment, {
+            children: [
+              /* @__PURE__ */ jsxDEV4(PickerRow, {
+                children: /* @__PURE__ */ jsxDEV4("text", {
+                  fg: colors2.primary,
+                  children: "Recent"
+                }, undefined, false, undefined, this)
+              }, undefined, false, undefined, this),
+              recentModels.map((model) => {
+                const isSelected = model.id === selectedModel.id;
+                const isFocused = isModelFocused(model.id, true);
+                return /* @__PURE__ */ jsxDEV4(PickerRow, {
+                  id: `recent-model-${model.id}`,
+                  backgroundColor: isFocused ? colors2.backgroundSelected : undefined,
+                  children: /* @__PURE__ */ jsxDEV4("text", {
+                    children: [
+                      /* @__PURE__ */ jsxDEV4("span", {
+                        fg: isFocused ? colors2.primary : colors2.text,
+                        children: [
+                          isSelected ? "●" : "○",
+                          " ",
+                          model.name
+                        ]
+                      }, undefined, true, undefined, this),
+                      /* @__PURE__ */ jsxDEV4("span", {
+                        fg: colors2.textMuted,
+                        children: `  ${getProviderDisplayName(model.provider)}`
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, undefined, true, undefined, this)
+                }, `recent-${model.id}`, false, undefined, this);
+              })
+            ]
+          }, undefined, true, undefined, this),
+          isSearching && (filteredModels.length === 0 ? /* @__PURE__ */ jsxDEV4(PickerRow, {
+            children: /* @__PURE__ */ jsxDEV4("text", {
+              fg: colors2.textMuted,
+              children: "No matching models"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this) : filteredModels.map((model) => {
+            const isSelected = model.id === selectedModel.id;
+            const isFocused = isModelFocused(model.id);
+            return /* @__PURE__ */ jsxDEV4(PickerRow, {
+              id: `model-${model.id}`,
+              backgroundColor: isFocused ? colors2.backgroundSelected : undefined,
               children: /* @__PURE__ */ jsxDEV4("text", {
-                fg: isFocused ? colors2.primary : isExpanded ? colors2.text : colors2.textMuted,
                 children: [
-                  isFocused ? "❯" : isExpanded ? "▾" : "▸",
-                  " ",
-                  providerName,
-                  modelCount > 0 ? ` (${modelCount})` : ""
+                  /* @__PURE__ */ jsxDEV4("span", {
+                    fg: isFocused ? colors2.primary : colors2.text,
+                    children: [
+                      isSelected ? "●" : "○",
+                      " ",
+                      model.name
+                    ]
+                  }, undefined, true, undefined, this),
+                  /* @__PURE__ */ jsxDEV4("span", {
+                    fg: colors2.textMuted,
+                    children: `  ${getProviderDisplayName(model.provider)}`
+                  }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this)
-            }, "local", false, undefined, this));
-            if (isExpanded) {
-              const isUrlFocused = isLocalFieldFocused("url");
-              const isUrlEditing = editingLocalField === "url";
-              if (isUrlEditing) {
-                elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-                  id: "local-input-url",
-                  paddingLeft: 2,
+            }, model.id, false, undefined, this);
+          })),
+          providerOrder.flatMap((provider) => {
+            if (isSearching)
+              return [];
+            const isExpanded = expandedProviders.has(provider);
+            const providerName = getProviderDisplayName(provider);
+            const isFocused = isProviderFocused(provider);
+            if (provider === "local") {
+              const localModels = groupedModels.local;
+              const modelCount = localModels?.length ?? 0;
+              const elements2 = [];
+              elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+                id: "provider-local",
+                children: /* @__PURE__ */ jsxDEV4("text", {
+                  fg: isFocused ? colors2.primary : isExpanded ? colors2.text : colors2.textMuted,
                   children: [
-                    /* @__PURE__ */ jsxDEV4("text", {
-                      fg: colors2.primary,
-                      children: " URL: "
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ jsxDEV4("input", {
-                      focused: true,
-                      value: localUrl,
-                      backgroundColor: "transparent",
-                      cursorColor: colors2.textMuted,
-                      onInput: (v) => setLocalUrl(typeof v === "string" ? v : ""),
-                      onPaste: (event) => {
-                        const cleaned = getPasteText(event).replace(/\r?\n/g, "");
-                        setLocalUrl((prev) => `${prev}${cleaned}`);
-                      },
-                      onSubmit: finishEditing
-                    }, undefined, false, undefined, this)
+                    isFocused ? "❯" : isExpanded ? "▾" : "▸",
+                    " ",
+                    providerName,
+                    modelCount > 0 ? ` (${modelCount})` : ""
                   ]
-                }, "local-url", true, undefined, this));
-              } else {
-                elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-                  id: "local-input-url",
-                  paddingLeft: 2,
-                  children: /* @__PURE__ */ jsxDEV4("text", {
-                    fg: isUrlFocused ? colors2.primary : colors2.textMuted,
-                    children: `  URL: ${localUrl || "(press Enter to set)"}`
-                  }, undefined, false, undefined, this)
-                }, "local-url", false, undefined, this));
-              }
-              const isModelFieldFocused = isLocalFieldFocused("model");
-              const isModelEditing = editingLocalField === "model";
-              if (isModelEditing) {
-                elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-                  id: "local-input-model",
-                  paddingLeft: 2,
-                  children: [
-                    /* @__PURE__ */ jsxDEV4("text", {
-                      fg: colors2.primary,
-                      children: " Model: "
-                    }, undefined, false, undefined, this),
-                    /* @__PURE__ */ jsxDEV4("input", {
-                      focused: true,
-                      value: localModelName,
-                      backgroundColor: "transparent",
-                      cursorColor: colors2.textMuted,
-                      onInput: (v) => setLocalModelName(typeof v === "string" ? v : ""),
-                      onPaste: (event) => {
-                        const cleaned = getPasteText(event).replace(/\r?\n/g, "");
-                        setLocalModelName((prev) => `${prev}${cleaned}`);
-                      },
-                      onSubmit: finishEditing
+                }, undefined, true, undefined, this)
+              }, "local", false, undefined, this));
+              if (isExpanded) {
+                const isUrlFocused = isLocalFieldFocused("url");
+                const isUrlEditing = editingLocalField === "url";
+                if (isUrlEditing) {
+                  elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+                    id: "local-input-url",
+                    paddingLeft: 2,
+                    children: [
+                      /* @__PURE__ */ jsxDEV4("text", {
+                        fg: colors2.primary,
+                        children: " URL: "
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV4("input", {
+                        focused: true,
+                        value: localUrl,
+                        backgroundColor: "transparent",
+                        cursorColor: colors2.textMuted,
+                        onInput: (v) => setLocalUrl(typeof v === "string" ? v : ""),
+                        onPaste: (event) => {
+                          const cleaned = getPasteText(event).replace(/\r?\n/g, "");
+                          setLocalUrl((prev) => `${prev}${cleaned}`);
+                        },
+                        onSubmit: finishEditing
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, "local-url", true, undefined, this));
+                } else {
+                  elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+                    id: "local-input-url",
+                    paddingLeft: 2,
+                    children: /* @__PURE__ */ jsxDEV4("text", {
+                      fg: isUrlFocused ? colors2.primary : colors2.textMuted,
+                      children: `  URL: ${localUrl || "(press Enter to set)"}`
                     }, undefined, false, undefined, this)
-                  ]
-                }, "local-model", true, undefined, this));
-              } else {
-                elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-                  id: "local-input-model",
-                  paddingLeft: 2,
-                  children: /* @__PURE__ */ jsxDEV4("text", {
-                    fg: isModelFieldFocused ? colors2.primary : colors2.textMuted,
-                    children: `  Model: ${localModelName || "(press Enter to set)"}`
-                  }, undefined, false, undefined, this)
-                }, "local-model", false, undefined, this));
-              }
-              if (localModels) {
-                for (const m of localModels) {
-                  const isSelected = m.id === selectedModel.id;
-                  const isMFocused = isModelFocused(m.id);
+                  }, "local-url", false, undefined, this));
+                }
+                const isModelFieldFocused = isLocalFieldFocused("model");
+                const isModelEditing = editingLocalField === "model";
+                if (isModelEditing) {
+                  elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+                    id: "local-input-model",
+                    paddingLeft: 2,
+                    children: [
+                      /* @__PURE__ */ jsxDEV4("text", {
+                        fg: colors2.primary,
+                        children: " Model: "
+                      }, undefined, false, undefined, this),
+                      /* @__PURE__ */ jsxDEV4("input", {
+                        focused: true,
+                        value: localModelName,
+                        backgroundColor: "transparent",
+                        cursorColor: colors2.textMuted,
+                        onInput: (v) => setLocalModelName(typeof v === "string" ? v : ""),
+                        onPaste: (event) => {
+                          const cleaned = getPasteText(event).replace(/\r?\n/g, "");
+                          setLocalModelName((prev) => `${prev}${cleaned}`);
+                        },
+                        onSubmit: finishEditing
+                      }, undefined, false, undefined, this)
+                    ]
+                  }, "local-model", true, undefined, this));
+                } else {
                   elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-                    id: `model-${m.id}`,
+                    id: "local-input-model",
                     paddingLeft: 2,
                     children: /* @__PURE__ */ jsxDEV4("text", {
-                      fg: isMFocused ? colors2.primary : colors2.textMuted,
-                      children: [
-                        isSelected ? "●" : "○",
-                        " ",
-                        m.name
-                      ]
-                    }, undefined, true, undefined, this)
-                  }, m.id, false, undefined, this));
+                      fg: isModelFieldFocused ? colors2.primary : colors2.textMuted,
+                      children: `  Model: ${localModelName || "(press Enter to set)"}`
+                    }, undefined, false, undefined, this)
+                  }, "local-model", false, undefined, this));
+                }
+                if (localModels) {
+                  for (const m of localModels) {
+                    const isSelected = m.id === selectedModel.id;
+                    const isMFocused = isModelFocused(m.id);
+                    elements2.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+                      id: `model-${m.id}`,
+                      paddingLeft: 2,
+                      children: /* @__PURE__ */ jsxDEV4("text", {
+                        fg: isMFocused ? colors2.primary : colors2.textMuted,
+                        children: [
+                          isSelected ? "●" : "○",
+                          " ",
+                          m.name
+                        ]
+                      }, undefined, true, undefined, this)
+                    }, m.id, false, undefined, this));
+                  }
                 }
               }
+              return elements2;
             }
-            return elements2;
-          }
-          const models = groupedModels[provider];
-          if (!models || models.length === 0)
-            return [];
-          const elements = [];
-          elements.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-            id: `provider-${provider}`,
-            children: /* @__PURE__ */ jsxDEV4("text", {
-              fg: isFocused ? colors2.primary : isExpanded ? colors2.text : colors2.textMuted,
-              children: [
-                isFocused ? "❯" : isExpanded ? "▾" : "▸",
-                " ",
-                providerName,
-                " (",
-                models.length,
-                ")"
-              ]
-            }, undefined, true, undefined, this)
-          }, provider, false, undefined, this));
-          if (isExpanded) {
-            for (const m of models) {
-              const isSelected = m.id === selectedModel.id;
-              const isMFocused = isModelFocused(m.id);
-              const isDefault = m.id === "claude-haiku-4-5" || m.id === "gpt-4o-mini";
-              elements.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
-                id: `model-${m.id}`,
-                paddingLeft: 2,
-                children: /* @__PURE__ */ jsxDEV4("text", {
-                  fg: isMFocused ? colors2.primary : colors2.textMuted,
-                  children: [
-                    isSelected ? "●" : "○",
-                    " ",
-                    m.name,
-                    isDefault && !isModelUserSelected && isSelected ? " [default]" : ""
-                  ]
-                }, undefined, true, undefined, this)
-              }, m.id, false, undefined, this));
+            const models = groupedModels[provider];
+            if (!models || models.length === 0)
+              return [];
+            const elements = [];
+            elements.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+              id: `provider-${provider}`,
+              children: /* @__PURE__ */ jsxDEV4("text", {
+                fg: isFocused ? colors2.primary : isExpanded ? colors2.text : colors2.textMuted,
+                children: [
+                  isFocused ? "❯" : isExpanded ? "▾" : "▸",
+                  " ",
+                  providerName,
+                  " (",
+                  models.length,
+                  ")"
+                ]
+              }, undefined, true, undefined, this)
+            }, provider, false, undefined, this));
+            if (isExpanded) {
+              for (const m of models) {
+                const isSelected = m.id === selectedModel.id;
+                const isMFocused = isModelFocused(m.id);
+                const isDefault = m.id === "claude-haiku-4-5" || m.id === "gpt-4o-mini";
+                elements.push(/* @__PURE__ */ jsxDEV4(PickerRow, {
+                  id: `model-${m.id}`,
+                  paddingLeft: 2,
+                  children: /* @__PURE__ */ jsxDEV4("text", {
+                    fg: isMFocused ? colors2.primary : colors2.textMuted,
+                    children: [
+                      isSelected ? "●" : "○",
+                      " ",
+                      m.name,
+                      isDefault && !isModelUserSelected && isSelected ? " [default]" : ""
+                    ]
+                  }, undefined, true, undefined, this)
+                }, m.id, false, undefined, this));
+              }
             }
-          }
-          return elements;
-        })
-      }, undefined, false, undefined, this),
-      onReasoningToggle && thinkingSupported && /* @__PURE__ */ jsxDEV4("box", {
+            return elements;
+          })
+        ]
+      }, isSearching ? "search-results" : "model-browser", true, undefined, this),
+      !isSearching && onReasoningToggle && thinkingSupported && /* @__PURE__ */ jsxDEV4("box", {
         flexShrink: 0,
         paddingTop: 1,
         children: /* @__PURE__ */ jsxDEV4(PickerRow, {
@@ -53637,7 +54120,7 @@ function ModelPicker({
           }, undefined, true, undefined, this)
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this),
-      onOpenAIReasoningEffortChange && openAIReasoningSupported && /* @__PURE__ */ jsxDEV4("box", {
+      !isSearching && onOpenAIReasoningEffortChange && openAIReasoningSupported && /* @__PURE__ */ jsxDEV4("box", {
         flexShrink: 0,
         paddingTop: 1,
         children: /* @__PURE__ */ jsxDEV4(PickerRow, {
@@ -53737,7 +54220,7 @@ function ConfigView({ config: config2, onBack, onStart }) {
       return;
     }
   });
-  const handleModelSelect = useCallback4((model) => {
+  const handleModelSelect = useCallback6((model) => {
     setSelectedModel(model);
     setIsModelUserSelected(true);
   }, []);
@@ -53913,7 +54396,7 @@ function isValidUrl(url) {
 }
 
 // src/tui/components/chat/home-view.tsx
-import { useCallback as useCallback11, useEffect as useEffect11, useState as useState18 } from "react";
+import { useCallback as useCallback13, useEffect as useEffect11, useState as useState18 } from "react";
 
 // src/core/history.ts
 init_storage();
@@ -53970,7 +54453,7 @@ function getEntries() {
 // src/tui/context/command.tsx
 import {
   createContext as createContext7,
-  useCallback as useCallback6,
+  useCallback as useCallback8,
   useContext as useContext7,
   useEffect as useEffect5,
   useMemo as useMemo8,
@@ -54365,7 +54848,7 @@ function deobfuscate(input) {
   return output;
 }
 // src/tui/command-registry.ts
-init_config2();
+init_config();
 
 // src/tui/utils/command-flags.ts
 import { readFileSync } from "node:fs";
@@ -55023,8 +55506,8 @@ var commands = [
     aliases: ["quit", "q"],
     description: "Exit the application",
     category: "General",
-    handler: async () => {
-      process.kill(process.pid, "SIGINT");
+    handler: async (_args, ctx2) => {
+      await ctx2.exitApplication?.();
     }
   },
   {
@@ -55268,7 +55751,7 @@ var useRoute = () => {
 // src/tui/context/toast.tsx
 import {
   createContext as createContext6,
-  useCallback as useCallback5,
+  useCallback as useCallback7,
   useContext as useContext6,
   useMemo as useMemo7,
   useState as useState8
@@ -55283,10 +55766,10 @@ var DEFAULT_DURATION = {
 };
 function ToastProvider({ children }) {
   const [toasts, setToasts] = useState8([]);
-  const dismiss = useCallback5((id) => {
+  const dismiss = useCallback7((id) => {
     setToasts((prev) => prev.filter((t) => t.id !== id));
   }, []);
-  const toast = useCallback5((message, variant = "default", duration) => {
+  const toast = useCallback7((message, variant = "default", duration) => {
     const id = nextId++;
     const ms = duration ?? DEFAULT_DURATION[variant];
     setToasts((prev) => [...prev, { id, message, variant, duration: ms }]);
@@ -55309,11 +55792,11 @@ function useToast() {
 import { jsxDEV as jsxDEV9 } from "@opentui/react/jsx-dev-runtime";
 var CommandContext = createContext7(null);
 function useCommand() {
-  const context = useContext7(CommandContext);
-  if (!context) {
+  const context2 = useContext7(CommandContext);
+  if (!context2) {
     throw new Error("useCommand must be used within CommandProvider");
   }
-  return context;
+  return context2;
 }
 function CommandProvider({
   children,
@@ -55326,7 +55809,8 @@ function CommandProvider({
   onOpenHelpDialog,
   onOpenAuthDialog,
   onOpenPentestDialog,
-  onOpenSkillsDialog
+  onOpenSkillsDialog,
+  onExit
 }) {
   const route = useRoute();
   const obfuscation = useObfuscation();
@@ -55347,6 +55831,7 @@ function CommandProvider({
       openAuthDialog: onOpenAuthDialog,
       openPentestDialog: onOpenPentestDialog,
       openSkillsDialog: onOpenSkillsDialog,
+      exitApplication: onExit,
       setObfuscation: (enabled) => {
         const current = isObfuscationEnabled();
         const next = typeof enabled === "boolean" ? enabled : !current;
@@ -55369,10 +55854,11 @@ function CommandProvider({
     onOpenAuthDialog,
     onOpenPentestDialog,
     onOpenSkillsDialog,
+    onExit,
     obfuscation,
     toast
   ]);
-  const refreshSkills = useCallback6(async () => {
+  const refreshSkills = useCallback8(async () => {
     await registry.refresh();
     setRegistryVersion((v) => v + 1);
   }, [registry]);
@@ -55388,7 +55874,7 @@ function CommandProvider({
     }
     return router2;
   }, []);
-  const resolveSkillContent = useCallback6((input) => {
+  const resolveSkillContent = useCallback8((input) => {
     const trimmed = input.trim().replace(/^\/+/, "").toLowerCase();
     const entry = registry.get(trimmed);
     if (entry) {
@@ -55458,7 +55944,7 @@ function CommandProvider({
     }
     return names;
   }, []);
-  const executeCommand = useCallback6(async (input) => {
+  const executeCommand = useCallback8(async (input) => {
     return await router.execute(input, ctx3);
   }, [router, ctx3]);
   const value = useMemo8(() => ({
@@ -55493,7 +55979,7 @@ function CommandProvider({
 import { useKeyboard as useKeyboard3, useRenderer as useRenderer3 } from "@opentui/react";
 import {
   createContext as createContext9,
-  useCallback as useCallback7,
+  useCallback as useCallback9,
   useContext as useContext9,
   useRef as useRef4,
   useState as useState10
@@ -55578,7 +56064,7 @@ function DialogProvider({ children }) {
   const [externalDialogOpen, setExternalDialogOpen] = useState10(false);
   const renderer = useRenderer3();
   const focusRef = useRef4(null);
-  const refocus = useCallback7(() => {
+  const refocus = useCallback9(() => {
     setTimeout(() => {
       const focus = focusRef.current;
       if (!focus)
@@ -55600,7 +56086,7 @@ function DialogProvider({ children }) {
       focus.focus();
     }, 1);
   }, [renderer]);
-  const clear = useCallback7(() => {
+  const clear = useCallback9(() => {
     for (const item of stack) {
       if (item.onClose)
         item.onClose();
@@ -55609,7 +56095,7 @@ function DialogProvider({ children }) {
     setStack([]);
     refocus();
   }, [stack, refocus]);
-  const replace = useCallback7((element, options) => {
+  const replace = useCallback9((element, options) => {
     if (stack.length === 0) {
       focusRef.current = renderer.currentFocusedRenderable;
     }
@@ -55673,7 +56159,7 @@ function useDialog() {
 // src/tui/context/focus.tsx
 import {
   createContext as createContext10,
-  useCallback as useCallback8,
+  useCallback as useCallback10,
   useContext as useContext10,
   useRef as useRef5
 } from "react";
@@ -55681,17 +56167,17 @@ import { jsxDEV as jsxDEV12 } from "@opentui/react/jsx-dev-runtime";
 var FocusContext = createContext10(undefined);
 function FocusProvider({ children }) {
   const promptRef = useRef5(null);
-  const refocusPrompt = useCallback8(() => {
+  const refocusPrompt = useCallback10(() => {
     setTimeout(() => {
       promptRef.current?.focus();
     }, 1);
   }, []);
-  const focusPrompt = useCallback8(() => promptRef.current?.focus(), []);
-  const blurPrompt = useCallback8(() => promptRef.current?.blur(), []);
-  const resetPrompt = useCallback8(() => promptRef.current?.reset(), []);
-  const setPromptValue = useCallback8((value) => promptRef.current?.setValue(value), []);
-  const getPromptValue = useCallback8(() => promptRef.current?.getValue() ?? "", []);
-  const registerPromptRef = useCallback8((ref) => {
+  const focusPrompt = useCallback10(() => promptRef.current?.focus(), []);
+  const blurPrompt = useCallback10(() => promptRef.current?.blur(), []);
+  const resetPrompt = useCallback10(() => promptRef.current?.reset(), []);
+  const setPromptValue = useCallback10((value) => promptRef.current?.setValue(value), []);
+  const getPromptValue = useCallback10(() => promptRef.current?.getValue() ?? "", []);
+  const registerPromptRef = useCallback10((ref) => {
     promptRef.current = ref;
   }, []);
   return /* @__PURE__ */ jsxDEV12(FocusContext.Provider, {
@@ -55709,17 +56195,17 @@ function FocusProvider({ children }) {
   }, undefined, false, undefined, this);
 }
 function useFocus() {
-  const context = useContext10(FocusContext);
-  if (!context) {
+  const context2 = useContext10(FocusContext);
+  if (!context2) {
     throw new Error("useFocus must be used within FocusProvider");
   }
-  return context;
+  return context2;
 }
 
 // src/tui/context/input.tsx
 import {
   createContext as createContext11,
-  useCallback as useCallback9,
+  useCallback as useCallback11,
   useContext as useContext11,
   useState as useState11
 } from "react";
@@ -55727,7 +56213,7 @@ import { jsxDEV as jsxDEV13 } from "@opentui/react/jsx-dev-runtime";
 var InputContext = createContext11(undefined);
 function InputProvider({ children }) {
   const [inputValue, setInputValue] = useState11("");
-  const clearInput = useCallback9(() => {
+  const clearInput = useCallback11(() => {
     setInputValue("");
   }, []);
   return /* @__PURE__ */ jsxDEV13(InputContext.Provider, {
@@ -55741,11 +56227,11 @@ function InputProvider({ children }) {
   }, undefined, false, undefined, this);
 }
 function useInput() {
-  const context = useContext11(InputContext);
-  if (!context) {
+  const context2 = useContext11(InputContext);
+  if (!context2) {
     throw new Error("useInput must be used within InputProvider");
   }
-  return context;
+  return context2;
 }
 
 // src/tui/components/shared/tool-registry.ts
@@ -57371,7 +57857,7 @@ function markdownToStyledText(rawContent, colors2) {
 import {
   SyntaxStyle
 } from "@opentui/core";
-import { useCallback as useCallback10, useMemo as useMemo9, useRef as useRef6 } from "react";
+import { useCallback as useCallback12, useMemo as useMemo9, useRef as useRef6 } from "react";
 function useMarkdownSyntaxStyle() {
   const { colors: colors2 } = useTheme();
   return useMemo9(() => SyntaxStyle.fromStyles({
@@ -57392,7 +57878,7 @@ function useMarkdownSyntaxStyle() {
 }
 function useMarkdownRenderNode() {
   const { colors: colors2 } = useTheme();
-  return useCallback10((token, ctx3) => {
+  return useCallback12((token, ctx3) => {
     if (token.type === "code") {
       const renderable = ctx3.defaultRender();
       if (renderable) {
@@ -58780,7 +59266,7 @@ function isToolMessage(msg) {
 }
 
 // src/tui/components/shared/tool-renderer.tsx
-import { jsxDEV as jsxDEV19, Fragment } from "@opentui/react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV19, Fragment as Fragment2 } from "@opentui/react/jsx-dev-runtime";
 var TOOLS_WITH_LOG_WINDOW = new Set([
   "execute_command",
   "run_attack_surface",
@@ -58843,7 +59329,7 @@ var ToolRenderer = memo2(function ToolRenderer2({
             children: isPending ? /* @__PURE__ */ jsxDEV19(ShiningText, {
               text: summary,
               fg: colors2.warning
-            }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV19(Fragment, {
+            }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV19(Fragment2, {
               children: [
                 /* @__PURE__ */ jsxDEV19("text", {
                   fg: isError ? colors2.error : colors2.success,
@@ -59990,7 +60476,7 @@ var PromptInput = forwardRef(function PromptInput2({
 import { useKeyboard as useKeyboard5 } from "@opentui/react";
 import { useEffect as useEffect9, useRef as useRef9, useState as useState16 } from "react";
 import { jsxDEV as jsxDEV22 } from "@opentui/react/jsx-dev-runtime";
-var PROVIDER_DISPLAY_NAMES = {
+var PROVIDER_DISPLAY_NAMES2 = {
   anthropic: "Anthropic",
   openai: "OpenAI",
   google: "Google",
@@ -60001,7 +60487,7 @@ var PROVIDER_DISPLAY_NAMES = {
   inception: "Inception",
   local: "Local"
 };
-var providerDisplayName = (p) => PROVIDER_DISPLAY_NAMES[p] ?? p;
+var providerDisplayName = (p) => PROVIDER_DISPLAY_NAMES2[p] ?? p;
 function OperatorModeBar({
   operatorMode,
   modelName,
@@ -60582,7 +61068,7 @@ function HomeView({ onNavigate, onStartSession }) {
   useEffect11(() => {
     load().then(setCommandHistory);
   }, []);
-  const launchOperator = useCallback11((message, options) => {
+  const launchOperator = useCallback13((message, options) => {
     const requireApproval = options?.requireApproval ?? true;
     route.navigate({
       type: "operator",
@@ -60593,10 +61079,10 @@ function HomeView({ onNavigate, onStartSession }) {
       }
     });
   }, [route]);
-  const pushHistory = useCallback11((entry) => {
+  const pushHistory = useCallback13((entry) => {
     push(entry).then(() => setCommandHistory([...getEntries()]));
   }, []);
-  const handleSubmit = useCallback11((value) => {
+  const handleSubmit = useCallback13((value) => {
     if (!value.trim())
       return;
     pushHistory(value.trim());
@@ -60608,7 +61094,7 @@ function HomeView({ onNavigate, onStartSession }) {
     const timer = setTimeout(() => setHintMessage(null), 3000);
     return () => clearTimeout(timer);
   }, [hintMessage]);
-  const handleCommandExecute = useCallback11(async (command) => {
+  const handleCommandExecute = useCallback13(async (command) => {
     const trimmed = command.trim();
     pushHistory(trimmed);
     const handled = await executeCommand(command);
@@ -60805,7 +61291,7 @@ function ChatApp({
       });
     }
   }, [initialSessionId]);
-  const handleNavigate = useCallback12((view, options) => {
+  const handleNavigate = useCallback14((view, options) => {
     if (view === "chat" && options?.sessionId) {
       sessions.get(options.sessionId).then((session) => {
         if (session) {
@@ -60817,7 +61303,7 @@ function ChatApp({
       setCurrentView(view);
     }
   }, []);
-  const handleStartSession = useCallback12(async (directive) => {
+  const handleStartSession = useCallback14(async (directive) => {
     const session = await sessions.create({
       name: `exploration-${Date.now()}`,
       targets: []
@@ -60826,7 +61312,7 @@ function ChatApp({
     setInitialDirective(directive);
     setCurrentView("chat");
   }, []);
-  const handleConfigSubmit = useCallback12(async (configData) => {
+  const handleConfigSubmit = useCallback14(async (configData) => {
     const hostname = parseHostFromTarget(configData.targetUrl);
     const timestamp = new Date().toISOString().split("T")[0];
     const sessionName = `${hostname}-${timestamp}`;
@@ -60849,12 +61335,12 @@ function ChatApp({
     setSessionModel(configData.model);
     setCurrentView("chat");
   }, []);
-  const handleExitChat = useCallback12(() => {
+  const handleExitChat = useCallback14(() => {
     setCurrentView("home");
     setActiveSession(null);
     setInitialDirective(undefined);
   }, []);
-  const handleBackFromConfig = useCallback12(() => {
+  const handleBackFromConfig = useCallback14(() => {
     setCurrentView("home");
   }, []);
   return /* @__PURE__ */ jsxDEV25("box", {
@@ -60887,7 +61373,7 @@ function parseHostFromTarget(target) {
 
 // src/tui/components/commands/advanced-settings.tsx
 import { useKeyboard as useKeyboard6 } from "@opentui/react";
-import { useCallback as useCallback13, useState as useState20 } from "react";
+import { useCallback as useCallback15, useState as useState20 } from "react";
 
 // src/tui/components/dialog-layout.tsx
 import { jsxDEV as jsxDEV26 } from "@opentui/react/jsx-dev-runtime";
@@ -60959,7 +61445,7 @@ function AdvancedSettings({ onClose }) {
   const [saving, setSaving] = useState20(false);
   const [error, setError] = useState20(null);
   const [draftStrikeMode, setDraftStrikeMode] = useState20(config2.data.strikeMode ?? false);
-  const saveSettings = useCallback13(async () => {
+  const saveSettings = useCallback15(async () => {
     if (saving)
       return;
     setSaving(true);
@@ -61041,9 +61527,9 @@ function AdvancedSettings({ onClose }) {
 
 // src/tui/components/commands/auth-flow.tsx
 import { useKeyboard as useKeyboard7 } from "@opentui/react";
-import { useCallback as useCallback14, useEffect as useEffect13, useRef as useRef11, useState as useState21 } from "react";
+import { useCallback as useCallback16, useEffect as useEffect13, useRef as useRef11, useState as useState21 } from "react";
 init_auth();
-init_config2();
+init_config();
 
 // src/tui/utils/open-url.ts
 var OPEN_FAILED_MSG = "Couldn't open browser — visit the URL shown instead";
@@ -61117,7 +61603,7 @@ function AuthFlow({ onClose, hideEsc }) {
   const goHome = () => {
     onClose();
   };
-  const cleanup = useCallback14(() => {
+  const cleanup = useCallback16(() => {
     abortRef.current?.abort();
     abortRef.current = null;
   }, []);
@@ -61678,9 +62164,9 @@ function AuthFlow({ onClose, hideEsc }) {
 
 // src/tui/components/commands/credits-flow.tsx
 import { useKeyboard as useKeyboard8 } from "@opentui/react";
-import { useCallback as useCallback15, useEffect as useEffect14, useState as useState22 } from "react";
+import { useCallback as useCallback17, useEffect as useEffect14, useState as useState22 } from "react";
 init_auth();
-import { jsxDEV as jsxDEV29, Fragment as Fragment2 } from "@opentui/react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV29, Fragment as Fragment3 } from "@opentui/react/jsx-dev-runtime";
 function CreditsFlow({
   onClose,
   onOpenAuthDialog
@@ -61706,7 +62192,7 @@ function CreditsFlow({
     });
     setStep("browser-opened");
   };
-  const fetchBalance = useCallback15(async () => {
+  const fetchBalance = useCallback17(async () => {
     setStep("loading");
     setError(null);
     try {
@@ -61816,7 +62302,7 @@ function CreditsFlow({
                   error
                 ]
               }, undefined, true, undefined, this)
-            }, undefined, false, undefined, this) : credits ? /* @__PURE__ */ jsxDEV29(Fragment2, {
+            }, undefined, false, undefined, this) : credits ? /* @__PURE__ */ jsxDEV29(Fragment3, {
               children: [
                 /* @__PURE__ */ jsxDEV29("box", {
                   children: /* @__PURE__ */ jsxDEV29("text", {
@@ -62109,7 +62595,6 @@ function HelpDialog({ onClose }) {
 // src/tui/components/commands/models-display.tsx
 import { useKeyboard as useKeyboard10 } from "@opentui/react";
 // src/tui/components/model-picker/ModelPickerDialog.tsx
-init_ai();
 import { jsxDEV as jsxDEV31 } from "@opentui/react/jsx-dev-runtime";
 function ModelPickerDialog({ onClose }) {
   const { colors: colors2 } = useTheme();
@@ -62123,17 +62608,9 @@ function ModelPickerDialog({ onClose }) {
     openAIReasoningEffort,
     setOpenAIReasoningEffort
   } = useAgent();
-  const thinkingSupported = modelSupportsThinking(model.id);
-  const openAIReasoningSupported = modelSupportsOpenAIReasoning(model.id);
   const footerActions = [
     { key: "Enter", label: "confirm", variant: "primary" }
   ];
-  if (thinkingSupported) {
-    footerActions.push({ key: "Space", label: "Extended Thinking" });
-  }
-  if (openAIReasoningSupported) {
-    footerActions.push({ key: "Space", label: "Reasoning Effort" });
-  }
   const title = /* @__PURE__ */ jsxDEV31("text", {
     children: [
       /* @__PURE__ */ jsxDEV31("span", {
@@ -62609,7 +63086,7 @@ function HITLWizard(props) {
 }
 
 // src/tui/components/commands/provider-manager.tsx
-init_config2();
+init_config();
 import { useKeyboard as useKeyboard14 } from "@opentui/react";
 import { useState as useState27 } from "react";
 
@@ -62863,7 +63340,7 @@ function ProviderSelection({
 }
 
 // src/tui/components/commands/provider-manager.tsx
-import { jsxDEV as jsxDEV37, Fragment as Fragment3 } from "@opentui/react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV37, Fragment as Fragment4 } from "@opentui/react/jsx-dev-runtime";
 function ProviderManager({
   onClose,
   onOpenModelDialog
@@ -62939,7 +63416,7 @@ function ProviderManager({
   };
   const otherProviders = AVAILABLE_PROVIDERS.filter((p) => p.id !== "pensar");
   const selectedProviderInfo = AVAILABLE_PROVIDERS.find((p) => p.id === selectedProvider);
-  return /* @__PURE__ */ jsxDEV37(Fragment3, {
+  return /* @__PURE__ */ jsxDEV37(Fragment4, {
     children: [
       flowState === "choosing" && /* @__PURE__ */ jsxDEV37(OnboardingChoice, {
         onPensarSelected: () => setFlowState("auth"),
@@ -63052,13 +63529,13 @@ function OnboardingChoice({
 
 // src/tui/components/commands/sessions-display.tsx
 import { useKeyboard as useKeyboard16 } from "@opentui/react";
-import { useCallback as useCallback17, useEffect as useEffect18, useRef as useRef14, useState as useState29 } from "react";
+import { useCallback as useCallback19, useEffect as useEffect18, useRef as useRef14, useState as useState29 } from "react";
 init_session();
 
 // src/tui/hooks/use-sessions-list.ts
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { useCallback as useCallback16, useEffect as useEffect17, useState as useState28 } from "react";
+import { useCallback as useCallback18, useEffect as useEffect17, useState as useState28 } from "react";
 init_session();
 function countFindings(findingsPath) {
   try {
@@ -63076,7 +63553,7 @@ function useSessionsList() {
   const [allSessions, setAllSessions] = useState28([]);
   const [loading, setLoading] = useState28(true);
   const [searchTerm, setSearchTerm] = useState28("");
-  const loadSessions = useCallback16(async () => {
+  const loadSessions = useCallback18(async () => {
     try {
       const enriched = [];
       for await (const session of list()) {
@@ -63101,7 +63578,7 @@ function useSessionsList() {
   useEffect17(() => {
     loadSessions();
   }, [loadSessions]);
-  const deleteSession = useCallback16(async (id) => {
+  const deleteSession = useCallback18(async (id) => {
     setAllSessions((prev) => prev.filter((s) => s.id !== id));
     await sessions.remove({ sessionId: id });
     await loadSessions();
@@ -63334,7 +63811,7 @@ function SessionsDisplay({ onClose }) {
     initialOverflowRef.current = estimatedRows > availableListHeight;
   }
   const listHeight = initialOverflowRef.current ? availableListHeight : undefined;
-  const viewReport = useCallback17(async (sessionId) => {
+  const viewReport = useCallback19(async (sessionId) => {
     const session = await sessions.get(sessionId);
     const content = readSessionReport(session.rootPath);
     if (!content) {
@@ -63345,7 +63822,7 @@ function SessionsDisplay({ onClose }) {
     setReportSessionPath(session.rootPath);
     setShowReportViewer(true);
   }, [toast]);
-  const openReportExternal = useCallback17(async () => {
+  const openReportExternal = useCallback19(async () => {
     if (!reportSessionPath)
       return;
     const err = await openSessionReport(reportSessionPath);
@@ -63971,9 +64448,9 @@ function SkillsDialog({
 }
 
 // src/tui/components/commands/theme-picker.tsx
-init_config2();
+init_config();
 import { useKeyboard as useKeyboard19 } from "@opentui/react";
-import { useCallback as useCallback18, useRef as useRef16, useState as useState31 } from "react";
+import { useCallback as useCallback20, useRef as useRef16, useState as useState31 } from "react";
 import { jsxDEV as jsxDEV42 } from "@opentui/react/jsx-dev-runtime";
 function ThemePicker({ onClose }) {
   const dimensions = useDimensions();
@@ -63992,14 +64469,14 @@ function ThemePicker({ onClose }) {
   const originalThemeRef = useRef16(theme.name);
   const originalModeRef = useRef16(mode);
   const originalTransparentRef = useRef16(transparent);
-  const handleClose = useCallback18(() => {
+  const handleClose = useCallback20(() => {
     setTheme(originalThemeRef.current);
     setMode(originalModeRef.current);
     if (transparent !== originalTransparentRef.current)
       toggleTransparent();
     onClose();
   }, [setTheme, setMode, transparent, toggleTransparent, onClose]);
-  const handleConfirm = useCallback18(async () => {
+  const handleConfirm = useCallback20(async () => {
     const currentThemeName = availableThemes[selectedIndex];
     if (currentThemeName) {
       await config.update({ theme: currentThemeName });
@@ -64125,7 +64602,7 @@ function ThemePicker({ onClose }) {
 // src/tui/components/commands/web-wizard.tsx
 import { useKeyboard as useKeyboard20 } from "@opentui/react";
 import { useEffect as useEffect20, useRef as useRef17, useState as useState32 } from "react";
-import { jsxDEV as jsxDEV43, Fragment as Fragment4 } from "@opentui/react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV43, Fragment as Fragment5 } from "@opentui/react/jsx-dev-runtime";
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
@@ -64611,7 +65088,7 @@ function WebWizard({
               }, undefined, false, undefined, this)
             ]
           }, undefined, true, undefined, this),
-          advancedExpanded && /* @__PURE__ */ jsxDEV43(Fragment4, {
+          advancedExpanded && /* @__PURE__ */ jsxDEV43(Fragment5, {
             children: [
               /* @__PURE__ */ jsxDEV43("box", {
                 id: `field-${promptFieldIndex}`,
@@ -64849,7 +65326,7 @@ function WebWizard({
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              state.headers.mode === "custom" && /* @__PURE__ */ jsxDEV43(Fragment4, {
+              state.headers.mode === "custom" && /* @__PURE__ */ jsxDEV43(Fragment5, {
                 children: [
                   /* @__PURE__ */ jsxDEV43("box", {
                     id: `field-${headersNameIndex}`,
@@ -64897,7 +65374,7 @@ function WebWizard({
 
 // src/tui/components/error-boundary.tsx
 init_logger();
-import React, { useCallback as useCallback19 } from "react";
+import React, { useCallback as useCallback21 } from "react";
 var MAX_ERRORS = 3;
 var ERROR_WINDOW_MS = 5000;
 
@@ -64932,7 +65409,7 @@ class ErrorBoundaryInner extends React.Component {
 }
 function ErrorBoundary({ children }) {
   const { toast } = useToast();
-  const handleError = useCallback19((message) => {
+  const handleError = useCallback21((message) => {
     toast(message, "error");
   }, [toast]);
   return React.createElement(ErrorBoundaryInner, { onError: handleError }, children);
@@ -64986,19 +65463,52 @@ var useSession = () => {
   return session;
 };
 
-// src/tui/components/footer.tsx
-import { jsxDEV as jsxDEV45, Fragment as Fragment5 } from "@opentui/react/jsx-dev-runtime";
+// src/tui/components/usage-labels.ts
+var WIDE_MIN_WIDTH = 86;
+var NARROW_MIN_WIDTH = 56;
 function formatTokenCount(count) {
   if (count >= 1e6) {
     const v2 = count / 1e6;
-    return `${Number.isInteger(v2) ? v2.toFixed(0) : v2.toFixed(1)}M`;
+    return `${Number.isInteger(v2) ? v2.toFixed(0) : v2.toFixed(1)}m`;
   }
   if (count >= 1000) {
     const v2 = count / 1000;
-    return `${Number.isInteger(v2) ? v2.toFixed(0) : v2.toFixed(1)}K`;
+    return `${Number.isInteger(v2) ? v2.toFixed(0) : v2.toFixed(1)}k`;
   }
   return count.toString();
 }
+function buildUsageFooterLabels(input) {
+  const { tokenUsage, contextUsage, width } = input;
+  if (width < NARROW_MIN_WIDTH) {
+    return { tokensLabel: null, contextLabel: null };
+  }
+  if (width >= WIDE_MIN_WIDTH) {
+    let tokensLabel = `in ${formatTokenCount(tokenUsage.inputTokens)}  out ${formatTokenCount(tokenUsage.outputTokens)}`;
+    if (tokenUsage.cacheReadTokens > 0) {
+      tokensLabel += `  cached ${formatTokenCount(tokenUsage.cacheReadTokens)}`;
+    }
+    return {
+      tokensLabel,
+      contextLabel: contextLabel(contextUsage, true)
+    };
+  }
+  const total = tokenUsage.inputTokens + tokenUsage.outputTokens;
+  return {
+    tokensLabel: `${formatTokenCount(total)} tokens`,
+    contextLabel: contextLabel(contextUsage, false)
+  };
+}
+function contextLabel(context2, wide) {
+  const percentage = contextPercentage(context2);
+  if (percentage === null || !context2)
+    return null;
+  const pct = Math.floor(percentage);
+  const limit = formatTokenCount(context2.contextLimit);
+  return wide ? `context ${pct}% / ${limit}` : `${pct}% / ${limit}`;
+}
+
+// src/tui/components/footer.tsx
+import { jsxDEV as jsxDEV45, Fragment as Fragment6 } from "@opentui/react/jsx-dev-runtime";
 function Footer({
   cwd = process.cwd(),
   showExitWarning = false
@@ -65077,126 +65587,54 @@ function Footer({
 }
 function AgentStatus() {
   const { colors: colors2 } = useTheme();
-  const { tokenUsage } = useAgent();
+  const { usageStore } = useAgent();
   const { width: termWidth } = useDimensions();
-  const showTokenCount = termWidth > 85;
-  const tokenLabel = `↓${formatTokenCount(tokenUsage.inputTokens)} ↑${formatTokenCount(tokenUsage.outputTokens)}${tokenUsage.cachedTokens > 0 ? ` ⚡${formatTokenCount(tokenUsage.cachedTokens)}` : ""} Σ${formatTokenCount(tokenUsage.totalTokens)}`;
+  const usage = useActiveSessionUsage(usageStore);
+  const { tokensLabel, contextLabel: contextLabel2 } = buildUsageFooterLabels({
+    tokenUsage: usage.tokenUsage,
+    contextUsage: usage.contextUsage,
+    width: termWidth
+  });
+  if (!tokensLabel)
+    return null;
   return /* @__PURE__ */ jsxDEV45("box", {
     flexDirection: "row",
     gap: 1,
     children: [
-      showTokenCount && /* @__PURE__ */ jsxDEV45(Fragment5, {
+      /* @__PURE__ */ jsxDEV45("text", {
+        fg: colors2.text,
+        children: tokensLabel
+      }, undefined, false, undefined, this),
+      contextLabel2 && /* @__PURE__ */ jsxDEV45(Fragment6, {
         children: [
-          /* @__PURE__ */ jsxDEV45("box", {
-            border: ["right"],
-            borderColor: colors2.primary
+          /* @__PURE__ */ jsxDEV45("text", {
+            fg: colors2.textMuted,
+            children: "|"
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV45("text", {
             fg: colors2.text,
-            children: tokenLabel
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV45("box", {
-            border: ["right"],
-            borderColor: colors2.primary
+            children: contextLabel2
           }, undefined, false, undefined, this)
         ]
-      }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV45(ContextProgress, {
-        width: 16,
-        showPercent: true
-      }, undefined, false, undefined, this)
+      }, undefined, true, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
-var FILL_CHAR = "▬";
-var DASH_CHAR = "─";
-function ContextProgress({
-  width = 20,
-  showPercent = false
-}) {
-  const { colors: colors2 } = useTheme();
-  const { model, tokenUsage } = useAgent();
-  const contextLength = model.contextLength ?? 200000;
-  const fraction = Math.max(0, Math.min(1, tokenUsage.totalTokens / contextLength));
-  const inner = Math.max(1, width - 2);
-  const filledCells = Math.round(fraction * inner);
-  const fillColor = colors2.success;
-  const sizeText = formatTokenCount(contextLength);
-  const labelText = showPercent ? `${Math.floor(fraction * 100)}% ${sizeText}` : sizeText;
-  const labelLen = labelText.length;
-  const labelStart = Math.max(0, inner - labelLen - 1);
-  const labelEnd = labelStart + labelLen;
-  const dashColor = withAlpha2(colors2.textMuted, 0.35);
-  const bracketColor = withAlpha2(colors2.textMuted, 0.7);
-  const cells = [];
-  cells.push({ ch: "[", fg: bracketColor });
-  for (let col = 0;col < inner; col++) {
-    const inLabel = col >= labelStart && col < labelEnd;
-    const isFilled = col < filledCells;
-    if (inLabel) {
-      cells.push({
-        ch: labelText[col - labelStart],
-        fg: colors2.text
-      });
-    } else if (isFilled) {
-      cells.push({ ch: FILL_CHAR, fg: fillColor });
-    } else {
-      cells.push({ ch: DASH_CHAR, fg: dashColor });
-    }
-  }
-  cells.push({ ch: "]", fg: bracketColor });
-  return /* @__PURE__ */ jsxDEV45("box", {
-    flexDirection: "row",
-    children: cells.map((cell, i) => /* @__PURE__ */ jsxDEV45("text", {
-      fg: cell.fg,
-      content: cell.ch
-    }, i, false, undefined, this))
-  }, undefined, false, undefined, this);
-}
 
 // src/tui/components/operator-dashboard/index.tsx
 init_dist();
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join3, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
 import { useKeyboard as useKeyboard26 } from "@opentui/react";
 import {
-  useCallback as useCallback20,
+  useCallback as useCallback22,
   useEffect as useEffect25,
   useMemo as useMemo22,
   useRef as useRef21,
   useState as useState39,
-  useSyncExternalStore as useSyncExternalStore2
+  useSyncExternalStore as useSyncExternalStore3
 } from "react";
 init_ai();
-
-// src/core/integrations/wandb/upload.ts
-async function createWandbUploader(session, opts) {
-  const resolved = resolveConfig(opts);
-  if (!resolved.available)
-    return null;
-  const tracer = await createWeaveTracer(resolved.config);
-  if (!tracer)
-    return null;
-  return {
-    onRecord: (record) => tracer.logRecord(record, session.id),
-    finalize: () => tracer.finish()
-  };
-}
-async function attachWandbToEventBus(session, eventBus, opts) {
-  const uploader = await createWandbUploader(session, opts);
-  if (!uploader)
-    return null;
-  const handler = (e) => {
-    uploader.onRecord(e.record);
-  };
-  eventBus.on("trace-record", handler);
-  return async () => {
-    eventBus.off("trace-record", handler);
-    await uploader.finalize();
-  };
-}
-
-// src/tui/components/operator-dashboard/index.tsx
 init_session();
 
 // src/tui/components/chat/approval-inline.tsx
@@ -66464,6 +66902,202 @@ function ScreenshotModal({ screenshots, initialIndex, onClose }) {
   }, undefined, true, undefined, this);
 }
 
+// src/tui/components/operator-dashboard/conversation.ts
+init_session();
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+function recoverAbortedConversation(conversation, partialText, displayMessages) {
+  if (conversation.at(-1)?.role !== "user")
+    return null;
+  const pendingTools = displayMessages.filter((message) => message.role === "tool" && typeof message.toolCallId === "string" && typeof message.toolName === "string" && (message.status === "pending" || message.status === "streaming"));
+  const assistantContent = [
+    {
+      type: "text",
+      text: partialText.trim() || "[Response interrupted by user.]"
+    },
+    ...pendingTools.map((tool) => ({
+      type: "tool-call",
+      toolCallId: tool.toolCallId,
+      toolName: tool.toolName,
+      input: tool.args ?? {}
+    }))
+  ];
+  const recovered = [
+    ...conversation,
+    {
+      role: "assistant",
+      content: assistantContent
+    }
+  ];
+  if (pendingTools.length === 0)
+    return recovered;
+  return [
+    ...recovered,
+    {
+      role: "tool",
+      content: pendingTools.map((tool) => ({
+        type: "tool-result",
+        toolCallId: tool.toolCallId,
+        toolName: tool.toolName ?? "unknown",
+        output: {
+          type: "text",
+          value: "Cancelled by user."
+        }
+      }))
+    }
+  ];
+}
+function rewriteToolResultOutput(conversation, toolCallId, value) {
+  const wrappedOutput = {
+    type: "json",
+    value
+  };
+  let changed = false;
+  const next = conversation.map((msg) => {
+    if (msg.role !== "tool")
+      return msg;
+    if (!Array.isArray(msg.content))
+      return msg;
+    let mutated = false;
+    const nextContent = msg.content.map((part) => {
+      if (part && typeof part === "object" && "type" in part && part.type === "tool-result" && part.toolCallId === toolCallId) {
+        mutated = true;
+        return {
+          ...part,
+          output: wrappedOutput
+        };
+      }
+      return part;
+    });
+    if (!mutated)
+      return msg;
+    changed = true;
+    return { ...msg, content: nextContent };
+  });
+  return changed ? next : conversation;
+}
+function recoverAbortedTranscript(input) {
+  const messagesPath = join3(input.rootPath, "messages.json");
+  let conversation = input.conversation;
+  let recovered = null;
+  try {
+    if (existsSync3(messagesPath)) {
+      const raw = JSON.parse(readFileSync3(messagesPath, "utf-8"));
+      if (Array.isArray(raw) && raw.length > 0) {
+        conversation = normalizeMessages(getResumeMessages(raw));
+      }
+    }
+    recovered = recoverAbortedConversation(conversation, input.partialText, input.displayMessages);
+  } catch {}
+  if (!recovered)
+    return conversation;
+  conversation = recovered;
+  try {
+    writeFileSync(messagesPath, JSON.stringify(recovered, null, 2));
+  } catch {}
+  return conversation;
+}
+
+// src/tui/components/operator-dashboard/display-state.ts
+var MAX_LOG_LINES = 200;
+function appendStreamedText(messages, accumulated) {
+  const last = messages[messages.length - 1];
+  if (last && last.role === "assistant") {
+    const updated = [...messages];
+    updated[updated.length - 1] = { ...last, content: accumulated };
+    return updated;
+  }
+  return [
+    ...messages,
+    { role: "assistant", content: accumulated, createdAt: new Date }
+  ];
+}
+function startStreamingToolCall(messages, toolCallId, toolName) {
+  return [
+    ...messages,
+    {
+      role: "tool",
+      content: "",
+      createdAt: new Date,
+      toolCallId,
+      toolName,
+      args: {},
+      status: "streaming"
+    }
+  ];
+}
+function applyToolCallDelta(messages, toolCallId, parsed) {
+  const contentText = extractStreamableContent(parsed);
+  const logs = contentText ? contentText.split(`
+`) : undefined;
+  const idx = messages.findIndex((m2) => isToolMessage(m2) && m2.toolCallId === toolCallId);
+  if (idx === -1)
+    return messages;
+  const updated = [...messages];
+  updated[idx] = { ...updated[idx], args: parsed, ...logs && { logs } };
+  return updated;
+}
+function applyToolCall(messages, toolCallId, toolName, args) {
+  const idx = messages.findIndex((m2) => isToolMessage(m2) && m2.toolCallId === toolCallId);
+  if (idx !== -1) {
+    const updated = [...messages];
+    updated[idx] = {
+      ...updated[idx],
+      args,
+      logs: undefined,
+      status: "pending"
+    };
+    return updated;
+  }
+  return [
+    ...messages,
+    {
+      role: "tool",
+      content: "",
+      createdAt: new Date,
+      toolCallId,
+      toolName,
+      args,
+      status: "pending"
+    }
+  ];
+}
+function applyToolResult(messages, toolCallId, result) {
+  const idx = messages.findIndex((m2) => isToolMessage(m2) && m2.toolCallId === toolCallId);
+  if (idx === -1)
+    return messages;
+  const updated = [...messages];
+  updated[idx] = { ...updated[idx], status: "completed", result };
+  return updated;
+}
+function mergeCommandOutput(messages, buf) {
+  const idx = messages.findLastIndex((m2) => isToolMessage(m2) && (m2.status === "pending" || m2.status === "streaming"));
+  if (idx === -1)
+    return messages;
+  const msg = messages[idx];
+  const existing = msg.logs ?? [];
+  const incoming = buf.split(`
+`);
+  let merged;
+  if (existing.length > 0 && !buf.startsWith(`
+`)) {
+    merged = [...existing];
+    merged[merged.length - 1] += incoming[0];
+    merged.push(...incoming.slice(1));
+  } else {
+    merged = [...existing, ...incoming];
+  }
+  if (merged.length > MAX_LOG_LINES) {
+    merged = merged.slice(-MAX_LOG_LINES);
+  }
+  const updated = [...messages];
+  updated[idx] = { ...msg, logs: merged };
+  return updated;
+}
+function markInFlightToolsErrored(messages, result) {
+  return messages.map((m2) => isToolMessage(m2) && (m2.status === "pending" || m2.status === "streaming") ? { ...m2, status: "error", result } : m2);
+}
+
 // src/tui/components/operator-dashboard/logic.ts
 var OPERATOR_ALLOWED_COMMANDS = new Set([
   "/models",
@@ -66741,17 +67375,6 @@ ${refinementBlock}`;
 function resolveInputFocused(status, dialogStackLength, externalDialogOpen) {
   return status !== "running" && dialogStackLength === 0 && !externalDialogOpen;
 }
-function accumulateTokenUsage(current, stepInputTokens, stepOutputTokens) {
-  if (stepInputTokens <= 0 && stepOutputTokens <= 0)
-    return null;
-  return {
-    inputTokens: current.inputTokens + stepInputTokens,
-    outputTokens: current.outputTokens + stepOutputTokens,
-    totalTokens: current.totalTokens + stepInputTokens + stepOutputTokens,
-    cachedTokens: current.cachedTokens,
-    cacheWriteTokens: current.cacheWriteTokens
-  };
-}
 
 // src/tui/components/operator-dashboard/queue.ts
 var nextId3 = 0;
@@ -66841,6 +67464,401 @@ function QueuedMessages({
   }, undefined, true, undefined, this);
 }
 
+// src/tui/components/operator-dashboard/workflow-data.ts
+function isPentestAgent(id) {
+  return id !== undefined && /^pentest-agent-\d+$/.test(id);
+}
+function initialWorkflowData() {
+  return {
+    currentPhase: "discovery",
+    discovery: { label: "", status: "pending", logs: [] },
+    pentesting: { label: "", status: "idle", subagents: {} },
+    reporting: { label: "", status: "idle" }
+  };
+}
+function updateWorkflowDataMessage(messages, updater) {
+  const idx = messages.findLastIndex((m2) => isToolMessage(m2) && m2.toolName === "run_pentest_workflow" && (m2.status === "pending" || m2.status === "streaming"));
+  if (idx === -1)
+    return messages;
+  const msg = messages[idx];
+  const wd = msg.workflowData ?? initialWorkflowData();
+  const updated = [...messages];
+  updated[idx] = { ...msg, workflowData: updater(wd) };
+  return updated;
+}
+function applyWorkflowSubagentSpawn(wd, subagentId, name) {
+  return {
+    ...wd,
+    pentesting: {
+      ...wd.pentesting,
+      subagents: {
+        ...wd.pentesting.subagents,
+        [subagentId]: { name, status: "pending", logs: [] }
+      }
+    }
+  };
+}
+function applyWorkflowSubagentComplete(wd, subagentId, status) {
+  const entry = wd.pentesting.subagents[subagentId];
+  if (!entry)
+    return wd;
+  return {
+    ...wd,
+    pentesting: {
+      ...wd.pentesting,
+      subagents: {
+        ...wd.pentesting.subagents,
+        [subagentId]: { ...entry, status }
+      }
+    }
+  };
+}
+function applyWorkflowPhaseStart(wd, phase, label) {
+  const next = { ...wd, currentPhase: phase };
+  if (phase === "discovery") {
+    next.discovery = { ...wd.discovery, label, status: "pending", logs: [] };
+  } else if (phase === "pentesting") {
+    next.pentesting = { ...wd.pentesting, label, status: "pending" };
+  } else if (phase === "reporting") {
+    next.reporting = { ...wd.reporting, label, status: "pending" };
+  }
+  return next;
+}
+function applyWorkflowPhaseComplete(wd, phase, summary) {
+  const next = { ...wd };
+  if (phase === "discovery") {
+    const targets = summary.targets ?? [];
+    next.discovery = {
+      ...wd.discovery,
+      status: "complete",
+      targets,
+      cached: summary.cached
+    };
+  } else if (phase === "pentesting") {
+    next.pentesting = { ...wd.pentesting, status: "complete" };
+  } else if (phase === "reporting") {
+    next.reporting = {
+      ...wd.reporting,
+      status: "complete",
+      findingsCount: summary.findingsCount,
+      findingsBySeverity: summary.findingsBySeverity,
+      reportPath: summary.reportPath
+    };
+    next.currentPhase = "complete";
+  }
+  return next;
+}
+
+// src/tui/components/operator-dashboard/run-events.ts
+function bindOperatorRunEvents(bus, options) {
+  const { isCurrent, handlers } = options;
+  const offs = [];
+  let boundError = false;
+  const bind = (event, handler) => {
+    if (!handler)
+      return;
+    if (event === "error")
+      boundError = true;
+    const wrapped = (e) => {
+      if (!isCurrent())
+        return;
+      try {
+        handler(e);
+      } catch (err) {
+        console.error(`[operator] ${event} handler failed:`, err);
+      }
+    };
+    bus.on(event, wrapped);
+    offs.push(() => bus.off(event, wrapped));
+  };
+  bind("text-delta", handlers.onTextDelta);
+  bind("tool-call-start", handlers.onToolCallStart);
+  bind("tool-call-delta", handlers.onToolCallDelta);
+  bind("tool-call-complete", handlers.onToolCallComplete);
+  bind("tool-result", handlers.onToolResult);
+  bind("command-output", handlers.onCommandOutput);
+  bind("error", handlers.onError);
+  bind("subagent-spawn", handlers.onSubagentSpawn);
+  bind("subagent-complete", handlers.onSubagentComplete);
+  bind("workflow-phase-start", handlers.onWorkflowPhaseStart);
+  bind("workflow-phase-complete", handlers.onWorkflowPhaseComplete);
+  let unbound = false;
+  return () => {
+    if (unbound)
+      return;
+    unbound = true;
+    for (const off of offs)
+      off();
+    offs.length = 0;
+    if (boundError)
+      bus.on("error", () => {});
+  };
+}
+var COMMAND_OUTPUT_FLUSH_MS = 150;
+function createDisplayEventHandlers(sink) {
+  let partialText = "";
+  const toolArgsDeltas = new Map;
+  let commandOutputBuf = "";
+  let flushTimer = null;
+  const flushCommandOutput = () => {
+    if (!commandOutputBuf)
+      return;
+    const buf = commandOutputBuf;
+    commandOutputBuf = "";
+    sink.updateMessages((messages) => mergeCommandOutput(messages, buf));
+  };
+  const stopCommandOutputFlush = () => {
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+  };
+  return {
+    onTextDelta(e) {
+      sink.setThinking(false);
+      partialText += e.text;
+      const accumulated = partialText;
+      sink.updateMessages((messages) => appendStreamedText(messages, accumulated));
+    },
+    onToolCallStart(e) {
+      sink.setThinking(false);
+      partialText = "";
+      toolArgsDeltas.set(e.toolCallId, { accumulated: "" });
+      sink.updateMessages((messages) => startStreamingToolCall(messages, e.toolCallId, e.toolName));
+    },
+    onToolCallDelta(e) {
+      const entry = toolArgsDeltas.get(e.toolCallId);
+      const accumulated = (entry?.accumulated ?? "") + e.argsTextDelta;
+      toolArgsDeltas.set(e.toolCallId, { accumulated });
+      const parsed = tryParsePartialJson(accumulated);
+      if (!parsed)
+        return;
+      sink.updateMessages((messages) => applyToolCallDelta(messages, e.toolCallId, parsed));
+    },
+    onToolCallComplete(e) {
+      sink.setThinking(false);
+      partialText = "";
+      toolArgsDeltas.delete(e.toolCallId);
+      const args = e.args && typeof e.args === "object" && !Array.isArray(e.args) && e.args !== null ? e.args : undefined;
+      sink.updateMessages((messages) => applyToolCall(messages, e.toolCallId, e.toolName, args));
+    },
+    onToolResult(e) {
+      flushCommandOutput();
+      stopCommandOutputFlush();
+      sink.setThinking(true);
+      partialText = "";
+      sink.updateMessages((messages) => applyToolResult(messages, e.toolCallId, e.result));
+    },
+    onCommandOutput(e) {
+      commandOutputBuf += e.data;
+      if (!flushTimer) {
+        flushTimer = setInterval(flushCommandOutput, COMMAND_OUTPUT_FLUSH_MS);
+      }
+    },
+    onError(e) {
+      console.error("Agent error:", e.error);
+      const errorMessage = e.error instanceof Error ? e.error.message : "Unknown error";
+      sink.setError(errorMessage);
+      sink.updateMessages((messages) => markInFlightToolsErrored(messages, errorMessage));
+    },
+    getPartialText() {
+      return partialText;
+    },
+    resetPartialText() {
+      partialText = "";
+    },
+    flushCommandOutput,
+    stopCommandOutputFlush,
+    dispose: stopCommandOutputFlush
+  };
+}
+function toRecordArgs(args) {
+  return args && typeof args === "object" && !Array.isArray(args) && args !== null ? args : undefined;
+}
+function createRunEventProjections(deps) {
+  const { display, subagents, updateWorkflowData } = deps;
+  return {
+    handlers: {
+      onTextDelta: (d2) => {
+        if (d2.subagentId) {
+          subagents.appendText(d2.subagentId, d2.text);
+          return;
+        }
+        display.onTextDelta(d2);
+      },
+      onToolCallStart: (d2) => {
+        if (d2.subagentId) {
+          subagents.addStreamingToolCall(d2.subagentId, d2.toolCallId, d2.toolName);
+          return;
+        }
+        display.onToolCallStart(d2);
+      },
+      onToolCallDelta: (d2) => {
+        if (d2.subagentId) {
+          subagents.appendToolCallDelta(d2.subagentId, d2.toolCallId, d2.argsTextDelta);
+          return;
+        }
+        display.onToolCallDelta(d2);
+      },
+      onToolCallComplete: (d2) => {
+        if (d2.subagentId) {
+          subagents.addToolCall(d2.subagentId, d2.toolCallId, d2.toolName, toRecordArgs(d2.args) ?? {});
+          return;
+        }
+        display.onToolCallComplete(d2);
+        deps.onRootToolCallStarted?.();
+        if (d2.toolName === ASK_USER_QUESTIONS_TOOL_NAME) {
+          const rawQuestions = toRecordArgs(d2.args)?.questions;
+          if (Array.isArray(rawQuestions) && rawQuestions.length > 0) {
+            deps.questions.onAsked(d2.toolCallId, rawQuestions);
+          }
+        }
+      },
+      onToolResult: (d2) => {
+        if (d2.subagentId) {
+          subagents.updateToolResult(d2.subagentId, d2.toolCallId, d2.result);
+          return;
+        }
+        display.onToolResult(d2);
+        if (d2.toolName === "submit_plan" && d2.result?.success === true) {
+          deps.onPlanSubmitted?.();
+        }
+      },
+      onCommandOutput: (d2) => {
+        if (d2.subagentId)
+          return;
+        display.onCommandOutput(d2);
+      },
+      onError: (d2) => {
+        if (d2.subagentId) {
+          const errMsg = d2.error instanceof Error ? d2.error.message : "Unknown error";
+          subagents.appendText(d2.subagentId, `
+Error: ${errMsg}
+`);
+          return;
+        }
+        display.onError(d2);
+        deps.questions.onCleared();
+      },
+      onSubagentSpawn: ({ subagentId, name }) => {
+        if (subagentId.startsWith("app:"))
+          return;
+        subagents.spawnSession(subagentId, name);
+        if (!isPentestAgent(subagentId))
+          return;
+        updateWorkflowData((wd) => applyWorkflowSubagentSpawn(wd, subagentId, name));
+      },
+      onSubagentComplete: ({ subagentId, status }) => {
+        if (subagentId.startsWith("app:"))
+          return;
+        subagents.completeSession(subagentId, status);
+        if (!isPentestAgent(subagentId))
+          return;
+        updateWorkflowData((wd) => applyWorkflowSubagentComplete(wd, subagentId, status));
+      },
+      onWorkflowPhaseStart: (d2) => {
+        display.resetPartialText();
+        if (d2.phase === "discovery") {
+          deps.clearSubagentSessions();
+        }
+        updateWorkflowData((wd) => applyWorkflowPhaseStart(wd, d2.phase, d2.label));
+      },
+      onWorkflowPhaseComplete: (d2) => {
+        display.resetPartialText();
+        updateWorkflowData((wd) => applyWorkflowPhaseComplete(wd, d2.phase, d2.summary));
+      }
+    }
+  };
+}
+
+// src/core/integrations/wandb/upload.ts
+async function createWandbUploader(session, opts) {
+  const resolved = resolveConfig(opts);
+  if (!resolved.available)
+    return null;
+  const tracer = await createWeaveTracer(resolved.config);
+  if (!tracer)
+    return null;
+  return {
+    onRecord: (record) => tracer.logRecord(record, session.id),
+    finalize: () => tracer.finish()
+  };
+}
+async function attachWandbToEventBus(session, eventBus, opts) {
+  const uploader = await createWandbUploader(session, opts);
+  if (!uploader)
+    return null;
+  const handler = (e) => {
+    uploader.onRecord(e.record);
+  };
+  eventBus.on("trace-record", handler);
+  return async () => {
+    eventBus.off("trace-record", handler);
+    await uploader.finalize();
+  };
+}
+
+// src/tui/components/operator-dashboard/run-tracing.ts
+class RunTraceSession {
+  eventBus;
+  options;
+  cleanup = null;
+  earlyBuffer = [];
+  countedSubagentSteps = new Set;
+  earlyBufferHandler = (e) => {
+    this.earlyBuffer?.push(e);
+  };
+  constructor(eventBus, options) {
+    this.eventBus = eventBus;
+    this.options = options;
+    eventBus.on("trace-record", this.earlyBufferHandler);
+    eventBus.on("trace-record", this.countSubagentStep);
+  }
+  async tryAttach(session) {
+    if (this.cleanup)
+      return;
+    const attach = this.options.attach ?? attachWandbToEventBus;
+    const cleanup = await attach(session, this.eventBus).catch((e) => {
+      console.error("[wandb] Attach failed:", e);
+      return null;
+    });
+    const buffered = this.earlyBuffer;
+    this.stopBuffering();
+    if (cleanup) {
+      this.cleanup = cleanup;
+      if (buffered) {
+        for (const e of buffered)
+          this.eventBus.emit("trace-record", e);
+      }
+    }
+  }
+  async cleanupRun() {
+    this.stopBuffering();
+    this.eventBus.off("trace-record", this.countSubagentStep);
+    if (this.cleanup) {
+      const fn = this.cleanup;
+      this.cleanup = null;
+      await fn().catch((e) => console.error("[wandb] Flush failed:", e));
+    }
+  }
+  stopBuffering() {
+    this.earlyBuffer = null;
+    this.eventBus.off("trace-record", this.earlyBufferHandler);
+  }
+  countSubagentStep = (e) => {
+    if (!this.options.isCurrent())
+      return;
+    const { record, subagentId } = e;
+    if (!subagentId || record.type !== "step")
+      return;
+    const key = `${subagentId}:${record.stepIndex}:${record.timestamp}`;
+    if (this.countedSubagentSteps.has(key))
+      return;
+    this.countedSubagentSteps.add(key);
+    this.options.recordTokenUsage(record.usage.inputTokens, record.usage.outputTokens, record.usage.cacheReadTokens ?? 0, record.usage.cacheWriteTokens ?? 0);
+  };
+}
+
 // src/tui/components/operator-dashboard/subagent-dialog.tsx
 import { useKeyboard as useKeyboard25 } from "@opentui/react";
 import {
@@ -66848,7 +67866,7 @@ import {
   useMemo as useMemo21,
   useRef as useRef20,
   useState as useState38,
-  useSyncExternalStore
+  useSyncExternalStore as useSyncExternalStore2
 } from "react";
 
 // src/tui/components/operator-dashboard/subagent-detail-view.tsx
@@ -66930,6 +67948,22 @@ function createSubagentStore() {
     setState
   };
 }
+function markSubagentsInterrupted(prev) {
+  let changed = false;
+  const next = new Map(prev);
+  for (const [id, session] of next) {
+    const hasInFlight = session.messages.some((m2) => m2.role === "tool" && (m2.status === "pending" || m2.status === "streaming"));
+    if (!hasInFlight && session.status !== "running")
+      continue;
+    changed = true;
+    next.set(id, {
+      ...session,
+      status: session.status === "running" ? "cancelled" : session.status,
+      messages: session.messages.map((m2) => m2.role === "tool" && (m2.status === "pending" || m2.status === "streaming") ? { ...m2, status: "error", result: "Interrupted" } : m2)
+    });
+  }
+  return changed ? next : prev;
+}
 function createSubagentSessionHelpers(setState) {
   const toolArgsDeltaBuffers = new Map;
   const spawnSession = (id, name, input) => {
@@ -67340,7 +68374,7 @@ function SubagentDialog({ store }) {
   const [view, setView] = useState38({ type: "hub" });
   const viewRef = useRef20(view);
   viewRef.current = view;
-  const sessions2 = useSyncExternalStore(store.subscribe, store.getSnapshot);
+  const sessions2 = useSyncExternalStore2(store.subscribe, store.getSnapshot);
   useEffect24(() => {
     setSize(view.type === "detail" ? "xlarge" : "large");
   }, [view.type, setSize]);
@@ -67498,10 +68532,7 @@ var SubagentStatusBar = memo6(function SubagentStatusBar2({
 });
 
 // src/tui/components/operator-dashboard/index.tsx
-import { jsxDEV as jsxDEV56, Fragment as Fragment6 } from "@opentui/react/jsx-dev-runtime";
-function markInFlightToolsErrored(messages, result) {
-  return messages.map((m2) => isToolMessage(m2) && (m2.status === "pending" || m2.status === "streaming") ? { ...m2, status: "error", result } : m2);
-}
+import { jsxDEV as jsxDEV56, Fragment as Fragment7 } from "@opentui/react/jsx-dev-runtime";
 function OperatorDashboard({
   sessionId,
   initialMessage,
@@ -67516,10 +68547,8 @@ function OperatorDashboard({
     isModelUserSelected,
     setThinking,
     setIsExecuting,
-    tokenUsage,
-    addTokenUsage,
-    addCacheUsage,
-    resetTokenUsage,
+    usageStore,
+    markExecuted,
     setSessionCwd,
     reasoningEnabled,
     openAIReasoningEffort
@@ -67579,7 +68608,7 @@ function OperatorDashboard({
   });
   const commandCancelledRef = useRef21(false);
   const subagentStore = useMemo22(() => createSubagentStore(), []);
-  const subagentSessions = useSyncExternalStore2(subagentStore.subscribe, subagentStore.getSnapshot);
+  const subagentSessions = useSyncExternalStore3(subagentStore.subscribe, subagentStore.getSnapshot);
   const subagentHelpers = useMemo22(() => createSubagentSessionHelpers(subagentStore.setState), [subagentStore]);
   const messageCountAtSubagentDoneRef = useRef21(null);
   const hasRunningSubagent = useMemo22(() => Array.from(subagentSessions.values()).some((s) => s.status === "running"), [subagentSessions]);
@@ -67592,7 +68621,7 @@ function OperatorDashboard({
       messageCountAtSubagentDoneRef.current = null;
     }
   }, [subagentSessions, hasRunningSubagent]);
-  const openSubagentDialog = useCallback20(() => {
+  const openSubagentDialog = useCallback22(() => {
     replaceDialog(/* @__PURE__ */ jsxDEV56(SubagentDialog, {
       store: subagentStore
     }, undefined, false, undefined, this), {
@@ -67603,7 +68632,6 @@ function OperatorDashboard({
   const [messages, setMessages] = useState39([]);
   const displayMessagesRef = useRef21([]);
   displayMessagesRef.current = messages;
-  const textRef = useRef21("");
   const conversationRef = useRef21([]);
   const [inputValue, setInputValue] = useState39("");
   const [queuedMessages, setQueuedMessages] = useState39([]);
@@ -67644,10 +68672,6 @@ function OperatorDashboard({
   useEffect25(() => {
     approvedPlanRef.current = approvedPlanContent;
   }, [approvedPlanContent]);
-  const tokenUsageRef = useRef21(tokenUsage);
-  useEffect25(() => {
-    tokenUsageRef.current = tokenUsage;
-  }, [tokenUsage]);
   useEffect25(() => {
     const gate = approvalGateRef.current;
     const onApprovalNeeded = () => {
@@ -67766,188 +68790,63 @@ function OperatorDashboard({
       refocusPrompt();
     }
   }, [loading, refocusPrompt]);
+  useEffect25(() => {
+    if (sessionId === undefined)
+      usageStore.beginNewSession();
+  }, [sessionId, usageStore]);
   useEffect25(() => {
     if (!session || !sessionId)
       return;
-    resetTokenUsage();
-    tokenUsageRef.current = {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-      cachedTokens: 0,
-      cacheWriteTokens: 0
-    };
     const metrics = readExecutionMetrics(session.rootPath);
-    const persisted = metrics?.tokenUsage;
-    if (persisted && (persisted.inputTokens > 0 || persisted.outputTokens > 0)) {
-      addTokenUsage(persisted.inputTokens, persisted.outputTokens);
-      tokenUsageRef.current = {
-        ...persisted,
-        cachedTokens: 0,
-        cacheWriteTokens: 0
-      };
-    }
-    try {
-      writeExecutionMetrics({
-        sessionRootPath: session.rootPath,
-        tokenUsage: tokenUsageRef.current
-      });
-    } catch {}
-  }, [session, sessionId, addTokenUsage, resetTokenUsage]);
-  const appendText = useCallback20((text) => {
-    textRef.current += text;
-    const accumulated = textRef.current;
-    setMessages((prev) => {
-      const last = prev[prev.length - 1];
-      if (last && last.role === "assistant") {
-        const updated = [...prev];
-        updated[updated.length - 1] = { ...last, content: accumulated };
-        return updated;
-      }
-      return [
-        ...prev,
-        { role: "assistant", content: accumulated, createdAt: new Date }
-      ];
-    });
-  }, []);
-  const toolArgsDeltaRef = useRef21(new Map);
-  const addStreamingToolCall = useCallback20((toolCallId, toolName) => {
-    textRef.current = "";
-    toolArgsDeltaRef.current.set(toolCallId, {
-      toolName,
-      accumulated: ""
-    });
-    setMessages((prev) => [
-      ...prev,
-      {
-        role: "tool",
-        content: "",
-        createdAt: new Date,
-        toolCallId,
-        toolName,
-        args: {},
-        status: "streaming"
-      }
-    ]);
-  }, []);
-  const appendToolCallDelta = useCallback20((toolCallId, argsTextDelta) => {
-    const entry = toolArgsDeltaRef.current.get(toolCallId);
-    const accumulated = (entry?.accumulated ?? "") + argsTextDelta;
-    toolArgsDeltaRef.current.set(toolCallId, {
-      toolName: entry?.toolName ?? "",
-      accumulated
-    });
-    const parsed = tryParsePartialJson(accumulated);
-    if (!parsed)
-      return;
-    const contentText = extractStreamableContent(parsed);
-    const logs = contentText ? contentText.split(`
-`) : undefined;
-    setMessages((msgs) => {
-      const idx = msgs.findIndex((m2) => isToolMessage(m2) && m2.toolCallId === toolCallId);
-      if (idx === -1)
-        return msgs;
-      const updated = [...msgs];
-      updated[idx] = { ...updated[idx], args: parsed, ...logs && { logs } };
-      return updated;
-    });
-  }, []);
-  const addToolCall = useCallback20((toolCallId, toolName, args) => {
-    textRef.current = "";
-    toolArgsDeltaRef.current.delete(toolCallId);
-    setMessages((prev) => {
-      const idx = prev.findIndex((m2) => isToolMessage(m2) && m2.toolCallId === toolCallId);
-      if (idx !== -1) {
-        const updated = [...prev];
-        updated[idx] = {
-          ...updated[idx],
-          args,
-          logs: undefined,
-          status: "pending"
-        };
-        return updated;
-      }
-      return [
-        ...prev,
-        {
-          role: "tool",
-          content: "",
-          createdAt: new Date,
-          toolCallId,
-          toolName,
-          args,
-          status: "pending"
-        }
-      ];
+    usageStore.enterSession(session.id, {
+      ...metrics?.tokenUsage ? { tokenUsage: metrics.tokenUsage } : {},
+      ...metrics?.contextUsage ? { contextUsage: metrics.contextUsage } : {}
     });
-  }, []);
-  const updateToolResult = useCallback20((toolCallId, _toolName, result) => {
-    textRef.current = "";
-    setMessages((prev) => {
-      const idx = prev.findIndex((m2) => isToolMessage(m2) && m2.toolCallId === toolCallId);
-      if (idx === -1)
-        return prev;
-      const updated = [...prev];
-      updated[idx] = { ...updated[idx], status: "completed", result };
-      return updated;
-    });
-  }, []);
-  const cmdOutputBufRef = useRef21("");
-  const cmdFlushTimerRef = useRef21(null);
-  const MAX_LOG_LINES = 200;
-  const flushCommandOutput = useCallback20(() => {
-    const buf = cmdOutputBufRef.current;
-    if (!buf)
-      return;
-    cmdOutputBufRef.current = "";
-    setMessages((prev) => {
-      const idx = prev.findLastIndex((m2) => isToolMessage(m2) && (m2.status === "pending" || m2.status === "streaming"));
-      if (idx === -1)
-        return prev;
-      const msg = prev[idx];
-      const existing = msg.logs ?? [];
-      const incoming = buf.split(`
-`);
-      let merged;
-      if (existing.length > 0 && !buf.startsWith(`
-`)) {
-        merged = [...existing];
-        merged[merged.length - 1] += incoming[0];
-        merged.push(...incoming.slice(1));
-      } else {
-        merged = [...existing, ...incoming];
-      }
-      if (merged.length > MAX_LOG_LINES) {
-        merged = merged.slice(-MAX_LOG_LINES);
-      }
-      const updated = [...prev];
-      updated[idx] = { ...msg, logs: merged };
-      return updated;
-    });
-  }, []);
-  const onCommandOutput = useCallback20((data) => {
-    cmdOutputBufRef.current += data;
-    if (!cmdFlushTimerRef.current) {
-      cmdFlushTimerRef.current = setInterval(() => {
-        flushCommandOutput();
-      }, 150);
-    }
-  }, [flushCommandOutput]);
+  }, [session, sessionId, usageStore]);
+  const runSessionIdRef = useRef21(null);
+  const displayEvents = useMemo22(() => createDisplayEventHandlers({
+    updateMessages: setMessages,
+    setThinking,
+    setError
+  }), [setThinking]);
   useEffect25(() => {
     return () => {
-      if (cmdFlushTimerRef.current) {
-        clearInterval(cmdFlushTimerRef.current);
-        cmdFlushTimerRef.current = null;
-      }
+      displayEvents.dispose();
     };
+  }, [displayEvents]);
+  const updateWorkflowData = useCallback22((updater) => {
+    setMessages((prev) => updateWorkflowDataMessage(prev, updater));
   }, []);
-  const handleApprove = useCallback20(() => {
+  const runEventProjections = useMemo22(() => createRunEventProjections({
+    display: displayEvents,
+    subagents: subagentHelpers,
+    updateWorkflowData,
+    clearSubagentSessions: () => subagentStore.setState(new Map),
+    questions: {
+      onAsked: (toolCallId, questions) => {
+        pendingToolCallIdRef.current = toolCallId;
+        setPendingQuestions(questions);
+      },
+      onCleared: () => {
+        pendingToolCallIdRef.current = null;
+        setPendingQuestions(null);
+      }
+    },
+    onRootToolCallStarted: () => {
+      commandCancelledRef.current = false;
+    },
+    onPlanSubmitted: () => {
+      planSubmittedRef.current = true;
+      planGateBypassedOnResumeRef.current = false;
+    }
+  }), [displayEvents, subagentHelpers, updateWorkflowData, subagentStore]);
+  const handleApprove = useCallback22(() => {
     const pending = approvalGateRef.current.getPendingApprovals();
     if (pending.length > 0) {
       approvalGateRef.current.approve(pending[0].id);
     }
   }, []);
-  const handleAutoApprove = useCallback20(() => {
+  const handleAutoApprove = useCallback22(() => {
     setOperatorMode("auto");
     setOperatorState((prev) => ({
       ...prev,
@@ -67960,17 +68859,18 @@ function OperatorDashboard({
       approvalGateRef.current.approve(p.id);
     }
   }, []);
-  const runAgent = useCallback20(async (prompt) => {
+  const runAgent = useCallback22(async (prompt) => {
     if (abortControllerRef.current) {
       abortControllerRef.current.abort();
       abortControllerRef.current = null;
     }
     const gen = ++generationRef.current;
+    runSessionIdRef.current = sessionRef.current?.id ?? session?.id ?? null;
     setStatus("running");
     setThinking(true);
     setIsExecuting(true);
     setError(null);
-    textRef.current = "";
+    displayEvents.resetPartialText();
     const controller = new AbortController;
     abortControllerRef.current = controller;
     const prevMessages = conversationRef.current;
@@ -67987,259 +68887,58 @@ function OperatorDashboard({
       conversationRef.current = nextMessages;
       if (sessionRef.current) {
         try {
-          const mp = join3(sessionRef.current.rootPath, "messages.json");
-          writeFileSync(mp, JSON.stringify(nextMessages, null, 2));
+          const mp = join4(sessionRef.current.rootPath, "messages.json");
+          writeFileSync2(mp, JSON.stringify(nextMessages, null, 2));
         } catch {}
       }
     } else {
       nextMessages = conversationRef.current;
     }
     const recordTokenUsage = (inputTokens, outputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) => {
-      const nextUsage = accumulateTokenUsage(tokenUsageRef.current, inputTokens, outputTokens);
-      if (nextUsage) {
-        tokenUsageRef.current = nextUsage;
-        addTokenUsage(inputTokens, outputTokens);
-        if (session) {
-          try {
-            writeExecutionMetrics({
-              sessionRootPath: session.rootPath,
-              tokenUsage: nextUsage
-            });
-          } catch {}
-        }
+      if (inputTokens > 0 || outputTokens > 0)
+        markExecuted();
+      const runSessionId = runSessionIdRef.current;
+      usageStore.addSessionTokens(runSessionId, {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens
+      });
+      const activeSession = sessionRef.current;
+      if (activeSession) {
+        try {
+          const usage = usageStore.getSnapshot(activeSession.id);
+          writeExecutionMetrics({
+            sessionRootPath: activeSession.rootPath,
+            tokenUsage: usage.tokenUsage,
+            ...usage.contextUsage ? { contextUsage: usage.contextUsage } : {}
+          });
+        } catch {}
       }
-      if (cacheReadTokens > 0 || cacheWriteTokens > 0) {
-        addCacheUsage(cacheReadTokens, cacheWriteTokens);
+    };
+    const runModelId = model.id;
+    const recordRootStepUsage = (usage) => {
+      const inputTokens = usage.inputTokens ?? 0;
+      if (inputTokens > 0) {
+        usageStore.setRootContext(runSessionIdRef.current, {
+          usedTokens: inputTokens,
+          contextLimit: getContextWindow(runModelId),
+          modelId: runModelId
+        });
       }
+      recordTokenUsage(inputTokens, usage.outputTokens ?? 0);
     };
     const onStepFinish = (event) => {
-      recordTokenUsage(event.usage?.inputTokens ?? 0, event.usage?.outputTokens ?? 0);
+      recordRootStepUsage(event.usage ?? {});
     };
     const eventBus = new AgentEventBus;
-    const isPentestAgent = (id) => id !== undefined && /^pentest-agent-\d+$/.test(id);
-    const updateWorkflowData = (updater) => {
-      setMessages((prev) => {
-        const idx = prev.findLastIndex((m2) => isToolMessage(m2) && m2.toolName === "run_pentest_workflow" && (m2.status === "pending" || m2.status === "streaming"));
-        if (idx === -1)
-          return prev;
-        const msg = prev[idx];
-        const wd = msg.workflowData ?? {
-          currentPhase: "discovery",
-          discovery: { label: "", status: "pending", logs: [] },
-          pentesting: {
-            label: "",
-            status: "idle",
-            subagents: {}
-          },
-          reporting: { label: "", status: "idle" }
-        };
-        const updated = [...prev];
-        updated[idx] = { ...msg, workflowData: updater(wd) };
-        return updated;
-      });
-    };
-    eventBus.on("text-delta", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId) {
-        subagentHelpers.appendText(d2.subagentId, d2.text);
-        return;
-      }
-      setThinking(false);
-      appendText(d2.text);
-    });
-    eventBus.on("tool-call-start", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId) {
-        subagentHelpers.addStreamingToolCall(d2.subagentId, d2.toolCallId, d2.toolName);
-        return;
-      }
-      setThinking(false);
-      addStreamingToolCall(d2.toolCallId, d2.toolName);
-    });
-    eventBus.on("tool-call-delta", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId) {
-        subagentHelpers.appendToolCallDelta(d2.subagentId, d2.toolCallId, d2.argsTextDelta);
-        return;
-      }
-      appendToolCallDelta(d2.toolCallId, d2.argsTextDelta);
+    const runTrace = new RunTraceSession(eventBus, {
+      isCurrent: () => gen === generationRef.current,
+      recordTokenUsage
     });
-    eventBus.on("tool-call-complete", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId) {
-        const args2 = d2.args && typeof d2.args === "object" && !Array.isArray(d2.args) && d2.args !== null ? d2.args : {};
-        subagentHelpers.addToolCall(d2.subagentId, d2.toolCallId, d2.toolName, args2);
-        return;
-      }
-      setThinking(false);
-      commandCancelledRef.current = false;
-      const args = d2.args && typeof d2.args === "object" && !Array.isArray(d2.args) && d2.args !== null ? d2.args : undefined;
-      addToolCall(d2.toolCallId, d2.toolName, args);
-      if (d2.toolName === ASK_USER_QUESTIONS_TOOL_NAME && args) {
-        const rawQuestions = args.questions;
-        if (Array.isArray(rawQuestions) && rawQuestions.length > 0) {
-          pendingToolCallIdRef.current = d2.toolCallId;
-          setPendingQuestions(rawQuestions);
-        }
-      }
-    });
-    eventBus.on("tool-result", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId) {
-        subagentHelpers.updateToolResult(d2.subagentId, d2.toolCallId, d2.result);
-        return;
-      }
-      flushCommandOutput();
-      if (cmdFlushTimerRef.current) {
-        clearInterval(cmdFlushTimerRef.current);
-        cmdFlushTimerRef.current = null;
-      }
-      setThinking(true);
-      updateToolResult(d2.toolCallId, d2.toolName, d2.result);
-      if (d2.toolName === "submit_plan" && d2.result?.success === true) {
-        planSubmittedRef.current = true;
-        planGateBypassedOnResumeRef.current = false;
-      }
-    });
-    eventBus.on("command-output", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId)
-        return;
-      onCommandOutput(d2.data);
-    });
-    eventBus.on("error", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      if (d2.subagentId) {
-        const errMsg = d2.error instanceof Error ? d2.error.message : "Unknown error";
-        subagentHelpers.appendText(d2.subagentId, `
-Error: ${errMsg}
-`);
-        return;
-      }
-      console.error("Agent error:", d2.error);
-      pendingToolCallIdRef.current = null;
-      setPendingQuestions(null);
-      const errorMessage = d2.error instanceof Error ? d2.error.message : "Unknown error";
-      setError(errorMessage);
-      setMessages((prev) => markInFlightToolsErrored(prev, errorMessage));
-    });
-    eventBus.on("subagent-spawn", ({ subagentId, name }) => {
-      if (gen !== generationRef.current)
-        return;
-      if (subagentId.startsWith("app:"))
-        return;
-      subagentHelpers.spawnSession(subagentId, name);
-      if (!isPentestAgent(subagentId))
-        return;
-      updateWorkflowData((wd) => ({
-        ...wd,
-        pentesting: {
-          ...wd.pentesting,
-          subagents: {
-            ...wd.pentesting.subagents,
-            [subagentId]: {
-              name,
-              status: "pending",
-              logs: []
-            }
-          }
-        }
-      }));
-    });
-    eventBus.on("subagent-complete", ({ subagentId, status: status2 }) => {
-      if (gen !== generationRef.current)
-        return;
-      if (subagentId.startsWith("app:"))
-        return;
-      subagentHelpers.completeSession(subagentId, status2);
-      if (!isPentestAgent(subagentId))
-        return;
-      updateWorkflowData((wd) => {
-        const entry = wd.pentesting.subagents[subagentId];
-        if (!entry)
-          return wd;
-        return {
-          ...wd,
-          pentesting: {
-            ...wd.pentesting,
-            subagents: {
-              ...wd.pentesting.subagents,
-              [subagentId]: { ...entry, status: status2 }
-            }
-          }
-        };
-      });
-    });
-    eventBus.on("workflow-phase-start", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      textRef.current = "";
-      if (d2.phase === "discovery") {
-        subagentStore.setState(new Map);
-      }
-      updateWorkflowData((wd) => {
-        const next = {
-          ...wd,
-          currentPhase: d2.phase
-        };
-        if (d2.phase === "discovery") {
-          next.discovery = {
-            ...wd.discovery,
-            label: d2.label,
-            status: "pending",
-            logs: []
-          };
-        } else if (d2.phase === "pentesting") {
-          next.pentesting = {
-            ...wd.pentesting,
-            label: d2.label,
-            status: "pending"
-          };
-        } else if (d2.phase === "reporting") {
-          next.reporting = {
-            ...wd.reporting,
-            label: d2.label,
-            status: "pending"
-          };
-        }
-        return next;
-      });
-    });
-    eventBus.on("workflow-phase-complete", (d2) => {
-      if (gen !== generationRef.current)
-        return;
-      textRef.current = "";
-      updateWorkflowData((wd) => {
-        const next = { ...wd };
-        if (d2.phase === "discovery") {
-          const targets = d2.summary.targets ?? [];
-          next.discovery = {
-            ...wd.discovery,
-            status: "complete",
-            targets,
-            cached: d2.summary.cached
-          };
-        } else if (d2.phase === "pentesting") {
-          next.pentesting = { ...wd.pentesting, status: "complete" };
-        } else if (d2.phase === "reporting") {
-          next.reporting = {
-            ...wd.reporting,
-            status: "complete",
-            findingsCount: d2.summary.findingsCount,
-            findingsBySeverity: d2.summary.findingsBySeverity,
-            reportPath: d2.summary.reportPath
-          };
-          next.currentPhase = "complete";
-        }
-        return next;
-      });
+    const unbindRunEvents = bindOperatorRunEvents(eventBus, {
+      isCurrent: () => gen === generationRef.current,
+      handlers: runEventProjections.handlers
     });
     const skillsCatalog = skillsRegistry.buildCatalog() || undefined;
     const commonInput = {
@@ -68267,59 +68966,24 @@ Error: ${errMsg}
       promptInjectionLibrarySource: initialConfig?.promptInjectionLibrarySource ?? (route.data.type === "operator" ? route.data.initialSkill?.args?.library : undefined),
       onStepFinish,
       onCacheMetrics: (metrics) => {
-        addCacheUsage(metrics.cacheReadInputTokens, metrics.cacheCreationInputTokens);
+        usageStore.addSessionTokens(runSessionIdRef.current, {
+          cacheReadTokens: metrics.cacheReadInputTokens,
+          cacheWriteTokens: metrics.cacheCreationInputTokens
+        });
       },
       eventBus,
       onSessionReady: (s) => {
         setSessionCwd(s.rootPath);
         sessionRef.current = s;
         setSession((prev) => prev ?? s);
-        tryAttachWandb(s);
-      }
-    };
-    let wandbCleanup = null;
-    let earlyBuffer = [];
-    const earlyBufferHandler = (e) => {
-      earlyBuffer?.push(e);
-    };
-    eventBus.on("trace-record", earlyBufferHandler);
-    const countedSubagentSteps = new Set;
-    eventBus.on("trace-record", ({ record, subagentId }) => {
-      if (gen !== generationRef.current)
-        return;
-      if (!subagentId || record.type !== "step")
-        return;
-      const key = `${subagentId}:${record.stepIndex}:${record.timestamp}`;
-      if (countedSubagentSteps.has(key))
-        return;
-      countedSubagentSteps.add(key);
-      recordTokenUsage(record.usage.inputTokens, record.usage.outputTokens, record.usage.cacheReadTokens ?? 0, record.usage.cacheWriteTokens ?? 0);
-    });
-    const tryAttachWandb = async (s) => {
-      if (wandbCleanup)
-        return;
-      const cleanup = await attachWandbToEventBus(s, eventBus).catch((e) => {
-        console.error("[wandb] Attach failed:", e);
-        return null;
-      });
-      if (cleanup) {
-        wandbCleanup = cleanup;
-        const buffered = earlyBuffer;
-        earlyBuffer = null;
-        eventBus.off("trace-record", earlyBufferHandler);
-        if (buffered) {
-          for (const e of buffered) {
-            eventBus.emit("trace-record", e);
-          }
-        }
-      } else {
-        earlyBuffer = null;
-        eventBus.off("trace-record", earlyBufferHandler);
+        runSessionIdRef.current = s.id;
+        usageStore.enterSession(s.id);
+        runTrace.tryAttach(s);
       }
     };
     const wandbSession = session ?? sessionRef.current;
     if (wandbSession) {
-      await tryAttachWandb(wandbSession);
+      await runTrace.tryAttach(wandbSession);
     }
     try {
       let agentResult;
@@ -68374,9 +69038,9 @@ Error: ${errMsg}
       if (gen === generationRef.current) {
         try {
           const rootPath = agentResult.session.rootPath;
-          const mp = join3(rootPath, "messages.json");
-          if (existsSync3(mp)) {
-            const raw = JSON.parse(readFileSync3(mp, "utf-8"));
+          const mp = join4(rootPath, "messages.json");
+          if (existsSync4(mp)) {
+            const raw = JSON.parse(readFileSync4(mp, "utf-8"));
             if (Array.isArray(raw) && raw.length > 0) {
               conversationRef.current = normalizeMessages(sessions.getResumeMessages(raw));
             }
@@ -68402,8 +69066,8 @@ Error: ${errMsg}
         setPendingQuestions(null);
         if (sessionRef.current) {
           try {
-            const mp = join3(sessionRef.current.rootPath, "messages.json");
-            writeFileSync(mp, JSON.stringify(prevMessages, null, 2));
+            const mp = join4(sessionRef.current.rootPath, "messages.json");
+            writeFileSync2(mp, JSON.stringify(prevMessages, null, 2));
           } catch {}
         }
         const errorMsg = e instanceof Error ? e.message : "Agent failed";
@@ -68418,12 +69082,8 @@ Error: ${errMsg}
         ]);
       }
     } finally {
-      earlyBuffer = null;
-      eventBus.off("trace-record", earlyBufferHandler);
-      if (wandbCleanup) {
-        const fn = wandbCleanup;
-        await fn().catch((e) => console.error("[wandb] Flush failed:", e));
-      }
+      unbindRunEvents();
+      await runTrace.cleanupRun();
       if (gen === generationRef.current) {
         setStatus(pendingToolCallIdRef.current ? "waiting" : "idle");
         setThinking(false);
@@ -68442,18 +69102,10 @@ Error: ${errMsg}
     operatorState,
     operatorMode,
     agentMode,
-    addTokenUsage,
-    appendText,
-    addStreamingToolCall,
-    appendToolCallDelta,
-    addToolCall,
-    updateToolResult,
-    flushCommandOutput,
-    onCommandOutput,
-    subagentHelpers,
+    displayEvents,
+    runEventProjections,
     setThinking,
     setIsExecuting,
-    addCacheUsage,
     initialConfig?.sandbox,
     initialConfig?.taskDriven,
     initialConfig?.target,
@@ -68462,14 +69114,15 @@ Error: ${errMsg}
     strikeMode,
     route.data,
     setSessionCwd,
-    subagentStore.setState,
     skillsRegistry.buildCatalog,
     requireApproval,
     skillsRegistry,
     reasoningEnabled,
-    openAIReasoningEffort
+    openAIReasoningEffort,
+    usageStore,
+    markExecuted
   ]);
-  const handleSubmit = useCallback20((value) => {
+  const handleSubmit = useCallback22((value) => {
     const pending = approvalGateRef.current.getPendingApprovals();
     const result = resolveSubmit(value, status, pending.length > 0);
     if (result.denyPending) {
@@ -68607,16 +69260,16 @@ ${content}
     planApprovedPendingRunRef.current = false;
     runAgentRef.current("Proceed with the approved plan.");
   }, [operatorMode]);
-  const addSystemMessage = useCallback20((content) => {
+  const addSystemMessage = useCallback22((content) => {
     setMessages((prev) => [
       ...prev,
       { role: "system", content, createdAt: new Date }
     ]);
   }, []);
-  const showModelPicker = useCallback20(() => {
+  const showModelPicker = useCallback22(() => {
     executeCommand("/models");
   }, [executeCommand]);
-  const handleHeadersSlash = useCallback20(async (op) => {
+  const handleHeadersSlash = useCallback22(async (op) => {
     const active = sessionRef.current;
     if (!active) {
       addSystemMessage("No active session — cannot manage headers yet.");
@@ -68687,7 +69340,7 @@ ${formatParseError(parsed.error)}`);
       }
     }
   }, [addSystemMessage]);
-  const handleCommandExecute = useCallback20(async (command) => {
+  const handleCommandExecute = useCallback22(async (command) => {
     const action = routeCommand(command, resolveSkillContent);
     switch (action.type) {
       case "show-models":
@@ -68761,7 +69414,7 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
     handleHeadersSlash,
     strikeMode
   ]);
-  const handleAbort = useCallback20(() => {
+  const handleAbort = useCallback22(() => {
     if (!abortControllerRef.current)
       return;
     const action = resolveAbortAction(commandCancelledRef.current, () => cancelHandleRef.current.cancel());
@@ -68789,77 +69442,15 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
     setThinking(false);
     setIsExecuting(false);
     setMessages((prev) => markInFlightToolsErrored(prev, "Interrupted"));
-    subagentStore.setState((prev) => {
-      let changed = false;
-      const next = new Map(prev);
-      for (const [id, session2] of next) {
-        const hasInFlight = session2.messages.some((m2) => m2.role === "tool" && (m2.status === "pending" || m2.status === "streaming"));
-        if (hasInFlight || session2.status === "running") {
-          changed = true;
-          next.set(id, {
-            ...session2,
-            status: session2.status === "running" ? "cancelled" : session2.status,
-            messages: session2.messages.map((m2) => m2.role === "tool" && (m2.status === "pending" || m2.status === "streaming") ? { ...m2, status: "error", result: "Interrupted" } : m2)
-          });
-        }
-      }
-      return changed ? next : prev;
-    });
+    subagentStore.setState(markSubagentsInterrupted);
     const activeSession = sessionRef.current;
     if (activeSession) {
-      try {
-        const messagesPath = join3(activeSession.rootPath, "messages.json");
-        if (existsSync3(messagesPath)) {
-          const raw = JSON.parse(readFileSync3(messagesPath, "utf-8"));
-          if (Array.isArray(raw) && raw.length > 0) {
-            conversationRef.current = normalizeMessages(sessions.getResumeMessages(raw));
-          }
-        }
-        const last = conversationRef.current[conversationRef.current.length - 1];
-        if (last?.role === "user") {
-          const partial = textRef.current.trim();
-          const pendingTools = displayMessagesRef.current.filter((m2) => isToolMessage(m2) && (m2.status === "pending" || m2.status === "streaming"));
-          const assistantContent = [
-            {
-              type: "text",
-              text: partial || "[Response interrupted by user.]"
-            }
-          ];
-          for (const t of pendingTools) {
-            assistantContent.push({
-              type: "tool-call",
-              toolCallId: t.toolCallId,
-              toolName: t.toolName,
-              input: t.args ?? {}
-            });
-          }
-          conversationRef.current = [
-            ...conversationRef.current,
-            {
-              role: "assistant",
-              content: assistantContent
-            }
-          ];
-          if (pendingTools.length > 0) {
-            conversationRef.current = [
-              ...conversationRef.current,
-              {
-                role: "tool",
-                content: pendingTools.map((t) => ({
-                  type: "tool-result",
-                  toolCallId: t.toolCallId,
-                  toolName: t.toolName ?? "unknown",
-                  output: {
-                    type: "text",
-                    value: "Cancelled by user."
-                  }
-                }))
-              }
-            ];
-          }
-          writeFileSync(join3(activeSession.rootPath, "messages.json"), JSON.stringify(conversationRef.current, null, 2));
-        }
-      } catch {}
+      conversationRef.current = recoverAbortedTranscript({
+        rootPath: activeSession.rootPath,
+        conversation: conversationRef.current,
+        partialText: displayEvents.getPartialText(),
+        displayMessages: displayMessagesRef.current
+      });
     }
     setMessages((prev) => {
       const updated = prev.map((m2) => isToolMessage(m2) && (m2.status === "pending" || m2.status === "streaming") ? { ...m2, status: "error", result: "Cancelled by user" } : m2);
@@ -68872,51 +69463,30 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
         }
       ];
     });
-  }, [setThinking, setIsExecuting, subagentStore.setState]);
-  const resumeWithQuestionResult = useCallback20((result) => {
+  }, [setThinking, setIsExecuting, subagentStore.setState, displayEvents]);
+  const resumeWithQuestionResult = useCallback22((result) => {
     const toolCallId = pendingToolCallIdRef.current;
     if (!toolCallId)
       return;
-    const wrappedOutput = {
-      type: "json",
-      value: result
-    };
-    const updated = conversationRef.current.map((msg) => {
-      if (msg.role !== "tool")
-        return msg;
-      if (!Array.isArray(msg.content))
-        return msg;
-      let mutated = false;
-      const nextContent = msg.content.map((part) => {
-        if (part && typeof part === "object" && "type" in part && part.type === "tool-result" && part.toolCallId === toolCallId) {
-          mutated = true;
-          return {
-            ...part,
-            output: wrappedOutput
-          };
-        }
-        return part;
-      });
-      return mutated ? { ...msg, content: nextContent } : msg;
-    });
+    const updated = rewriteToolResultOutput(conversationRef.current, toolCallId, result);
     conversationRef.current = updated;
     const activeSession = sessionRef.current;
     if (activeSession) {
       try {
-        writeFileSync(join3(activeSession.rootPath, "messages.json"), JSON.stringify(updated, null, 2));
+        writeFileSync2(join4(activeSession.rootPath, "messages.json"), JSON.stringify(updated, null, 2));
       } catch {}
     }
     pendingToolCallIdRef.current = null;
     setPendingQuestions(null);
     runAgentRef.current(null);
   }, []);
-  const handleQuestionsSubmit = useCallback20((answers) => {
+  const handleQuestionsSubmit = useCallback22((answers) => {
     resumeWithQuestionResult({ answers, skipped: false });
   }, [resumeWithQuestionResult]);
-  const handleQuestionsSkip = useCallback20(() => {
+  const handleQuestionsSkip = useCallback22(() => {
     resumeWithQuestionResult({ answers: [], skipped: true });
   }, [resumeWithQuestionResult]);
-  const transitionToMode = useCallback20((next) => {
+  const transitionToMode = useCallback22((next) => {
     approvalGateRef.current.updateConfig({
       requireApproval: next === "manual"
     });
@@ -68931,7 +69501,7 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
       sessions.updateOperatorSettings(sid, { initialMode: next }).catch((e) => console.error("[operator] Failed to persist mode:", e));
     }
   }, []);
-  const cycleMode = useCallback20(() => {
+  const cycleMode = useCallback22(() => {
     const current = operatorModeRef.current;
     const idx = OPERATOR_MODE_CYCLE.indexOf(current);
     const next = OPERATOR_MODE_CYCLE[(idx + 1) % OPERATOR_MODE_CYCLE.length];
@@ -68972,11 +69542,8 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
           const removeIdx = selectedQueueIndex;
           setQueuedMessages((prev) => prev.filter((_2, i) => i !== removeIdx));
           setSelectedQueueIndex(-1);
-          flushCommandOutput();
-          if (cmdFlushTimerRef.current) {
-            clearInterval(cmdFlushTimerRef.current);
-            cmdFlushTimerRef.current = null;
-          }
+          displayEvents.flushCommandOutput();
+          displayEvents.stopCommandOutputFlush();
           setMessages((prev) => prev.map((m2) => isToolMessage(m2) && m2.status === "pending" ? { ...m2, status: "error", result: "Interrupted" } : m2));
           runAgentRef.current(msg);
           return;
@@ -69021,34 +69588,15 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
       key.preventDefault?.();
       const toolCallId = pendingToolCallIdRef.current;
       if (toolCallId) {
-        const abortedResult = {
-          type: "json",
-          value: {
-            answers: [],
-            skipped: true,
-            aborted: true
-          }
-        };
-        conversationRef.current = conversationRef.current.map((msg) => {
-          if (msg.role !== "tool" || !Array.isArray(msg.content))
-            return msg;
-          let mutated = false;
-          const nextContent = msg.content.map((part) => {
-            if (part && typeof part === "object" && "type" in part && part.type === "tool-result" && part.toolCallId === toolCallId) {
-              mutated = true;
-              return {
-                ...part,
-                output: abortedResult
-              };
-            }
-            return part;
-          });
-          return mutated ? { ...msg, content: nextContent } : msg;
+        conversationRef.current = rewriteToolResultOutput(conversationRef.current, toolCallId, {
+          answers: [],
+          skipped: true,
+          aborted: true
         });
         const activeSession = sessionRef.current;
         if (activeSession) {
           try {
-            writeFileSync(join3(activeSession.rootPath, "messages.json"), JSON.stringify(conversationRef.current, null, 2));
+            writeFileSync2(join4(activeSession.rootPath, "messages.json"), JSON.stringify(conversationRef.current, null, 2));
           } catch {}
         }
       }
@@ -69197,7 +69745,7 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
               fg: colors2.warning,
               children: "STRIKE"
             }, undefined, false, undefined, this),
-            (session?.targets[0] || initialConfig?.target) && /* @__PURE__ */ jsxDEV56(Fragment6, {
+            (session?.targets[0] || initialConfig?.target) && /* @__PURE__ */ jsxDEV56(Fragment7, {
               children: [
                 /* @__PURE__ */ jsxDEV56("text", {
                   fg: colors2.textMuted,
@@ -69240,7 +69788,7 @@ ${planContent}` : "No plan exists yet. Switch to plan mode (Shift+Tab) to create
         questions: pendingQuestions,
         onSubmit: handleQuestionsSubmit,
         onSkip: handleQuestionsSkip
-      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV56(Fragment6, {
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV56(Fragment7, {
         children: [
           /* @__PURE__ */ jsxDEV56(QueuedMessages, {
             messages: queuedMessages,
@@ -69368,19 +69916,19 @@ function ResponsibleUseDisclosure({
 
 // src/tui/components/switch.tsx
 import React2 from "react";
-import { jsxDEV as jsxDEV58, Fragment as Fragment7 } from "@opentui/react/jsx-dev-runtime";
+import { jsxDEV as jsxDEV58, Fragment as Fragment8 } from "@opentui/react/jsx-dev-runtime";
 var CaseSymbol = Symbol("Switch.Case");
 var DefaultSymbol = Symbol("Switch.Default");
 function CaseComponent({
   children
 }) {
-  return /* @__PURE__ */ jsxDEV58(Fragment7, {
+  return /* @__PURE__ */ jsxDEV58(Fragment8, {
     children
   }, undefined, false, undefined, this);
 }
 CaseComponent[CaseSymbol] = true;
 function DefaultComponent({ children }) {
-  return /* @__PURE__ */ jsxDEV58(Fragment7, {
+  return /* @__PURE__ */ jsxDEV58(Fragment8, {
     children
   }, undefined, false, undefined, this);
 }
@@ -69403,7 +69951,7 @@ function SwitchComponent({
       }
     }
   });
-  return /* @__PURE__ */ jsxDEV58(Fragment7, {
+  return /* @__PURE__ */ jsxDEV58(Fragment8, {
     children: matchedChild || defaultChild
   }, undefined, false, undefined, this);
 }
@@ -69616,6 +70164,7 @@ function createKeybindings(deps) {
     setExternalDialogOpen,
     setFocusIndex,
     navigableItems,
+    onExit,
     setShowToolsPanel
   } = deps;
   const route = useRoute();
@@ -69631,9 +70180,7 @@ function createKeybindings(deps) {
         const now = Date.now();
         const lastPress = ctrlCPressTime;
         if (lastPress && now - lastPress < 1000) {
-          cleanupTerminalFocusMode();
-          renderer.destroy();
-          process.exit(0);
+          await onExit();
         } else {
           setInputKey((prev) => prev + 1);
           setCtrlCPressTime(now);
@@ -69829,7 +70376,7 @@ import { jsxDEV as jsxDEV61 } from "@opentui/react/jsx-dev-runtime";
 installObfuscationTextPatch();
 extend({ frameBuffer: FrameBufferRenderable });
 extend({ frameBuffer: FrameBufferRenderable });
-function App({ appConfig }) {
+function App({ appConfig, onExit }) {
   const [focusIndex, setFocusIndex] = useState40(0);
   const [cwd, setCwd] = useState40(process.cwd());
   const [ctrlCPressTime, setCtrlCPressTime] = useState40(null);
@@ -69860,6 +70407,7 @@ function App({ appConfig }) {
               children: /* @__PURE__ */ jsxDEV61(DialogProvider, {
                 children: /* @__PURE__ */ jsxDEV61(AgentProvider, {
                   children: /* @__PURE__ */ jsxDEV61(CommandProvider, {
+                    onExit,
                     onOpenSessionsDialog: () => setShowSessionsDialog(true),
                     onOpenThemeDialog: () => setShowThemeDialog(true),
                     onOpenAdvancedDialog: () => setShowAdvancedDialog(true),
@@ -69885,7 +70433,8 @@ function App({ appConfig }) {
                         setShowSessionsDialog,
                         setShowShortcutsDialog,
                         setFocusIndex,
-                        navigableItems
+                        navigableItems,
+                        onExit
                       },
                       children: /* @__PURE__ */ jsxDEV61(AppContent, {
                         focusIndex,
@@ -69982,7 +70531,7 @@ function AppContent({
       toast(`Update available: v${currentVersion} → v${latestVersion}. Run: pensar upgrade`, "warn", 8000);
     });
     const checkAuthToken = async () => {
-      const { isTokenExpired, isConnected: isConnected2 } = await import("./index-4ad3sdwk.js");
+      const { isTokenExpired, isConnected: isConnected2 } = await import("./index-4v5jc2td.js");
       if (isConnected2(config2.data) && config2.data.accessToken && isTokenExpired(config2.data.accessToken, 60) && !config2.data.refreshToken && !config2.data.pensarAPIKey) {
         toast("Your Pensar Console session has expired. Run /login to refresh.", "warn", 8000);
       }
@@ -70317,6 +70866,7 @@ async function main() {
   const transparent = appConfig.transparentBackground ?? false;
   const themeColors = resolveThemeColors(getTheme(themeName), mode, transparent);
   overlayThemeRef.current = themeColors;
+  const observabilityRuntime = startObservabilityRuntime();
   const renderer = await createCliRenderer({
     exitOnCtrlC: false,
     consoleOptions: buildConsoleOptions(themeColors),
@@ -70324,27 +70874,19 @@ async function main() {
   });
   const { copyToClipboard } = createClipboardManager(renderer);
   setupAutoCopy(renderer, copyToClipboard);
-  const cleanup = () => {
-    cleanupTerminalFocusMode();
-    renderer.destroy();
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  process.on("uncaughtException", (err) => {
-    cleanupTerminalFocusMode();
-    renderer.destroy();
-    console.error("Uncaught exception:", err);
-    writeErrorLog(err, "UNCAUGHT");
-    process.exit(1);
-  });
-  process.on("unhandledRejection", (reason) => {
-    cleanupTerminalFocusMode();
-    renderer.destroy();
-    console.error("Unhandled rejection:", reason);
-    writeErrorLog(reason, "UNHANDLED_REJECTION");
-    process.exit(1);
+  const exitWith = installObservabilityExitHandlers(observabilityRuntime, {
+    cleanup: () => {
+      cleanupTerminalFocusMode();
+      renderer.destroy();
+    },
+    onError: (error, source) => {
+      const uncaught = source === "uncaughtException";
+      const label = uncaught ? "Uncaught exception:" : "Unhandled rejection:";
+      console.error(label, error);
+      writeErrorLog(error, uncaught ? "UNCAUGHT" : "UNHANDLED_REJECTION");
+    }
   });
+  const cleanup = () => exitWith(0);
   const obfuscateEnabled = process.env.PENSAR_OBFUSCATE === "1";
   createRoot(renderer).render(/* @__PURE__ */ jsxDEV61(ObfuscationProvider, {
     initialEnabled: obfuscateEnabled,
@@ -70359,7 +70901,8 @@ async function main() {
             children: [
               /* @__PURE__ */ jsxDEV61(ErrorBoundary, {
                 children: /* @__PURE__ */ jsxDEV61(App, {
-                  appConfig
+                  appConfig,
+                  onExit: cleanup
                 }, undefined, false, undefined, this)
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsxDEV61(ToastContainer, {}, undefined, false, undefined, this)