@bike4mind/cli 0.2.25-feat-cli-multi-agentic-workflow.18573 → 0.2.25-fix-anthropic-overloaded-fallback.18535

package/dist/index.js

@@ -10,9 +10,8 @@ import {
   ConfigStore
 } from "./chunk-23T2XGSZ.js";
 import {
-  selectActiveBackgroundAgents,
   useCliStore
-} from "./chunk-TVW4ZESU.js";
+} from "./chunk-EIDW3VBS.js";
 import "./chunk-RAI6IM62.js";
 import "./chunk-NJW6ZADK.js";
 import {
@@ -88,15 +87,14 @@ import {
 } from "./chunk-OCYRD7D6.js";
 
 // src/index.tsx
-import React21, { useState as useState9, useEffect as useEffect6, useCallback as useCallback2, useRef as useRef3 } from "react";
-import { render, Box as Box20, Text as Text20, useApp, useInput as useInput9 } from "ink";
+import React19, { useState as useState8, useEffect as useEffect4, useCallback, useRef as useRef3 } from "react";
+import { render, Box as Box18, Text as Text18, useApp, useInput as useInput8 } from "ink";
 import { execSync } from "child_process";
-import { randomBytes as randomBytes5 } from "crypto";
 import { v4 as uuidv411 } from "uuid";
 
 // src/components/App.tsx
-import React15, { useState as useState5, useEffect as useEffect4 } from "react";
-import { Box as Box14, Text as Text14, Static, useInput as useInput6 } from "ink";
+import React13, { useState as useState4 } from "react";
+import { Box as Box12, Text as Text12, Static, useInput as useInput5 } from "ink";
 
 // src/components/StatusBar.tsx
 import React from "react";
@@ -1151,101 +1149,23 @@ var AgentThinking = React7.memo(function AgentThinking2() {
   return /* @__PURE__ */ React7.createElement(Box6, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React7.createElement(ThoughtStream, { isThinking }));
 });
 
-// src/components/BackgroundAgentStatus.tsx
-import React8, { useMemo as useMemo2 } from "react";
-import { Box as Box7, Text as Text7 } from "ink";
-import Spinner2 from "ink-spinner";
-var JobItem = React8.memo(function JobItem2({
-  job,
-  indented = false
-}) {
-  const elapsed = Math.round((Date.now() - job.startTime) / 1e3);
-  const maxTaskLength = indented ? 50 : 60;
-  const taskPreview = job.task.length > maxTaskLength ? job.task.slice(0, maxTaskLength - 3) + "..." : job.task;
-  const isQueued = job.status === "queued";
-  return /* @__PURE__ */ React8.createElement(Box7, null, indented && /* @__PURE__ */ React8.createElement(Text7, null, " "), isQueued ? /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "\u23F3") : /* @__PURE__ */ React8.createElement(Text7, { color: "blue" }, /* @__PURE__ */ React8.createElement(Spinner2, { type: "dots" })), /* @__PURE__ */ React8.createElement(Text7, { color: isQueued ? "yellow" : "blue" }, " ", job.agentName), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " ", "[", job.id, "] ", taskPreview, " ", isQueued ? "(queued)" : `(${elapsed}s)`));
-});
-function formatStatusCounts(jobs) {
-  let running = 0;
-  let queued = 0;
-  for (const job of jobs) {
-    if (job.status === "running") running++;
-    else if (job.status === "queued") queued++;
-  }
-  const parts = [];
-  if (running > 0) parts.push(`${running} running`);
-  if (queued > 0) parts.push(`${queued} queued`);
-  return parts.join(", ");
-}
-function groupJobsByTurn(jobs) {
-  const groups = /* @__PURE__ */ new Map();
-  const ungrouped = [];
-  for (const job of jobs) {
-    if (job.turnId) {
-      const existing = groups.get(job.turnId);
-      if (existing) {
-        existing.jobs.push(job);
-        if (!existing.description && job.groupDescription) {
-          existing.description = job.groupDescription;
-        }
-      } else {
-        groups.set(job.turnId, {
-          description: job.groupDescription,
-          jobs: [job]
-        });
-      }
-    } else {
-      ungrouped.push(job);
-    }
-  }
-  return { groups, ungrouped };
-}
-function BackgroundAgentStatus() {
-  const activeJobs = useCliStore(selectActiveBackgroundAgents);
-  const permissionPrompt = useCliStore((state) => state.permissionPrompt);
-  const { groups, ungrouped } = useMemo2(() => groupJobsByTurn(activeJobs), [activeJobs]);
-  if (activeJobs.length === 0) return null;
-  if (permissionPrompt) {
-    return /* @__PURE__ */ React8.createElement(Box7, { paddingX: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Background agents: ", formatStatusCounts(activeJobs)));
-  }
-  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", paddingX: 1, marginBottom: 0 }, Array.from(groups.entries()).map(([turnId, group]) => /* @__PURE__ */ React8.createElement(Box7, { key: turnId, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { color: "magenta" }, "\u25B8 "), /* @__PURE__ */ React8.createElement(Text7, { color: "magenta", bold: true }, group.description || "Background Tasks"), /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, " (", formatStatusCounts(group.jobs), ")")), group.jobs.map((job) => /* @__PURE__ */ React8.createElement(JobItem, { key: job.id, job, indented: true })))), ungrouped.map((job) => /* @__PURE__ */ React8.createElement(JobItem, { key: job.id, job })));
-}
-
-// src/components/CompletedGroupNotification.tsx
-import React9, { useEffect as useEffect3 } from "react";
-import { Box as Box8, Text as Text8 } from "ink";
-var NOTIFICATION_DISPLAY_DURATION_MS = 3e3;
-function CompletedGroupNotification() {
-  const notifications = useCliStore((state) => state.completedGroupNotifications);
-  const clearNotifications = useCliStore((state) => state.clearCompletedGroupNotifications);
-  useEffect3(() => {
-    if (notifications.length > 0) {
-      const timer = setTimeout(() => {
-        clearNotifications();
-      }, NOTIFICATION_DISPLAY_DURATION_MS);
-      return () => clearTimeout(timer);
-    }
-  }, [notifications.length, clearNotifications]);
-  if (notifications.length === 0) return null;
-  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", paddingX: 1, marginBottom: 1 }, notifications.map((item, index) => /* @__PURE__ */ React9.createElement(Box8, { key: `${item.timestamp}-${index}`, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { color: "green", bold: true }, "\u2714", " "), /* @__PURE__ */ React9.createElement(Text8, { color: "green", bold: true }, item.groupDescription ? `Background tasks completed: "${item.groupDescription}"` : "Background tasks completed")), /* @__PURE__ */ React9.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, italic: true }, "Results will be incorporated in the next response.")))));
-}
-
 // src/components/PermissionPrompt.tsx
-import React10, { useState as useState3, useCallback } from "react";
-import { Box as Box9, Text as Text9, useInput as useInput3 } from "ink";
+import React8 from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import SelectInput from "ink-select-input";
 function renderDiffPreview(preview) {
   const lines = preview.split("\n");
   return lines.map((line, index) => {
     if (line.startsWith("+")) {
-      return /* @__PURE__ */ React10.createElement(Text9, { key: index, color: "green" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "green" }, line);
     }
     if (line.startsWith("-")) {
-      return /* @__PURE__ */ React10.createElement(Text9, { key: index, color: "red" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "red" }, line);
     }
     if (line.startsWith("@@")) {
-      return /* @__PURE__ */ React10.createElement(Text9, { key: index, color: "cyan" }, line);
+      return /* @__PURE__ */ React8.createElement(Text7, { key: index, color: "cyan" }, line);
     }
-    return /* @__PURE__ */ React10.createElement(Text9, { key: index, dimColor: true }, line);
+    return /* @__PURE__ */ React8.createElement(Text7, { key: index, dimColor: true }, line);
   });
 }
 function PermissionPrompt({
@@ -1264,36 +1184,16 @@ function PermissionPrompt({
     { label: "\u2713 Allow once", value: "allow-once" },
     { label: "\u2717 Deny", value: "deny" }
   ];
-  const [selectedIndex, setSelectedIndex] = useState3(0);
-  const [responded, setResponded] = useState3(false);
-  const handleSelect = useCallback(() => {
-    if (responded) return;
-    setResponded(true);
-    onResponse(items[selectedIndex].value);
-  }, [responded, onResponse, items, selectedIndex]);
-  useInput3(
-    (_input, key) => {
-      if (responded) return;
-      if (key.upArrow) {
-        setSelectedIndex((i) => i > 0 ? i - 1 : items.length - 1);
-      } else if (key.downArrow) {
-        setSelectedIndex((i) => i < items.length - 1 ? i + 1 : 0);
-      } else if (key.return) {
-        handleSelect();
-      }
-    },
-    { isActive: !responded }
-  );
   const MAX_ARGS_LENGTH = 500;
   const rawArgsString = typeof args === "string" ? args : JSON.stringify(args, null, 2);
   const argsString = rawArgsString.length > MAX_ARGS_LENGTH ? rawArgsString.slice(0, MAX_ARGS_LENGTH) + `
 ... (${rawArgsString.length - MAX_ARGS_LENGTH} more chars)` : rawArgsString;
-  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Tool: "), /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "Action: "), /* @__PURE__ */ React10.createElement(Text9, null, toolDescription)), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, "Arguments:"), /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text9, { bold: true }, "Preview:"), /* @__PURE__ */ React10.createElement(Box9, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, flexDirection: "column" }, items.map((item, index) => /* @__PURE__ */ React10.createElement(Box9, { key: item.value }, /* @__PURE__ */ React10.createElement(Text9, { color: index === selectedIndex ? "cyan" : void 0, bold: index === selectedIndex }, index === selectedIndex ? "\u276F " : "  ", item.label)))));
+  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", borderStyle: "bold", borderColor: "yellow", padding: 1, marginY: 1 }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "yellow" }, "\u26A0\uFE0F Permission Required")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Tool: "), /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "cyan" }, toolName)), toolDescription && /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "Action: "), /* @__PURE__ */ React8.createElement(Text7, null, toolDescription)), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Arguments:"), /* @__PURE__ */ React8.createElement(Box7, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, argsString))), preview && /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text7, { bold: true }, "Preview:"), /* @__PURE__ */ React8.createElement(Box7, { borderStyle: "single", borderColor: "gray", paddingX: 1, flexDirection: "column" }, renderDiffPreview(preview))), !canBeTrusted && /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "red", dimColor: true }, "Note: This tool cannot be trusted due to its dangerous nature.")), /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(SelectInput, { items, onSelect: (item) => onResponse(item.value) })));
 }
 
 // src/components/ConfigEditor.tsx
