fluxflow-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,2781 @@
+#!/usr/bin/env node
+
+// src/cli.jsx
+import React9 from "react";
+import { render } from "ink";
+
+// src/app.jsx
+import React8, { useState as useState4, useEffect as useEffect3, useRef, useMemo } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput3, useStdout, Static } from "ink";
+import { MultilineInput } from "ink-multiline-input";
+import TextInput2 from "ink-text-input";
+
+// src/components/ChatLayout.jsx
+import React2 from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/components/TerminalBox.jsx
+import React from "react";
+import { Box, Text } from "ink";
+var TerminalBox = ({ command, output, completed = false }) => {
+  const cleanOutput = (output || "").replace(/\r/g, "").trim();
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: completed ? "#334155" : "cyan", paddingX: 2, paddingY: completed ? 0 : 1, width: "100%" }, /* @__PURE__ */ React.createElement(Box, { justifyContent: "space-between" }, /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: completed ? "gray" : "cyan", bold: true }, completed ? "\u{1F3C1} FINISHED:" : "\u26A1 EXECUTING:", " "), /* @__PURE__ */ React.createElement(Text, { color: completed ? "gray" : "white" }, command)), /* @__PURE__ */ React.createElement(Text, { color: completed ? "#475569" : "yellow", bold: true }, completed ? "\u25CF ARCHIVED" : "\u25CF LIVE")), cleanOutput ? /* @__PURE__ */ React.createElement(Box, { marginTop: completed ? 0 : 1, backgroundColor: "#0a0a0a", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { color: completed ? "gray" : "green", wrap: "anywhere" }, cleanOutput)) : !completed && /* @__PURE__ */ React.createElement(Box, { marginTop: 1, backgroundColor: "#0a0a0a", paddingX: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", italic: true }, "Waiting for output...")), !completed && /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true, italic: true }, "Double-press ESC to terminate if hanging.")));
+};
+
+// src/components/ChatLayout.jsx
+var cleanSignals = (text) => {
+  if (!text) return text;
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    const trigger = "tool:functions.";
+    if (text.substring(i, i + trigger.length).toLowerCase() === trigger) {
+      let balance = 0;
+      let foundStart = false;
+      let j = i;
+      while (j < text.length) {
+        if (text[j] === "(") {
+          balance++;
+          foundStart = true;
+        } else if (text[j] === ")") {
+          balance--;
+        }
+        j++;
+        if (foundStart && balance === 0) break;
+      }
+      i = j;
+    } else {
+      result += text[i];
+      i++;
+    }
+  }
+  return result.replace(/^\[TOOL_RESULT\]:\s*/gi, "").split("\n").filter((line) => !line.trim().startsWith("SUCCESS:") && !line.trim().startsWith("ERROR:")).join("\n").replace(/\[\s*(turn\s*:)?\s*(continue|finish)\s*\]/gi, "").replace(/\n\s*turn\s*:\s*(continue|finish)\s*$/gi, "").replace(/\n\nResponded on .*/g, "").replace(/\n\n\[Prompted on: .*\]/g, "").trim();
+};
+var formatThinkText = (text) => {
+  const cleaned = cleanSignals(text);
+  if (!cleaned) return null;
+  const lines = cleaned.split("\n").filter((l) => l.trim() !== "");
+  return lines.map((line, i) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("**") && trimmed.endsWith("**") || trimmed.startsWith("#")) {
+      return /* @__PURE__ */ React2.createElement(Box2, { key: i, marginTop: i === 0 ? 0 : 1, marginBottom: 0 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, trimmed.replace(/\*|#/g, "").trim()));
+    }
+    const isBullet = trimmed.startsWith("*");
+    return /* @__PURE__ */ React2.createElement(Box2, { key: i, marginLeft: isBullet ? 2 : 0 }, /* @__PURE__ */ React2.createElement(Text2, { italic: true, color: "gray", wrap: "anywhere" }, isBullet ? "\u2022 " : "", trimmed.replace(/^\*|\s\*/g, "").trim()));
+  });
+};
+var CodeRenderer = ({ text }) => {
+  if (!text) return null;
+  if (text.includes("[DIFF_START]")) {
+    const beforeDiff = text.substring(0, text.indexOf("[DIFF_START]")).trim();
+    const afterDiff = text.substring(text.indexOf("[DIFF_END]") + 10).trim();
+    const match = text.match(/\[DIFF_START\]([\s\S]*?)\[DIFF_END\]/);
+    const diffBody = match ? match[1].trim() : "";
+    const diffLines = diffBody.split("\n");
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", width: "100%" }, beforeDiff && /* @__PURE__ */ React2.createElement(MarkdownText, { text: beforeDiff }), /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1, backgroundColor: "#1a1a1a", paddingY: 0 }, diffLines.map((line, i) => {
+      const isContext = line.includes("[UI_CONTEXT]");
+      const cleanLine = line.replace("[UI_CONTEXT]", "");
+      const isRemoval = cleanLine.startsWith("-");
+      const isAddition = cleanLine.startsWith("+");
+      const parts = cleanLine.substring(1).split("|");
+      const lineNum = parts[0]?.trim() || "";
+      const content = parts.slice(1).join("|");
+      const bgColor = isRemoval ? "#3a0c0c" : isAddition ? "#0c3a1a" : "#1a1a1a";
+      const textColor = isRemoval ? "#ff4d4d" : isAddition ? "#4dff88" : "white";
+      return /* @__PURE__ */ React2.createElement(Box2, { key: i, backgroundColor: bgColor, paddingX: 1 }, /* @__PURE__ */ React2.createElement(Box2, { width: 5, flexShrink: 0 }, /* @__PURE__ */ React2.createElement(Text2, { color: isRemoval ? "#cf3a3a" : isAddition ? "#3acf65" : "gray", dimColor: true }, lineNum)), /* @__PURE__ */ React2.createElement(Box2, { width: 2, flexShrink: 0, marginLeft: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: textColor, bold: true }, isRemoval ? "-" : isAddition ? "+" : " ")), /* @__PURE__ */ React2.createElement(Box2, { flexGrow: 1, marginLeft: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: textColor, wrap: "anywhere" }, content)));
+    })), afterDiff && /* @__PURE__ */ React2.createElement(MarkdownText, { text: afterDiff }));
+  }
+  if (text.includes("```")) {
+    const parts = text.split(/(```[\s\S]*?```)/g);
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", width: "100%" }, parts.map((part, i) => {
+      if (part.startsWith("```") && part.endsWith("```")) {
+        const match = part.match(/```(\w*)\n([\s\S]*?)```/);
+        const lang = match ? match[1] : "code";
+        const code = match ? match[2] : part.slice(3, -3);
+        return /* @__PURE__ */ React2.createElement(Box2, { key: i, flexDirection: "column", marginY: 1, backgroundColor: "#111", borderStyle: "round", borderColor: "#333", paddingX: 1 }, /* @__PURE__ */ React2.createElement(Box2, { alignSelf: "flex-end", marginTop: -1, marginRight: 1 }, /* @__PURE__ */ React2.createElement(Text2, { backgroundColor: "#333", color: "white" }, " ", lang.toUpperCase(), " ")), /* @__PURE__ */ React2.createElement(Box2, { paddingY: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", wrap: "anywhere" }, code.trim())));
+      }
+      return /* @__PURE__ */ React2.createElement(MarkdownText, { key: i, text: part });
+    }));
+  }
+  return /* @__PURE__ */ React2.createElement(MarkdownText, { text });
+};
+var MarkdownText = ({ text, color = "white" }) => {
+  const cleaned = cleanSignals(text);
+  if (!cleaned) return null;
+  const lines = cleaned.split("\n");
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", width: "100%" }, lines.map((line, i) => {
+    const trimmed = line.trim();
+    if (trimmed === "---" || trimmed === "***" || trimmed === "___") {
+      return /* @__PURE__ */ React2.createElement(Box2, { key: i, marginY: 1, borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, width: "100%", borderColor: "#333" });
+    }
+    const headingMatch = trimmed.match(/^(#{1,3})\s+(.*)/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const hText = headingMatch[2];
+      return /* @__PURE__ */ React2.createElement(Box2, { key: i, marginTop: 1, marginBottom: 0 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: level === 1 ? "cyan" : level === 2 ? "magenta" : "yellow", underline: true }, hText.toUpperCase()));
+    }
+    const isUnordered = trimmed.startsWith("* ") || trimmed.startsWith("- ");
+    const isOrdered = /^\d+\.\s/.test(trimmed);
+    let content = trimmed;
+    if (isUnordered || isOrdered) {
+      content = (isUnordered ? "  \u2022 " : "") + trimmed.replace(/^[\*\-\d+\.]+\s/, "");
+    }
+    const parts = content.split(/(\*\*.*?\*\*|\*.*?\*|`.*?`)/g);
+    return /* @__PURE__ */ React2.createElement(Text2, { key: i, color, wrap: "anywhere" }, parts.map((part, j) => {
+      if (part.startsWith("**") && part.endsWith("**")) {
+        return /* @__PURE__ */ React2.createElement(Text2, { key: j, bold: true, color: "white" }, part.slice(2, -2));
+      }
+      if (part.startsWith("*") && part.endsWith("*")) {
+        return /* @__PURE__ */ React2.createElement(Text2, { key: j, italic: true, color: "gray" }, part.slice(1, -1));
+      }
+      if (part.startsWith("`") && part.endsWith("`")) {
+        return /* @__PURE__ */ React2.createElement(Text2, { key: j, color: "cyan", backgroundColor: "#003333" }, " ", part.slice(1, -1), " ");
+      }
+      return part;
+    }));
+  }));
+};
+function ChatLayout({ messages, showFullThinking }) {
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", width: "100%" }, messages.map((msg, idx) => {
+    const isDiffResult = msg.role === "system" && msg.text.includes("[DIFF_START]");
+    const isTerminalRecord = msg.isTerminalRecord;
+    if (msg.role === "system" && msg.text.includes("[TOOL_RESULT]") && !isDiffResult && !isTerminalRecord) return null;
+    if (isTerminalRecord) {
+      const cmdMatch = msg.text.match(/COMMAND: (.*)\n/);
+      const outputMatch = msg.text.match(/OUTPUT: ([\s\S]*)$/);
+      const cmd = cmdMatch ? cmdMatch[1] : "Unknown";
+      const outputList = outputMatch ? outputMatch[1] : "";
+      return /* @__PURE__ */ React2.createElement(Box2, { key: idx, marginBottom: 1, paddingX: 1, width: "100%" }, /* @__PURE__ */ React2.createElement(TerminalBox, { command: cmd, output: outputList, completed: true }));
+    }
+    let color = "white";
+    let content = cleanSignals(msg.text);
+    if (msg.role === "think" && !showFullThinking) {
+      content = content.split("\n").filter((line) => {
+        const trimmed = line.trim();
+        const isHeading = trimmed.startsWith("# ");
+        const isActionStep = trimmed.startsWith("**") && trimmed.endsWith("**");
+        return isHeading || isActionStep;
+      }).join("\n");
+      if (!content.trim()) content = "*Reasoning...*";
+    }
+    return /* @__PURE__ */ React2.createElement(Box2, { key: idx, marginBottom: 1, flexDirection: "column", flexShrink: 0, width: "100%" }, msg.role === "user" ? /* @__PURE__ */ React2.createElement(
+      Box2,
+      {
+        backgroundColor: "#262626",
+        paddingX: 1,
+        paddingY: 1,
+        width: "100%",
+        flexDirection: "column"
+      },
+      content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\\\n/g, "\n").replace(/\\$/, "").split("\n").map((line, lineIdx) => /* @__PURE__ */ React2.createElement(Box2, { key: lineIdx, flexDirection: "row" }, /* @__PURE__ */ React2.createElement(Box2, { flexShrink: 0, width: 2 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, lineIdx === 0 ? "\u276F" : " ")), /* @__PURE__ */ React2.createElement(Box2, { flexGrow: 1, marginLeft: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: msg.color || "white", wrap: "anywhere" }, line))))
+    ) : msg.role === "think" ? /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "white" }, "Thinking..."), /* @__PURE__ */ React2.createElement(Box2, { borderStyle: "single", borderLeft: true, borderRight: false, borderTop: false, borderBottom: false, paddingLeft: 2, flexDirection: "column" }, formatThinkText(content))) : /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", paddingX: 1, marginTop: 1 }, /* @__PURE__ */ React2.createElement(CodeRenderer, { text: content }), msg.memoryUpdated && /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "yellow", italic: true }, "\u2728 [Memory Updated]"))));
+  }));
+}
+
+// src/components/StatusBar.jsx
+import React3 from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+function StatusBar({ mode, thinkingLevel, tokens = "0.0k", chatId = "NEW-SESSION", isMemoryEnabled = true }) {
+  const modeColor = mode === "Flux" ? "yellow" : "cyan";
+  const modeIcon = mode === "Flux" ? "\u26A1" : "\u{1F30A}";
+  const memStatus = isMemoryEnabled ? "ON" : "OFF";
+  return /* @__PURE__ */ React3.createElement(
+    Box3,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      flexDirection: "row",
+      justifyContent: "space-between",
+      paddingX: 1,
+      width: "100%"
+    },
+    /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: modeColor, bold: true }, modeIcon, " ", mode.toUpperCase()), /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, " \u2502 "), /* @__PURE__ */ React3.createElement(Text3, { color: "magenta" }, "\u{1F9E0} ", thinkingLevel)),
+    /* @__PURE__ */ React3.createElement(Box3, { flexGrow: 1, justifyContent: "center", paddingX: 2 }, /* @__PURE__ */ React3.createElement(Text3, { color: "gray", dimColor: true }, "\u{1F4C1} "), /* @__PURE__ */ React3.createElement(Text3, { color: "blue", dimColor: true, italic: true }, process.cwd())),
+    /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, "MEM: "), /* @__PURE__ */ React3.createElement(Text3, { color: memStatus === "ON" ? "green" : "red" }, memStatus), /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, " \u2502 "), /* @__PURE__ */ React3.createElement(Text3, { color: "blue" }, " Tokens ", tokens > 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : tokens, " (", Math.round(tokens / 128e3 * 100), "%)"), /* @__PURE__ */ React3.createElement(Text3, { color: "gray" }, " \u2502 "), /* @__PURE__ */ React3.createElement(Text3, { color: "dim" }, "ID: ", chatId, " "))
+  );
+}
+
+// src/components/CommandMenu.jsx
+import React4 from "react";
+import { Box as Box4, Text as Text4 } from "ink";
+import SelectInput from "ink-select-input";
+var CustomItem = ({ label, isSelected }) => {
+  const isCancel = label === "Cancel" || label.toLowerCase().includes("exit");
+  return /* @__PURE__ */ React4.createElement(Box4, { marginTop: isCancel ? 1 : 0 }, /* @__PURE__ */ React4.createElement(Text4, { color: isSelected ? "cyan" : "white" }, isSelected ? "\u276F " : "  ", label));
+};
+function CommandMenu({ title, items, onSelect }) {
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", padding: 1, marginTop: 1, flexShrink: 0 }, /* @__PURE__ */ React4.createElement(Text4, { color: "magenta", bold: true }, title), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React4.createElement(
+    SelectInput,
+    {
+      items,
+      onSelect,
+      itemComponent: CustomItem,
+      indicatorComponent: () => null
+    }
+  )), /* @__PURE__ */ React4.createElement(Text4, { color: "gray", dimColor: true, marginTop: 1 }, "(Use Up/Down arrows to select, Enter to confirm)"));
+}
+
+// src/components/ProfileForm.jsx
+import React5, { useState } from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import TextInput from "ink-text-input";
+function ProfileForm({ onSave, onCancel }) {
+  const [step, setStep] = useState(0);
+  const [currentInput, setCurrentInput] = useState("");
+  const [profile, setProfile] = useState({ name: "", nickname: "", instructions: "" });
+  const steps = [
+    { key: "name", label: "Enter your Name: " },
+    { key: "nickname", label: "Enter a Nickname (Agent will use this): " },
+    { key: "instructions", label: "System Instructions (Persona overrides): " }
+  ];
+  const handleSubmit = (val) => {
+    const currentKey = steps[step].key;
+    const newProfile = { ...profile, [currentKey]: val.trim() };
+    setProfile(newProfile);
+    setCurrentInput("");
+    if (step < steps.length - 1) {
+      setStep(step + 1);
+    } else {
+      onSave(newProfile);
+    }
+  };
+  return /* @__PURE__ */ React5.createElement(Box5, { borderStyle: "round", borderColor: "magenta", padding: 1, marginTop: 1, flexShrink: 0, flexDirection: "column" }, /* @__PURE__ */ React5.createElement(Text5, { color: "magenta", bold: true }, "\u{1F464} Edit Profile Configuration"), /* @__PURE__ */ React5.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, steps[step].label), /* @__PURE__ */ React5.createElement(
+    TextInput,
+    {
+      value: currentInput,
+      onChange: setCurrentInput,
+      onSubmit: handleSubmit
+    }
+  )), /* @__PURE__ */ React5.createElement(Text5, { color: "gray", dimColor: true, marginTop: 1 }, "(Press Enter to submit, type /cancel to abort)"));
+}
+
+// src/app.jsx
+import gradient from "gradient-string";
+
+// src/utils/secrets.js
+import fs2 from "fs-extra";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/crypto.js
+import fs from "fs";
+import path from "path";
+var XOR_KEY = 66;
+var xorTransform = (data) => {
+  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  const result = Buffer.alloc(buffer.length);
+  for (let i = 0; i < buffer.length; i++) {
+    result[i] = buffer[i] ^ XOR_KEY;
+  }
+  return result;
+};
+var readEncryptedJson = (filePath, defaultValue = {}) => {
+  try {
+    if (!fs.existsSync(filePath)) return defaultValue;
+    const encryptedData = fs.readFileSync(filePath);
+    const decryptedData = xorTransform(encryptedData).toString();
+    return JSON.parse(decryptedData);
+  } catch (err) {
+    console.error(`Vault Read Error [${path.basename(filePath)}]:`, err.message);
+    return defaultValue;
+  }
+};
+var writeEncryptedJson = (filePath, data) => {
+  try {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const jsonData = JSON.stringify(data, null, 2);
+    const encryptedData = xorTransform(jsonData);
+    fs.writeFileSync(filePath, encryptedData);
+  } catch (err) {
+    console.error(`Vault Write Error [${path.basename(filePath)}]:`, err.message);
+  }
+};
+
+// src/utils/secrets.js
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+var AGENT_ROOT = path2.join(__dirname, "../../");
+var SECRET_DIR = path2.join(AGENT_ROOT, "secret");
+var SECRET_FILE = path2.join(SECRET_DIR, "secrets.json");
+var getAPIKey = async () => {
+  try {
+    const secrets = readEncryptedJson(SECRET_FILE, {});
+    if (secrets.API_KEY) return secrets.API_KEY;
+  } catch (e) {
+  }
+  return null;
+};
+var saveSecret = async (key, value) => {
+  await fs2.ensureDir(SECRET_DIR);
+  let current = readEncryptedJson(SECRET_FILE, {});
+  current[key] = value;
+  writeEncryptedJson(SECRET_FILE, current);
+};
+var saveAPIKey = async (apiKey) => saveSecret("API_KEY", apiKey);
+var removeSecret = async (key) => {
+  try {
+    const secrets = readEncryptedJson(SECRET_FILE, {});
+    delete secrets[key];
+    writeEncryptedJson(SECRET_FILE, secrets);
+  } catch (e) {
+  }
+};
+var removeAPIKey = async () => removeSecret("API_KEY");
+
+// src/utils/ai.js
+import { GoogleGenAI, ThinkingLevel } from "@google/genai";
+
+// src/data/main_tools.js
+var TOOL_PROTOCOL = (mode) => `
+-- START FUNCTION CALLING PROTOCOL --
+You have access to internal tools. To call a tool, you MUST use the following exact syntax on a new line:
+tool:functions.tool_name(arguments)
+
+- WEB TOOLS (Available in Flux & Flow) -
+    1. Web Search: tool:functions.web_search(query="<query>", limit=number). Find info. limit is optional (3-10, default 10). If user asks about something that is not in your training data, proactively use this tool to find the information.Winder search recomemded (limit = 10) when exploring a topic.
+    2. Web Scrape: tool:functions.web_scrape(url="<url>"). provides detail from a URL.
+${mode === "Flux" ? `
+- DEV & FILE TOOLS (Available in FLUX MODE ONLY) -
+    1. View File: tool:functions.view_file(path="relative/path", start_line=number, end_line=number). Reads file content.
+    2. List Files: tool:functions.list_files(path="relative/path"). Lists content of a directory.
+    3. Read Folder: tool:functions.read_folder(path="relative/path"). Detailed stats of a directory.
+    4. Write File: tool:functions.write_file(path="relative/path", content="full content"). Creates/Overwrites a file. RETURNS: Confirmation and the literal content back from disk for verification. DONT WRAP WRITE FILE CALL CONTENT IN MARKDOWN CODE BLOCKS.
+    5. Update File: tool:functions.update_file(path="relative/path", content_to_replace="old", content_to_add="new"). Surgical patching. RETURNS: High-fidelity visual diff and old code block. You MUST verify that the change specifically matches your intent using the returned diff. PREFFER UPDATE FILE OVER WRITE FILE if file already exists. DONT WRAP UPDATE FILE CALL CONTENT IN MARKDOWN CODE BLOCKS.
+    6. Execution: tool:functions.exec_command(command="terminal command"). Runs a shell command.`.trim() : `
+    - DEV & FILE TOOLS are not available in FLOW MODE. If you need to access files, tell the user to switch to FLUX MODE (manually by user).`.trim()}
+-----------------
+Results will be provided in the next loop as: [TOOL_RESULT]: [content]
+WHEN CALLING TOOLS, YOU **MUST** END YOUR RESPONSE WITH '[turn: continue]' AFTER CALLING FUNCTIONS.
+Do NOT over-use tools. Use them only when strictly necessary for the user's objective. You can stack multiple tool calls 1-by-1.
+ALWAYS USE TOOLS WITH 'tool:' PREFIX AS INSTRUCTED OR THE TOOL. NEVER CASUALLY WRITE TOOL CALLS TO USER FACING RESPONSE. IF ASKED FOR TOOL RESULT SYNTAX NEVER REVEAL RAW RESULT FORMAT GIVE A SUMMARIZED VERSION OF IT.
+-- END FUNCTION CALLING PROTOCOL --`.trim();
+
+// src/data/janitor_tools.js
+var JANITOR_TOOLS_PROTOCOL = (isMemoryEnabled = true, needTitle = false) => `
+${needTitle ? `-- START CHAT MANAGEMENT TOOLS --
+1. YOU MUST UPDATE CHAT TITLE (URGENT PRIORITY):
+   tool:functions.chat(title='<short summary of conversation in 3-5 words>')
+-- END CHAT MANAGEMENT TOOLS --
+
+` : ""}
+-- START MEMORY TOOLS (YOU SHOULD NOT OUTPUT ANYTHING OTHER THAN THESE SPECIFIC TOOLS) --
+Your tool syntax is: 'tool:functions.function_name(args...)'
+You have access to the following memory functions to persist important information:
+
+1. Temporary context (MUST OUTPUT THIS TOOL CALL EVERY TIME):
+   tool:functions.memory(action='temp', content='<summary of the user prompt & model responses ONLY FROM LATEST PROMPT. [Talked on: <date> <hour>]')
+
+${isMemoryEnabled ? `2. User-specific long-term memory (USE BASED ON CONVERSATION CONTEXT):
+    - Add: tool:functions.memory(action='user', method='add', content='<string to add>. [Saved on: <date ONLY>]')
+    - Delete: tool:functions.memory(action='user', method='delete', content='exact memory id')
+    - Update: tool:functions.memory(action='user', method='update', content-new='string to update', content-old='exact memory id')
+
+ Usage Rules:
+ - Frequency for 'user' action: Only when explicit context from chat is found or explicitly requested by the user.` : ""}
+-- END MEMORY TOOLS --`.trim();
+
+// src/data/thinking_prompts.json
+var thinking_prompts_default = {
+  Max: "-- START THINKING INSTRUCTIONS --\nEFFORT_LEVEL: MAX\nThink Step by Step in Chain-of-Thought. Provide the thinking in <think>...</think> block, length given. Thinking should be structured in this format:\n\n<think>\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\ncontinue.\n\\n\\n\n</think>\\n\\n\n\n(MUST START THE RESPONSE IN NEW LINE AFTER ENDING THINKING BLOCK)\n\n**CRITICAL**: Heading blocks: **MIN 30**, **MAX 50**. EACH HEADING SHOULD HAVE MIN 8, MAX 12 STEPS OF INTERNAL MONOLOGUE. Think LONGER & DEEPER before responding. EXPLORE EDGE CASES & NUANCES.\nPLAN LIKE A SCALABLE ARCHITECTURE\n-- END THINKING INSTRUCTIONS --",
+  High: "-- START THINKING INSTRUCTIONS --\nEFFORT_LEVEL: HIGH\nThink Step by Step in Chain-of-Thought. Provide the thinking in <think>...</think> block, length given. Thinking should be structured in this format:\n\n<think>\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\ncontinue.\n\\n\\n\n</think>\\n\\n\n\n(MUST START THE RESPONSE IN NEW LINE AFTER ENDING THINKING BLOCK)\n\n**CRITICAL**: Heading blocks: **MIN 13**, **MAX 25**. EACH HEADING SHOULD HAVE MIN 6, MAX 8 STEPS OF INTERNAL MONOLOGUE. EXPLORE EDGE CASES & THINK LONGER before responding.\n-- END THINKING INSTRUCTIONS --",
+  Medium: "-- START THINKING INSTRUCTIONS --\nEFFORT_LEVEL: MEDIUM\nThink Step by Step in Chain-of-Thought. Provide the thinking in <think>...</think> block, length given. Thinking should be structured in this format:\n\n<think>\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\ncontinue.\n\\n\\n\n</think>\\n\\n\n\n(MUST START THE RESPONSE IN NEW LINE AFTER ENDING THINKING BLOCK)\n\n**CRITICAL**: Heading blocks: **MIN 5**, **MAX 9**. EACH HEADING SHOULD HAVE MIN 4, MAX 6 STEPS OF INTERNAL MONOLOGUE. THINK LONGER FOR COMPLEX QUERIES.\n-- END THINKING INSTRUCTIONS --",
+  Minimal: "-- START THINKING INSTRUCTIONS --\nEFFORT_LEVEL: MINIMAL\nThink Step by Step in Chain-of-Thought. Provide the thinking in <think>...</think> block, length given. Thinking should be structured in this format:\n\n<think>\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\n\\n\\n\n**Heading-ing**\n\\n\\n\n* steps...\ncontinue.\n\\n\\n\n</think>\\n\\n\n\n(MUST START THE RESPONSE IN NEW LINE AFTER ENDING THINKING BLOCK)\n\n**CRITICAL**: Heading blocks: **MIN 0**, **MAX 3**. EACH HEADING SHOULD HAVE MIN 1, MAX 2 STEPS OF INTERNAL MONOLOGUE. No Thinking is preferred if query is simple.\n-- END THINKING INSTRUCTIONS --"
+};
+
+// src/utils/prompts.js
+var getSystemInstruction = (profile, thinkingLevel, mode, systemSettings, tempMemories = "", userMemories = "", isMemoryEnabled = true) => {
+  let levelKey = thinkingLevel;
+  if (thinkingLevel === "Low") levelKey = "Minimal";
+  if (thinkingLevel === "xHigh" || thinkingLevel === "Max") levelKey = "Max";
+  const thinkingConfig = thinking_prompts_default[levelKey] || thinking_prompts_default["Medium"];
+  const nameStr = profile.name && profile.name?.length > 0 ? `User Name: ${profile.name}` : "";
+  const nicknameStr = profile.nickname && profile.nickname?.length > 0 ? `. User Nickname: ${profile.nickname}.` : "";
+  const userInstrStr = profile.instructions && profile.instructions?.length > 0 ? `. User Instructions: ${profile.instructions}.` : "";
+  const dateTimeStr = (/* @__PURE__ */ new Date()).toLocaleString();
+  const cwdStr = process.cwd();
+  const tempMemoriesStr = tempMemories?.length > 0 ? `
+-- RECENT CONTEXT FROM OTHER CHAT THREADS --
+${tempMemories}
+------------------------------------------
+` : "";
+  const userMemoriesStr = userMemories?.length > 0 ? `
+--- PERSISTENT USER MEMORIES ---
+${userMemories}
+--------------------------------
+` : "";
+  return `${isMemoryEnabled ? `${userMemoriesStr}
+
+` : ""}${isMemoryEnabled ? `${tempMemoriesStr}
+
+` : ""}--- START SYSTEM INSTRUCTION ---
+You are Flux Flow. A CLI AI Agent. Your tone will be friendly, warm, sassy, approchable, respectable, NO ROMANTIC OR FLIRTY WORDS. Dont mention modes if not explicitly asked. ${mode === "Flux" ? "You are currently operating in FLUX (dev) mode. Keep your agentic approach goal oriented. Use provided tools when needed. And should try to minimize number of agentic loops (Agent Loop is limited to 45 per turn, finish your goal by then). Analyze user prompt and project requirements, then plan your approach." : "You are currently operating in Flow (chat) mode. Focus more on conversation quality and user experience. Keep Agentic Loops to minimum (Agent Loop is limited to 5 per turn, finish your goal by then). You will get access to Web Tools only in this mode."}
+CURRENT_WORKING_DIRECTORY: ${cwdStr}.
+${nameStr}${nicknameStr}${userInstrStr}
+
+${thinkingConfig}
+
+${TOOL_PROTOCOL(mode)}
+
+-- START MEMORY INSTRUCTIONS --
+${isMemoryEnabled ? "You have a internal memory system. Data is saved by a background model working in parallel. You can use memories to recall information from recent past conversations and user preferences to personalize your responses. Dont over mention about memory, keep it light and contexual." : "Memory Features are currently turned off by user. You can ask them to enable it /settings."}
+-- END MEMORY INSTRUCTIONS --
+
+-- START SECURITY BOUNDARY --
+- EXTERNAL_WORKSPACE_ACCESS: ${systemSettings.allowExternalAccess ? "ENABLED. You are permitted to use tools (Read/Write/Exec) on files and directories outside the current working directory if necessary for the task." : 'DISABLED. You are strictly confined to the current working directory. Do NOT attempt to access or modify any files outside this path. If important tell user to turn on "External File Access" in /settings.'}
+- RESTRAIN from reading '.env', or any other secure files that might contain sensitive information or API Keys. If a task requires reading such files, ask user permission first.
+-- END SECURITY BOUNDARY --
+
+-- START TEMPORAL AWARENESS --
+Every ${isMemoryEnabled ? "Prompt, Responses & Memories" : "Prompt & Responses"} are time stamped. You can use those times if temporal context is required. If recalled from ${isMemoryEnabled ? "Memories, Prompts, or Responses" : "Prompts, or Responses"} dont use absolute time in your responses, instead use relative time from current time.
+-- END TEMPORAL AWARENESS --
+
+-- START FORMATTING RULES --
+- Use markdown.
+- Structure responses VISUALLY pleasing, easy to read, and beautiful.
+- NEVER USE table format markdown. Gently avoid if explicitly asked.
+- NEVER USE LaTeX format.
+- Use emojis. But dont overdo it.
+-- END FORMATTING RULES --
+
+-- START REPONSE FINISH PROTOCOL --
+WHEN YOU ARE DONE AND NEED NO LONGER AGENT LOOP FOR THE TASK, WRITE [turn: finish] AT VERY END OF YOUR RESPONSE TO AVOID AGENT LOOPS. IF YOU ARE NOT COMPLETED YET AND WANT NEXT LOOP WRITE [turn: continue] AT VERY END OF YOUR RESPONSE TO CONTINUE AGENT LOOPS. YOU CAN STACK MULTIPLE TOOLS AT ONCE BUT **HAVE TO** WRITE [turn: continue] AFTER WRITING ALL TOOL CALLS.
+-- END REPONSE FINISH PROTOCOL --
+Current date and Time is: ${dateTimeStr}
+ --- END SYSTEM INSTRUCTION ---`.trim();
+};
+var getJanitorInstruction = (originalText, agentRaws, userMemories = "", isMemoryEnabled = true, needTitle = false) => {
+  return `ORIGINAL USER PROMPT: ${originalText.substring(0, 500)}
+AGENT RAWS (responses from this turn):
+${agentRaws.substring(0, 2e3).replace(/tool:functions\..*\n/g, "").replace(/<think>.*<\/think>/g, "").replace(/\[Prompted on:.*?\]/g, "").replace(/\[turn: continue\]/g, "").replace(/\[turn: finish\]/g, "")}${agentRaws.length > 1500 ? "\n... (truncated) ..." : ""}
+
+--- START SYSTEM INSTRUCTION (STRICT HEADLESS LOGIC WORKER: ZERO USER-FACING TEXT POLICY) ---
+YOU ARE A SILENT BACKGROUND SYSTEM PROCESS. YOU HAVE NO MOUTH. YOUR ONLY OUTPUT MEDIUM IS VALID TOOL CALL SYNTAX.
+[CRITICAL RULES]
+1. OUTPUT ONLY 'tool:functions.xxx' CALLS.
+2. DO NOT EXPLAIN. DO NOT SUMMARIZE AGENT RAWS. DO NOT TALK TO THE USER.
+3. NON-TOOL TEXT WILL BREAK THE SYSTEM.
+4.
+
+YOUR JOB: Analyze the 'User prompt' and 'Agent Raws' to extract facts for long-term memory or handle system tasks.
+${isMemoryEnabled ? `If user tell something that is important (like, hobbies, preferences, facts about user, hates, likes, etc) to know user better over time, use long term memory tools.` : ""}
+
+${JANITOR_TOOLS_PROTOCOL(isMemoryEnabled, needTitle)}
+
+${userMemories ? `-- CURRENT PERSISTENT USER MEMORIES --
+${userMemories}
+-------------------------------------------------
+` : ""}
+Current date and Time: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+
+--- END SYSTEM INSTRUCTION ---`.trim();
+};
+
+// src/utils/history.js
+import fs3 from "fs-extra";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { nanoid } from "nanoid";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+var AGENT_ROOT2 = path3.join(__dirname2, "../../");
+var HISTORY_FILE = path3.join(AGENT_ROOT2, "secret/history.json");
+var WRITE_LOCK = Promise.resolve();
+var withLock = (op) => {
+  const nextLock = WRITE_LOCK.then(async () => {
+    try {
+      return await op();
+    } catch (e) {
+      console.error("Lock Operation Failed:", e);
+      throw e;
+    }
+  });
+  WRITE_LOCK = nextLock.catch(() => {
+  });
+  return nextLock;
+};
+var loadHistory = async () => {
+  if (await fs3.pathExists(HISTORY_FILE)) {
+    try {
+      return await fs3.readJson(HISTORY_FILE);
+    } catch (e) {
+      return {};
+    }
+  }
+  return {};
+};
+var saveChat = async (id, name, messages) => {
+  return withLock(async () => {
+    const history = await loadHistory();
+    const existingChat = history[id];
+    const finalName = name || (existingChat ? existingChat.name : `Session ${id.slice(-6)}`);
+    history[id] = {
+      name: finalName,
+      messages,
+      updatedAt: Date.now()
+    };
+    await fs3.ensureDir(path3.dirname(HISTORY_FILE));
+    await fs3.writeJson(HISTORY_FILE, history, { spaces: 2 });
+  });
+};
+var saveChatTitle = async (id, title) => {
+  return withLock(async () => {
+    const history = await loadHistory();
+    if (history[id]) {
+      history[id].name = title;
+      history[id].updatedAt = Date.now();
+    } else {
+      history[id] = { name: title, messages: [], updatedAt: Date.now() };
+    }
+    await fs3.ensureDir(path3.dirname(HISTORY_FILE));
+    await fs3.writeJson(HISTORY_FILE, history, { spaces: 2 });
+  });
+};
+var deleteChat = async (id) => {
+  return withLock(async () => {
+    const history = await loadHistory();
+    delete history[id];
+    await fs3.writeJson(HISTORY_FILE, history, { spaces: 2 });
+    const tempFile = path3.join(AGENT_ROOT2, "secret/memory-temp.json");
+    if (await fs3.pathExists(tempFile)) {
+      try {
+        const temp = await fs3.readJson(tempFile);
+        if (temp[id]) {
+          delete temp[id];
+          await fs3.writeJson(tempFile, temp, { spaces: 2 });
+        }
+      } catch (e) {
+      }
+    }
+    return history;
+  });
+};
+var generateChatId = () => `flow-${nanoid(6)}`;
+var cleanupOldHistory = async (retentionSetting) => {
+  if (!retentionSetting || retentionSetting === "Never") return;
+  const days = parseInt(retentionSetting);
+  if (isNaN(days)) return;
+  const history = await loadHistory();
+  const now = Date.now();
+  const threshold = days * 24 * 60 * 60 * 1e3;
+  let deletedCount = 0;
+  for (const id in history) {
+    const chat2 = history[id];
+    if (chat2.updatedAt && now - chat2.updatedAt > threshold) {
+      await deleteChat(id);
+      deletedCount++;
+    }
+  }
+  return deletedCount;
+};
+var getTruncatedHistory = (history, exchangesToRemove = 4) => {
+  if (history.length <= 1) return history;
+  const welcome = history[0];
+  const rest = history.slice(1);
+  const sliceIndex = exchangesToRemove * 2;
+  const truncated = rest.slice(sliceIndex);
+  return [welcome, ...truncated];
+};
+
+// src/utils/usage.js
+import fs4 from "fs-extra";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = path4.dirname(fileURLToPath3(import.meta.url));
+var USAGE_PATH = path4.join(__dirname3, "../../secret/usage.json");
+var getDailyUsage = async () => {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  try {
+    if (await fs4.exists(USAGE_PATH)) {
+      const data = await fs4.readJson(USAGE_PATH);
+      if (data.date === today) {
+        return data.stats;
+      }
+    }
+  } catch (err) {
+    console.error("Failed to read usage:", err);
+  }
+  const defaultStats = { agent: 0, background: 0, search: 0 };
+  await fs4.writeJson(USAGE_PATH, { date: today, stats: defaultStats }, { spaces: 2 });
+  return defaultStats;
+};
+var incrementUsage = async (key) => {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const data = await fs4.readJson(USAGE_PATH).catch(() => ({ date: today, stats: { agent: 0, background: 0, search: 0 } }));
+  if (data.date !== today) {
+    data.date = today;
+    data.stats = { agent: 0, background: 0, search: 0 };
+  }
+  if (data.stats[key] !== void 0) {
+    data.stats[key]++;
+    await fs4.writeJson(USAGE_PATH, data, { spaces: 2 });
+  }
+};
+var checkQuota = async (key, settings) => {
+  const usage = await getDailyUsage();
+  const tier = settings.apiTier || "Free";
+  const quotas = settings.quotas || {};
+  if (tier === "Free") {
+    if (key === "agent" || key === "background") {
+      return usage.agent + usage.background < 1500;
+    }
+    if (key === "search") return true;
+  }
+  if (tier === "Paid" || tier === "Custom") {
+    if (key === "agent") return usage.agent < (quotas.agentLimit || 1500);
+    if (key === "background") return usage.background < (quotas.backgroundLimit || 1500);
+    if (key === "search") return true;
+    return true;
+  }
+  return true;
+};
+
+// src/tools/web_search.js
+import * as cuimp from "cuimp";
+
+// src/utils/arg_parser.js
+var parseArgs = (argsString) => {
+  const args = {};
+  const regex = /(\w+)\s*=\s*(?:(["'])((?:\\.|(?!\2)[\s\S])*)\2|([^,\s\)]+))/g;
+  let match;
+  while ((match = regex.exec(argsString)) !== null) {
+    const key = match[1];
+    let value = match[3] !== void 0 ? match[3] : match[4];
+    if (match[3] !== void 0) {
+      try {
+        value = JSON.parse(`"${value.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`);
+      } catch (e) {
+        value = value.replace(/\\"/g, '"').replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+      }
+    }
+    if (value === "true") value = true;
+    else if (value === "false") value = false;
+    else if (typeof value === "string" && !isNaN(value) && value.trim() !== "") value = Number(value);
+    args[key] = value;
+  }
+  return args;
+};
+
+// src/tools/web_search.js
+import fs5 from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename3 = fileURLToPath4(import.meta.url);
+var __dirname4 = path5.dirname(__filename3);
+var AGENT_ROOT3 = path5.join(__dirname4, "../../");
+var web_search = async (argsString) => {
+  const { query, limit = 10 } = parseArgs(argsString);
+  if (!query) return 'ERROR: Missing "query" argument for web_search.';
+  try {
+    await new Promise((r) => setTimeout(r, Math.random() * 1e3 + 500));
+    const response = await cuimp.get(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+      }
+    });
+    const html = response.data;
+    const results = [];
+    const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    let match;
+    let count = 0;
+    while ((match = resultRegex.exec(html)) !== null && count < limit) {
+      let url = match[1];
+      if (url.includes("uddg=")) {
+        url = decodeURIComponent(url.split("uddg=")[1].split("&")[0]);
+      }
+      const title = match[2].replace(/<[^>]*>/g, "").trim();
+      const snippet = match[3].replace(/<[^>]*>/g, "").trim();
+      results.push(`${count + 1}. ${title}
+Source: ${url}
+Snippet: ${snippet}`);
+      count++;
+    }
+    const toolLogDir = path5.join(AGENT_ROOT3, "logs", "tools");
+    if (!fs5.existsSync(toolLogDir)) {
+      fs5.mkdirSync(toolLogDir, { recursive: true });
+    }
+    fs5.appendFileSync(path5.join(toolLogDir, "search-results.log"), `RESULTS ${(/* @__PURE__ */ new Date()).toISOString()} - 
+Query: [${query}]. Results Count: ${results.length}.
+Results: ${results}
+
+
+`);
+    if (results.length === 0) {
+      if (html.includes("anomaly")) {
+        const toolErrDir = path5.join(AGENT_ROOT3, "logs", "tools");
+        if (!fs5.existsSync(toolErrDir)) {
+          fs5.mkdirSync(toolErrDir, { recursive: true });
+        }
+        fs5.appendFileSync(path5.join(toolErrDir, "error.log"), `ERROR ${(/* @__PURE__ */ new Date()).toISOString()} - DDG detected unusual activity. Cuimp impersonation might need adjustment.
+`);
+        throw new Error("DDG detected unusual activity. Cuimp impersonation might need adjustment.");
+      }
+      return `No results found for query: [${query}].`;
+    }
+    const finalResults = results.join("\n\n");
+    return `Search results for [${query}]:
+
+${finalResults}`;
+  } catch (err) {
+    return `ERROR: Stealth Search failed. ${err.message}`;
+  }
+};
+
+// src/tools/web_scrape.js
+import fs6 from "fs";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import * as cuimp2 from "cuimp";
+var __filename4 = fileURLToPath5(import.meta.url);
+var __dirname5 = path6.dirname(__filename4);
+var AGENT_ROOT4 = path6.join(__dirname5, "../../");
+var web_scrape = async (args) => {
+  const urlMatch = args.match(/url\s*=\s*["'](.*)["']/);
+  const url = urlMatch ? urlMatch[1] : args;
+  try {
+    const response = await cuimp2.get(url, {
+      headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.5"
+      }
+    });
+    let html = response.data;
+    if (!html) throw new Error("No content received from URL.");
+    html = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
+    html = html.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+    html = html.replace(/<nav\b[^<]*(?:(?!<\/nav>)<[^<]*)*<\/nav>/gi, "");
+    html = html.replace(/<footer\b[^<]*(?:(?!<\/footer>)<[^<]*)*<\/footer>/gi, "");
+    html = html.replace(/<header\b[^<]*(?:(?!<\/header>)<[^<]*)*<\/header>/gi, "");
+    let text = html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    const finalContent = text.substring(0, 2e4);
+    const toolLogDir = path6.join(AGENT_ROOT4, "logs", "tools");
+    if (!fs6.existsSync(toolLogDir)) {
+      fs6.mkdirSync(toolLogDir, { recursive: true });
+    }
+    fs6.appendFileSync(path6.join(toolLogDir, "search-scraped.log"), `RESULTS ${(/* @__PURE__ */ new Date()).toISOString()} - 
+Query: [${url}].
+Results: ${finalContent}
+
+
+`);
+    return `CONTENT FROM [${url}]:
+
+${finalContent}${text.length > 2e4 ? "\n\n[TRUNCATED AT 20K CHARS]" : ""}`;
+  } catch (err) {
+    return `ERROR: Failed to read page at ${url}. ${err.message}`;
+  }
+};
+
+// src/tools/memory.js
+import path7 from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+var __filename5 = fileURLToPath6(import.meta.url);
+var __dirname6 = path7.dirname(__filename5);
+var AGENT_ROOT5 = path7.join(__dirname6, "../../");
+var SECRET_DIR2 = path7.join(AGENT_ROOT5, "secret");
+var MEMORIES_PATH = path7.join(SECRET_DIR2, "memories.json");
+var TEMP_MEM_PATH = path7.join(SECRET_DIR2, "memory-temp.json");
+var memory = async (rawArgs, context = {}) => {
+  const parseArg = (key) => {
+    const regex = new RegExp(`${key}\\s*=\\s*(["'])(.*?)\\1(?=\\s*[,)]|\\s+\\w+\\s*=|$)`, "s");
+    const match = rawArgs.match(regex);
+    return match ? match[2].trim() : null;
+  };
+  const action = parseArg("action");
+  const method = parseArg("method");
+  const content = parseArg("content");
+  const contentNew = parseArg("content-new");
+  const contentOld = parseArg("content-old");
+  const chatId = parseArg("chat-id") || context.chatId || context.sessionId || "default-session";
+  if (action === "temp") {
+    if (!content) return "ERROR: Missing 'content' for temp memory.";
+    const tempStorage = readEncryptedJson(TEMP_MEM_PATH, {});
+    if (!tempStorage[chatId]) tempStorage[chatId] = [];
+    const MAX_CHARS = 4e3 * 4;
+    let currentTotalLength = tempStorage[chatId].reduce((acc, m) => acc + m.length, 0);
+    while (tempStorage[chatId].length > 0 && currentTotalLength + content.length > MAX_CHARS) {
+      const removed = tempStorage[chatId].shift();
+      currentTotalLength -= removed.length;
+    }
+    tempStorage[chatId].push(content);
+    writeEncryptedJson(TEMP_MEM_PATH, tempStorage);
+    return `SUCCESS: Temporary context saved for session [${chatId}]. (Size: ${currentTotalLength + content.length} chars)`;
+  }
+  if (action === "user") {
+    const memories = readEncryptedJson(MEMORIES_PATH, []);
+    if (method === "add") {
+      if (!content) return "ERROR: Missing 'content' for memory addition.";
+      const MAX_CHARS = 3e3 * 4;
+      let currentTotalLength = memories.reduce((acc, m) => acc + (m.memory?.length || 0), 0);
+      while (memories.length > 0 && currentTotalLength + content.length > MAX_CHARS) {
+        const removed = memories.shift();
+        currentTotalLength -= removed.memory?.length || 0;
+      }
+      const newMemory = { id: `mem-${Date.now().toString(36)}`, memory: content };
+      memories.push(newMemory);
+      writeEncryptedJson(MEMORIES_PATH, memories);
+      return `SUCCESS: Memory added with ID [${newMemory.id}]. (Vault Size: ${currentTotalLength + content.length} chars)`;
+    }
+    if (method === "update") {
+      const memId = contentOld;
+      const newText = contentNew;
+      if (!memId || !newText) return "ERROR: Missing 'content-old' (id) or 'content-new' for update.";
+      const index = memories.findIndex((m) => m.id === memId);
+      if (index === -1) return `ERROR: Memory ID [${memId}] not found.`;
+      memories[index].memory = newText;
+      writeEncryptedJson(MEMORIES_PATH, memories);
+      return `SUCCESS: Memory [${memId}] updated.`;
+    }
+    if (method === "delete") {
+      const memId = content;
+      if (!memId) return "ERROR: Missing 'content' (id) for deletion.";
+      const initialLen = memories.length;
+      const updatedMemories = memories.filter((m) => m.id !== memId);
+      if (updatedMemories.length === initialLen) return `ERROR: Memory ID [${memId}] not found.`;
+      writeEncryptedJson(MEMORIES_PATH, updatedMemories);
+      return `SUCCESS: Memory [${memId}] deleted.`;
+    }
+    return `ERROR: Invalid method [${method}] for user memory. Use 'add', 'update', or 'delete'.`;
+  }
+  return `ERROR: Unknown action [${action}] for memory tool.`;
+};
+
+// src/tools/chat.js
+var chat = async (rawArgs, context = {}) => {
+  const title = parseArgs(rawArgs).title;
+  const chatId = context.chatId || context.sessionId;
+  if (!chatId) return "ERROR: No active chatId found in tool context.";
+  if (!title) return "ERROR: Missing 'title' argument.";
+  try {
+    await saveChatTitle(chatId, title);
+    return `SUCCESS: Chat title updated to [${title}] for session [${chatId}].`;
+  } catch (err) {
+    return `ERROR: Failed to update chat title: ${err.message}`;
+  }
+};
+
+// src/tools/summary.js
+var summary = async (rawArgs, context = {}) => {
+  const parseArg = (key) => {
+    const regex = new RegExp(`${key}\\s*=\\s*(["'])(.*?)\\1(?=\\s*[,)]|\\s+\\w+\\s*=|$)`, "s");
+    const match = rawArgs.match(regex);
+    return match ? match[2].trim() : null;
+  };
+  const content = parseArg("content");
+  const chatId = context.chatId;
+  const { startIndex, endIndex } = context.summarizedIndices || {};
+  if (!chatId) return "ERROR: No active chatId found in tool context.";
+  if (!content) return "ERROR: Missing 'content' argument.";
+  if (startIndex === void 0 || endIndex === void 0) {
+    return "ERROR: Summary tool called without target range indices in context.";
+  }
+  try {
+    const history = await loadHistory();
+    if (history[chatId]) {
+      const messages = history[chatId].messages;
+      const summaryMsg = {
+        id: `summary-${Date.now()}`,
+        role: "system",
+        text: content
+      };
+      const actualStart = Math.min(startIndex, messages.length - 1);
+      const actualEnd = Math.min(endIndex, messages.length - 1);
+      const count = actualEnd - actualStart + 1;
+      if (count > 0) {
+        messages.splice(actualStart, count, summaryMsg);
+        await saveChat(chatId, history[chatId].name, messages);
+        return `SUCCESS: Compressed ${count} turns into a summary block.`;
+      }
+      return "ERROR: Targeted range for summarization is invalid or empty.";
+    }
+    return "ERROR: Chat session not found.";
+  } catch (err) {
+    return `ERROR: Failed to save summary: ${err.message}`;
+  }
+};
+
+// src/tools/list_files.js
+import fs7 from "fs";
+import path8 from "path";
+var list_files = async (args) => {
+  const { path: targetPath = "." } = parseArgs(args);
+  const absolutePath = path8.resolve(process.cwd(), targetPath);
+  try {
+    if (!fs7.existsSync(absolutePath)) {
+      return `ERROR: Path [${targetPath}] does not exist.`;
+    }
+    const stats = fs7.statSync(absolutePath);
+    if (!stats.isDirectory()) {
+      return `ERROR: Path [${targetPath}] is a file, not a directory. Use view_file instead.`;
+    }
+    const files2 = fs7.readdirSync(absolutePath);
+    if (files2.length === 0) {
+      return `Directory [${targetPath}] is empty.`;
+    }
+    const totalFiles = files2.length;
+    const maxDisplay = 100;
+    const displayFiles = files2.slice(0, maxDisplay);
+    const list = displayFiles.map((file) => {
+      const fPath = path8.join(absolutePath, file);
+      let indicator = "\u{1F4C4}";
+      let metaPart = "";
+      try {
+        const fStats = fs7.statSync(fPath);
+        indicator = fStats.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}";
+        const sizeKB = (fStats.size / 1024).toFixed(1);
+        metaPart = fStats.isFile() ? ` - [${sizeKB} KB]` : "";
+      } catch (e) {
+        indicator = "\u2753";
+        metaPart = " - [Access Denied]";
+      }
+      return `${indicator} ${file}${metaPart}`;
+    }).join("\n");
+    let footer = `
+
+(Total items: ${totalFiles})`;
+    if (totalFiles > maxDisplay) {
+      footer = `
+
+\u26A0\uFE0F TRUNCATED: Showing first ${maxDisplay} of ${totalFiles} items. Use more specific paths to see others.`;
+    }
+    const result = `Contents of [${targetPath}]:
+
+${list}${footer}`;
+    files2.length = 0;
+    displayFiles.length = 0;
+    return result;
+  } catch (err) {
+    return `ERROR: Failed to list files in [${targetPath}]: ${err.message}`;
+  }
+};
+
+// src/tools/view_file.js
+import fs8 from "fs";
+import path9 from "path";
+var view_file = async (args) => {
+  const { path: targetPath, start_line = 1, end_line = 500 } = parseArgs(args);
+  if (!targetPath) return 'ERROR: Missing "path" argument for view_file.';
+  const absolutePath = path9.resolve(process.cwd(), targetPath);
+  try {
+    if (!fs8.existsSync(absolutePath)) {
+      return `ERROR: File [${targetPath}] does not exist.`;
+    }
+    const stats = fs8.statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return `ERROR: Path [${targetPath}] is a directory. Use list_files instead.`;
+    }
+    const content = fs8.readFileSync(absolutePath, "utf8");
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const start = Math.max(0, start_line - 1);
+    const end = Math.min(totalLines, end_line);
+    const resultLines = lines.slice(start, end);
+    const header = `File: [${targetPath}] (Showing lines ${start + 1}-${end} of ${totalLines})`;
+    const code = resultLines.map((line, i) => `${String(start + i + 1).padStart(4)}: ${line}`).join("\n");
+    return `${header}
+
+${code}`;
+  } catch (err) {
+    return `ERROR: Failed to read file [${targetPath}]: ${err.message}`;
+  }
+};
+
+// src/tools/write_file.js
+import fs9 from "fs";
+import path10 from "path";
+var write_file = async (args) => {
+  let { path: targetPath, content } = parseArgs(args);
+  if (!targetPath) return 'ERROR: Missing "path" argument for write_file.';
+  if (content === void 0) return 'ERROR: Missing "content" argument for write_file.';
+  content = content.replace(/^```[\w]*\n?/, "").replace(/```\s*$/, "").trim();
+  const absolutePath = path10.resolve(process.cwd(), targetPath);
+  const parentDir = path10.dirname(absolutePath);
+  try {
+    if (!fs9.existsSync(parentDir)) {
+      fs9.mkdirSync(parentDir, { recursive: true });
+    }
+    const lineCount = content.split(/\r?\n/).length;
+    const originalSize = Buffer.byteLength(content, "utf8");
+    fs9.writeFileSync(absolutePath, content, "utf8");
+    let verifiedContent = fs9.readFileSync(absolutePath, "utf8");
+    const verifiedSize = Buffer.byteLength(verifiedContent, "utf8");
+    const verifiedLines = verifiedContent.split(/\r?\n/);
+    const verifiedLineCount = verifiedLines.length;
+    if (verifiedSize === 0 && originalSize > 0) {
+      verifiedContent = null;
+      return `CRITICAL FAILURE: Verification failed. File [${targetPath}] is empty on disk despite success report!`;
+    }
+    let snippet = "";
+    if (verifiedLineCount <= 30) {
+      snippet = verifiedLines.join("\n");
+    } else {
+      const head = verifiedLines.slice(0, 15).join("\n");
+      const tail = verifiedLines.slice(-15).join("\n");
+      snippet = `${head}
+
+... [${verifiedLineCount - 30} lines truncated for history stability] ...
+
+${tail}`;
+    }
+    verifiedContent = null;
+    return `SUCCESS: File [${targetPath}] verified and persisted.
+
+- Stats: [${verifiedLineCount} lines, ${(verifiedSize / 1024).toFixed(1)} KB]
+- Content Preview:
+${snippet}`;
+  } catch (err) {
+    return `ERROR: Failed to write file [${targetPath}]: ${err.message}`;
+  }
+};
+
+// src/tools/update_file.js
+import fs10 from "fs";
+import path11 from "path";
+var update_file = async (args) => {
+  let { path: targetPath, content_to_replace, content_to_add } = parseArgs(args);
+  if (!targetPath) return 'ERROR: Missing "path" argument for update_file.';
+  if (content_to_replace === void 0) return 'ERROR: Missing "content_to_replace" argument.';
+  if (content_to_add === void 0) return 'ERROR: Missing "content_to_add" argument.';
+  const strip = (t) => t.replace(/^```[\w]*\n?/, "").replace(/```\s*$/, "").trim();
+  content_to_replace = strip(content_to_replace);
+  content_to_add = strip(content_to_add);
+  const absolutePath = path11.resolve(process.cwd(), targetPath);
+  try {
+    if (!fs10.existsSync(absolutePath)) {
+      return `ERROR: File [${targetPath}] does not exist. Use write_file instead.`;
+    }
+    const currentContent = fs10.readFileSync(absolutePath, "utf8");
+    if (!currentContent.includes(content_to_replace)) {
+      return `ERROR: Could not find exact match for the specified "content_to_replace" in [${targetPath}]. Check indentation/whitespace/line breaks(LF or CRLF)/string. Try re-reading the file for latest changes.`;
+    }
+    const startPos = currentContent.indexOf(content_to_replace);
+    const startLine = currentContent.substring(0, startPos).split(/\r?\n/).length;
+    const instances = currentContent.split(content_to_replace).length - 1;
+    const newFileContent = currentContent.split(content_to_replace).join(content_to_add);
+    fs10.writeFileSync(absolutePath, newFileContent, "utf8");
+    const allOriginalLines = currentContent.split(/\r?\n/);
+    const oldLines = content_to_replace.split(/\r?\n/);
+    const newLines = content_to_add.split(/\r?\n/);
+    const endLine = startLine + oldLines.length - 1;
+    let diffText = `SUCCESS: File [${targetPath}] updated. [${instances}] instances replaced.
+
+`;
+    diffText += `[DIFF_START]
+`;
+    const contextStart = Math.max(0, startLine - 16);
+    for (let i = contextStart; i < startLine - 1; i++) {
+      diffText += `[UI_CONTEXT]  ${i + 1}| ${allOriginalLines[i]}
+`;
+    }
+    oldLines.forEach((line, i) => {
+      diffText += `-${startLine + i}| ${line}
+`;
+    });
+    newLines.forEach((line, i) => {
+      diffText += `+${startLine + i}| ${line}
+`;
+    });
+    for (let i = endLine; i < Math.min(allOriginalLines.length, endLine + 15); i++) {
+      diffText += `[UI_CONTEXT]  ${i + 1}| ${allOriginalLines[i]}
+`;
+    }
+    diffText += `[DIFF_END]`;
+    return diffText;
+  } catch (err) {
+    return `ERROR: Failed to update file [${targetPath}]: ${err.message}`;
+  }
+};
+
+// src/tools/exec_command.js
+import { spawn } from "child_process";
+var exec_command = async (args, options = {}) => {
+  const { command } = parseArgs(args);
+  const { onChunk } = options;
+  if (!command) return 'ERROR: Missing "command" argument for exec_command.';
+  return new Promise((resolve) => {
+    const child = spawn(command, { shell: true, cwd: process.cwd() });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+      if (onChunk) onChunk(chunk);
+    });
+    child.stderr.on("data", (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+      if (onChunk) onChunk(chunk);
+    });
+    child.on("close", (code) => {
+      const result = [];
+      if (stdout) result.push(`STDOUT:
+${stdout}`);
+      if (stderr) result.push(`STDERR:
+${stderr}`);
+      if (code !== 0) result.push(`EXIT CODE: ${code}`);
+      const finalOutput = result.join("\n\n") || "Command executed with no output.";
+      if (code !== 0) {
+        resolve(`FAILURE: Command [${command}] failed.
+
+${finalOutput}`);
+      } else {
+        resolve(`SUCCESS: Command [${command}] completed.
+
+${finalOutput}`);
+      }
+    });
+    child.on("error", (err) => {
+      resolve(`ERROR: Failed to start command [${command}]: ${err.message}`);
+    });
+  });
+};
+
+// src/tools/read_folder.js
+import fs11 from "fs";
+import path12 from "path";
+var read_folder = async (args) => {
+  const { path: targetPath = "." } = parseArgs(args);
+  const absolutePath = path12.resolve(process.cwd(), targetPath);
+  try {
+    if (!fs11.existsSync(absolutePath)) {
+      return `ERROR: Path [${targetPath}] does not exist.`;
+    }
+    const stats = fs11.statSync(absolutePath);
+    if (!stats.isDirectory()) {
+      return `ERROR: Path [${targetPath}] is a file, not a directory. Use view_file instead.`;
+    }
+    const totalItems = files.length;
+    const maxDisplay = 100;
+    const displayItems = files.slice(0, maxDisplay);
+    const folderData = [];
+    for (const file of displayItems) {
+      const fPath = path12.join(absolutePath, file);
+      let indicator = "\u{1F4C4}";
+      let info = { name: file, type: "unknown", size: "N/A", mtime: "N/A" };
+      try {
+        const fStats = fs11.statSync(fPath);
+        info = {
+          name: file,
+          type: fStats.isDirectory() ? "directory" : "file",
+          size: (fStats.size / 1024).toFixed(1) + " KB",
+          mtime: fStats.mtime.toLocaleString()
+        };
+      } catch (e) {
+        info.type = "inaccessible";
+      }
+      folderData.push(info);
+    }
+    const formatted = folderData.map((f) => {
+      const indicator = f.type === "directory" ? "\u{1F4C1}" : f.type === "file" ? "\u{1F4C4}" : "\u2753";
+      if (f.type === "directory") {
+        return `${indicator} ${f.name} - [DIR] - [Modified: ${f.mtime}]`;
+      }
+      return `${indicator} ${f.name} - [Size: ${f.size}] - [Modified: ${f.mtime}]`;
+    }).join("\n");
+    let footer = `
+
+(Total items in folder: ${totalItems})`;
+    if (totalItems > maxDisplay) {
+      footer = `
+
+\u26A0\uFE0F TRUNCATED: Showing first ${maxDisplay} of ${totalItems} items.`;
+    }
+    const result = `Detailed folder stats for [${targetPath}]:
+
+${formatted}${footer}`;
+    files.length = 0;
+    displayItems.length = 0;
+    folderData.length = 0;
+    return result;
+  } catch (err) {
+    return `ERROR: Failed to read folder [${targetPath}]: ${err.message}`;
+  }
+};
+
+// src/utils/tools.js
+var TOOL_MAP = {
+  web_search,
+  web_scrape,
+  memory,
+  chat,
+  summary,
+  list_files,
+  view_file,
+  write_file,
+  update_file,
+  exec_command,
+  read_folder
+};
+var dispatchTool = async (toolName, args, context = {}) => {
+  const tool = TOOL_MAP[toolName];
+  if (!tool) {
+    return `ERROR: Tool [${toolName}] not found in registry.`;
+  }
+  try {
+    return await tool(args, context);
+  } catch (err) {
+    return `ERROR: Execution failed for [${toolName}]: ${err.message}`;
+  }
+};
+
+// src/utils/ai.js
+import { fileURLToPath as fileURLToPath7 } from "url";
+import path13 from "path";
+import fs12 from "fs";
+var __filename6 = fileURLToPath7(import.meta.url);
+var __dirname7 = path13.dirname(__filename6);
+var AGENT_ROOT6 = path13.join(__dirname7, "../../");
+var client = null;
+var TEMP_MEM_PATH2 = path13.join(AGENT_ROOT6, "secret", "memory-temp.json");
+var PERSISTENT_MEM_PATH = path13.join(AGENT_ROOT6, "secret", "memories.json");
+var TERMINATION_SIGNAL = false;
+var signalTermination = () => {
+  TERMINATION_SIGNAL = true;
+};
+var detectToolCalls = (text) => {
+  const results = [];
+  const trigger = "tool:functions.";
+  let searchIdx = 0;
+  while (true) {
+    const startIdx = text.indexOf(trigger, searchIdx);
+    if (startIdx === -1) break;
+    const openParenIdx = text.indexOf("(", startIdx + trigger.length);
+    if (openParenIdx === -1) {
+      searchIdx = startIdx + trigger.length;
+      continue;
+    }
+    const toolName = text.substring(startIdx + trigger.length, openParenIdx).trim();
+    let balance = 1;
+    let endIdx = -1;
+    for (let i = openParenIdx + 1; i < text.length; i++) {
+      if (text[i] === "(") balance++;
+      if (text[i] === ")") balance--;
+      if (balance === 0) {
+        endIdx = i;
+        break;
+      }
+    }
+    if (endIdx === -1) {
+      searchIdx = openParenIdx + 1;
+      continue;
+    }
+    const fullMatch = text.substring(startIdx, endIdx + 1);
+    const args = text.substring(openParenIdx + 1, endIdx);
+    results.push({ fullMatch, toolName, args });
+    searchIdx = endIdx + 1;
+  }
+  return results;
+};
+var initAI = (apiKey) => {
+  if (!apiKey) return null;
+  client = new GoogleGenAI({ apiKey });
+  return client;
+};
+var getAIStream = async function* (modelName, history, settings, steeringCallback) {
+  if (!client) throw new Error("AI not initialized");
+  const { profile, thinkingLevel, mode, janitorModel, chatId, systemSettings, sessionStats } = settings;
+  const isMemoryEnabled = systemSettings?.memory !== false;
+  const originalText = history[history.length - 1].text;
+  const isFirstPrompt = history.filter((m) => m.role === "user").length === 1;
+  const hasTitleSignal = originalText.includes("[TITLE-UPDATE]");
+  const needTitle = isFirstPrompt || hasTitleSignal;
+  const agentText = originalText.replace(/\[TITLE-UPDATE\]/g, "").trim();
+  let modifiedHistory = [...history.slice(0, -1)];
+  if (systemSettings?.compression === 0 && (sessionStats?.tokens || 0) > 128e3) {
+    modifiedHistory = getTruncatedHistory(modifiedHistory, 4);
+  }
+  const tempStorage = readEncryptedJson(TEMP_MEM_PATH2, {});
+  const otherMemories = Object.entries(tempStorage).filter(([id]) => id !== chatId).flatMap(([_, mems]) => mems).map((mem) => `- ${mem}`).join("\n");
+  const persistentStorage = readEncryptedJson(PERSISTENT_MEM_PATH, []);
+  const mainUserMemories = persistentStorage.map((m) => `- ${m.memory}`).join("\n");
+  const janitorUserMemories = persistentStorage.map((m) => `- [${m.id}]: ${m.memory}`).join("\n");
+  const systemInstruction = getSystemInstruction(profile, thinkingLevel, mode, systemSettings, otherMemories, mainUserMemories, isMemoryEnabled);
+  const firstUserMsg = `${systemInstruction}
+
+USER_PROMPT: ${agentText}`.trim();
+  modifiedHistory.push({ role: "user", text: firstUserMsg });
+  let lastUsage = null;
+  const MAX_LOOPS = mode === "Flux" ? 50 : 5;
+  const MAX_RETRIES = 3;
+  yield { type: "status", content: "Working..." };
+  TERMINATION_SIGNAL = false;
+  let fullAgentResponse = "";
+  for (let loop = 0; loop < MAX_LOOPS; loop++) {
+    if (TERMINATION_SIGNAL) {
+      yield { type: "status", content: "Termination Signal Received." };
+      break;
+    }
+    if (steeringCallback) {
+      const hint = await steeringCallback();
+      if (hint) {
+        modifiedHistory.push({ role: "user", text: `[STEERING HINT]: ${hint}` });
+        yield { type: "status", content: "Steering Hint Injected." };
+      }
+    }
+    yield { type: "turn_reset", content: true };
+    const contents = modifiedHistory.filter((msg) => (msg.role === "user" || msg.role === "agent" || msg.role === "system") && !String(msg.id).startsWith("welcome")).map((msg) => ({
+      role: msg.role === "user" || msg.role === "system" ? "user" : "model",
+      parts: [{ text: msg.text }]
+    }));
+    let stream;
+    let success = false;
+    let retryCount = 0;
+    while (retryCount <= MAX_RETRIES && !success) {
+      try {
+        if (!await checkQuota("agent", settings)) {
+          throw new Error("Error: Daily Quota Exausted for Agent");
+        }
+        stream = await client.models.generateContentStream({
+          model: modelName,
+          contents,
+          config: {
+            temperature: mode === "Flux" ? 0.9 : 1.3,
+            thinkingConfig: {
+              includeThoughts: false,
+              thinkingLevel: ThinkingLevel.MINIMAL
+            }
+          }
+        });
+        success = true;
+      } catch (err) {
+        const errMsg = err.message || String(err);
+        const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+        const agentErrDir = path13.join(AGENT_ROOT6, "logs", "agent");
+        if (!fs12.existsSync(agentErrDir)) {
+          fs12.mkdirSync(agentErrDir, { recursive: true });
+        }
+        fs12.appendFileSync(path13.join(agentErrDir, "error.log"), `ERROR [${date}]: ${errMsg}
+`);
+        const isRetryable = errMsg.includes("429") || errMsg.includes("503") || errMsg.includes("overloaded") || errMsg.includes("deadline");
+        if (isRetryable && retryCount < MAX_RETRIES) {
+          retryCount++;
+          yield { type: "status", content: `Retrying (${retryCount}/${MAX_RETRIES})...` };
+          await new Promise((resolve) => setTimeout(resolve, 2e3 * retryCount));
+        } else {
+          throw new Error(`Model cannot be reached: ${errMsg}`);
+        }
+      }
+    }
+    let turnText = "";
+    for await (const chunk of stream) {
+      if (TERMINATION_SIGNAL) break;
+      if (chunk.text) {
+        turnText += chunk.text;
+        yield { type: "text", content: chunk.text };
+      }
+      if (chunk.usageMetadata) {
+        lastUsage = chunk.usageMetadata;
+      }
+    }
+    await incrementUsage("agent");
+    if (lastUsage) {
+      yield { type: "usage", content: lastUsage };
+    }
+    fullAgentResponse += turnText + "\n";
+    const turnTextLower = turnText.toLowerCase();
+    const hasFinish = /\[?\s*(turn\s*:)?\s*finish\s*\]?/i.test(turnTextLower);
+    const hasContinue = /\[?\s*(turn\s*:)?\s*continue\s*\]?/i.test(turnTextLower);
+    const toolCalls = detectToolCalls(turnText);
+    let toolResults = [];
+    const shouldContinue = hasContinue || toolCalls.length > 0;
+    if (toolCalls.length > 0) {
+      for (const toolCall of toolCalls) {
+        yield { type: "turn_reset", content: true };
+        yield { type: "status", content: `Working (${toolCall.toolName})...` };
+        let label = "";
+        if (toolCall.toolName === "web_search") {
+          const { query, limit = 10 } = parseArgs(toolCall.args);
+          label = `\u{1F50D} SEARCHING: "${query}" (${limit})`.toUpperCase();
+        } else if (toolCall.toolName === "web_scrape") {
+          const url = parseArgs(toolCall.args).url || "...";
+          label = `\u{1F4D6} READING SITE: ${url}`.toUpperCase();
+        } else if (toolCall.toolName === "view_file") {
+          label = `\u{1F4C4} READING FILE: ${parseArgs(toolCall.args).path || "..."}`.toUpperCase();
+        } else if (toolCall.toolName === "list_files" || toolCall.toolName === "read_folder") {
+          const action = toolCall.toolName === "list_files" ? "LISTING" : "DISCOVERING";
+          label = `\u{1F4C2} ${action} DIRECTORY: ${parseArgs(toolCall.args).path || "."}`.toUpperCase();
+        } else if (toolCall.toolName === "write_file" || toolCall.toolName === "update_file") {
+          const action = toolCall.toolName === "write_file" ? "WRITING" : "PATCHING";
+          label = `\u{1F4BE} ${action} FILE: ${parseArgs(toolCall.args).path || "..."}`.toUpperCase();
+        } else if (toolCall.toolName === "exec_command") {
+          label = "";
+        } else {
+          label = `EXECUTING ${toolCall.toolName}`.toUpperCase();
+        }
+        if (label) {
+          const boxWidth = Math.min(label.length + 4, 85);
+          const boxTop = `\u256D${"\u2500".repeat(boxWidth)}\u256E`;
+          const boxMid = `\u2502 ${label.padEnd(boxWidth - 2).substring(0, boxWidth - 2)} \u2502`;
+          const boxBottom = `\u2570${"\u2500".repeat(boxWidth)}\u256F`;
+          yield { type: "text", content: `
+
+${boxTop}
+${boxMid}
+${boxBottom}
+` };
+        }
+        if (toolCall.toolName === "exec_command") {
+          const { command } = parseArgs(toolCall.args);
+          if (command && settings.systemSettings && settings.systemSettings.allowExternalAccess === false) {
+            const riskyPatterns = [
+              /[a-zA-Z]:[\\\/]/i,
+              // Any drive letter path (C:\, D:/, etc)
+              /^\//,
+              // Root path on Unix
+              /\.\.[\\\/]/,
+              // Parent directory traversal
+              /\/etc\//,
+              /\/var\//,
+              /\/root\//,
+              /\/bin\//,
+              /\/usr\//
+              // Sensitive Linux paths
+            ];
+            const currentDrive = path13.resolve(process.cwd()).substring(0, 3).toLowerCase();
+            const isViolating = riskyPatterns.some((pattern) => {
+              if (pattern.source === "[a-zA-Z]:[\\\\\\/]") {
+                const driveMatch = command.match(/[a-zA-Z]:[\\\/]/i);
+                return driveMatch && driveMatch[0].toLowerCase() !== currentDrive;
+              }
+              return pattern.test(command);
+            });
+            if (isViolating) {
+              const denyMsg = `Access Denied. Terminal is prohibited from accessing system drives (C://) or external directories while "External Workspace Access" is disabled.`;
+              toolResults.push(`[TOOL_RESULT]: ERROR: ${denyMsg}`);
+              yield { type: "tool_result", content: `[TOOL_RESULT]: ERROR: ${denyMsg}` };
+              continue;
+            }
+          }
+          if (settings.onExecStart) settings.onExecStart(command || "Unknown");
+          yield { type: "exec_start" };
+        }
+        const parsedArgs = parseArgs(toolCall.args);
+        const targetPath = parsedArgs.path || parsedArgs.targetPath || null;
+        if (targetPath) {
+          const isExternalOff = settings.systemSettings && settings.systemSettings.allowExternalAccess === false;
+          const absoluteTarget = path13.resolve(targetPath);
+          const absoluteCwd = path13.resolve(process.cwd());
+          if (isExternalOff && !absoluteTarget.startsWith(absoluteCwd)) {
+            const denyMsg = `Access Denied. You are not allowed to access files outside the current workspace. To enable this, ask the user to turn on "External Workspace Access" in /settings.`;
+            toolResults.push(`[TOOL_RESULT]: ERROR: ${denyMsg}`);
+            yield { type: "tool_result", content: `[TOOL_RESULT]: ERROR: ${denyMsg}` };
+            continue;
+          }
+        }
+        if (settings.onToolApproval) {
+          let shouldPrompt = false;
+          if (toolCall.toolName === "write_file" || toolCall.toolName === "update_file") {
+            shouldPrompt = true;
+          } else if (toolCall.toolName === "exec_command") {
+            shouldPrompt = true;
+          }
+          if (shouldPrompt) {
+            const approval = await settings.onToolApproval(toolCall.toolName, toolCall.args);
+            if (approval === "deny") {
+              if (toolCall.toolName === "exec_command" && settings.onExecEnd) settings.onExecEnd();
+              const denyMsg = `Permission Denied: User rejected the ${toolCall.toolName === "exec_command" ? "terminal execution" : "file edit"}.`;
+              toolResults.push(`[TOOL_RESULT]: ERROR: ${denyMsg}`);
+              yield { type: "tool_result", content: `[TOOL_RESULT]: ERROR: ${denyMsg}` };
+              continue;
+            }
+          }
+        }
+        const result = await dispatchTool(toolCall.toolName, toolCall.args, {
+          chatId,
+          history,
+          onChunk: (chunk) => settings.onExecChunk ? settings.onExecChunk(chunk) : null
+        });
+        if (toolCall.toolName === "exec_command" && settings.onExecEnd) {
+          await new Promise((resolve) => setTimeout(resolve, 800));
+          settings.onExecEnd();
+        }
+        try {
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+          const isErr = result.startsWith("ERROR:");
+          const logStatus = isErr ? result.trim() : "SUCCESS";
+          const toolHistDir = path13.join(AGENT_ROOT6, "logs", "tools");
+          if (!fs12.existsSync(toolHistDir)) {
+            fs12.mkdirSync(toolHistDir, { recursive: true });
+          }
+          fs12.appendFileSync(path13.join(toolHistDir, "history.log"), `HISTORY [${timestamp}]: ${toolCall.toolName} [${logStatus}]
+`);
+        } catch (logErr) {
+        }
+        const cleanResultForAI = result.split(/\r?\n/).filter((line) => !line.includes("[UI_CONTEXT]")).join("\n");
+        toolResults.push(`[TOOL_RESULT]: ${cleanResultForAI}`);
+        yield { type: "tool_result", content: `[TOOL_RESULT]: ${result}` };
+        if (toolCall.toolName === "memory" && result.includes("SUCCESS")) {
+          yield { type: "memory_updated" };
+        }
+      }
+    }
+    const cleanedTurnText = turnText.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/\[?\s*(turn\s*:)?\s*(continue|finish)\s*\]?/gi, "").trim();
+    if (hasFinish || !shouldContinue && toolResults.length === 0) {
+      const lateHint = await steeringCallback();
+      if (lateHint) {
+        toolResults.push(`[USER STEERING HINT]: ${lateHint}`);
+        yield { type: "status", content: "Steering detected... resuming!" };
+        continue;
+      }
+      yield { type: "status", content: "Finalizing..." };
+      const janitorContents = history.slice(-3).filter((msg) => msg.text && !msg.text.includes("[TOOL_RESULT]") && !msg.text.includes("OBSERVATION:")).map((msg) => ({
+        role: msg.role === "user" ? "user" : "model",
+        parts: [{ text: msg.text.replace(/<think>[\s\S]*?<\/think>/g, "").trim() }]
+      }));
+      const cleanedFullResponse = fullAgentResponse.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+      const janitorPrompt = getJanitorInstruction(
+        agentText,
+        cleanedFullResponse,
+        janitorUserMemories,
+        isMemoryEnabled,
+        needTitle
+      );
+      janitorContents.push({ role: "user", parts: [{ text: janitorPrompt }] });
+      let finalSynthesis = "";
+      try {
+        if (!await checkQuota("background", settings)) {
+          console.warn("Quota Exhausted for Background Model. Skipping refinement.");
+          throw new Error("QUOTA_BLOCKED");
+        }
+        const janitorResult = await client.models.generateContent({
+          model: janitorModel || "gemma-4-26b-a4b-it",
+          contents: janitorContents,
+          config: {
+            thinkingConfig: {
+              includeThoughts: false,
+              thinkingLevel: ThinkingLevel.MINIMAL
+            }
+          }
+        });
+        const parts = janitorResult.candidates?.[0]?.content?.parts;
+        if (parts && parts[1]?.text) {
+          finalSynthesis = parts[1].text;
+          const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+          const janitorLogDir = path13.join(AGENT_ROOT6, "logs", "janitor");
+          if (!fs12.existsSync(janitorLogDir)) {
+            fs12.mkdirSync(janitorLogDir, { recursive: true });
+          }
+          fs12.appendFileSync(path13.join(janitorLogDir, "debug.log"), `DEBUG [${date}]: ${finalSynthesis}
+`);
+        } else if (parts && parts[0]?.text) finalSynthesis = parts[0].text;
+        else if (janitorResult.response && janitorResult.response.text) finalSynthesis = janitorResult.response.text();
+        else throw new Error("No synthesis generated by Janitor.");
+        await incrementUsage("background");
+        yield { type: "background_increment" };
+        const janitorToolCalls = detectToolCalls(finalSynthesis);
+        for (const janitorToolCall of janitorToolCalls) {
+          const toolContext = { chatId, sessionId: chatId, history };
+          const result = await dispatchTool(janitorToolCall.toolName, janitorToolCall.args, toolContext);
+          const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+          const janitorLogDir = path13.join(AGENT_ROOT6, "logs", "janitor");
+          fs12.appendFileSync(path13.join(janitorLogDir, "debug.log"), `DEBUG [${date}]: RESULT [${janitorToolCall.toolName}]: ${result}
+`);
+          if (janitorToolCall.toolName === "memory" && !janitorToolCall.args.includes("action='temp'")) {
+            yield { type: "memory_updated" };
+          }
+        }
+      } catch (janitorErr) {
+        const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
+        const janitorErrDir = path13.join(AGENT_ROOT6, "logs", "janitor");
+        if (!fs12.existsSync(janitorErrDir)) {
+          fs12.mkdirSync(janitorErrDir, { recursive: true });
+        }
+        fs12.appendFileSync(path13.join(janitorErrDir, "error.log"), `ERROR [${date}]: ${janitorErr.message}
+`);
+        console.error("Janitor Background Tasks Failed:", janitorErr.message);
+      }
+      const timestamp = `Responded on ${(/* @__PURE__ */ new Date()).toLocaleString()}`;
+      const finalWithTime = `${cleanedFullResponse}
+
+${timestamp}`;
+      if (modifiedHistory.length > 0 && modifiedHistory[modifiedHistory.length - 1].role === "agent") {
+        modifiedHistory[modifiedHistory.length - 1].text = finalWithTime;
+      } else {
+        modifiedHistory.push({ role: "agent", text: finalWithTime });
+      }
+      break;
+    }
+    if (!shouldContinue && toolResults.length === 0) break;
+    const nextAgentMsg = cleanedTurnText.trim() || "*Working...*";
+    modifiedHistory.push({ role: "agent", text: nextAgentMsg });
+    const nextUserMsg = toolResults.length > 0 ? `${toolResults.join("\n")}` : "";
+    if (nextUserMsg) {
+      modifiedHistory.push({ role: "user", text: nextUserMsg });
+    }
+  }
+  yield { type: "status", content: null };
+};
+
+// src/utils/settings.js
+import fs13 from "fs-extra";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+var __dirname8 = path14.dirname(fileURLToPath8(import.meta.url));
+var SETTINGS_PATH = path14.join(__dirname8, "../../settings.json");
+var DEFAULT_SETTINGS = {
+  mode: "Flux",
+  thinkingLevel: "Medium",
+  activeModel: "gemma-4-31b-it",
+  showFullThinking: false,
+  apiTier: "Free",
+  quotas: {
+    agentLimit: 1500,
+    backgroundLimit: 1500,
+    searchLimit: 100,
+    customModelId: "",
+    customLimit: 0
+  },
+  systemSettings: {
+    memory: true,
+    compression: 0,
+    autoExec: false,
+    allowExternalAccess: false,
+    autoDeleteHistory: "7d"
+  },
+  profileData: {
+    name: null,
+    nickname: null,
+    instructions: null
+  }
+};
+var loadSettings = async () => {
+  try {
+    if (await fs13.exists(SETTINGS_PATH)) {
+      const saved = await fs13.readJson(SETTINGS_PATH);
+      return {
+        ...DEFAULT_SETTINGS,
+        ...saved,
+        quotas: { ...DEFAULT_SETTINGS.quotas, ...saved.quotas },
+        systemSettings: { ...DEFAULT_SETTINGS.systemSettings, ...saved.systemSettings },
+        profileData: { ...DEFAULT_SETTINGS.profileData, ...saved.profileData }
+      };
+    }
+  } catch (err) {
+    console.error("Failed to load settings:", err);
+  }
+  return DEFAULT_SETTINGS;
+};
+var saveSettings = async (settings) => {
+  try {
+    const current = await loadSettings();
+    const updated = { ...current, ...settings };
+    await fs13.writeJson(SETTINGS_PATH, updated, { spaces: 2 });
+    return true;
+  } catch (err) {
+    console.error("Failed to save settings:", err);
+    return false;
+  }
+};
+
+// src/components/ResumeModal.jsx
+import React6, { useState as useState2, useEffect } from "react";
+import { Box as Box6, Text as Text6, useInput } from "ink";
+function ResumeModal({ onSelect, onDelete, onClose }) {
+  const [history, setHistory] = useState2({});
+  const [keys, setKeys] = useState2([]);
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  useEffect(() => {
+    const fetchHistory = async () => {
+      const h = await loadHistory();
+      setHistory(h);
+      setKeys(Object.keys(h).sort((a, b) => (h[b].updatedAt || 0) - (h[a].updatedAt || 0)));
+    };
+    fetchHistory();
+  }, []);
+  useInput((input, key) => {
+    if (key.escape) onClose();
+    if (key.upArrow) setSelectedIndex((prev) => Math.max(0, prev - 1));
+    if (key.downArrow) setSelectedIndex((prev) => Math.min(keys.length - 1, prev + 1));
+    if (key.return && keys[selectedIndex]) onSelect(keys[selectedIndex]);
+    if (input === "x" && keys[selectedIndex]) {
+      const targetId = keys[selectedIndex];
+      onDelete(targetId).then((newHistory) => {
+        const safeHistory = newHistory || {};
+        setHistory(safeHistory);
+        const newKeys = Object.keys(safeHistory).sort((a, b) => (safeHistory[b]?.updatedAt || 0) - (safeHistory[a]?.updatedAt || 0));
+        setKeys(newKeys);
+        setSelectedIndex((prev) => Math.max(0, Math.min(newKeys.length - 1, prev)));
+      });
+    }
+  });
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", borderStyle: "double", borderColor: "cyan", padding: 1, width: 80 }, /* @__PURE__ */ React6.createElement(Box6, { justifyContent: "center", marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text6, { bold: true, color: "cyan" }, " \u{1F4C2} RESUME SESSION ")), keys.length === 0 ? /* @__PURE__ */ React6.createElement(Text6, { italic: true, color: "gray" }, " No saved chats found. ") : keys.map((id, index) => {
+    const chat2 = history[id];
+    const isSelected = index === selectedIndex;
+    return /* @__PURE__ */ React6.createElement(Box6, { key: id, paddingX: 1 }, /* @__PURE__ */ React6.createElement(Text6, { color: isSelected ? "cyan" : "white" }, isSelected ? "\u276F " : "  ", /* @__PURE__ */ React6.createElement(Text6, { bold: isSelected }, chat2.name || id), /* @__PURE__ */ React6.createElement(Text6, { color: "gray" }, " [", id.slice(5), "]")), isSelected && /* @__PURE__ */ React6.createElement(Box6, { marginLeft: "auto" }, /* @__PURE__ */ React6.createElement(Text6, { color: "red" }, " (x to delete) ")));
+  }), /* @__PURE__ */ React6.createElement(Box6, { marginTop: 1, justifyContent: "center", borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " \u2191\u2193 navigate \u2022 Enter select \u2022 x delete \u2022 Esc close ")));
+}
+
+// src/components/MemoryModal.jsx
+import React7, { useState as useState3, useEffect as useEffect2 } from "react";
+import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
+import path15 from "path";
+var MEMORIES_PATH2 = path15.join(process.cwd(), "secret", "memories.json");
+function MemoryModal({ onClose }) {
+  const [memories, setMemories] = useState3([]);
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const loadMemories = () => {
+    const data = readEncryptedJson(MEMORIES_PATH2, []);
+    setMemories(data);
+  };
+  useEffect2(() => {
+    loadMemories();
+  }, []);
+  useInput2((input, key) => {
+    if (key.escape) onClose();
+    if (key.upArrow) setSelectedIndex((prev) => Math.max(0, prev - 1));
+    if (key.downArrow) setSelectedIndex((prev) => Math.min(memories.length - 1, prev + 1));
+    if (input === "x" && memories.length > 0) {
+      const idToDelete = memories[selectedIndex].id;
+      const updated = memories.filter((m) => m.id !== idToDelete);
+      writeEncryptedJson(MEMORIES_PATH2, updated);
+      setMemories(updated);
+      if (selectedIndex >= updated.length && updated.length > 0) {
+        setSelectedIndex(updated.length - 1);
+      }
+    }
+  });
+  const cleanDisplay = (text) => {
+    return text.replace(/\[Saved on: .*?\]/g, "").trim();
+  };
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", borderStyle: "double", borderColor: "yellow", padding: 1, width: 80 }, /* @__PURE__ */ React7.createElement(Box7, { justifyContent: "center", marginBottom: 1 }, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "yellow" }, "\u{1F9E0} LONG-TERM MEMORY VAULT")), memories.length === 0 ? /* @__PURE__ */ React7.createElement(Box7, { justifyContent: "center", paddingY: 2 }, /* @__PURE__ */ React7.createElement(Text7, { italic: true, color: "gray" }, "The vault is currently empty...")) : memories.map((mem, idx) => /* @__PURE__ */ React7.createElement(Box7, { key: mem.id, paddingX: 1, backgroundColor: idx === selectedIndex ? "#333" : void 0 }, /* @__PURE__ */ React7.createElement(Text7, { color: idx === selectedIndex ? "yellow" : "white" }, idx === selectedIndex ? "\u276F " : "  ", idx + 1, ". ", cleanDisplay(mem.memory)))), /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, paddingTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "gray" }, "\u2191/\u2193 Navigate \u2022 ", /* @__PURE__ */ React7.createElement(Text7, { color: "red" }, "x"), " Delete Memory \u2022 ", /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, "Esc"), " Back to Chat")));
+}
+
+// src/app.jsx
+var SESSION_START_TIME = Date.now();
+var ResolutionModal = ({ data, onResolve, onEdit }) => /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 2, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { color: "magenta", bold: true, underline: true }, "\u{1F7E3} STEERING HINT RESOLUTION"), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "The agent already finished the task (turn: finish) before your hint was consumed."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1, backgroundColor: "#222", paddingX: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { italic: true, color: "gray" }, '"', data, '"')), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, { color: "cyan" }, "How would you like to proceed?")), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+  CommandMenu,
+  {
+    title: "Select Action",
+    items: [
+      { label: "Send Anyway", value: "send" },
+      { label: "Edit Prompt", value: "edit" }
+    ],
+    onSelect: (val) => {
+      if (val === "send") onResolve(data);
+      else onEdit(data);
+    }
+  }
+)));
+var FLUX_LOGO = gradient(["#00ffff", "#0077ff", "#ff00ff"]).multiline(
+  `\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557     \u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557      \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557    \u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D    \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551    \u2588\u2588\u2551
+\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551
+\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2554\u2588\u2588\u2557     \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551
+\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u255D \u2588\u2588\u2557    \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D
+\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D    \u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D`
+);
+function App() {
+  const { stdout } = useStdout();
+  const [input, setInput] = useState4("");
+  const [mode, setMode] = useState4("Flux");
+  const [terminalSize, setTerminalSize] = useState4({
+    columns: stdout?.columns || 80,
+    rows: stdout?.rows || 24
+  });
+  useEffect3(() => {
+    const handleResize = () => {
+      stdout.write("\x1Bc");
+      setTerminalSize({
+        columns: stdout.columns,
+        rows: stdout.rows
+      });
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  const [thinkingLevel, setThinkingLevel] = useState4("Medium");
+  const [showFullThinking, setShowFullThinking] = useState4(false);
+  const [activeModel, setActiveModel] = useState4("gemma-4-31b-it");
+  const [janitorModel, setJanitorModel] = useState4("gemma-4-26b-a4b-it");
+  const [isInitializing, setIsInitializing] = useState4(true);
+  const [apiKey, setApiKey] = useState4(null);
+  const [tempKey, setTempKey] = useState4("");
+  const [activeView, setActiveView] = useState4("chat");
+  const [apiTier, setApiTier] = useState4("Free");
+  const [quotas, setQuotas] = useState4({ agentLimit: 1500, backgroundLimit: 1500, searchLimit: 100, customModelId: "", customLimit: 0 });
+  const [inputConfig, setInputConfig] = useState4(null);
+  const [systemSettings, setSystemSettings] = useState4({ memory: true, compression: 0, autoExec: false, autoDeleteHistory: "7d" });
+  const [profileData, setProfileData] = useState4({ name: null, nickname: null, instructions: null });
+  const [sessionStats, setSessionStats] = useState4({ tokens: 0 });
+  const [sessionAgentCalls, setSessionAgentCalls] = useState4(0);
+  const [sessionBackgroundCalls, setSessionBackgroundCalls] = useState4(0);
+  const [sessionTotalTokens, setSessionTotalTokens] = useState4(0);
+  const [dailyUsage, setDailyUsage] = useState4(null);
+  const [chatId, setChatId] = useState4(generateChatId());
+  const [activeCommand, setActiveCommand] = useState4(null);
+  const [execOutput, setExecOutput] = useState4("");
+  const activeCommandRef = useRef(null);
+  const execOutputRef = useRef("");
+  useEffect3(() => {
+    activeCommandRef.current = activeCommand;
+  }, [activeCommand]);
+  useEffect3(() => {
+    execOutputRef.current = execOutput;
+  }, [execOutput]);
+  const [autoAcceptWrites, setAutoAcceptWrites] = useState4(false);
+  const [pendingApproval, setPendingApproval] = useState4(null);
+  const formatDuration = (totalSecs) => {
+    const h = Math.floor(totalSecs / 3600);
+    const m = Math.floor(totalSecs % 3600 / 60);
+    const s = totalSecs % 60;
+    if (h > 0) {
+      return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+    }
+    return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+  };
+  const [statusText, setStatusText] = useState4(null);
+  const [isProcessing, setIsProcessing] = useState4(false);
+  const [escPressed, setEscPressed] = useState4(false);
+  const [escTimer, setEscTimer] = useState4(null);
+  const [queuedPrompt, setQueuedPrompt] = useState4(null);
+  const [resolutionData, setResolutionData] = useState4(null);
+  const [messages, setMessages] = useState4([
+    { id: "welcome", role: "system", text: FLUX_LOGO + "\n\n\u{1F30A}\u26A1 Welcome to Flux Flow! Type /help for commands.\n" }
+  ]);
+  const [completedIndex, setCompletedIndex] = useState4(1);
+  useInput3((inputText, key) => {
+    if (key.escape) {
+      if (isProcessing) {
+        if (!escPressed) {
+          setEscPressed(true);
+          if (escTimer) clearTimeout(escTimer);
+          setEscTimer(setTimeout(() => setEscPressed(false), 3e3));
+        } else {
+          signalTermination();
+          setEscPressed(false);
+          if (escTimer) clearTimeout(escTimer);
+        }
+      } else if (activeView !== "chat") {
+        setActiveView("chat");
+      }
+    }
+    if (key.tab && suggestions.length > 0 && activeView === "chat") {
+      const nextCmd = suggestions[0];
+      setInput(nextCmd + " ");
+    }
+    if (key.ctrl && inputText === "c" && activeView !== "exit") {
+      setActiveView("exit");
+    }
+    if (key.return && (key.ctrl || key.meta)) {
+      setInput((prev) => prev.replace(/\\\r?$/, "").replace(/\r?$/, "") + "\n");
+    }
+  });
+  useEffect3(() => {
+    async function init() {
+      const saved = await loadSettings();
+      setMode(saved.mode);
+      setThinkingLevel(saved.thinkingLevel);
+      setActiveModel(saved.activeModel);
+      setShowFullThinking(saved.showFullThinking);
+      setApiTier(saved.apiTier || "Free");
+      setQuotas(saved.quotas || { agentLimit: 1500, searchLimit: 100, customModelId: "", customLimit: 0 });
+      setSystemSettings(saved.systemSettings);
+      setProfileData(saved.profileData);
+      const key = await getAPIKey();
+      if (key) {
+        setApiKey(key);
+        initAI(key);
+      }
+      if (saved.systemSettings?.autoDeleteHistory) {
+        cleanupOldHistory(saved.systemSettings.autoDeleteHistory);
+      }
+      setIsInitializing(false);
+    }
+    init();
+  }, []);
+  useEffect3(() => {
+    if (!isInitializing) {
+      saveSettings({
+        mode,
+        thinkingLevel,
+        activeModel,
+        showFullThinking,
+        systemSettings,
+        profileData
+      });
+    }
+  }, [mode, thinkingLevel, activeModel, showFullThinking, systemSettings, profileData, isInitializing]);
+  const handleSetup = async (val) => {
+    const key = val.trim();
+    if (key.length >= 30) {
+      await saveAPIKey(key);
+      setApiKey(key);
+      initAI(key);
+      setMessages((prev) => [...prev, { role: "system", text: "\u2705 API Key saved successfully! Initialization complete." }]);
+    } else {
+      setMessages((prev) => [...prev, { role: "system", text: `\u274C INVALID KEY: Gemini API keys must be at least 30 characters.` }]);
+      setTempKey("");
+    }
+  };
+  const COMMANDS = ["/mode", "/thinking", "/model", "/resume", "/memory", "/profile", "/settings", "/key", "/stats", "/help", "/clear", "/quit"];
+  const handleSubmit = (value) => {
+    const normalizedValue = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trimEnd();
+    if (normalizedValue.endsWith("\\")) {
+      setInput(normalizedValue.slice(0, -1) + "\n");
+      return;
+    }
+    const absoluteClean = normalizedValue.replace(/\\\s*\n/g, "\n").split("\n").map((l) => l.replace(/\\$/, "")).join("\n");
+    if (!absoluteClean.trim()) return;
+    if (isProcessing) {
+      const hintText = absoluteClean.trim();
+      setQueuedPrompt(hintText);
+      setMessages((prev) => {
+        setCompletedIndex(prev.length + 1);
+        return [...prev, { id: "hint-" + Date.now(), role: "user", text: `[STEERING HINT: QUEUED] 
+${hintText}`, color: "magenta" }];
+      });
+      setInput("");
+      return;
+    }
+    if (!apiKey) {
+      handleSetup(absoluteClean);
+      setTempKey("");
+      return;
+    }
+    if (absoluteClean.startsWith("/")) {
+      const parts = absoluteClean.split(" ");
+      const cmd = parts[0]?.toLowerCase();
+      switch (cmd) {
+        case "/quit": {
+          setActiveView("exit");
+          break;
+        }
+        case "/resume": {
+          if (parts[1]) {
+            const targetId = parts[1];
+            const resumeSession = async () => {
+              const h = await loadHistory();
+              const target = h[targetId] || Object.values(h).find((h2) => h2.name.toLowerCase() === targetId.toLowerCase());
+              if (target) {
+                process.stdout.write("\x1Bc");
+                setChatId(targetId);
+                setMessages(target.messages);
+                setMessages((prev) => [...prev, { id: "sys-" + Date.now(), role: "system", text: `\u{1F4E1} SESSION RESUMED: [${targetId}]` }]);
+                setCompletedIndex(0);
+              } else {
+                setMessages((prev) => [...prev, { id: "err-" + Date.now(), role: "system", text: `\u274C ERROR: Session [${targetId}] not found.` }]);
+              }
+            };
+            resumeSession();
+          } else {
+            setActiveView("resume");
+          }
+          break;
+        }
+        case "/clear": {
+          process.stdout.write("\x1Bc");
+          setMessages([{ id: "welcome-" + Date.now(), role: "system", text: FLUX_LOGO + "\n\n\u{1F30A}\u26A1 Welcome back to Flux Flow! Context cleared.\n" }]);
+          setCompletedIndex(0);
+          setChatId(generateChatId());
+          setSessionStats({ tokens: 0 });
+          break;
+        }
+        case "/mode": {
+          if (parts[1]) {
+            const newMode = parts[1].toLowerCase() === "flow" ? "Flow" : "Flux";
+            setMode(newMode);
+            setMessages((prev) => {
+              setCompletedIndex(prev.length + 1);
+              return [...prev, { id: Date.now(), role: "system", text: `\u2699\uFE0F [SYSTEM] Mode switched to ${newMode}` }];
+            });
+          } else {
+            setActiveView("mode");
+          }
+          break;
+        }
+        case "/thinking": {
+          const arg = parts[1]?.toLowerCase();
+          if (arg === "show") {
+            setShowFullThinking(true);
+            setMessages((prev) => {
+              setCompletedIndex(prev.length + 1);
+              return [...prev, { id: Date.now(), role: "system", text: "\u2699\uFE0F [SYSTEM] Full Thinking Process: VISIBLE" }];
+            });
+          } else if (arg === "hide") {
+            setShowFullThinking(false);
+            setMessages((prev) => {
+              setCompletedIndex(prev.length + 1);
+              return [...prev, { id: Date.now(), role: "system", text: "\u2699\uFE0F [SYSTEM] Full Thinking Process: HIDDEN (Headings only)" }];
+            });
+          } else if (parts[1]) {
+            let val = parts[1].toLowerCase();
+            if (val === "xhigh") val = "max";
+            const formattedLevel = val.charAt(0).toUpperCase() + val.slice(1);
+            if (mode === "Flow" && (formattedLevel === "High" || formattedLevel === "Max")) {
+              setMessages((prev) => {
+                setCompletedIndex(prev.length + 1);
+                return [...prev, { id: Date.now(), role: "system", text: `\u274C [RESTRICTED] "${formattedLevel}" is restricted in Flow mode. Switch to /mode Flux to enable Deep Thinking.` }];
+              });
+            } else {
+              setThinkingLevel(formattedLevel);
+              setMessages((prev) => {
+                setCompletedIndex(prev.length + 1);
+                return [...prev, { id: Date.now(), role: "system", text: `\u2699\uFE0F [SYSTEM] Thinking level set to ${formattedLevel}` }];
+              });
+            }
+          } else {
+            setActiveView("thinking");
+          }
+          break;
+        }
+        case "/model": {
+          if (parts[1]) {
+            const mod = parts.slice(1).join(" ");
+            setActiveModel(mod);
+            setMessages((prev) => {
+              setCompletedIndex(prev.length + 1);
+              return [...prev, { id: Date.now(), role: "system", text: `\u2699\uFE0F [SYSTEM] Model switched to ${mod}` }];
+            });
+          } else {
+            setActiveView("model");
+          }
+          break;
+        }
+        case "/settings": {
+          setActiveView("settings");
+          break;
+        }
+        case "/key": {
+          setActiveView("key");
+          break;
+        }
+        case "/profile": {
+          setActiveView("profile");
+          break;
+        }
+        case "/stats": {
+          const run = async () => {
+            const usage = await getDailyUsage();
+            setDailyUsage(usage);
+            setActiveView("stats");
+          };
+          run();
+          break;
+        }
+        case "/save": {
+          const name = parts.slice(1).join(" ") || `Session ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`;
+          saveChat(chatId, name, messages);
+          setMessages((prev) => {
+            setCompletedIndex(prev.length + 1);
+            return [...prev, { id: Date.now(), role: "system", text: `\u{1F4BE} [MEMORY] Chat saved as "${name}" (ID: ${chatId})` }];
+          });
+          break;
+        }
+        case "/chats": {
+          const run = async () => {
+            const history = await loadHistory();
+            const list = Object.entries(history).map(([id, info]) => `\u2022 ${id}: ${info.name}`).join("\n");
+            setMessages((prev) => {
+              setCompletedIndex(prev.length + 1);
+              return [...prev, { id: Date.now(), role: "system", text: `\u{1F5C3}\uFE0F [HISTORY] Saved Chats:
+${list || "No saved chats found."}` }];
+            });
+          };
+          run();
+          break;
+        }
+        case "/memory": {
+          setActiveView("memory");
+          break;
+        }
+        case "/help": {
+          setMessages((prev) => {
+            setCompletedIndex(prev.length + 1);
+            return [...prev, { id: Date.now(), role: "system", text: "\u2699\uFE0F [SYSTEM] Available commands: " + COMMANDS.join(", ") }];
+          });
+          break;
+        }
+        default:
+          setMessages((prev) => {
+            setCompletedIndex(prev.length + 1);
+            return [...prev, { id: Date.now(), role: "system", text: `\u2699\uFE0F [SYSTEM] Unknown command: ${cmd}` }];
+          });
+      }
+    } else {
+      const timestamp = `[Prompted on: ${(/* @__PURE__ */ new Date()).toLocaleString()}]`;
+      const userMessage = { id: "user-" + Date.now(), role: "user", text: `${absoluteClean}
+
+${timestamp}` };
+      setMessages((prev) => {
+        setCompletedIndex(prev.length + 1);
+        return [...prev, userMessage];
+      });
+      const streamChat = async () => {
+        setIsProcessing(true);
+        try {
+          const cleanHistoryForAI = [...messages, userMessage].filter(
+            (m) => m.role !== "think" && !String(m.id).startsWith("welcome")
+          );
+          const stream = getAIStream(
+            activeModel,
+            cleanHistoryForAI,
+            {
+              profile: profileData,
+              thinkingLevel,
+              mode,
+              systemSettings,
+              janitorModel,
+              sessionStats,
+              chatId,
+              onExecStart: (cmd) => {
+                setActiveCommand(cmd);
+                setExecOutput("");
+              },
+              onExecChunk: (chunk) => {
+                setExecOutput((prev) => prev + chunk);
+              },
+              onExecEnd: () => {
+                setMessages((prev) => {
+                  const finalStatus = `[TERMINAL_RECORD]
+COMMAND: ${activeCommandRef.current}
+OUTPUT: ${execOutputRef.current}`;
+                  return [...prev, { id: "term-" + Date.now(), role: "system", text: finalStatus, isTerminalRecord: true }];
+                });
+                setActiveCommand(null);
+                setExecOutput("");
+              },
+              onToolApproval: async (tool, args) => {
+                const isAuto = autoAcceptWrites || systemSettings.autoExec;
+                if (tool === "exec_command") {
+                  const { command } = parseArgs(args || "{}");
+                  const safeRegex = /^(echo|ls|dir|pwd|cd|git status|git log|git diff|type|cat|help)\b/i;
+                  if (isAuto || command && safeRegex.test(command.trim())) return "allow";
+                  return new Promise((resolve) => {
+                    setPendingApproval({ tool, args, resolve });
+                    setActiveView("terminalApproval");
+                  });
+                }
+                if (isAuto) return "allow";
+                return new Promise((resolve) => {
+                  setPendingApproval({ tool, args, resolve });
+                  setActiveView("approval");
+                });
+              }
+            },
+            async () => {
+              if (queuedPrompt) {
+                const p = queuedPrompt;
+                setQueuedPrompt(null);
+                return p;
+              }
+              return null;
+            }
+          );
+          let inThinkMode = false;
+          let currentThinkId = null;
+          let currentAgentId = null;
+          const signalRegex = /\[?_DISABLED_SIGNAL_REGEX_\]?/gi;
+          for await (const packet of stream) {
+            if (packet.type === "status") {
+              setStatusText(packet.content);
+              continue;
+            }
+            if (packet.type === "turn_reset") {
+              currentThinkId = null;
+              currentAgentId = null;
+              inThinkMode = false;
+              continue;
+            }
+            if (packet.type === "memory_updated") {
+              setMessages((prev) => {
+                const newMsgs = [...prev];
+                if (newMsgs.length > 0) {
+                  newMsgs[newMsgs.length - 1].memoryUpdated = true;
+                }
+                return newMsgs;
+              });
+              continue;
+            }
+            if (packet.type === "exec_start") {
+              continue;
+            }
+            if (packet.type === "usage") {
+              const total = packet.content.totalTokenCount || 0;
+              setSessionStats({ tokens: total });
+              setSessionTotalTokens((prev) => prev + total);
+              setSessionAgentCalls((prev) => prev + 1);
+              continue;
+            }
+            if (packet.type === "background_increment") {
+              setSessionBackgroundCalls((prev) => prev + 1);
+              continue;
+            }
+            if (packet.type === "tool_result") {
+              setMessages((prev) => [...prev, { id: "tool-" + Date.now(), role: "system", text: packet.content }]);
+              continue;
+            }
+            let chunkText = packet.content;
+            if (chunkText.includes("<think>") && !inThinkMode) {
+              inThinkMode = true;
+              chunkText = chunkText.replace("<think>", "");
+              currentThinkId = "think-" + Date.now();
+              setMessages((prev) => [...prev, { id: currentThinkId, role: "think", text: "" }]);
+            }
+            if (chunkText.includes("</think>")) {
+              const [thinkPart, agentPart] = chunkText.split("</think>");
+              if (inThinkMode) {
+                setMessages((prev) => {
+                  const newMsgs = [...prev];
+                  const thinkMsg = newMsgs.find((m) => m.id === currentThinkId);
+                  if (thinkMsg) thinkMsg.text += thinkPart.replace(signalRegex, "");
+                  currentAgentId = "agent-" + Date.now();
+                  const cleanedAgentPart = (agentPart || "").replace(signalRegex, "");
+                  return [...newMsgs, { id: currentAgentId, role: "agent", text: cleanedAgentPart }];
+                });
+                inThinkMode = false;
+              } else {
+                const cleanedContent = (agentPart || thinkPart || "").replace(signalRegex, "");
+                if (!currentAgentId) {
+                  currentAgentId = "agent-" + Date.now();
+                  setMessages((prev) => [...prev, { id: currentAgentId, role: "agent", text: cleanedContent }]);
+                } else {
+                  setMessages((prev) => {
+                    const newMsgs = [...prev];
+                    const msg = newMsgs.find((m) => m.id === currentAgentId);
+                    if (msg) msg.text += cleanedContent;
+                    return newMsgs;
+                  });
+                }
+              }
+              continue;
+            }
+            if (inThinkMode && currentThinkId) {
+              setMessages((prev) => {
+                const newMsgs = [...prev];
+                const msg = newMsgs.find((m) => m.id === currentThinkId);
+                if (msg) msg.text += chunkText.replace(signalRegex, "");
+                return newMsgs;
+              });
+            } else if (!inThinkMode) {
+              const cleanedText = chunkText.replace("<think>", "").replace(signalRegex, "");
+              if (!currentAgentId) {
+                currentAgentId = "agent-" + Date.now();
+                setMessages((prev) => [...prev, { id: currentAgentId, role: "agent", text: cleanedText }]);
+              } else {
+                setMessages((prev) => {
+                  const newMsgs = [...prev];
+                  const msg = newMsgs.find((m) => m.id === currentAgentId);
+                  if (msg) msg.text += cleanedText;
+                  return newMsgs;
+                });
+              }
+            }
+          }
+        } catch (err) {
+          setMessages((prev) => {
+            setCompletedIndex(prev.length + 1);
+            return [...prev, { id: "error-" + Date.now(), role: "system", text: `\u274C ERROR: ${err.message}` }];
+          });
+        } finally {
+          setIsProcessing(false);
+          setStatusText(null);
+          if (queuedPrompt) {
+            setResolutionData(queuedPrompt);
+            setQueuedPrompt(null);
+            setActiveView("resolution");
+          }
+          setMessages((prev) => {
+            const historyToSave = prev.filter((m) => !String(m.id).startsWith("welcome"));
+            saveChat(chatId, null, historyToSave);
+            setCompletedIndex(prev.length);
+            return prev;
+          });
+        }
+      };
+      streamChat();
+    }
+    setInput("");
+  };
+  const getSuggestions = () => {
+    if (!input.startsWith("/") || input.includes(" ")) return [];
+    return COMMANDS.filter((c) => c.startsWith(input.toLowerCase()));
+  };
+  const suggestions = getSuggestions();
+  const renderActiveView = () => {
+    switch (activeView) {
+      case "mode":
+        return /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "\u26A1 Select Operating Mode",
+            items: [{ label: "Flux (Dev mode - Tools Enabled)", value: "Flux" }, { label: "Flow (Chat mode - No Tools)", value: "Flow" }, { label: "Cancel", value: "Cancel" }],
+            onSelect: (item) => {
+              if (item.value !== "Cancel") {
+                setMode(item.value);
+                if (item.value === "Flow") {
+                  setThinkingLevel("Medium");
+                } else if (item.value === "Flux") {
+                  setThinkingLevel("High");
+                }
+              }
+              setActiveView("chat");
+            }
+          }
+        );
+      case "thinking": {
+        const options = mode === "Flow" ? [
+          { label: "Low (Fastest)", value: "Low" },
+          { label: "Medium (Balanced)", value: "Medium" }
+        ] : [
+          { label: "Low (Fastest)", value: "Low" },
+          { label: "Medium (Balanced)", value: "Medium" },
+          { label: "High (Complex coding)", value: "High" },
+          { label: "Max (Architecture)", value: "Max" }
+        ];
+        options.push({ label: "Cancel", value: "Cancel" });
+        return /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: `\u{1F9E0} Select Thinking Level (${mode} Mode)`,
+            items: options,
+            onSelect: (item) => {
+              if (item.value !== "Cancel") setThinkingLevel(item.value);
+              setActiveView("chat");
+            }
+          }
+        );
+      }
+      case "model":
+        return /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "\u{1F916} Select AI Model",
+            items: [{ label: "Gemma 4 31B (Default)", value: "gemma-4-31b-it" }, { label: "Gemini 3.1 Pro (Req. paid API Key)", value: "gemini-3.1-pro-preview" }, { label: "Gemini 3 Flash", value: "gemini-3-flash-preview" }, { label: "Gemini 3.1 Flash Lite", value: "gemini-3.1-flash-lite" }, { label: "Cancel", value: "Cancel" }],
+            onSelect: (item) => {
+              if (item.value !== "Cancel") setActiveModel(item.value);
+              setActiveView("chat");
+            }
+          }
+        );
+      case "settings":
+        return /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "System Settings",
+            items: [
+              { label: `Toggle Memory [ ${systemSettings.memory ? "ON" : "OFF"} ]`, value: "memory" },
+              { label: `Toggle Auto-Exec [ ${systemSettings.autoExec ? "ON" : "OFF"} ]`, value: "autoExec" },
+              { label: `External Workspace Access [ ${systemSettings.allowExternalAccess ? "ON" : "OFF"} ]`, value: "externalAccess" },
+              { label: `API Tier [ ${apiTier} ]`, value: "apiTier" },
+              { label: `Auto-Delete History [ ${systemSettings.autoDeleteHistory} ]`, value: "autoDelete" },
+              { label: "Exit Settings", value: "Cancel" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "memory") setSystemSettings((s) => ({ ...s, memory: !s.memory }));
+              else if (item.value === "autoExec") {
+                if (!systemSettings.autoExec) {
+                  if (systemSettings.allowExternalAccess) {
+                    setActiveView("doubleDanger");
+                  } else {
+                    setActiveView("autoExecDanger");
+                  }
+                } else {
+                  setSystemSettings((s) => ({ ...s, autoExec: false }));
+                }
+              } else if (item.value === "externalAccess") {
+                if (!systemSettings.allowExternalAccess) {
+                  if (systemSettings.autoExec) {
+                    setActiveView("doubleDanger");
+                  } else {
+                    setActiveView("externalDanger");
+                  }
+                } else {
+                  setSystemSettings((s) => ({ ...s, allowExternalAccess: false }));
+                }
+              } else if (item.value === "apiTier") setActiveView("apiTier");
+              else if (item.value === "autoDelete") {
+                const options = ["1d", "7d", "30d"];
+                const currentIndex = options.indexOf(systemSettings.autoDeleteHistory || "30d");
+                const nextIndex = (currentIndex + 1) % options.length;
+                setSystemSettings((s) => ({ ...s, autoDeleteHistory: options[nextIndex] }));
+              } else if (item.value === "Cancel") setActiveView("chat");
+            }
+          }
+        );
+      case "apiTier":
+        return /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: `API Tier: ${apiTier}`,
+            items: [
+              { label: "Free Tier (1,500/day)", value: "Free" },
+              { label: `Paid Tier (Budget: ${quotas.agentLimit})`, value: "Paid" },
+              { label: `Custom Model (Endpoint: ${quotas.customModelId || "None"})`, value: "Custom" },
+              { label: "Back", value: "settings" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "settings" || item.value === "Back") {
+                setActiveView("settings");
+                return;
+              }
+              const newTier = item.value;
+              setApiTier(newTier);
+              if (newTier === "Paid") {
+                setInputConfig({
+                  label: "Daily Agent Limit for default model (Gemma 4 31B):",
+                  note: "NOTE: If you have your own Gemini API supported model, use Custom mode.",
+                  key: "quotas",
+                  subKey: "agentLimit",
+                  value: String(quotas.agentLimit),
+                  next: (q) => ({
+                    label: "Daily default background model limit (Gemma 4 26B A4B):",
+                    key: "quotas",
+                    subKey: "backgroundLimit",
+                    value: String(q.backgroundLimit)
+                  })
+                });
+                setActiveView("input");
+              } else if (newTier === "Custom") {
+                setInputConfig({
+                  label: "Enter Agent Model ID:",
+                  key: "activeModel",
+                  value: activeModel,
+                  next: (val) => ({
+                    label: "Enter Background Model ID:",
+                    key: "janitorModel",
+                    value: janitorModel,
+                    next: (val2) => ({
+                      label: "Enter Agent daily limit (calls):",
+                      key: "quotas",
+                      subKey: "agentLimit",
+                      value: String(quotas.agentLimit),
+                      next: (q) => ({
+                        label: "Enter Background daily limit (calls):",
+                        key: "quotas",
+                        subKey: "backgroundLimit",
+                        value: String(quotas.backgroundLimit)
+                      })
+                    })
+                  })
+                });
+                setActiveView("input");
+              } else {
+                saveSettings({ apiTier: newTier, quotas });
+                setActiveView("settings");
+              }
+            },
+            onClose: () => setActiveView("settings")
+          }
+        );
+      case "input":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 }, inputConfig?.note && /* @__PURE__ */ React8.createElement(Box8, { marginBottom: 1 }, /* @__PURE__ */ React8.createElement(Text8, { color: "yellow", dimColor: true }, inputConfig.note)), /* @__PURE__ */ React8.createElement(Text8, { color: "cyan" }, inputConfig?.label), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          TextInput2,
+          {
+            value: inputConfig?.value || "",
+            onChange: (val) => setInputConfig((prev) => ({ ...prev, value: val })),
+            onSubmit: (val) => {
+              const { key, subKey, next } = inputConfig;
+              let newQuotas = { ...quotas };
+              let newSettings = {};
+              if (key === "quotas") {
+                const parsedValue = subKey.toLowerCase().includes("limit") ? parseInt(val) || 0 : val;
+                newQuotas[subKey] = parsedValue;
+                setQuotas(newQuotas);
+                newSettings.quotas = newQuotas;
+              } else if (key === "activeModel") {
+                setActiveModel(val);
+                newSettings.activeModel = val;
+              } else if (key === "janitorModel") {
+                setJanitorModel(val);
+                newSettings.janitorModel = val;
+              }
+              if (next) {
+                setInputConfig(next(key === "quotas" ? newQuotas : val));
+              } else {
+                saveSettings({ ...newSettings, apiTier, quotas: newQuotas });
+                setInputConfig(null);
+                setActiveView("settings");
+              }
+            }
+          }
+        )), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true, marginTop: 1 }, "(Press Enter to confirm)"));
+      case "stats":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React8.createElement(Text8, { color: "cyan", bold: true }, "\u{1F4CA} DAILY PERFORMANCE LEDGER"), /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Agent Model Calls:    ", /* @__PURE__ */ React8.createElement(Text8, { color: "green" }, dailyUsage?.agent || 0)), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Background Tasks:     ", /* @__PURE__ */ React8.createElement(Text8, { color: "blue" }, dailyUsage?.background || 0))), /* @__PURE__ */ React8.createElement(Text8, { dimColor: true, marginTop: 1 }, "(Press ESC to return to chat)"));
+      case "autoExecDanger":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { color: "yellow", bold: true, underline: true }, "\u26A0\uFE0F SECURITY WARNING: AUTO-EXEC MODE"), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "Turning this ON allows the agent to execute terminal commands automatically without requiring your approval for each step."), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1, color: "yellow" }, "RISKS INVOLVED:"), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 The agent may execute destructive commands (rm -rf, etc.) by mistake."), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Unintended system changes if the agent hallucinates a path or command."), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Reduced control over the agent's step-by-step decision making."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Confirm Intent",
+            items: [
+              { label: "I know the risk and turning on intentionally", value: "on" },
+              { label: "Keep Off (Recommended)", value: "off" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "on") {
+                setSystemSettings((s) => ({ ...s, autoExec: true }));
+              }
+              setActiveView("settings");
+            }
+          }
+        )));
+      case "externalDanger":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 2, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { color: "red", bold: true, underline: true }, "\u26A0\uFE0F SECURITY WARNING: EXTERNAL WORKSPACE ACCESS"), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "Turning this ON allows the agent to execute tools (Read/Write/Exec) outside of the current active workspace directory."), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1, color: "yellow" }, "RISKS INVOLVED:"), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Access to sensitive system files (SSH keys, Browser data, etc.)"), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Potential for accidental or malicious deletion of OS-critical files."), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Unauthorized script execution across your entire file system."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Confirm Intent",
+            items: [
+              { label: "I know the risk and turning on intentionally", value: "on" },
+              { label: "Keep Off (Recommended)", value: "off" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "on") {
+                setSystemSettings((s) => ({ ...s, allowExternalAccess: true }));
+              }
+              setActiveView("settings");
+            }
+          }
+        )));
+      case "doubleDanger":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 2, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { color: "red", bold: true, underline: true }, "\u26D4 CRITICAL SECURITY WARNING: COMBINED SYSTEM RISK"), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "You are attempting to enable BOTH [Auto-Exec] and [External Workspace Access] simultaneously."), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1, color: "red", bold: true }, "THIS IS NOT RECOMMENDED."), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1, color: "yellow" }, "THE CRITICAL RISK:"), /* @__PURE__ */ React8.createElement(Text8, null, "The agent will have the power to execute any command across your entire system WITHOUT your approval or supervision."), /* @__PURE__ */ React8.createElement(Text8, { color: "red", italic: true, marginTop: 1 }, "A single hallucination or error could result in full system wipe or data theft."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Final Confirmation",
+            items: [
+              { label: "I agree knowing the consequences", value: "on" },
+              { label: "Keep Off", value: "off" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "on") {
+                setSystemSettings((s) => ({ ...s, autoExec: true, allowExternalAccess: true }));
+              }
+              setActiveView("settings");
+            }
+          }
+        )));
+      case "key":
+        return /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "\u{1F511} API KEY MANAGEMENT",
+            items: [
+              { label: "Edit Current Key (Update)", value: "edit" },
+              { label: "Remove Current Key (Purge)", value: "remove" },
+              { label: "Cancel", value: "Cancel" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "edit") {
+                setApiKey(null);
+                setActiveView("chat");
+                setMessages((prev) => [...prev, { id: Date.now(), role: "system", text: "\u{1F5DD}\uFE0F [ACTION] Flux waiting for new API Key..." }]);
+              } else if (item.value === "remove") {
+                setActiveView("deleteKey");
+              } else {
+                setActiveView("chat");
+              }
+            }
+          }
+        );
+      case "deleteKey":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 2, paddingY: 1 }, /* @__PURE__ */ React8.createElement(Text8, { color: "red", bold: true }, "\u26A0\uFE0F DANGER: PURGE API KEY"), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "This will permanently delete the saved API key from the project vault. You will need to enter it again to use Flux."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Are you absolutely sure?",
+            items: [
+              { label: "YES, PURGE KEY", value: "yes" },
+              { label: "NO, GO BACK", value: "no" }
+            ],
+            onSelect: async (item) => {
+              if (item.value === "yes") {
+                await removeAPIKey();
+                setApiKey(null);
+                setActiveView("chat");
+                setMessages((prev) => [...prev, { id: Date.now(), role: "system", text: "\u{1F9FC} [VAULT PURGED] API Key removed successfully." }]);
+              } else {
+                setActiveView("key");
+              }
+            }
+          }
+        )));
+      case "exit":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", paddingX: 3, paddingY: 1, borderColor: "red" }, /* @__PURE__ */ React8.createElement(Text8, { color: "red", bold: true }, "\u{1F3C1} SESSION DASHBOARD"), /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Agent Active For:      ", /* @__PURE__ */ React8.createElement(Text8, { color: "yellow" }, formatDuration(Math.floor((Date.now() - SESSION_START_TIME) / 1e3)))), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Total Agent Queries:  ", /* @__PURE__ */ React8.createElement(Text8, { color: "green" }, sessionAgentCalls)), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Memory Tasks:        ", /* @__PURE__ */ React8.createElement(Text8, { color: "blue" }, sessionBackgroundCalls)), /* @__PURE__ */ React8.createElement(Text8, null, "\u2022 Total Tokens Consumed: ", /* @__PURE__ */ React8.createElement(Text8, { color: "magenta" }, (sessionTotalTokens / 1e3).toFixed(2), "k"))), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "Are you sure you want to exit?"), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Exit Confirmation",
+            items: [
+              { label: "Yes, Shutdown Flux", value: "yes" },
+              { label: "No, Back to terminal", value: "no" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "yes") {
+                process.exit(0);
+              } else {
+                setActiveView("chat");
+              }
+            }
+          }
+        )));
+      case "resume":
+        return /* @__PURE__ */ React8.createElement(Box8, { width: "100%", alignItems: "center", justifyContent: "center" }, /* @__PURE__ */ React8.createElement(
+          ResumeModal,
+          {
+            onSelect: async (id) => {
+              const h = await loadHistory();
+              if (h[id]) {
+                setChatId(id);
+                setMessages(h[id].messages);
+                setActiveView("chat");
+                setMessages((prev) => [...prev, { id: "sys-" + Date.now(), role: "system", text: `\u{1F4E1} SESSION RESUMED: [${id}]` }]);
+                setCompletedIndex(0);
+              }
+            },
+            onDelete: async (id) => {
+              const newHistory = await deleteChat(id);
+              return newHistory;
+            },
+            onClose: () => setActiveView("chat")
+          }
+        ));
+      case "memory":
+        return /* @__PURE__ */ React8.createElement(Box8, { width: "100%", alignItems: "center", justifyContent: "center" }, /* @__PURE__ */ React8.createElement(MemoryModal, { onClose: () => setActiveView("chat") }));
+      case "profile":
+        return /* @__PURE__ */ React8.createElement(
+          ProfileForm,
+          {
+            onSave: (profile) => {
+              setProfileData(profile);
+              setMessages((prev) => [...prev, { id: Date.now(), role: "system", text: `\u2705 Profile updated: ${profile.name} (${profile.nickname})` }]);
+              setActiveView("chat");
+            },
+            onCancel: () => setActiveView("chat")
+          }
+        );
+      case "resolution":
+        return /* @__PURE__ */ React8.createElement(Box8, { width: "100%", alignItems: "center", justifyContent: "center" }, /* @__PURE__ */ React8.createElement(
+          ResolutionModal,
+          {
+            data: resolutionData,
+            onResolve: (val) => {
+              setResolutionData(null);
+              setActiveView("chat");
+              handleSubmit(val);
+            },
+            onEdit: (val) => {
+              setResolutionData(null);
+              setActiveView("chat");
+              setInput(val);
+            }
+          }
+        ));
+      case "approval":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 2, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { color: "yellow", bold: true, underline: true }, "\u{1F6E1}\uFE0F SECURITY GATE: FILE WRITE PERMISSION"), /* @__PURE__ */ React8.createElement(Text8, { marginTop: 1 }, "The agent is attempting to modify: ", /* @__PURE__ */ React8.createElement(Text8, { color: "cyan" }, parseArgs(pendingApproval?.args || "{}").path || "Unknown File")), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1, borderStyle: "single", borderColor: "#333", paddingX: 1, flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "--- PROPOSED CONTENT / DIFF ---"), (() => {
+          const args = parseArgs(pendingApproval?.args || "{}");
+          const oldVal = args.TargetContent || args.content_to_replace || null;
+          const newVal = args.content || args.ReplacementContent || args.content_to_add || args.replacementContent || null;
+          if (oldVal && newVal) {
+            return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text8, { color: "red", wrap: "anywhere", bold: true }, "- ", oldVal)), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, { color: "green", wrap: "anywhere", bold: true }, "+ ", newVal)));
+          }
+          return /* @__PURE__ */ React8.createElement(Text8, { color: "white", wrap: "anywhere" }, newVal || "Updating file content...");
+        })()), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Action Required",
+            items: [
+              { label: "\u2705 Accept this time", value: "allow" },
+              { label: "\u{1F6E1}\uFE0F Accept for this session", value: "always" },
+              { label: "\u274C Don't accept", value: "deny" }
+            ],
+            onSelect: (item) => {
+              if (item.value === "always") setAutoAcceptWrites(true);
+              const decision = item.value === "deny" ? "deny" : "allow";
+              pendingApproval.resolve(decision);
+              setPendingApproval(null);
+              setActiveView("chat");
+            }
+          }
+        )));
+      case "terminalApproval":
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 2, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Text8, { color: "red", bold: true, underline: true }, "\u{1F6E1}\uFE0F SECURITY GATE: TERMINAL COMMAND OVERSIGHT"), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, null, "Agent requested to run: ", /* @__PURE__ */ React8.createElement(Text8, { color: "yellow", bold: true }, parseArgs(pendingApproval?.args || "{}").command || "Unknown Command"))), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(
+          CommandMenu,
+          {
+            title: "Risk Assessment Required",
+            items: [
+              { label: "\u{1F680} Run", value: "allow" },
+              { label: "\u274C Deny", value: "deny" }
+            ],
+            onSelect: (item) => {
+              pendingApproval.resolve(item.value);
+              setPendingApproval(null);
+              setActiveView("chat");
+            }
+          }
+        )));
+      default:
+        const terminalWidth = stdout.columns || 80;
+        const wrapWidth = Math.max(20, terminalWidth - 10);
+        const wrappedLines = input.split("\n").reduce((acc, line) => {
+          return acc + Math.max(1, Math.ceil(line.length / wrapWidth));
+        }, 0);
+        const maxLines = Math.max(1, wrappedLines);
+        return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", marginTop: 1, flexShrink: 0, width: "100%" }, statusText && /* @__PURE__ */ React8.createElement(Box8, { paddingX: 1, marginBottom: 0 }, /* @__PURE__ */ React8.createElement(Text8, { color: "magenta", italic: true }, "\u23F3 ", statusText)), suggestions.length > 0 && /* @__PURE__ */ React8.createElement(Box8, { paddingX: 1, marginBottom: 0 }, /* @__PURE__ */ React8.createElement(Text8, { color: "gray" }, "\u{1F4A1} Suggestions: "), suggestions.map((s, i) => /* @__PURE__ */ React8.createElement(Text8, { key: s, color: "yellow", bold: i === 0 }, " ", s, " "))), /* @__PURE__ */ React8.createElement(Box8, { backgroundColor: "#333333", paddingX: 1, paddingY: 1, width: "100%" }, /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: "100%" }, maxLines > 3 ? /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: "100%", paddingY: 0 }, /* @__PURE__ */ React8.createElement(Text8, { color: "gray", dimColor: true }, "[\u{1F4E6} ", maxLines, " lines of text in buffer - Full content will be sent]"), /* @__PURE__ */ React8.createElement(
+          Box8,
+          {
+            flexDirection: "row",
+            width: "100%",
+            height: 1,
+            overflow: "hidden",
+            alignItems: "flex-end"
+          },
+          /* @__PURE__ */ React8.createElement(Box8, { flexShrink: 0, width: 3 }, /* @__PURE__ */ React8.createElement(Text8, { color: "yellow" }, "\u276F ")),
+          /* @__PURE__ */ React8.createElement(Box8, { flexGrow: 1 }, /* @__PURE__ */ React8.createElement(
+            MultilineInput,
+            {
+              value: input.split("\n").pop() || "",
+              onChange: (val) => {
+                const cleanVal = val.replace(/\\$/, "");
+                const lines = input.split("\n");
+                lines[lines.length - 1] = cleanVal;
+                setInput(lines.join("\n"));
+              },
+              onSubmit: handleSubmit,
+              placeholder: escPressed ? "Press ESC again to cancel the request." : isProcessing ? "Flux Flow is thinking..." : "Type your message or /command...",
+              keyBindings: {
+                submit: (key) => key.return && !key.shift && !key.ctrl,
+                newline: (key) => key.return && key.shift || key.return && key.ctrl
+              }
+            }
+          ))
+        )) : /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "row", width: "100%", paddingY: 0 }, /* @__PURE__ */ React8.createElement(Box8, { flexShrink: 0, width: 3 }, /* @__PURE__ */ React8.createElement(Text8, { color: "yellow" }, "\u276F ")), /* @__PURE__ */ React8.createElement(Box8, { flexGrow: 1 }, /* @__PURE__ */ React8.createElement(
+          MultilineInput,
+          {
+            value: input,
+            onChange: (val) => {
+              const cleanVal = val.replace(/\\\s*\n/g, "\n");
+              setInput(cleanVal);
+            },
+            onSubmit: handleSubmit,
+            placeholder: escPressed ? "Press ESC again to cancel the request." : isProcessing ? "Flux Flow is thinking..." : "Type your message or /command...",
+            maxRows: 3,
+            keyBindings: {
+              submit: (key) => key.return && !key.shift && !key.ctrl,
+              newline: (key) => key.return && key.shift || key.return && key.ctrl
+            }
+          }
+        ))))));
+    }
+  };
+  return /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column" }, messages.slice(0, completedIndex).map((msg, idx) => /* @__PURE__ */ React8.createElement(ChatLayout, { key: msg.id || idx, messages: [msg], showFullThinking }))), /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", padding: 1, width: "100%" }, activeView === "chat" && /* @__PURE__ */ React8.createElement(Box8, { flexDirection: "column", width: "100%" }, /* @__PURE__ */ React8.createElement(ChatLayout, { messages: messages.slice(completedIndex), showFullThinking }), activeCommand && /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(TerminalBox, { command: activeCommand, output: execOutput }))), isInitializing ? /* @__PURE__ */ React8.createElement(Box8, { borderStyle: "double", borderColor: "magenta", padding: 1, flexShrink: 0 }, /* @__PURE__ */ React8.createElement(Text8, { color: "magenta" }, "\u{1F30A} Starting Flux Flow...")) : !apiKey ? /* @__PURE__ */ React8.createElement(Box8, { borderStyle: "bold", borderColor: "yellow", padding: 1, flexDirection: "column", flexShrink: 0 }, /* @__PURE__ */ React8.createElement(Text8, { color: "yellow", bold: true }, "\u{1F511} API KEY REQUIRED"), /* @__PURE__ */ React8.createElement(Text8, null, "Please enter your Gemini API Key to initialize the agent's brain."), /* @__PURE__ */ React8.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text8, { color: "cyan" }, "\u276F "), /* @__PURE__ */ React8.createElement(
+    TextInput2,
+    {
+      value: tempKey,
+      onChange: setTempKey,
+      onSubmit: handleSetup,
+      mask: "*"
+    }
+  ))) : renderActiveView(), /* @__PURE__ */ React8.createElement(Box8, { flexShrink: 0, width: "100%" }, /* @__PURE__ */ React8.createElement(
+    StatusBar,
+    {
+      mode,
+      thinkingLevel,
+      tokens: sessionStats.tokens,
+      chatId,
+      isMemoryEnabled: systemSettings.memory
+    }
+  ))));
+}
+
+// src/cli.jsx
+process.stdout.write("\x1Bc");
+render(/* @__PURE__ */ React9.createElement(App, null));