-import React11, { useState as useState4, useMemo as useMemo3 } from "react";
-import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
+import React9, { useState as useState3, useMemo as useMemo2 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
 var MAX_ITERATIONS_OPTIONS = [
   { label: "10", value: 10 },
   { label: "20", value: 20 },
@@ -1437,12 +1337,12 @@ function buildConfigItems(availableModels) {
   return items;
 }
 function ConfigEditor({ config, availableModels, onSave, onClose }) {
-  const [selectedIndex, setSelectedIndex] = useState4(0);
-  const [editedConfig, setEditedConfig] = useState4(config);
-  const [saveError, setSaveError] = useState4(null);
-  const [isSaving, setIsSaving] = useState4(false);
-  const configItems = useMemo3(() => buildConfigItems(availableModels), [availableModels]);
-  const hasChanges = useMemo3(() => {
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [editedConfig, setEditedConfig] = useState3(config);
+  const [saveError, setSaveError] = useState3(null);
+  const [isSaving, setIsSaving] = useState3(false);
+  const configItems = useMemo2(() => buildConfigItems(availableModels), [availableModels]);
+  const hasChanges = useMemo2(() => {
     return JSON.stringify(config.preferences) !== JSON.stringify(editedConfig.preferences) || config.defaultModel !== editedConfig.defaultModel;
   }, [config.preferences, editedConfig.preferences, config.defaultModel, editedConfig.defaultModel]);
   const handleSaveAndClose = async () => {
@@ -1460,7 +1360,7 @@ function ConfigEditor({ config, availableModels, onSave, onClose }) {
     }
     onClose();
   };
-  useInput4((input, key) => {
+  useInput3((input, key) => {
     const currentItem = configItems[selectedIndex];
     if (key.upArrow) {
       setSelectedIndex((prev) => prev > 0 ? prev - 1 : configItems.length - 1);
@@ -1525,33 +1425,33 @@ function ConfigEditor({ config, availableModels, onSave, onClose }) {
     }
     return String(value);
   };
-  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, marginY: 1 }, /* @__PURE__ */ React11.createElement(Box10, { justifyContent: "space-between", marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: "cyan" }, "Settings"), isSaving ? /* @__PURE__ */ React11.createElement(Text10, { color: "yellow" }, "Saving...") : hasChanges ? /* @__PURE__ */ React11.createElement(Text10, { dimColor: true, color: "yellow" }, "(unsaved changes)") : null), saveError && /* @__PURE__ */ React11.createElement(Box10, { marginBottom: 1 }, /* @__PURE__ */ React11.createElement(Text10, { color: "red" }, "Error: ", saveError)), /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", marginBottom: 1 }, configItems.map((item, index) => {
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, { justifyContent: "space-between", marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: "cyan" }, "Settings"), isSaving ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "Saving...") : hasChanges ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, color: "yellow" }, "(unsaved changes)") : null), saveError && /* @__PURE__ */ React9.createElement(Box8, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "red" }, "Error: ", saveError)), /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginBottom: 1 }, configItems.map((item, index) => {
     const isSelected = index === selectedIndex;
     const value = item.getValue(editedConfig);
     const displayValue = formatValue(item, value);
     const hasOptions = item.type === "select" || item.type === "boolean" || item.type === "number";
-    return /* @__PURE__ */ React11.createElement(Box10, { key: item.key }, /* @__PURE__ */ React11.createElement(Text10, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  "), /* @__PURE__ */ React11.createElement(Box10, { width: 18 }, /* @__PURE__ */ React11.createElement(Text10, { bold: isSelected, color: isSelected ? "white" : "gray" }, item.label, ":")), /* @__PURE__ */ React11.createElement(Box10, null, hasOptions && isSelected && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "< "), /* @__PURE__ */ React11.createElement(Text10, { bold: isSelected, color: isSelected ? "green" : void 0 }, displayValue), hasOptions && isSelected && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, " >")));
-  })), /* @__PURE__ */ React11.createElement(Box10, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "\u2191/\u2193: Navigate | Space/\u2190/\u2192: Change | q/Esc: Save & Exit")));
+    return /* @__PURE__ */ React9.createElement(Box8, { key: item.key }, /* @__PURE__ */ React9.createElement(Text8, { color: isSelected ? "cyan" : void 0 }, isSelected ? "> " : "  "), /* @__PURE__ */ React9.createElement(Box8, { width: 18 }, /* @__PURE__ */ React9.createElement(Text8, { bold: isSelected, color: isSelected ? "white" : "gray" }, item.label, ":")), /* @__PURE__ */ React9.createElement(Box8, null, hasOptions && isSelected && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "< "), /* @__PURE__ */ React9.createElement(Text8, { bold: isSelected, color: isSelected ? "green" : void 0 }, displayValue), hasOptions && isSelected && /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " >")));
+  })), /* @__PURE__ */ React9.createElement(Box8, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u2191/\u2193: Navigate | Space/\u2190/\u2192: Change | q/Esc: Save & Exit")));
 }
 
 // src/components/McpViewer.tsx
-import React12 from "react";
-import { Box as Box11, Text as Text11, useInput as useInput5 } from "ink";
+import React10 from "react";
+import { Box as Box9, Text as Text9, useInput as useInput4 } from "ink";
 function McpViewer({ config, mcpManager, onClose }) {
-  useInput5((input, key) => {
+  useInput4((input, key) => {
     if (key.escape || input === "q") {
       onClose();
     }
   });
   if (config.mcpServers.length === 0) {
-    return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React12.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "cyan" }, "\u{1F4E1} MCP Server Status")), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "No MCP servers configured."), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "To add MCP servers, edit your config file:")), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " Global: ~/.bike4mind/config.json"), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " Project: .bike4mind/config.json"), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 2 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true, italic: true }, "Press Esc or q to close")));
+    return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React10.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, "\u{1F4E1} MCP Server Status")), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "No MCP servers configured."), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "To add MCP servers, edit your config file:")), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Global: ~/.bike4mind/config.json"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Project: .bike4mind/config.json"), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true, italic: true }, "Press Esc or q to close")));
   }
   const enabledServers = config.mcpServers.filter((s) => s.enabled);
-  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React12.createElement(Box11, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "cyan" }, "\u{1F4E1} MCP Server Status")), /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", marginBottom: 2 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true, dimColor: true }, "Configured Servers:"), config.mcpServers.map((server) => {
+  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React10.createElement(Box9, { marginBottom: 1 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "cyan" }, "\u{1F4E1} MCP Server Status")), /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", marginBottom: 2 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, dimColor: true }, "Configured Servers:"), config.mcpServers.map((server) => {
     const status = server.enabled ? "\u2705 Enabled" : "\u23F8\uFE0F  Disabled";
     const commandInfo = server.command ? `${server.command} ${(server.args || []).join(" ")}` : "(internal)";
-    return /* @__PURE__ */ React12.createElement(Box11, { key: server.name, flexDirection: "column", marginTop: 1, marginLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, null, "\u2022 ", /* @__PURE__ */ React12.createElement(Text11, { bold: true }, server.name), " - ", /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, status)), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " Command: ", commandInfo), Object.keys(server.env).length > 0 && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " Env vars: ", Object.keys(server.env).join(", ")));
-  })), enabledServers.length > 0 && mcpManager && /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", marginBottom: 2 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true, dimColor: true }, "Connection Status:"), enabledServers.map((server) => {
+    return /* @__PURE__ */ React10.createElement(Box9, { key: server.name, flexDirection: "column", marginTop: 1, marginLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, null, "\u2022 ", /* @__PURE__ */ React10.createElement(Text9, { bold: true }, server.name), " - ", /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, status)), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Command: ", commandInfo), Object.keys(server.env).length > 0 && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Env vars: ", Object.keys(server.env).join(", ")));
+  })), enabledServers.length > 0 && mcpManager && /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", marginBottom: 2 }, /* @__PURE__ */ React10.createElement(Text9, { bold: true, dimColor: true }, "Connection Status:"), enabledServers.map((server) => {
     const state = mcpManager.getConnectionState(server.name);
     let icon;
     let statusText;
@@ -1581,30 +1481,30 @@ function McpViewer({ config, mcpManager, onClose }) {
     const serverTools = toolCounts.find((t) => t.serverName === server.name);
     const toolCount = serverTools?.count || 0;
     const toolInfo = state === "connected" && toolCount > 0 ? ` (${toolCount} tool${toolCount === 1 ? "" : "s"})` : "";
-    return /* @__PURE__ */ React12.createElement(Box11, { key: server.name, marginTop: 1, marginLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, null, "\u2022 ", /* @__PURE__ */ React12.createElement(Text11, { bold: true }, server.name), " \xB7 ", /* @__PURE__ */ React12.createElement(Text11, { color }, icon), " ", /* @__PURE__ */ React12.createElement(Text11, { color }, statusText), toolInfo && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, toolInfo)));
-  }), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1, marginLeft: 2 }, (() => {
+    return /* @__PURE__ */ React10.createElement(Box9, { key: server.name, marginTop: 1, marginLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, null, "\u2022 ", /* @__PURE__ */ React10.createElement(Text9, { bold: true }, server.name), " \xB7 ", /* @__PURE__ */ React10.createElement(Text9, { color }, icon), " ", /* @__PURE__ */ React10.createElement(Text9, { color }, statusText), toolInfo && /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, toolInfo)));
+  }), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1, marginLeft: 2 }, (() => {
     const toolCounts = mcpManager.getToolCount();
     const totalTools = toolCounts.reduce((sum2, s) => sum2 + s.count, 0);
     if (totalTools > 0) {
-      return /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "green" }, "Total: ", totalTools, " MCP tool", totalTools === 1 ? "" : "s", " available");
+      return /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "green" }, "Total: ", totalTools, " MCP tool", totalTools === 1 ? "" : "s", " available");
     } else {
-      return /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "No MCP tools available yet (servers still connecting)");
+      return /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "No MCP tools available yet (servers still connecting)");
     }
-  })())), enabledServers.length === 0 && /* @__PURE__ */ React12.createElement(Box11, { marginBottom: 2 }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "\u26A0\uFE0F No MCP servers enabled"), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " Use `b4m mcp enable ", "<name>", "` to enable a server")), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true, italic: true }, "Press Esc or q to close")));
+  })())), enabledServers.length === 0 && /* @__PURE__ */ React10.createElement(Box9, { marginBottom: 2 }, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u26A0\uFE0F No MCP servers enabled"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " Use `b4m mcp enable ", "<name>", "` to enable a server")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true, italic: true }, "Press Esc or q to close")));
 }
 
 // src/components/MessageItem.tsx
-import React14 from "react";
-import { Box as Box13, Text as Text13 } from "ink";
+import React12 from "react";
+import { Box as Box11, Text as Text11 } from "ink";
 
 // src/components/MarkdownRenderer.tsx
-import React13 from "react";
-import { Box as Box12, Text as Text12 } from "ink";
+import React11 from "react";
+import { Box as Box10, Text as Text10 } from "ink";
 import { marked } from "marked";
 import { highlight } from "cli-highlight";
 function MarkdownRenderer({ content }) {
   const tokens = marked.lexer(content);
-  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column" }, tokens.map((token, idx) => renderToken(token, idx)));
+  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column" }, tokens.map((token, idx) => renderToken(token, idx)));
 }
 function renderToken(token, idx) {
   switch (token.type) {
@@ -1619,12 +1519,12 @@ function renderToken(token, idx) {
     case "blockquote":
       return renderBlockquote(token, idx);
     case "hr":
-      return /* @__PURE__ */ React13.createElement(Text12, { key: idx, dimColor: true }, "\u2500".repeat(50));
+      return /* @__PURE__ */ React11.createElement(Text10, { key: idx, dimColor: true }, "\u2500".repeat(50));
     case "space":
       return null;
     default:
       if ("text" in token) {
-        return /* @__PURE__ */ React13.createElement(Text12, { key: idx }, token.text);
+        return /* @__PURE__ */ React11.createElement(Text10, { key: idx }, token.text);
       }
       return null;
   }
@@ -1639,7 +1539,7 @@ function renderHeading(token, idx) {
     6: "white"
   };
   const color = colors[token.depth] || "white";
-  return /* @__PURE__ */ React13.createElement(Box12, { key: idx, marginTop: idx > 0 ? 1 : 0 }, /* @__PURE__ */ React13.createElement(Text12, { bold: true, color }, parseInlineText(token.text)));
+  return /* @__PURE__ */ React11.createElement(Box10, { key: idx, marginTop: idx > 0 ? 1 : 0 }, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color }, parseInlineText(token.text)));
 }
 function renderCodeBlock(token, idx) {
   let highlightedCode;
@@ -1651,20 +1551,20 @@ function renderCodeBlock(token, idx) {
   } catch (error) {
     highlightedCode = token.text;
   }
-  return /* @__PURE__ */ React13.createElement(Box12, { key: idx, flexDirection: "column", paddingLeft: 2 }, token.lang && /* @__PURE__ */ React13.createElement(Text12, { dimColor: true, color: "gray" }, token.lang), /* @__PURE__ */ React13.createElement(Text12, null, highlightedCode));
+  return /* @__PURE__ */ React11.createElement(Box10, { key: idx, flexDirection: "column", paddingLeft: 2 }, token.lang && /* @__PURE__ */ React11.createElement(Text10, { dimColor: true, color: "gray" }, token.lang), /* @__PURE__ */ React11.createElement(Text10, null, highlightedCode));
 }
 function renderParagraph(token, idx) {
-  return /* @__PURE__ */ React13.createElement(Box12, { key: idx }, /* @__PURE__ */ React13.createElement(Text12, null, parseInlineText(token.text)));
+  return /* @__PURE__ */ React11.createElement(Box10, { key: idx }, /* @__PURE__ */ React11.createElement(Text10, null, parseInlineText(token.text)));
 }
 function renderList(token, idx) {
-  return /* @__PURE__ */ React13.createElement(Box12, { key: idx, flexDirection: "column" }, token.items.map((item, itemIdx) => renderListItem(item, itemIdx, token.ordered, itemIdx + 1)));
+  return /* @__PURE__ */ React11.createElement(Box10, { key: idx, flexDirection: "column" }, token.items.map((item, itemIdx) => renderListItem(item, itemIdx, token.ordered, itemIdx + 1)));
 }
 function renderListItem(item, idx, ordered, number) {
   const bullet = ordered ? `${number}.` : "\u2022";
-  return /* @__PURE__ */ React13.createElement(Box12, { key: idx, paddingLeft: 2 }, /* @__PURE__ */ React13.createElement(Text12, null, bullet, " ", parseInlineText(item.text)));
+  return /* @__PURE__ */ React11.createElement(Box10, { key: idx, paddingLeft: 2 }, /* @__PURE__ */ React11.createElement(Text10, null, bullet, " ", parseInlineText(item.text)));
 }
 function renderBlockquote(token, idx) {
-  return /* @__PURE__ */ React13.createElement(Box12, { key: idx, paddingLeft: 2, borderStyle: "single", borderLeft: true, borderColor: "gray" }, token.tokens.map((t, i) => renderToken(t, i)));
+  return /* @__PURE__ */ React11.createElement(Box10, { key: idx, paddingLeft: 2, borderStyle: "single", borderLeft: true, borderColor: "gray" }, token.tokens.map((t, i) => renderToken(t, i)));
 }
 function parseInlineText(text) {
   const parts = [];
@@ -1677,15 +1577,15 @@ function parseInlineText(text) {
     }
     if (match[1]) {
       parts.push(
-        /* @__PURE__ */ React13.createElement(Text12, { key: match.index, bold: true }, match[2])
+        /* @__PURE__ */ React11.createElement(Text10, { key: match.index, bold: true }, match[2])
       );
     } else if (match[3]) {
       parts.push(
-        /* @__PURE__ */ React13.createElement(Text12, { key: match.index, italic: true }, match[4])
+        /* @__PURE__ */ React11.createElement(Text10, { key: match.index, italic: true }, match[4])
       );
     } else if (match[5]) {
       parts.push(
-        /* @__PURE__ */ React13.createElement(Text12, { key: match.index, color: "cyan" }, match[6])
+        /* @__PURE__ */ React11.createElement(Text10, { key: match.index, color: "cyan" }, match[6])
       );
     }
     lastIndex = regex.lastIndex;
@@ -1696,45 +1596,27 @@ function parseInlineText(text) {
   if (parts.length === 0) {
     return text;
   }
-  return /* @__PURE__ */ React13.createElement(React13.Fragment, null, parts);
+  return /* @__PURE__ */ React11.createElement(React11.Fragment, null, parts);
 }
 
 // src/components/MessageItem.tsx
-function truncateValue(value, maxLength) {
-  const str = typeof value === "string" ? value : JSON.stringify(value);
-  if (str.length <= maxLength) {
-    return str;
-  }
-  return str.slice(0, maxLength) + "...";
-}
-function getRoleDisplay(role) {
-  switch (role) {
-    case "user":
-      return { color: "cyan", label: "\u{1F464} You" };
-    case "system":
-      return { color: "gray", label: "\u2139\uFE0F  System" };
-    default:
-      return { color: "green", label: "\u{1F916} Assistant" };
-  }
-}
-var MessageItem = React14.memo(function MessageItem2({ message }) {
+function MessageItem({ message }) {
   const isUser = message.role === "user";
-  const isContinuation = message.metadata?.isContinuation === true;
-  const roleDisplay = getRoleDisplay(message.role);
-  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", marginBottom: 1 }, !isContinuation && /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { bold: true, color: roleDisplay.color }, roleDisplay.label), isUser && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), isUser && message.content && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { backgroundColor: "whiteBright", color: "black" }, " ", message.content, " ")), !isUser && message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+  const isSystem = message.role === "system";
+  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: isUser ? "cyan" : isSystem ? "gray" : "green" }, isUser ? "\u{1F464} You" : isSystem ? "\u2139\uFE0F  System" : "\u{1F916} Assistant"), isUser && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), isUser && message.content && /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { backgroundColor: "whiteBright", color: "black" }, " ", message.content, " ")), !isUser && message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
     if (step.type === "thought") {
-      return /* @__PURE__ */ React14.createElement(Box13, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   ${step.content}`));
+      return /* @__PURE__ */ React12.createElement(Box11, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `   ${step.content}`));
     }
     if (step.type === "action") {
       const toolName = step.metadata?.toolName || "unknown";
       const toolInput = step.metadata?.toolInput;
-      const observationStep = message.metadata?.steps?.[idx + 1];
+      const observationStep = message.metadata.steps[idx + 1];
       const result = observationStep?.type === "observation" ? observationStep.content : null;
-      return /* @__PURE__ */ React14.createElement(Box13, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Input: ${truncateValue(toolInput, 100)}`), result && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Result: ${truncateValue(result, 200)}`));
+      return /* @__PURE__ */ React12.createElement(Box11, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
     }
     return null;
-  }).filter(Boolean)), !isUser && message.content !== "..." && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginTop: message.metadata?.steps?.length ? 1 : 0 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React14.createElement(MarkdownRenderer, { content: message.content })), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
-});
+  }).filter(Boolean)), !isUser && message.content !== "..." && /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2, marginTop: message.metadata?.steps?.length ? 1 : 0 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React12.createElement(MarkdownRenderer, { content: message.content })), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React12.createElement(Box11, { paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)));
+}
 
 // src/utils/processFileReferences.ts
 import * as fs2 from "fs";
@@ -1853,7 +1735,6 @@ function hasFileReferences(message) {
 // src/components/App.tsx
 function App({
   onMessage,
-  onBackgroundCompletion,
   onCommand,
   onBashCommand,
   onPermissionResponse,
@@ -1880,22 +1761,14 @@ function App({
   const setShowMcpViewer = useCliStore((state) => state.setShowMcpViewer);
   const exitRequested = useCliStore((state) => state.exitRequested);
   const setIsThinking = useCliStore((state) => state.setIsThinking);
-  const pendingBackgroundTrigger = useCliStore((state) => state.pendingBackgroundTrigger);
-  const setPendingBackgroundTrigger = useCliStore((state) => state.setPendingBackgroundTrigger);
-  useEffect4(() => {
-    if (pendingBackgroundTrigger && !isThinking && onBackgroundCompletion) {
-      setPendingBackgroundTrigger(false);
-      onBackgroundCompletion();
-    }
-  }, [pendingBackgroundTrigger, isThinking, setPendingBackgroundTrigger, onBackgroundCompletion]);
   const toggleAutoAcceptEdits = useCliStore((state) => state.toggleAutoAcceptEdits);
-  useInput6((_input, key) => {
+  useInput5((_input, key) => {
     if (key.tab && key.shift) {
       toggleAutoAcceptEdits();
     }
   });
-  const [isBashMode, setIsBashMode] = useState5(false);
-  const handleSubmit = React15.useCallback(
+  const [isBashMode, setIsBashMode] = useState4(false);
+  const handleSubmit = React13.useCallback(
     async (input) => {
       const trimmed = input.trim();
       if (!trimmed) return;
@@ -1924,7 +1797,7 @@ ${errorBlock}`;
     },
     [onMessage, onCommand, setIsThinking]
   );
-  return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column" }, showConfigEditor && config && onSaveConfig ? /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React15.createElement(
+  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column" }, showConfigEditor && config && onSaveConfig ? /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(
     ConfigEditor,
     {
       config,
@@ -1934,8 +1807,8 @@ ${errorBlock}`;
     }
   )) : showMcpViewer && config ? (
     /* MCP Viewer - full screen takeover */
-    /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React15.createElement(McpViewer, { config, mcpManager, onClose: () => setShowMcpViewer(false) }))
-  ) : /* @__PURE__ */ React15.createElement(React15.Fragment, null, /* @__PURE__ */ React15.createElement(Static, { items: messages }, (message) => /* @__PURE__ */ React15.createElement(Box14, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React15.createElement(MessageItem, { message }))), /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column" }, pendingMessages.map((message) => /* @__PURE__ */ React15.createElement(Box14, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React15.createElement(MessageItem, { message })))), permissionPrompt && /* @__PURE__ */ React15.createElement(Box14, { key: permissionPrompt.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React15.createElement(
+    /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(McpViewer, { config, mcpManager, onClose: () => setShowMcpViewer(false) }))
+  ) : /* @__PURE__ */ React13.createElement(React13.Fragment, null, /* @__PURE__ */ React13.createElement(Static, { items: messages }, (message) => /* @__PURE__ */ React13.createElement(Box12, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(MessageItem, { message }))), /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column" }, pendingMessages.map((message) => /* @__PURE__ */ React13.createElement(Box12, { key: message.id, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(MessageItem, { message })))), permissionPrompt && /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(
     PermissionPrompt,
     {
       toolName: permissionPrompt.toolName,
@@ -1944,7 +1817,7 @@ ${errorBlock}`;
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )), !permissionPrompt && /* @__PURE__ */ React15.createElement(AgentThinking, null), /* @__PURE__ */ React15.createElement(BackgroundAgentStatus, null), /* @__PURE__ */ React15.createElement(CompletedGroupNotification, null), exitRequested && /* @__PURE__ */ React15.createElement(Box14, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React15.createElement(Text14, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React15.createElement(Box14, { borderStyle: "single", borderColor: isBashMode ? "yellow" : "cyan", paddingX: 1 }, /* @__PURE__ */ React15.createElement(
+  )), !permissionPrompt && /* @__PURE__ */ React13.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React13.createElement(Box12, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React13.createElement(Box12, { borderStyle: "single", borderColor: isBashMode ? "yellow" : "cyan", paddingX: 1 }, /* @__PURE__ */ React13.createElement(
     InputPrompt,
     {
       onSubmit: handleSubmit,
@@ -1957,24 +1830,24 @@ ${errorBlock}`;
       onPrefillConsumed,
       onBashModeChange: setIsBashMode
     }
-  )), /* @__PURE__ */ React15.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
+  )), /* @__PURE__ */ React13.createElement(StatusBar, { sessionName, model: currentModel, tokenUsage: totalTokens })));
 }
 
 // src/components/MessageList.tsx
-import React16 from "react";
-import { Box as Box15, Text as Text15 } from "ink";
+import React14 from "react";
+import { Box as Box13, Text as Text13 } from "ink";
 function stripThinkingTags(content) {
   return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
-var MessageList = React16.memo(
+var MessageList = React14.memo(
   function MessageList2({ messages }) {
     if (messages.length === 0) {
-      return /* @__PURE__ */ React16.createElement(Box15, { paddingY: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "No messages yet. Type a message to start!"));
+      return /* @__PURE__ */ React14.createElement(Box13, { paddingY: 1 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "No messages yet. Type a message to start!"));
     }
-    return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React16.createElement(Box15, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React16.createElement(Box15, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React16.createElement(Text15, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React16.createElement(Text15, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React16.createElement(Box15, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " tools used,", " ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
+    return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", gap: 1, paddingY: 1 }, messages.map((message, index) => /* @__PURE__ */ React14.createElement(Box13, { key: index, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u26A0\uFE0F ", stripThinkingTags(message.content)) : /* @__PURE__ */ React14.createElement(Text13, null, stripThinkingTags(message.content))), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " tools used,", " ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
       if (step.type === "thought") {
-        return /* @__PURE__ */ React16.createElement(Box15, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React16.createElement(Text15, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React16.createElement(
-          Text15,
+        return /* @__PURE__ */ React14.createElement(Box13, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "blue" }, "\u{1F4AD} Thought:"), /* @__PURE__ */ React14.createElement(
+          Text13,
           {
             dimColor: true
           },
@@ -1986,10 +1859,10 @@ var MessageList = React16.memo(
         const toolInput = step.metadata?.toolInput;
         const observationStep = message.metadata.steps[idx + 1];
         const result = observationStep?.type === "observation" ? observationStep.content : null;
-        return /* @__PURE__ */ React16.createElement(Box15, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React16.createElement(Text15, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
+        return /* @__PURE__ */ React14.createElement(Box13, { key: idx, paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "\u{1F527} Action: ", toolName), toolInput && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Input: ${typeof toolInput === "string" ? toolInput : JSON.stringify(toolInput).slice(0, 100)}`), result && /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `   Result: ${typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200)}${(typeof result === "string" ? result.length : JSON.stringify(result).length) > 200 ? "..." : ""}`));
       }
       return null;
-    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React16.createElement(Box15, { paddingLeft: 2 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
+    }).filter(Boolean)), message.metadata?.tokenUsage && (!message.metadata.steps || message.metadata.steps.length === 0) && /* @__PURE__ */ React14.createElement(Box13, { paddingLeft: 2 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `${message.metadata.tokenUsage.total} tokens`)))));
   },
   (prevProps, nextProps) => {
     if (prevProps.messages.length !== nextProps.messages.length) {
@@ -2000,9 +1873,9 @@ var MessageList = React16.memo(
 );
 
 // src/components/TrustLocationSelector.tsx
-import React17 from "react";
-import { Box as Box16, Text as Text16 } from "ink";
-import SelectInput from "ink-select-input";
+import React15 from "react";
+import { Box as Box14, Text as Text14 } from "ink";
+import SelectInput2 from "ink-select-input";
 function TrustLocationSelector({ inProject, onSelect, onCancel }) {
   const items = [];
   if (inProject) {
@@ -2022,24 +1895,24 @@ function TrustLocationSelector({ inProject, onSelect, onCancel }) {
   const handleSelect = (item) => {
     onSelect(item.value);
   };
-  return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "Where should this rule be saved?")), /* @__PURE__ */ React17.createElement(
-    SelectInput,
+  return /* @__PURE__ */ React15.createElement(Box14, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React15.createElement(Box14, { marginBottom: 1 }, /* @__PURE__ */ React15.createElement(Text14, { bold: true }, "Where should this rule be saved?")), /* @__PURE__ */ React15.createElement(
+    SelectInput2,
     {
       items,
       onSelect: handleSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Text14, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
     }
-  ), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
+  ), /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1 }, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
 }
 
 // src/components/RewindSelector.tsx
-import React18, { useState as useState6 } from "react";
-import { Box as Box17, Text as Text17, useInput as useInput7 } from "ink";
-import SelectInput2 from "ink-select-input";
+import React16, { useState as useState5 } from "react";
+import { Box as Box15, Text as Text15, useInput as useInput6 } from "ink";
+import SelectInput3 from "ink-select-input";
 function RewindSelector({ messages, onSelect, onCancel }) {
-  const [step, setStep] = useState6("selection");
-  const [selectedMessageIndex, setSelectedMessageIndex] = useState6(null);
-  useInput7((input, key) => {
+  const [step, setStep] = useState5("selection");
+  const [selectedMessageIndex, setSelectedMessageIndex] = useState5(null);
+  useInput6((input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
         setStep("selection");
@@ -2076,14 +1949,14 @@ function RewindSelector({ messages, onSelect, onCancel }) {
     return sum2 + (msg.metadata?.tokenUsage?.total || 0);
   }, 0);
   if (step === "selection") {
-    return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1 }, /* @__PURE__ */ React18.createElement(Text17, { bold: true }, "Select a point to rewind to:")), /* @__PURE__ */ React18.createElement(
-      SelectInput2,
+    return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1 }, /* @__PURE__ */ React16.createElement(Text15, { bold: true }, "Select a point to rewind to:")), /* @__PURE__ */ React16.createElement(
+      SelectInput3,
       {
         items,
         onSelect: handleSelectionSelect,
-        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
       }
-    ), /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
+    ), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
   }
   const confirmationItems = [
     { label: "Yes, rewind to this point", value: "confirm" },
@@ -2091,24 +1964,24 @@ function RewindSelector({ messages, onSelect, onCancel }) {
   ];
   const selectedMessage = selectedMessageIndex !== null && selectedMessageIndex >= 0 && selectedMessageIndex < messages.length ? messages[selectedMessageIndex] : null;
   const selectedPreview = selectedMessage ? selectedMessage.content.length > 50 ? selectedMessage.content.substring(0, 50) + "..." : selectedMessage.content : "";
-  return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React18.createElement(Text17, { bold: true }, "Confirm rewind operation:"), /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, "Message: ", selectedPreview), /* @__PURE__ */ React18.createElement(Text17, { color: "yellow" }, "This will remove ", messagesToRemove.length, " message(s) (", tokensToRemove.toLocaleString(), " tokens)"), /* @__PURE__ */ React18.createElement(Text17, { color: "cyan" }, "The selected message will be placed in your input for editing.")), /* @__PURE__ */ React18.createElement(
-    SelectInput2,
+  return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React16.createElement(Box15, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React16.createElement(Text15, { bold: true }, "Confirm rewind operation:"), /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Message: ", selectedPreview), /* @__PURE__ */ React16.createElement(Text15, { color: "yellow" }, "This will remove ", messagesToRemove.length, " message(s) (", tokensToRemove.toLocaleString(), " tokens)"), /* @__PURE__ */ React16.createElement(Text15, { color: "cyan" }, "The selected message will be placed in your input for editing.")), /* @__PURE__ */ React16.createElement(
+    SelectInput3,
     {
       items: confirmationItems,
       onSelect: handleConfirmationSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
     }
-  ), /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
+  ), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
 }
 
 // src/components/SessionSelector.tsx
-import React19, { useState as useState7 } from "react";
-import { Box as Box18, Text as Text18, useInput as useInput8 } from "ink";
-import SelectInput3 from "ink-select-input";
+import React17, { useState as useState6 } from "react";
+import { Box as Box16, Text as Text16, useInput as useInput7 } from "ink";
+import SelectInput4 from "ink-select-input";
 function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
-  const [step, setStep] = useState7("selection");
-  const [selectedSession, setSelectedSession] = useState7(null);
-  useInput8((_input, key) => {
+  const [step, setStep] = useState6("selection");
+  const [selectedSession, setSelectedSession] = useState6(null);
+  useInput7((_input, key) => {
     if (key.escape) {
       if (step === "confirmation") {
         setStep("selection");
@@ -2158,33 +2031,33 @@ function SessionSelector({ sessions, currentSession, onSelect, onCancel }) {
     }
   };
   if (step === "selection") {
-    return /* @__PURE__ */ React19.createElement(Box18, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React19.createElement(Box18, { marginBottom: 1 }, /* @__PURE__ */ React19.createElement(Text18, { bold: true }, "Select a session to resume:")), /* @__PURE__ */ React19.createElement(
-      SelectInput3,
+    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "Select a session to resume:")), /* @__PURE__ */ React17.createElement(
+      SelectInput4,
       {
         items,
         onSelect: handleSelectionSelect,
-        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Text18, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
       }
-    ), /* @__PURE__ */ React19.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
+    ), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
   }
   const confirmationItems = [
     { label: "Yes, resume this session", value: "confirm" },
     { label: "No, go back to selection", value: "cancel" }
   ];
-  return /* @__PURE__ */ React19.createElement(Box18, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React19.createElement(Box18, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React19.createElement(Text18, { bold: true }, 'Resume session: "', selectedSession?.name, '"'), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, selectedSession?.messages.length, " messages | ", selectedSession?.model, " |", " ", selectedSession?.metadata?.totalTokens?.toLocaleString() ?? 0, " tokens"), hasUnsavedWork && /* @__PURE__ */ React19.createElement(Text18, { color: "yellow" }, "Warning: Your current session has unsaved messages. Use /save first if needed.")), /* @__PURE__ */ React19.createElement(
-    SelectInput3,
+  return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React17.createElement(Text16, { bold: true }, 'Resume session: "', selectedSession?.name, '"'), /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, selectedSession?.messages.length, " messages | ", selectedSession?.model, " |", " ", selectedSession?.metadata?.totalTokens?.toLocaleString() ?? 0, " tokens"), hasUnsavedWork && /* @__PURE__ */ React17.createElement(Text16, { color: "yellow" }, "Warning: Your current session has unsaved messages. Use /save first if needed.")), /* @__PURE__ */ React17.createElement(
+    SelectInput4,
     {
       items: confirmationItems,
       onSelect: handleConfirmationSelect,
-      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Text18, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
     }
-  ), /* @__PURE__ */ React19.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
+  ), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
 }
 
 // src/components/LoginFlow.tsx
-import React20, { useState as useState8, useEffect as useEffect5 } from "react";
-import { Box as Box19, Text as Text19 } from "ink";
-import Spinner3 from "ink-spinner";
+import React18, { useState as useState7, useEffect as useEffect3 } from "react";
+import { Box as Box17, Text as Text17 } from "ink";
+import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
 import open from "open";
 
@@ -2299,11 +2172,11 @@ var OAuthClient = class {
 
 // src/components/LoginFlow.tsx
 function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, onError }) {
-  const [status, setStatus] = useState8("initiating");
-  const [deviceFlow, setDeviceFlow] = useState8(null);
-  const [statusMessage, setStatusMessage] = useState8("Initiating device authorization...");
-  const [error, setError] = useState8(null);
-  useEffect5(() => {
+  const [status, setStatus] = useState7("initiating");
+  const [deviceFlow, setDeviceFlow] = useState7(null);
+  const [statusMessage, setStatusMessage] = useState7("Initiating device authorization...");
+  const [error, setError] = useState7(null);
+  useEffect3(() => {
     const runLoginFlow = async () => {
       const oauth = new OAuthClient(apiUrl);
       try {
@@ -2338,7 +2211,7 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     };
     runLoginFlow();
   }, [apiUrl, configStore, onSuccess, onError]);
-  useEffect5(() => {
+  useEffect3(() => {
     if (deviceFlow && status === "waiting") {
       open(deviceFlow.verification_uri_complete).catch((err) => {
         console.error("Failed to auto-open browser:", err);
@@ -2346,15 +2219,15 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     }
   }, [deviceFlow, status]);
   if (status === "initiating") {
-    return /* @__PURE__ */ React20.createElement(Box19, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React20.createElement(Box19, null, /* @__PURE__ */ React20.createElement(Text19, { color: "cyan" }, /* @__PURE__ */ React20.createElement(Spinner3, { type: "dots" }), " Initiating device authorization...")));
+    return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { color: "cyan" }, /* @__PURE__ */ React18.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
   }
   if (status === "error") {
-    return /* @__PURE__ */ React20.createElement(Box19, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1 }, /* @__PURE__ */ React20.createElement(Text19, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React20.createElement(Box19, null, /* @__PURE__ */ React20.createElement(Text19, { color: "red" }, error)));
+    return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1 }, /* @__PURE__ */ React18.createElement(Text17, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { color: "red" }, error)));
   }
   if (status === "success") {
-    return /* @__PURE__ */ React20.createElement(Box19, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1 }, /* @__PURE__ */ React20.createElement(Text19, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React20.createElement(Box19, null, /* @__PURE__ */ React20.createElement(Text19, { dimColor: true }, "You can now use B4M CLI with your account.")));
+    return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1 }, /* @__PURE__ */ React18.createElement(Text17, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, "You can now use B4M CLI with your account.")));
   }
-  return /* @__PURE__ */ React20.createElement(Box19, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1 }, /* @__PURE__ */ React20.createElement(Text19, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1 }, /* @__PURE__ */ React20.createElement(Text19, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React20.createElement(Text19, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1 }, /* @__PURE__ */ React20.createElement(Text19, null, "And enter this code when prompted:")), /* @__PURE__ */ React20.createElement(Box19, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React20.createElement(Text19, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React20.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text19, { color: "cyan" }, /* @__PURE__ */ React20.createElement(Spinner3, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React20.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text19, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
+  return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1 }, /* @__PURE__ */ React18.createElement(Text17, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1 }, /* @__PURE__ */ React18.createElement(Text17, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React18.createElement(Text17, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1 }, /* @__PURE__ */ React18.createElement(Text17, null, "And enter this code when prompted:")), /* @__PURE__ */ React18.createElement(Box17, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React18.createElement(Text17, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text17, { color: "cyan" }, /* @__PURE__ */ React18.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
 }
 
 // src/storage/SessionStore.ts
@@ -3847,16 +3720,8 @@ CORE BEHAVIOR:
 
 FOR SOFTWARE ENGINEERING TASKS:
 When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
-1. **Understand:** Think about the user's request and the relevant codebase context. Use '${TOOL_GREP_SEARCH}' and '${TOOL_GLOB_FILES}' search tools extensively (in parallel if independent) to understand file structures, existing code patterns, and conventions. Use '${TOOL_FILE_READ}' to understand context and validate any assumptions you may have.
-
-   IMPORTANT FILE READING RULES:
-   - Read each file ONCE and refer to it in conversation history instead of re-reading
-   - Read files COMPLETELY by default (without offset/limit parameters)
-   - Only use offset/limit for files that are too large to fit in context (thousands of lines)
-   - If you need to read multiple DIFFERENT files, make multiple parallel calls to '${TOOL_FILE_READ}'
-   - NEVER make multiple calls to read the SAME file with different offsets unless it's truly too large
-
-   When the task involves **complex refactoring, codebase exploration or system-wide analysis**, your **first and primary action** must be to delegate to the '${EXPLORE_SUBAGENT_TYPE}' agent using the '${TOOL_SUBAGENT_DELEGATE}' tool. Use it to build a comprehensive understanding of the code, its structure, and dependencies. For **simple, targeted searches** (like finding a specific function name, file path, or variable declaration), you should use '${TOOL_GREP_SEARCH}' or '${TOOL_GLOB_FILES}' directly.
+1. **Understand:** Think about the user's request and the relevant codebase context. Use '${TOOL_GREP_SEARCH}' and '${TOOL_GLOB_FILES}' search tools extensively (in parallel if independent) to understand file structures, existing code patterns, and conventions. Use '${TOOL_FILE_READ}' to understand context and validate any assumptions you may have. If you need to read multiple files, you should make multiple parallel calls to '${TOOL_FILE_READ}'.
+                   When the task involves **complex refactoring, codebase exploration or system-wide analysis**, your **first and primary action** must be to delegate to the '${EXPLORE_SUBAGENT_TYPE}' agent using the '${TOOL_SUBAGENT_DELEGATE}' tool. Use it to build a comprehensive understanding of the code, its structure, and dependencies. For **simple, targeted searches** (like finding a specific function name, file path, or variable declaration), you should use '${TOOL_GREP_SEARCH}' or '${TOOL_GLOB_FILES}' directly.
 2. **Plan:** Build a coherent and grounded (based on the understanding in step 1) plan for how you intend to resolve the user's task. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
   If '${EXPLORE_SUBAGENT_TYPE}' subagent was used, do not ignore the output of the agent, you must use it as the foundation of your plan. For complex tasks, break them down into smaller, manageable subtasks and use the \`${TOOL_WRITE_TODOS}\` tool to track your progress. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
 3. **Implement:** Use the available tools (e.g., '${TOOL_EDIT_LOCAL_FILE}', '${TOOL_CREATE_FILE}', '${TOOL_BASH_EXECUTE}' ...) to act on the plan, strictly adhering to the project's established conventions.
@@ -9216,7 +9081,7 @@ import { existsSync as existsSync3, statSync as statSync4 } from "fs";
 import path7 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
-  const { path: filePath, encoding = "utf-8", offset = 0, limit } = params;
+  const { path: filePath, encoding = "utf-8", maxLines } = params;
   const normalizedPath = path7.normalize(filePath);
   const resolvedPath = path7.resolve(process.cwd(), normalizedPath);
   const cwd = path7.resolve(process.cwd());
@@ -9238,39 +9103,16 @@ async function readFileContent(params) {
     throw new Error(`File appears to be binary. Use encoding 'base64' to read binary files, or specify a different encoding.`);
   }
   const content = await fs8.readFile(resolvedPath, encoding);
-  if (typeof content === "string") {
+  if (maxLines && typeof content === "string") {
     const lines = content.split("\n");
-    const totalLines = lines.length;
-    if (offset < 0) {
-      throw new Error(`Invalid offset: ${offset}. Offset must be 0 or greater.`);
-    }
-    if (offset >= totalLines) {
-      return `No content to show. File has ${totalLines} lines, but offset is ${offset}.
-(offset is 0-based, so valid range is 0-${Math.max(0, totalLines - 1)})`;
-    }
-    if (limit !== void 0 && limit > 0) {
-      const endLine = Math.min(offset + limit, totalLines);
-      const paginatedContent = lines.slice(offset, endLine).join("\n");
-      if (endLine < totalLines) {
-        const nextOffset = endLine;
-        return `${paginatedContent}
+    if (lines.length > maxLines) {
+      const truncatedContent = lines.slice(0, maxLines).join("\n");
+      return `${truncatedContent}
 
-... Showing lines ${offset + 1}-${endLine} of ${totalLines} total lines (${stats.size} bytes total).
-To read more, use offset: ${nextOffset}`;
-      }
-      return `${paginatedContent}
-
-... Showing lines ${offset + 1}-${endLine} of ${totalLines} total lines (${stats.size} bytes total). End of file reached.`;
+... (truncated: ${lines.length - maxLines} more lines, ${stats.size} bytes total)`;
     }
-    if (offset > 0) {
-      const paginatedContent = lines.slice(offset).join("\n");
-      return `${paginatedContent}
-
-... Showing lines ${offset + 1}-${totalLines} of ${totalLines} total lines (${stats.size} bytes total).`;
-    }
-    return content;
   }
-  return `[Binary content, ${stats.size} bytes, base64 encoded]
+  return typeof content === "string" ? content : `[Binary content, ${stats.size} bytes, base64 encoded]
 ${content}`;
 }
 async function checkIfBinary(filePath) {
@@ -9307,7 +9149,7 @@ var fileReadTool = {
     },
     toolSchema: {
       name: "file_read",
-      description: "Read the contents of a file from the local filesystem. Supports text files with various encodings. Files are restricted to the current working directory and subdirectories for security. IMPORTANT: Read files completely by default (without offset/limit). Only use offset/limit for extremely large files (thousands of lines) that exceed context limits. Never re-read the same file multiple times - refer to previous reads in conversation history instead.",
+      description: "Read the contents of a file from the local filesystem. Supports text files with various encodings. Files are restricted to the current working directory and subdirectories for security.",
       parameters: {
         type: "object",
         properties: {
@@ -9320,13 +9162,9 @@ var fileReadTool = {
             description: "File encoding (default: utf-8). Use base64 for binary files.",
             enum: ["utf-8", "ascii", "base64"]
           },
-          offset: {
+          maxLines: {
             type: "number",
-            description: "OPTIONAL: For text files, the 0-based line number to start reading from. Only use for extremely large files (thousands of lines) that cannot fit in context. Default behavior is to read the entire file, which is preferred for most cases."
-          },
-          limit: {
-            type: "number",
-            description: "OPTIONAL: Maximum number of lines to read from offset. Only use for extremely large files (thousands of lines) that cannot fit in context. Default behavior is to read the entire file, which is preferred for most cases."
+            description: "Maximum number of lines to return (optional). Useful for previewing large files. Returns full file by default."
           }
         },
         required: ["path"]
@@ -11361,7 +11199,7 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
         agentContext.observationQueue.push({ toolName, result: result2 });
         return result2;
       }
-      const { useCliStore: useCliStore2 } = await import("./store-FU6NDC2W.js");
+      const { useCliStore: useCliStore2 } = await import("./store-JNTO6SRG.js");
       if (useCliStore2.getState().autoAcceptEdits) {
         const result2 = await executeTool(toolName, args, apiClient, originalFn);
         agentContext.observationQueue.push({ toolName, result: result2 });
@@ -13036,40 +12874,6 @@ var ServerLlmBackend = class {
   }
 };
 
-// src/llm/NotifyingLlmBackend.ts
-var NotifyingLlmBackend = class {
-  constructor(inner, backgroundManager) {
-    this.inner = inner;
-    this.backgroundManager = backgroundManager;
-  }
-  get currentModel() {
-    return this.inner.currentModel;
-  }
-  set currentModel(model) {
-    this.inner.currentModel = model;
-  }
-  async complete(model, messages, options, callback) {
-    const notifications = this.backgroundManager.drainNotifications();
-    let effectiveMessages = messages;
-    if (notifications.length > 0) {
-      const notificationText = notifications.join("\n\n---\n\n");
-      const notificationMessage = {
-        role: "user",
-        content: `[System Notification]
-
-${notificationText}
-
-Please acknowledge these background agent results and incorporate them into your current work.`
-      };
-      effectiveMessages = [...messages, notificationMessage];
-    }
-    return this.inner.complete(model, effectiveMessages, options, callback);
-  }
-  async getModelInfo() {
-    return this.inner.getModelInfo();
-  }
-};
-
 // src/auth/ApiClient.ts
 import axios11 from "axios";
 var ApiClient = class {
@@ -13207,7 +13011,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.25-feat-cli-multi-agentic-workflow.18573+8959c583b",
+  version: "0.2.25-fix-anthropic-overloaded-fallback.18535+44e7b5760",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13315,10 +13119,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.47.2-feat-cli-multi-agentic-workflow.18573+8959c583b",
-    "@bike4mind/mcp": "1.28.1-feat-cli-multi-agentic-workflow.18573+8959c583b",
-    "@bike4mind/services": "2.45.2-feat-cli-multi-agentic-workflow.18573+8959c583b",
-    "@bike4mind/utils": "2.3.4-feat-cli-multi-agentic-workflow.18573+8959c583b",
+    "@bike4mind/common": "2.47.2-fix-anthropic-overloaded-fallback.18535+44e7b5760",
+    "@bike4mind/mcp": "1.28.1-fix-anthropic-overloaded-fallback.18535+44e7b5760",
+    "@bike4mind/services": "2.45.2-fix-anthropic-overloaded-fallback.18535+44e7b5760",
+    "@bike4mind/utils": "2.3.4-fix-anthropic-overloaded-fallback.18535+44e7b5760",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -13335,7 +13139,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "8959c583b664ae1081979a1b42a778bdf3be2729"
+  gitHead: "44e7b5760cfc839f3777b505abfbac911e341c26"
 };
 
 // src/config/constants.ts
@@ -13933,7 +13737,7 @@ Describe the expected output format here.
 };
 
 // src/agents/delegateTool.ts
-function createAgentDelegateTool(orchestrator, agentStore, parentSessionId, backgroundManager) {
+function createAgentDelegateTool(orchestrator, agentStore, parentSessionId) {
   const agents = agentStore.getAllAgents();
   const agentDescriptions = agents.map((a) => `- **${a.name}**: ${a.description}`).join("\n");
   const agentNames = agentStore.getAgentNames();
@@ -13950,21 +13754,13 @@ function createAgentDelegateTool(orchestrator, agentStore, parentSessionId, back
         const available = agentNames.join(", ");
         throw new Error(`agent_delegate: unknown agent "${params.agent}". Available agents: ${available}`);
       }
-      const spawnOptions = {
+      const result = await orchestrator.delegateToAgent({
         task: params.task,
         agentName: params.agent,
         thoroughness: params.thoroughness,
         variables: params.variables,
         parentSessionId
-      };
-      if (params.run_in_background && backgroundManager) {
-        const jobId = backgroundManager.spawn({
-          ...spawnOptions,
-          groupDescription: params.group_description
-        });
-        return `Background agent started. Job ID: ${jobId}. Use check_agent_status tool with this job ID to retrieve results when ready.`;
-      }
-      const result = await orchestrator.delegateToAgent(spawnOptions);
+      });
       return result.summary;
     },
     toolSchema: {
@@ -14015,14 +13811,6 @@ ${agentDescriptions}
             type: "object",
             additionalProperties: { type: "string" },
             description: 'Custom variables to substitute in agent system prompt. For example: { "DOMAIN": "authentication", "STRICTNESS": "high" }'
-          },
-          run_in_background: {
-            type: "boolean",
-            description: "Run the agent in the background (non-blocking). Returns a job ID immediately. Use check_agent_status to poll for results. Useful for parallel work or long-running tasks."
-          },
-          group_description: {
-            type: "string",
-            description: 'Short description of what this group of background agents is working on (e.g., "Implementing user authentication"). Only needed for the first background agent in a group. All background agents spawned in the same turn are automatically grouped.'
           }
         },
         required: ["task", "agent"]
@@ -14031,399 +13819,6 @@ ${agentDescriptions}
   };
 }
 
-// src/agents/BackgroundAgentManager.ts
-import { randomBytes as randomBytes4 } from "crypto";
-var DEFAULT_MAX_CONCURRENT = 4;
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
-function isTerminalStatus(status) {
-  return TERMINAL_STATUSES.has(status);
-}
-var DEFAULT_MAX_JOB_AGE_MS = 60 * 60 * 1e3;
-var MAX_JOBS_BEFORE_CLEANUP = 100;
-function pluralize(count) {
-  return count === 1 ? "" : "s";
-}
-var BackgroundAgentManager = class {
-  constructor(orchestrator, maxConcurrent = DEFAULT_MAX_CONCURRENT) {
-    this.jobs = /* @__PURE__ */ new Map();
-    this.queue = [];
-    // Job IDs waiting to start
-    this.runningCount = 0;
-    this.onStatusChange = null;
-    this.onGroupCompletion = null;
-    this.pendingNotifications = [];
-    this.turnGroups = /* @__PURE__ */ new Map();
-    this.currentTurnId = null;
-    this.orchestrator = orchestrator;
-    this.maxConcurrent = maxConcurrent;
-  }
-  /**
-   * Set the current turn ID. Jobs spawned while this is set will be grouped.
-   * Call with null to clear (after agent.run() completes).
-   */
-  setCurrentTurn(turnId) {
-    this.currentTurnId = turnId;
-  }
-  /**
-   * Get the current turn ID (for testing/debugging)
-   */
-  getCurrentTurnId() {
-    return this.currentTurnId;
-  }
-  /**
-   * Set a callback that fires whenever a job changes status.
-   * Used to update the Zustand store / UI.
-   */
-  setOnStatusChange(callback) {
-    this.onStatusChange = callback;
-  }
-  /**
-   * Set a callback that fires when all jobs in a turn group complete.
-   * Used to notify the user that background work is done.
-   */
-  setOnGroupCompletion(callback) {
-    this.onGroupCompletion = callback;
-  }
-  /**
-   * Spawn an agent in the background. Returns the job ID immediately.
-   * If concurrency limit is reached, the job is queued and starts when a slot opens.
-   */
-  spawn(options) {
-    const id = `bg-${randomBytes4(4).toString("hex")}`;
-    const abortController = new AbortController();
-    const isQueued = this.runningCount >= this.maxConcurrent;
-    const job = {
-      id,
-      agentName: options.agentName,
-      task: options.task,
-      status: isQueued ? "queued" : "running",
-      startTime: Date.now(),
-      turnId: this.currentTurnId ?? void 0,
-      groupDescription: options.groupDescription
-    };
-    const internal = { job, options, abortController };
-    this.jobs.set(id, internal);
-    this.notifyStatusChange(job);
-    if (this.currentTurnId) {
-      let group = this.turnGroups.get(this.currentTurnId);
-      if (!group) {
-        group = {
-          turnId: this.currentTurnId,
-          description: options.groupDescription,
-          jobIds: [],
-          notifications: []
-        };
-        this.turnGroups.set(this.currentTurnId, group);
-      } else if (options.groupDescription && !group.description) {
-        group.description = options.groupDescription;
-      }
-      group.jobIds.push(id);
-    }
-    if (isQueued) {
-      this.queue.push(id);
-    } else {
-      this.startJob(internal);
-    }
-    return id;
-  }
-  /**
-   * Get a job by ID (public-facing snapshot without internals)
-   */
-  getJob(id) {
-    return this.jobs.get(id)?.job;
-  }
-  /**
-   * Get the full result of a completed job
-   */
-  getResult(id) {
-    return this.jobs.get(id)?.result;
-  }
-  /**
-   * List all jobs (public-facing snapshots)
-   */
-  listJobs() {
-    return Array.from(this.jobs.values()).map((j) => j.job);
-  }
-  /**
-   * Cancel a running or queued job
-   */
-  cancelJob(id) {
-    const internal = this.jobs.get(id);
-    if (!internal) return false;
-    if (internal.job.status === "queued") {
-      this.queue = this.queue.filter((qid) => qid !== id);
-      this.updateJob(id, { status: "cancelled", endTime: Date.now() });
-      return true;
-    }
-    if (internal.job.status === "running") {
-      internal.abortController.abort();
-      this.updateJob(id, { status: "cancelled", endTime: Date.now() });
-      this.runningCount--;
-      this.processQueue();
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Drain all pending notifications (called by the LLM wrapper before each completion).
-   * Returns notification strings and clears the queue.
-   */
-  drainNotifications() {
-    return this.pendingNotifications.splice(0);
-  }
-  /**
-   * Handle job completion - routes to grouped or immediate notification
-   */
-  handleJobCompletion(job, status, content) {
-    if (job.turnId) {
-      const group = this.turnGroups.get(job.turnId);
-      if (group) {
-        group.notifications.push({
-          jobId: job.id,
-          agentName: job.agentName,
-          task: job.task,
-          status,
-          content
-        });
-        this.checkTurnGroupCompletion(job.turnId);
-        return;
-      }
-    }
-    this.pendingNotifications.push(content);
-  }
-  /**
-   * Check if all jobs in a turn group have completed
-   */
-  checkTurnGroupCompletion(turnId) {
-    const group = this.turnGroups.get(turnId);
-    if (!group) return;
-    const allComplete = group.jobIds.every((jobId) => {
-      const internal = this.jobs.get(jobId);
-      return internal && isTerminalStatus(internal.job.status);
-    });
-    if (allComplete) {
-      const notification = this.createConsolidatedNotification(group);
-      this.pendingNotifications.push(notification);
-      if (this.onGroupCompletion) {
-        this.onGroupCompletion(notification, group.description);
-      }
-      this.turnGroups.delete(turnId);
-      this.cleanupOldJobs();
-    }
-  }
-  /**
-   * Create a consolidated notification for a completed turn group
-   */
-  createConsolidatedNotification(group) {
-    const statusCounts = { completed: 0, failed: 0, cancelled: 0 };
-    for (const notification of group.notifications) {
-      statusCounts[notification.status]++;
-    }
-    const total = group.notifications.length;
-    const statsSummary = Object.entries(statusCounts).filter(([, count]) => count > 0).map(([status, count]) => `${count} ${status}`).join(", ");
-    const agentCount = `${total} agent${pluralize(total)} finished`;
-    const header = group.description ? `[Background Agents Completed] "${group.description}" - ${agentCount} (${statsSummary})` : `[Background Agents Completed] ${agentCount} (${statsSummary})`;
-    const details = group.notifications.map((n) => {
-      const statusLabel = n.status.toUpperCase();
-      return `=== Agent "${n.agentName}" (job ${n.jobId}) - ${statusLabel} ===
-Task: ${n.task}
-${n.status === "completed" ? "Result" : "Error"}:
-${n.content}`;
-    }).join("\n\n");
-    return `${header}
-
-${details}`;
-  }
-  startJob(internal) {
-    this.runningCount++;
-    this.updateJob(internal.job.id, { status: "running" });
-    const { job, options } = internal;
-    internal.promise = this.orchestrator.delegateToAgent(options).then((result) => {
-      this.updateJob(job.id, {
-        status: "completed",
-        endTime: Date.now(),
-        resultSummary: result.summary
-      });
-      internal.result = result;
-      this.handleJobCompletion(job, "completed", result.summary);
-      return result;
-    }).catch((error) => {
-      const isCancelled = internal.abortController.signal.aborted;
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      const status = isCancelled ? "cancelled" : "failed";
-      this.updateJob(job.id, {
-        status,
-        endTime: Date.now(),
-        error: errorMsg
-      });
-      this.handleJobCompletion(job, status, errorMsg);
-    }).finally(() => {
-      this.runningCount--;
-      this.processQueue();
-    });
-  }
-  /** Start the next queued job if there's capacity */
-  processQueue() {
-    while (this.queue.length > 0 && this.runningCount < this.maxConcurrent) {
-      const nextId = this.queue.shift();
-      const internal = this.jobs.get(nextId);
-      if (internal && internal.job.status === "queued") {
-        this.startJob(internal);
-      }
-    }
-  }
-  updateJob(id, updates) {
-    const internal = this.jobs.get(id);
-    if (!internal) return;
-    Object.assign(internal.job, updates);
-    this.notifyStatusChange(internal.job);
-  }
-  notifyStatusChange(job) {
-    if (this.onStatusChange) {
-      this.onStatusChange({ ...job });
-    }
-  }
-  /**
-   * Clean up old completed jobs to prevent memory leaks.
-   * Removes jobs that have been in a terminal state for longer than maxAgeMs.
-   * Also removes jobs when total count exceeds MAX_JOBS_BEFORE_CLEANUP.
-   */
-  cleanupOldJobs(maxAgeMs = DEFAULT_MAX_JOB_AGE_MS) {
-    const now = Date.now();
-    let cleanedCount = 0;
-    for (const [id, internal] of this.jobs.entries()) {
-      if (isTerminalStatus(internal.job.status) && internal.job.endTime && now - internal.job.endTime > maxAgeMs) {
-        this.jobs.delete(id);
-        cleanedCount++;
-      }
-    }
-    if (this.jobs.size > MAX_JOBS_BEFORE_CLEANUP) {
-      const completedJobs = Array.from(this.jobs.entries()).filter(([, j]) => isTerminalStatus(j.job.status)).sort((a, b) => (a[1].job.endTime || 0) - (b[1].job.endTime || 0));
-      const toRemove = completedJobs.slice(0, this.jobs.size - MAX_JOBS_BEFORE_CLEANUP + 10);
-      for (const [id] of toRemove) {
-        this.jobs.delete(id);
-        cleanedCount++;
-      }
-    }
-    return cleanedCount;
-  }
-  /**
-   * Get the current number of jobs (for monitoring)
-   */
-  getJobCount() {
-    let running = 0;
-    let queued = 0;
-    let completed = 0;
-    for (const internal of this.jobs.values()) {
-      switch (internal.job.status) {
-        case "running":
-          running++;
-          break;
-        case "queued":
-          queued++;
-          break;
-        default:
-          completed++;
-      }
-    }
-    return { total: this.jobs.size, running, queued, completed };
-  }
-};
-
-// src/agents/backgroundTools.ts
-function createBackgroundAgentTools(manager) {
-  const checkAgentStatus = {
-    toolFn: async (args) => {
-      const { job_id } = args;
-      if (!job_id) throw new Error("check_agent_status: job_id is required");
-      const job = manager.getJob(job_id);
-      if (!job) return `No background agent found with ID: ${job_id}`;
-      switch (job.status) {
-        case "queued":
-          return `Agent "${job.agentName}" is queued (waiting for a concurrency slot). Task: ${job.task}`;
-        case "running": {
-          const elapsed = Math.round((Date.now() - job.startTime) / 1e3);
-          return `Agent "${job.agentName}" is still running (${elapsed}s elapsed). Task: ${job.task}`;
-        }
-        case "completed": {
-          const result = manager.getResult(job_id);
-          return result?.summary || `Agent "${job.agentName}" completed but no summary available.`;
-        }
-        case "failed":
-          return `Agent "${job.agentName}" failed: ${job.error || "Unknown error"}`;
-        case "cancelled":
-          return `Agent "${job.agentName}" was cancelled.`;
-      }
-    },
-    toolSchema: {
-      name: "check_agent_status",
-      description: "Check the status and retrieve results of a background agent job. Use after spawning an agent with run_in_background: true.",
-      parameters: {
-        type: "object",
-        properties: {
-          job_id: {
-            type: "string",
-            description: "The job ID returned by agent_delegate when run_in_background was true"
-          }
-        },
-        required: ["job_id"]
-      }
-    }
-  };
-  const listBackgroundAgents = {
-    toolFn: async () => {
-      const jobs = manager.listJobs();
-      if (jobs.length === 0) return "No background agents.";
-      return jobs.map((job) => {
-        const elapsed = Math.round(((job.endTime || Date.now()) - job.startTime) / 1e3);
-        const statusIcons = {
-          queued: "\u{1F550}",
-          running: "\u23F3",
-          completed: "\u2705",
-          failed: "\u274C",
-          cancelled: "\u{1F6AB}"
-        };
-        const statusIcon = statusIcons[job.status] || "\u2753";
-        return `${statusIcon} [${job.id}] ${job.agentName} (${job.status}, ${elapsed}s) - ${job.task.slice(0, 80)}`;
-      }).join("\n");
-    },
-    toolSchema: {
-      name: "list_background_agents",
-      description: "List all background agent jobs with their current status.",
-      parameters: {
-        type: "object",
-        properties: {}
-      }
-    }
-  };
-  const cancelBackgroundAgent = {
-    toolFn: async (args) => {
-      const { job_id } = args;
-      if (!job_id) throw new Error("cancel_background_agent: job_id is required");
-      const cancelled = manager.cancelJob(job_id);
-      if (cancelled) return `Background agent ${job_id} has been cancelled.`;
-      const job = manager.getJob(job_id);
-      if (!job) return `No background agent found with ID: ${job_id}`;
-      return `Cannot cancel agent ${job_id} - status is already "${job.status}".`;
-    },
-    toolSchema: {
-      name: "cancel_background_agent",
-      description: "Cancel a running background agent job.",
-      parameters: {
-        type: "object",
-        properties: {
-          job_id: {
-            type: "string",
-            description: "The job ID of the background agent to cancel"
-          }
-        },
-        required: ["job_id"]
-      }
-    }
-  };
-  return [checkAgentStatus, listBackgroundAgents, cancelBackgroundAgent];
-}
-
 // src/tools/skillTool.ts
 async function executeHook(script, context) {
   const result = await runShellCommand({
@@ -14798,7 +14193,7 @@ var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
   const imageRenderer = new ImageRenderer();
-  const [state, setState] = useState9({
+  const [state, setState] = useState8({
     session: null,
     sessionStore: new SessionStore(),
     configStore: new ConfigStore(),
@@ -14818,20 +14213,18 @@ function CliApp() {
     orchestrator: null,
     agentStore: null,
     abortController: null,
-    contextContent: "",
-    backgroundManager: null
+    contextContent: ""
   });
-  const [isInitialized, setIsInitialized] = useState9(false);
-  const [initError, setInitError] = useState9(null);
-  const [commandHistory, setCommandHistory] = useState9([]);
+  const [isInitialized, setIsInitialized] = useState8(false);
+  const [initError, setInitError] = useState8(null);
+  const [commandHistory, setCommandHistory] = useState8([]);
   const imageStoreInitPromise = useRef3(null);
   const setStoreSession = useCliStore((state2) => state2.setSession);
-  const enqueuePermissionPrompt = useCliStore((state2) => state2.enqueuePermissionPrompt);
-  const dequeuePermissionPrompt = useCliStore((state2) => state2.dequeuePermissionPrompt);
+  const setPermissionPrompt = useCliStore((state2) => state2.setPermissionPrompt);
   const setShowConfigEditor = useCliStore((state2) => state2.setShowConfigEditor);
   const setShowMcpViewer = useCliStore((state2) => state2.setShowMcpViewer);
   const setExitRequested = useCliStore((state2) => state2.setExitRequested);
-  const performCleanup = useCallback2(async () => {
+  const performCleanup = useCallback(async () => {
     const cleanupTasks = [];
     if (state.session) {
       cleanupTasks.push(
@@ -14866,7 +14259,7 @@ function CliApp() {
       process.exit(0);
     }, 100);
   }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
-  useInput9((input, key) => {
+  useInput8((input, key) => {
     if (key.escape) {
       if (state.abortController) {
         logger.debug("[ABORT] ESC pressed - aborting current operation...");
@@ -14898,7 +14291,7 @@ function CliApp() {
       }
     }
   });
-  const init = useCallback2(async () => {
+  const init = useCallback(async () => {
     try {
       const config = await state.configStore.load();
       const history = await state.commandHistoryStore.load();
@@ -15015,17 +14408,16 @@ function CliApp() {
         config.tools.disabled || []
         // denied tools from project config
       );
-      let permissionPromptCounter = 0;
       const promptFn = (toolName, args, preview) => {
         return new Promise((resolve3) => {
           const canBeTrusted = permissionManager.canBeTrusted(toolName);
-          const id = `perm-${++permissionPromptCounter}`;
-          const prompt = { id, toolName, args, preview, canBeTrusted, resolve: resolve3 };
+          const prompt = { toolName, args, preview, canBeTrusted, resolve: resolve3 };
           setState((prev) => ({
             ...prev,
-            permissionManager
+            permissionManager,
+            permissionPrompt: prompt
           }));
-          enqueuePermissionPrompt(prompt);
+          setPermissionPrompt(prompt);
         });
       };
       const agentContext = {
@@ -15071,17 +14463,7 @@ function CliApp() {
         agentStore,
         enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
       });
-      const backgroundManager = new BackgroundAgentManager(orchestrator);
-      backgroundManager.setOnStatusChange((job) => {
-        useCliStore.getState().upsertBackgroundAgent(job);
-      });
-      backgroundManager.setOnGroupCompletion((notification, groupDescription) => {
-        useCliStore.getState().addCompletedGroupNotification(notification, groupDescription);
-        useCliStore.getState().setPendingBackgroundTrigger(true);
-      });
-      const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id, backgroundManager);
-      const backgroundTools = createBackgroundAgentTools(backgroundManager);
-      const notifyingLlm = new NotifyingLlmBackend(llm, backgroundManager);
+      const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id);
       const todoStore = createTodoStore();
       const writeTodosTool = createWriteTodosTool(todoStore);
       const enableSkillTool = config.preferences.enableSkillTool !== false;
@@ -15090,14 +14472,13 @@ function CliApp() {
         subagentOrchestrator: orchestrator,
         sessionId: newSession.id
       }) : null;
-      const cliTools = [agentDelegateTool, ...backgroundTools, writeTodosTool];
+      const cliTools = [agentDelegateTool, writeTodosTool];
       if (skillTool) {
         cliTools.push(skillTool);
       }
       const allTools = [...b4mTools2, ...mcpTools, ...cliTools];
       console.log(`\u{1F4C2} Working directory: ${process.cwd()}`);
-      const agentNamesList = agentStore.getAgentNames().join(", ");
-      console.log(`\u{1F916} Subagent delegation enabled (${agentNamesList}) + background execution`);
+      console.log(`\u{1F916} Subagent delegation enabled (explore, plan, review)`);
       if (skillTool) {
         const skillCount = state.customCommandStore.getCommandCount();
         if (skillCount > 0) {
@@ -15134,7 +14515,7 @@ ${contextResult.mergedContent}` : "";
       const agent = new ReActAgent({
         userId: config.userId,
         logger: silentLogger,
-        llm: notifyingLlm,
+        llm,
         model: modelInfo.id,
         tools: allTools,
         maxIterations,
@@ -15186,10 +14567,8 @@ ${contextResult.mergedContent}` : "";
         // Store orchestrator for step handler updates
         agentStore,
         // Store agent store for agent management commands
-        contextContent: contextResult.mergedContent,
+        contextContent: contextResult.mergedContent
         // Store raw context for compact instructions
-        backgroundManager
-        // Store for grouped notification turn tracking
       }));
       setStoreSession(newSession);
       setIsInitialized(true);
@@ -15203,11 +14582,11 @@ ${contextResult.mergedContent}` : "";
     setCommandHistory,
     setIsInitialized,
     setInitError,
-    enqueuePermissionPrompt,
+    setPermissionPrompt,
     setStoreSession,
     setState
   ]);
-  useEffect6(() => {
+  useEffect4(() => {
     init();
   }, [init]);
   const handleCustomCommandMessage = async (fullTemplate, displayMessage) => {
@@ -15283,19 +14662,12 @@ ${contextResult.mergedContent}` : "";
         content: msg.content
       }));
       const cliConfig = await state.configStore.get();
-      const turnId = `turn-${randomBytes5(4).toString("hex")}`;
-      state.backgroundManager?.setCurrentTurn(turnId);
-      let result;
-      try {
-        result = await state.agent.run(messageContent, {
-          previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-          signal: abortController.signal,
-          parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
-          isReadOnlyTool
-        });
-      } finally {
-        state.backgroundManager?.setCurrentTurn(null);
-      }
+      const result = await state.agent.run(messageContent, {
+        previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
+        signal: abortController.signal,
+        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
+        isReadOnlyTool
+      });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
         console.log("\n\u26A0\uFE0F  Action denied by user\n");
@@ -15496,19 +14868,12 @@ ${contextResult.mergedContent}` : "";
         content: msg.content
       }));
       const cliConfig = await state.configStore.get();
-      const turnId = `turn-${randomBytes5(4).toString("hex")}`;
-      state.backgroundManager?.setCurrentTurn(turnId);
-      let result;
-      try {
-        result = await state.agent.run(messageContent, {
-          previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-          signal: abortController.signal,
-          parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
-          isReadOnlyTool
-        });
-      } finally {
-        state.backgroundManager?.setCurrentTurn(null);
-      }
+      const result = await state.agent.run(messageContent, {
+        previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
+        signal: abortController.signal,
+        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
+        isReadOnlyTool
+      });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
         console.log("\n\u26A0\uFE0F  Action denied by user\n");
@@ -15584,88 +14949,7 @@ ${contextResult.mergedContent}` : "";
       useCliStore.getState().setIsThinking(false);
     }
   };
-  const handleBackgroundCompletion = async () => {
-    if (!state.agent || !state.session) {
-      return;
-    }
-    const authTokens = await state.configStore.getAuthTokens();
-    if (!authTokens || new Date(authTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
-      return;
-    }
-    useCliStore.getState().setIsThinking(true);
-    const abortController = new AbortController();
-    setState((prev) => ({ ...prev, abortController }));
-    try {
-      const pendingAssistantMessage = {
-        id: uuidv411(),
-        role: "assistant",
-        content: "...",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        metadata: {
-          steps: []
-        }
-      };
-      useCliStore.getState().addPendingMessage(pendingAssistantMessage);
-      const recentMessages = state.session.messages.slice(-20);
-      const previousMessages = recentMessages.filter((msg) => msg.role === "user" || msg.role === "assistant").map((msg) => ({
-        role: msg.role,
-        content: msg.content
-      }));
-      const cliConfig = await state.configStore.get();
-      const result = await state.agent.run(
-        "[System: Background agents have completed. Review and summarize the results.]",
-        {
-          previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-          signal: abortController.signal,
-          parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
-          isReadOnlyTool
-        }
-      );
-      const successfulToolCalls = result.steps.filter((s) => s.type === "observation").length;
-      const currentSession = useCliStore.getState().session;
-      if (!currentSession) return;
-      const continuationMessage = {
-        id: uuidv411(),
-        role: "assistant",
-        content: "---\n\n**Background Agent Results:**\n\n" + result.finalAnswer,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        metadata: {
-          isContinuation: true,
-          // Flag to skip "Assistant" header in MessageItem
-          steps: result.steps.map(formatStep),
-          tokenUsage: {
-            prompt: 0,
-            completion: 0,
-            total: result.completionInfo.totalTokens
-          }
-        }
-      };
-      const updatedSession = {
-        ...currentSession,
-        messages: [...currentSession.messages, continuationMessage],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        metadata: {
-          ...currentSession.metadata,
-          totalTokens: currentSession.metadata.totalTokens + result.completionInfo.totalTokens,
-          toolCallCount: currentSession.metadata.toolCallCount + successfulToolCalls
-        }
-      };
-      useCliStore.getState().clearPendingMessages();
-      setState((prev) => ({ ...prev, session: updatedSession }));
-      setStoreSession(updatedSession);
-      await state.sessionStore.save(updatedSession);
-    } catch (error) {
-      useCliStore.getState().clearPendingMessages();
-      if (error instanceof Error && error.name === "AbortError") {
-        return;
-      }
-      console.error("Error processing background results:", error);
-    } finally {
-      setState((prev) => ({ ...prev, abortController: null }));
-      useCliStore.getState().setIsThinking(false);
-    }
-  };
-  const handleBashCommand = useCallback2(
+  const handleBashCommand = useCallback(
     (command) => {
       if (!state.session) return;
       let output;
@@ -16640,12 +15924,12 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     }
   };
   if (initError) {
-    return /* @__PURE__ */ React21.createElement(Box20, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React21.createElement(Text20, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React21.createElement(Text20, null, initError), /* @__PURE__ */ React21.createElement(Text20, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
+    return /* @__PURE__ */ React19.createElement(Box18, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React19.createElement(Text18, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React19.createElement(Text18, null, initError), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
   }
   if (state.trustLocationSelector) {
     const projectDir = state.configStore.getProjectConfigDir();
     const inProject = projectDir !== null;
-    return /* @__PURE__ */ React21.createElement(
+    return /* @__PURE__ */ React19.createElement(
       TrustLocationSelector,
       {
         inProject,
@@ -16663,7 +15947,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (state.rewindSelector && state.session) {
-    return /* @__PURE__ */ React21.createElement(
+    return /* @__PURE__ */ React19.createElement(
       RewindSelector,
       {
         messages: state.session.messages,
@@ -16681,7 +15965,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (state.sessionSelector) {
-    return /* @__PURE__ */ React21.createElement(
+    return /* @__PURE__ */ React19.createElement(
       SessionSelector,
       {
         sessions: state.sessionSelector.sessions,
@@ -16701,7 +15985,7 @@ No usage data available for the last ${USAGE_DAYS} days.`);
   }
   if (state.showLoginFlow) {
     const loginApiUrl = getApiUrl(state.config?.apiConfig);
-    return /* @__PURE__ */ React21.createElement(
+    return /* @__PURE__ */ React19.createElement(
       LoginFlow,
       {
         apiUrl: loginApiUrl,
@@ -16724,14 +16008,13 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (!isInitialized) {
-    return /* @__PURE__ */ React21.createElement(Box20, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React21.createElement(Text20, null, "\u{1F680} Initializing..."));
+    return /* @__PURE__ */ React19.createElement(Box18, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React19.createElement(Text18, null, "\u{1F680} Initializing..."));
   }
   const allCommands = mergeCommands(state.customCommandStore.getAllCommands());
-  return /* @__PURE__ */ React21.createElement(
+  return /* @__PURE__ */ React19.createElement(
     App,
     {
       onMessage: handleMessage,
-      onBackgroundCompletion: handleBackgroundCompletion,
       onCommand: handleCommand,
       onBashCommand: handleBashCommand,
       onImageDetected: handleImageDetected,
@@ -16746,10 +16029,10 @@ No usage data available for the last ${USAGE_DAYS} days.`);
       },
       mcpManager: state.mcpManager ?? void 0,
       onPermissionResponse: (response) => {
-        const currentPrompt = useCliStore.getState().permissionPrompt;
-        if (currentPrompt) {
-          currentPrompt.resolve({ action: response });
-          dequeuePermissionPrompt();
+        if (state.permissionPrompt) {
+          state.permissionPrompt.resolve({ action: response });
+          setState((prev) => ({ ...prev, permissionPrompt: null }));
+          setPermissionPrompt(null);
         }
       }
     }
@@ -16770,6 +16053,6 @@ var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "d
 if (isDevMode) {
   logger.debug("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
-render(/* @__PURE__ */ React21.createElement(CliApp, null), {
+render(/* @__PURE__ */ React19.createElement(CliApp, null), {
   exitOnCtrlC: false
 });