@nomad-e/bluma-cli 0.1.32 → 0.1.34

package/dist/main.js

@@ -17,8 +17,8 @@ __export(async_command_exports, {
   runCommandAsync: () => runCommandAsync,
   sendCommandInput: () => sendCommandInput
 });
-import os2 from "os";
-import { spawn } from "child_process";
+import os5 from "os";
+import { spawn as spawn2 } from "child_process";
 import { v4 as uuidv42 } from "uuid";
 function cleanupOldCommands() {
   if (runningCommands.size <= MAX_STORED_COMMANDS) return;
@@ -63,7 +63,7 @@ async function runCommandAsync(args) {
       };
     }
     const commandId = uuidv42().substring(0, 8);
-    const platform = os2.platform();
+    const platform = os5.platform();
     let shellCmd;
     let shellArgs;
     if (platform === "win32") {
@@ -83,7 +83,7 @@ async function runCommandAsync(args) {
       startTime: Date.now(),
       process: null
     };
-    const child = spawn(shellCmd, shellArgs, {
+    const child = spawn2(shellCmd, shellArgs, {
       cwd,
       env: process.env,
       windowsHide: true
@@ -331,16 +331,19 @@ var init_async_command = __esm({
 import React12 from "react";
 import { render } from "ink";
 import { EventEmitter as EventEmitter3 } from "events";
-import fs15 from "fs";
+import fs17 from "fs";
+import path21 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { v4 as uuidv46 } from "uuid";
 
 // src/app/ui/App.tsx
-import { useState as useState6, useEffect as useEffect7, useRef as useRef5, useCallback as useCallback2, memo as memo12 } from "react";
+import { useState as useState6, useEffect as useEffect7, useRef as useRef5, useCallback as useCallback3, memo as memo12 } from "react";
 import { Box as Box20, Text as Text19, Static } from "ink";
 
 // src/app/ui/layout.tsx
-import { Box, Text } from "ink";
+import { Box, Text, useStdout } from "ink";
 import { memo } from "react";
+import os from "os";
 
 // src/app/ui/theme/blumaTerminal.ts
 var BLUMA_TERMINAL = {
@@ -375,24 +378,106 @@ var BLUMA_TERMINAL = {
 
 // src/app/ui/layout.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
+function buildTopBorder(cols, leftW, rightW, titleInLeft) {
+  const t = titleInLeft.length <= leftW ? titleInLeft : titleInLeft.slice(0, leftW);
+  const leftFill = t + "\u2500".repeat(Math.max(0, leftW - t.length));
+  const rightFill = "\u2500".repeat(rightW);
+  return "\u250C" + leftFill + "\u252C" + rightFill + "\u2510";
+}
+function buildBottomBorder(leftW, rightW) {
+  return "\u2514" + "\u2500".repeat(leftW) + "\u2534" + "\u2500".repeat(rightW) + "\u2518";
+}
 var HeaderComponent = ({
   sessionId,
-  workdir
+  workdir,
+  cliVersion = "?",
+  recentActivitySummary
 }) => {
-  const dirName = workdir.split("/").pop() || workdir;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", flexWrap: "wrap", children: [
-      /* @__PURE__ */ jsx(Text, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "BluMa" }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2014 " }),
-      /* @__PURE__ */ jsx(Text, { children: "Base Language Unit" }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
-      /* @__PURE__ */ jsx(Text, { color: BLUMA_TERMINAL.brandMagenta, bold: true, children: "Model Agent" })
+  const { stdout } = useStdout();
+  const cols = Math.max(52, stdout?.columns ?? 80);
+  let username = "there";
+  try {
+    username = os.userInfo().username || username;
+  } catch {
+  }
+  const inner = cols - 3;
+  const leftW = Math.max(24, Math.floor(inner * 0.48));
+  const rightW = Math.max(22, inner - leftW);
+  const borderTitle = ` BluMa v${cliVersion} `;
+  const topLine = buildTopBorder(cols, leftW, rightW, borderTitle);
+  const bottomLine = buildBottomBorder(leftW, rightW);
+  const M = BLUMA_TERMINAL.brandMagenta;
+  const B = BLUMA_TERMINAL.panelBorder;
+  const ruleW = Math.max(6, rightW - 2);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, width: cols, children: [
+    /* @__PURE__ */ jsx(Text, { color: B, children: topLine }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", width: cols, children: [
+      /* @__PURE__ */ jsx(Text, { color: B, children: "\u2502" }),
+      /* @__PURE__ */ jsxs(
+        Box,
+        {
+          width: leftW,
+          flexDirection: "column",
+          alignItems: "center",
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+              /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "BluMa" }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2014 " }),
+              /* @__PURE__ */ jsx(Text, { bold: true, color: B, children: "Base Language Unit" }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
+              /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "Model Agent" })
+            ] }),
+            /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", alignItems: "center", children: /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Welcome back " }),
+              /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: username }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "!" })
+            ] }) }),
+            /* @__PURE__ */ jsxs(Box, { marginY: 1, flexDirection: "column", alignItems: "center", children: [
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(Math.min(13, Math.max(7, leftW - 6))) }),
+              /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: " \u27E8 \u03BB \u27E9 " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(Math.min(13, Math.max(7, leftW - 6))) })
+            ] }),
+            /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignSelf: "flex-start", width: leftW - 2, children: [
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, wrap: "wrap", children: [
+                /* @__PURE__ */ jsx(Text, { color: "white", children: "auto" }),
+                /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 FactorRouter \xB7 session " }),
+                /* @__PURE__ */ jsx(Text, { color: B, children: sessionId.slice(0, 8) })
+              ] }),
+              /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: workdir })
+            ] })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { color: B, children: "\u2502" }),
+      /* @__PURE__ */ jsxs(Box, { width: rightW, flexDirection: "column", paddingX: 1, children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "Tips for getting started" }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, wrap: "wrap", children: [
+          "Run ",
+          /* @__PURE__ */ jsx(Text, { color: "white", children: "/init" }),
+          " to scaffold project context (BluMa.md). Use",
+          " ",
+          /* @__PURE__ */ jsx(Text, { color: "white", children: "/help" }),
+          ", ",
+          /* @__PURE__ */ jsx(Text, { color: "white", children: "/img" }),
+          ", ",
+          /* @__PURE__ */ jsx(Text, { color: "white", children: "!" }),
+          " ",
+          "as needed."
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginY: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(ruleW) }) }),
+        /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "Recent activity" }) }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: recentActivitySummary?.trim() ? recentActivitySummary.trim() : "No recent activity." })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: B, children: "\u2502" })
     ] }),
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", flexWrap: "wrap", children: [
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "cwd " }),
-      /* @__PURE__ */ jsx(Text, { color: BLUMA_TERMINAL.brandBlue, children: dirName }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 session " }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: sessionId.slice(0, 8) })
+    /* @__PURE__ */ jsx(Text, { color: B, children: bottomLine }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\xB7 " }),
+      /* @__PURE__ */ jsx(Text, { color: B, bold: true, children: "NomadEngenuity" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 Factor stack \xB7 " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, color: M, children: "/help" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " for shortcuts" })
     ] })
   ] });
 };
@@ -441,7 +526,7 @@ var TaskStatusBarComponent = ({
 var TaskStatusBar = memo(TaskStatusBarComponent);
 
 // src/app/ui/components/InputPrompt.tsx
-import { Box as Box2, Text as Text2, useStdout, useInput as useInput2 } from "ink";
+import { Box as Box2, Text as Text2, useStdout as useStdout2, useInput as useInput2 } from "ink";
 
 // src/app/ui/utils/useSimpleInputBuffer.ts
 import { useReducer, useRef, useCallback, useEffect } from "react";
@@ -505,6 +590,13 @@ function inputReducer(state, action, viewWidth) {
       }
       return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
     }
+    case "INSERT_AT_CURSOR": {
+      const cleanInput = action.payload.replace(/(\r\n|\r)/gm, "\n");
+      const newText = state.text.slice(0, state.cursorPosition) + cleanInput + state.text.slice(state.cursorPosition);
+      const newCursorPosition = state.cursorPosition + cleanInput.length;
+      const newViewStart = adjustView(newCursorPosition, state.viewStart);
+      return { text: newText, cursorPosition: newCursorPosition, viewStart: newViewStart };
+    }
     case "NEWLINE": {
       const newText = state.text.slice(0, state.cursorPosition) + "\n" + state.text.slice(state.cursorPosition);
       const newCursorPosition = state.cursorPosition + 1;
@@ -590,11 +682,28 @@ function inputReducer(state, action, viewWidth) {
       return state;
   }
 }
+function isClipboardPasteChord(input, key) {
+  if (key.ctrl && key.shift && input === "i") {
+    return true;
+  }
+  if (key.meta && (input === "v" || input === "V")) {
+    return true;
+  }
+  if (key.ctrl && (input === "v" || input === "V")) {
+    return true;
+  }
+  if (key.ctrl && input.length >= 1 && input.charCodeAt(0) === 22) {
+    return true;
+  }
+  return false;
+}
 var useCustomInput = ({
   onSubmit,
   viewWidth,
   isReadOnly,
-  onInterrupt
+  onInterrupt,
+  onChordPaste,
+  transformInputChunk
 }) => {
   const [state, dispatch] = useReducer(
     (s, a) => inputReducer(s, a, viewWidth),
@@ -602,14 +711,31 @@ var useCustomInput = ({
   );
   const inputBuffer = useRef("");
   const flushScheduled = useRef(false);
+  const applyChunkTransform = useCallback(
+    (buffered) => transformInputChunk ? transformInputChunk(buffered) : buffered,
+    [transformInputChunk]
+  );
   const flushInputBuffer = useCallback(() => {
     if (inputBuffer.current.length > 0) {
       const buffered = inputBuffer.current;
       inputBuffer.current = "";
-      dispatch({ type: "INPUT", payload: buffered });
+      dispatch({ type: "INPUT", payload: applyChunkTransform(buffered) });
     }
     flushScheduled.current = false;
-  }, []);
+  }, [applyChunkTransform]);
+  const insertAtCursor = useCallback(
+    (s) => {
+      if (inputBuffer.current.length > 0) {
+        const buffered = inputBuffer.current;
+        inputBuffer.current = "";
+        flushScheduled.current = false;
+        dispatch({ type: "INPUT", payload: applyChunkTransform(buffered) });
+      }
+      const clean = s.replace(/(\r\n|\r)/gm, "\n");
+      dispatch({ type: "INSERT_AT_CURSOR", payload: clean });
+    },
+    [applyChunkTransform]
+  );
   useEffect(() => {
     return () => {
       if (flushScheduled.current) {
@@ -670,6 +796,13 @@ var useCustomInput = ({
         if (key.rightArrow) return dispatch({ type: "MOVE_CURSOR", direction: "right" });
         if (key.upArrow) return dispatch({ type: "MOVE_CURSOR", direction: "up" });
         if (key.downArrow) return dispatch({ type: "MOVE_CURSOR", direction: "down" });
+        if (isClipboardPasteChord(input, key) && onChordPaste) {
+          if (inputBuffer.current.length > 0) {
+            flushInputBuffer();
+          }
+          void Promise.resolve(onChordPaste(insertAtCursor));
+          return;
+        }
         if (key.ctrl || key.meta || key.tab) return;
         inputBuffer.current += input;
         if (!flushScheduled.current) {
@@ -704,6 +837,13 @@ var useCustomInput = ({
       if (key.ctrl && input === "e") {
         return dispatch({ type: "MOVE_LINE_END" });
       }
+      if (isClipboardPasteChord(input, key) && onChordPaste) {
+        if (inputBuffer.current.length > 0) {
+          flushInputBuffer();
+        }
+        void Promise.resolve(onChordPaste(insertAtCursor));
+        return;
+      }
       if (key.ctrl || key.meta || key.tab) return;
       inputBuffer.current += input;
       if (!flushScheduled.current) {
@@ -732,22 +872,116 @@ var useCustomInput = ({
         flushInputBuffer();
       }
       dispatch({ type: "SET_CURSOR", payload: pos });
-    }, [flushInputBuffer])
+    }, [flushInputBuffer]),
+    insertAtCursor
   };
 };
 
 // src/app/ui/components/InputPrompt.tsx
-import { useEffect as useEffect3, useMemo, useState as useState2, memo as memo2 } from "react";
+import {
+  useEffect as useEffect3,
+  useMemo,
+  useState as useState2,
+  useRef as useRef3,
+  memo as memo2,
+  useLayoutEffect,
+  useCallback as useCallback2
+} from "react";
 import { EventEmitter as EventEmitter2 } from "events";
 
 // src/app/ui/utils/slashRegistry.ts
 var getSlashCommands = () => [
-  { name: "/help", description: "list commands" },
-  { name: "/mcp", description: "list tools connected via MCP" },
-  { name: "/tools", description: "list native tools" },
-  { name: "/init", description: "create a new BluMa.md file with codebase documentation" },
-  { name: "/clear", description: "clear history" }
+  {
+    name: "Ctrl+V / Cmd+V",
+    description: "paste from clipboard: image \u2192 file path under ~/.cache/bluma/clipboard; else text (all OS via clipboardy)",
+    category: "input"
+  },
+  {
+    name: "Ctrl+Shift+I",
+    description: "same as Ctrl+V / Cmd+V (paste image or text)",
+    category: "input"
+  },
+  {
+    name: "/help",
+    description: "list all slash commands (grouped)",
+    category: "help"
+  },
+  {
+    name: "/clear",
+    description: "clear chat below the welcome panel (welcome + session file unchanged)",
+    category: "session"
+  },
+  {
+    name: "/img",
+    description: "send local image(s) to the model: /img ./shot.png [your question]",
+    category: "agent"
+  },
+  {
+    name: "/image",
+    description: "alias of /img",
+    category: "agent"
+  },
+  {
+    name: "/skills",
+    description: "list load_skill modules (bundled + project + ~/.bluma)",
+    category: "inspect"
+  },
+  {
+    name: "/tools",
+    description: "list native tools (optional filter: /tools grep)",
+    category: "inspect"
+  },
+  {
+    name: "/mcp",
+    description: "list MCP tools (optional filter: /mcp fs)",
+    category: "inspect"
+  },
+  {
+    name: "/init",
+    description: "run init subagent \u2014 BluMa.md codebase documentation",
+    category: "agent"
+  }
 ];
+var SLASH_ROUTE_KEYWORDS = new Set(
+  getSlashCommands().filter((c) => c.name.startsWith("/")).map((c) => c.name.slice(1).toLowerCase())
+);
+function isSlashRoutingLine(text) {
+  const t = text.trimStart();
+  if (!t.startsWith("/")) {
+    return false;
+  }
+  const rest = t.slice(1).trim();
+  if (!rest) {
+    return true;
+  }
+  const first = rest.split(/\s+/)[0];
+  if (first.includes("/") || first.includes("\\")) {
+    return false;
+  }
+  return SLASH_ROUTE_KEYWORDS.has(first.toLowerCase());
+}
+var CATEGORY_LABEL = {
+  session: "Session & UI",
+  inspect: "Inspect",
+  agent: "Agent",
+  help: "Help",
+  input: "Input"
+};
+function formatSlashHelpLines() {
+  const cmds = getSlashCommands();
+  const byCat = (cat) => cmds.filter((c) => c.category === cat);
+  const lines = [];
+  for (const cat of ["help", "session", "input", "agent", "inspect"]) {
+    const group = byCat(cat);
+    if (group.length === 0) continue;
+    lines.push(`${CATEGORY_LABEL[cat]}:`);
+    for (const c of group) {
+      lines.push(`  ${c.name.padEnd(14)} ${c.description}`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
 var filterSlashCommands = (query) => {
   const list = getSlashCommands();
   const q = (query || "").toLowerCase();
@@ -942,6 +1176,390 @@ var TOOL_PREVIEW_MAX_LINES = 8;
 var EXPAND_OVERLAY_MAX_LINES = 60;
 var TERMINAL_RULE_CHAR = "\u2500";
 
+// src/app/ui/utils/clipboardImage.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+import { spawn, execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+var execFile = promisify(execFileCb);
+var CLIPBOARD_MAX_BYTES = 4 * 1024 * 1024;
+function extFromMagic(buf) {
+  if (buf.length < 12) return null;
+  if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) {
+    return ".png";
+  }
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
+    return ".jpg";
+  }
+  if (buf.slice(0, 6).toString("ascii") === "GIF87a" || buf.slice(0, 6).toString("ascii") === "GIF89a") {
+    return ".gif";
+  }
+  if (buf.slice(0, 4).toString("ascii") === "RIFF" && buf.slice(8, 12).toString("ascii") === "WEBP") {
+    return ".webp";
+  }
+  return null;
+}
+function runCapture(cmd, args) {
+  return new Promise((resolve2) => {
+    const chunks = [];
+    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    child.stdout.on("data", (c) => chunks.push(c));
+    child.stderr.on("data", () => {
+    });
+    child.on("error", () => resolve2(Buffer.alloc(0)));
+    child.on("close", () => {
+      resolve2(Buffer.concat(chunks));
+    });
+  });
+}
+async function tryWlPaste(mime) {
+  const args = mime ? ["--type", mime] : [];
+  return runCapture("wl-paste", args);
+}
+async function tryXclip(mime) {
+  return runCapture("xclip", ["-selection", "clipboard", "-t", mime, "-o"]);
+}
+async function tryPngpaste() {
+  return runCapture("pngpaste", ["-"]);
+}
+function writeBufferIfImage(baseDir, buf) {
+  if (buf.length < 80 || buf.length > CLIPBOARD_MAX_BYTES) {
+    return null;
+  }
+  const ext = extFromMagic(buf);
+  if (!ext) {
+    return null;
+  }
+  const out = path2.join(
+    baseDir,
+    `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
+  );
+  fs2.writeFileSync(out, buf);
+  return out;
+}
+function unlinkQuiet(p) {
+  try {
+    if (fs2.existsSync(p)) {
+      fs2.unlinkSync(p);
+    }
+  } catch {
+  }
+}
+async function tryDarwinClipboardy(baseDir) {
+  let tmpPaths = [];
+  try {
+    const { default: cb } = await import("clipboardy");
+    if (typeof cb.hasImages !== "function" || !await cb.hasImages()) {
+      return null;
+    }
+    tmpPaths = await cb.readImages();
+    if (!tmpPaths?.length) {
+      return null;
+    }
+    for (const src of tmpPaths) {
+      if (!src || !fs2.existsSync(src)) {
+        continue;
+      }
+      let st;
+      try {
+        st = fs2.statSync(src);
+      } catch {
+        continue;
+      }
+      if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
+        continue;
+      }
+      const ext = path2.extname(src).toLowerCase();
+      const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
+      const out = path2.join(
+        baseDir,
+        `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
+      );
+      fs2.copyFileSync(src, out);
+      for (const p of tmpPaths) {
+        unlinkQuiet(p);
+      }
+      return out;
+    }
+  } catch {
+  }
+  for (const p of tmpPaths) {
+    unlinkQuiet(p);
+  }
+  return null;
+}
+async function tryWindowsPowerShell(outFile) {
+  const ps = process.env.SystemRoot != null ? path2.join(
+    process.env.SystemRoot,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe"
+  ) : "powershell.exe";
+  if (!fs2.existsSync(ps)) {
+    return false;
+  }
+  const script = "$ErrorActionPreference='Stop';Add-Type -AssemblyName System.Windows.Forms;Add-Type -AssemblyName System.Drawing;$img=[System.Windows.Forms.Clipboard]::GetImage();if($null -eq $img){exit 2};$img.Save($env:BLUMA_CLIP_OUT,[System.Drawing.Imaging.ImageFormat]::Png);exit 0";
+  try {
+    await execFile(
+      ps,
+      ["-NoProfile", "-Sta", "-WindowStyle", "Hidden", "-Command", script],
+      {
+        env: { ...process.env, BLUMA_CLIP_OUT: outFile },
+        windowsHide: true,
+        timeout: 25e3
+      }
+    );
+  } catch (e) {
+    const status = e && typeof e === "object" && "status" in e ? e.status : null;
+    if (status === 2) {
+      return false;
+    }
+    return false;
+  }
+  try {
+    const st = fs2.statSync(outFile);
+    return st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES;
+  } catch {
+    return false;
+  }
+}
+async function tryUnixLikeClipboard(baseDir) {
+  const attempts = [];
+  if (process.env.WAYLAND_DISPLAY) {
+    attempts.push(() => tryWlPaste("image/png"));
+    attempts.push(() => tryWlPaste("image/jpeg"));
+    attempts.push(() => tryWlPaste());
+  }
+  attempts.push(() => tryXclip("image/png"));
+  attempts.push(() => tryXclip("image/jpeg"));
+  attempts.push(() => tryXclip("image/webp"));
+  for (const run of attempts) {
+    try {
+      const buf = await run();
+      const saved = writeBufferIfImage(baseDir, buf);
+      if (saved) {
+        return saved;
+      }
+    } catch {
+    }
+  }
+  try {
+    const buf = await tryPngpaste();
+    return writeBufferIfImage(baseDir, buf);
+  } catch {
+    return null;
+  }
+}
+async function readClipboardImageToTempFile() {
+  const baseDir = path2.join(os2.homedir(), ".cache", "bluma", "clipboard");
+  fs2.mkdirSync(baseDir, { recursive: true });
+  if (process.platform === "darwin") {
+    const fromCb = await tryDarwinClipboardy(baseDir);
+    if (fromCb) {
+      return fromCb;
+    }
+    try {
+      const buf = await tryPngpaste();
+      return writeBufferIfImage(baseDir, buf);
+    } catch {
+      return null;
+    }
+  }
+  if (process.platform === "win32") {
+    const outFile = path2.join(
+      baseDir,
+      `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
+    );
+    const ok = await tryWindowsPowerShell(outFile);
+    return ok ? outFile : null;
+  }
+  return tryUnixLikeClipboard(baseDir);
+}
+
+// src/app/ui/utils/inlineImageInputLabels.ts
+function resolveInlineImageLabels(raw, idToPath) {
+  return raw.replace(/\[IMAGE #(\d+)\]/g, (full, numStr) => {
+    const id = Number.parseInt(numStr, 10);
+    if (Number.isNaN(id)) {
+      return full;
+    }
+    const p = idToPath.get(id);
+    if (!p) {
+      return full;
+    }
+    return p.includes(" ") ? `"${p}"` : p;
+  });
+}
+
+// src/app/agent/utils/user_message_images.ts
+import fs3 from "fs";
+import os3 from "os";
+import path3 from "path";
+var IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
+var MAX_IMAGE_BYTES = 4 * 1024 * 1024;
+var MAX_IMAGES = 6;
+var MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp"
+};
+function expandUserPath(p) {
+  const t = p.trim();
+  if (t.startsWith("~")) {
+    return path3.join(os3.homedir(), t.slice(1).replace(/^\//, ""));
+  }
+  return t;
+}
+function isPathAllowed(absResolved, cwd) {
+  const resolved = path3.normalize(path3.resolve(absResolved));
+  const cwdR = path3.normalize(path3.resolve(cwd));
+  const homeR = path3.normalize(path3.resolve(os3.homedir()));
+  const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path3.sep);
+  const underHome = resolved === homeR || resolved.startsWith(homeR + path3.sep);
+  return underCwd || underHome;
+}
+function mimeFor(abs) {
+  const ext = path3.extname(abs).toLowerCase();
+  return MIME[ext] || "application/octet-stream";
+}
+var IMAGE_EXT_SRC = String.raw`(?:png|jpe?g|gif|webp|bmp)`;
+var UNIX_PATH_WITH_IMAGE_EXT = new RegExp(
+  String.raw`(?:^|[\s"'(])(\/(?:[^\s/'"<>|]+\/)*[^\s/'"<>|]+\.${IMAGE_EXT_SRC})\b`,
+  "gi"
+);
+var WIN_PATH_WITH_IMAGE_EXT = new RegExp(
+  String.raw`(?:^|[\s"'(])(([A-Za-z]:(?:\\[^\\/:*?"<>|\r\n]+)+\.${IMAGE_EXT_SRC}))\b`,
+  "gi"
+);
+function collectImagePathStrings(raw) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    const t = p.trim();
+    if (!t || seen.has(t)) return;
+    seen.add(t);
+    found.push(t);
+  };
+  const quoted = /(["'])((?:(?!\1).)*?\.(?:png|jpe?g|gif|webp|bmp))\1/gi;
+  for (const m of raw.matchAll(quoted)) {
+    push(m[2].trim());
+  }
+  const withoutQuoted = raw.replace(quoted, " ");
+  const tokens = withoutQuoted.split(/\s+/);
+  for (let tok of tokens) {
+    tok = tok.replace(/^[([{]+/, "").replace(/[)\]},;:]+$/, "");
+    if (!tok || !IMAGE_EXT.test(tok)) continue;
+    push(tok);
+  }
+  for (const m of raw.matchAll(UNIX_PATH_WITH_IMAGE_EXT)) {
+    if (m[1]) {
+      push(m[1]);
+    }
+  }
+  for (const m of raw.matchAll(WIN_PATH_WITH_IMAGE_EXT)) {
+    push(m[1]);
+  }
+  return found;
+}
+function resolveImagePath(candidate, cwd) {
+  const expanded = expandUserPath(candidate);
+  const abs = path3.isAbsolute(expanded) ? path3.normalize(expanded) : path3.normalize(path3.resolve(cwd, expanded));
+  if (!isPathAllowed(abs, cwd)) return null;
+  try {
+    if (!fs3.existsSync(abs) || !fs3.statSync(abs).isFile()) return null;
+  } catch {
+    return null;
+  }
+  if (!IMAGE_EXT.test(abs)) return null;
+  return abs;
+}
+function tryPasteChunkAsSingleImagePath(chunk, cwd) {
+  const normalized = chunk.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  const t = (lines[0] ?? "").trim();
+  if (!t) {
+    return null;
+  }
+  if (lines.length > 1 && lines.slice(1).some((l) => l.trim().length > 0)) {
+    return null;
+  }
+  const paths = collectImagePathStrings(t);
+  if (paths.length !== 1) {
+    return null;
+  }
+  if (stripImagePathStrings(t, paths).trim().length > 0) {
+    return null;
+  }
+  const abs = resolveImagePath(paths[0], cwd);
+  if (!abs) {
+    return null;
+  }
+  try {
+    const st = fs3.statSync(abs);
+    if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  return abs;
+}
+function stripImagePathStrings(text, paths) {
+  let out = text;
+  for (const p of paths) {
+    const q = p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(`["']${q}["']`, "gi"), " ");
+    out = out.replace(new RegExp(`(?<=^|\\s)${q}(?=\\s|$)`, "gi"), " ");
+  }
+  return out.replace(/\s{2,}/g, " ").trim();
+}
+function buildUserMessageContent(raw, cwd) {
+  const trimmed = raw.trim();
+  if (!trimmed) return trimmed;
+  const candidates = collectImagePathStrings(trimmed);
+  const resolvedAbs = [];
+  const usedStrings = [];
+  for (const c of candidates) {
+    if (resolvedAbs.length >= MAX_IMAGES) break;
+    const abs = resolveImagePath(c, cwd);
+    if (!abs) continue;
+    try {
+      const st = fs3.statSync(abs);
+      if (st.size > MAX_IMAGE_BYTES) continue;
+    } catch {
+      continue;
+    }
+    resolvedAbs.push(abs);
+    usedStrings.push(c);
+  }
+  if (resolvedAbs.length === 0) {
+    return trimmed;
+  }
+  let textPart = stripImagePathStrings(trimmed, usedStrings);
+  if (!textPart) {
+    textPart = "(User attached image(s) only \u2014 describe, compare, or answer using the image(s).)";
+  }
+  const parts = [{ type: "text", text: textPart }];
+  for (const abs of resolvedAbs) {
+    const buf = fs3.readFileSync(abs);
+    const b64 = buf.toString("base64");
+    const mime = mimeFor(abs);
+    parts.push({
+      type: "image_url",
+      image_url: {
+        url: `data:${mime};base64,${b64}`,
+        detail: "auto"
+      }
+    });
+  }
+  return parts;
+}
+
 // src/app/ui/components/InputPrompt.tsx
 import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var uiEventBus = global.__bluma_ui_eventbus__ || new EventEmitter2();
@@ -1006,7 +1624,9 @@ var SlashSuggestions = memo2(({
       s.name,
       " ",
       /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-        "- ",
+        "[",
+        s.category,
+        "] ",
         s.description
       ] })
     ] })
@@ -1014,13 +1634,21 @@ var SlashSuggestions = memo2(({
 }) }));
 SlashSuggestions.displayName = "SlashSuggestions";
 var InputRuleLine = memo2(() => {
-  const { stdout } = useStdout();
+  const { stdout } = useStdout2();
   const cols = stdout?.columns ?? 80;
   const n = Math.max(8, cols);
   return /* @__PURE__ */ jsx2(Text2, { color: "white", children: TERMINAL_RULE_CHAR.repeat(n) });
 });
 InputRuleLine.displayName = "InputRuleLine";
-var Footer = memo2(({ isReadOnly }) => /* @__PURE__ */ jsx2(Box2, { justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: isReadOnly ? "ctrl+c to exit | Enter to send message | Shift+Enter for new line | esc interrupt | Ctrl+O expand last clip" : "ctrl+c to exit | Enter to submit | Shift+Enter for new line | /help commands | esc interrupt | Ctrl+O expand last clip" }) }));
+var Footer = memo2(
+  ({
+    isReadOnly,
+    clipHint
+  }) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", alignItems: "center", children: [
+    clipHint ? /* @__PURE__ */ jsx2(Box2, { marginBottom: 0, children: /* @__PURE__ */ jsx2(Text2, { color: "yellow", dimColor: true, children: clipHint }) }) : null,
+    /* @__PURE__ */ jsx2(Box2, { justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: isReadOnly ? "ctrl+c to exit | Enter to send message | Shift+Enter for new line | esc interrupt | Ctrl+O expand last clip" : "ctrl+c to exit | Enter submit | Shift+Enter newline | Ctrl+V / Cmd+V paste | /help \xB7 /img \xB7 esc \xB7 Ctrl+O" }) })
+  ] })
+);
 Footer.displayName = "Footer";
 var TextLinesRenderer = memo2(({
   lines,
@@ -1058,19 +1686,52 @@ var InputPrompt = memo2(({
   onInterrupt,
   disableWhileProcessing = false
 }) => {
-  const { stdout } = useStdout();
+  const { stdout } = useStdout2();
   const [viewWidth] = useState2(() => stdout.columns - 6);
   const [slashOpen, setSlashOpen] = useState2(false);
   const [slashIndex, setSlashIndex] = useState2(0);
+  const [clipHint, setClipHint] = useState2(null);
+  const textRef = useRef3("");
+  const cursorRef = useRef3(0);
+  const inlineImageByIdRef = useRef3(/* @__PURE__ */ new Map());
+  const nextInlineImageIdRef = useRef3(1);
+  const clearInlineImageSlots = () => {
+    inlineImageByIdRef.current.clear();
+    nextInlineImageIdRef.current = 1;
+  };
+  const cwd = process.cwd();
+  const transformInputChunk = useCallback2(
+    (chunk) => {
+      const abs = tryPasteChunkAsSingleImagePath(chunk, cwd);
+      if (!abs) {
+        return chunk;
+      }
+      const id = nextInlineImageIdRef.current++;
+      inlineImageByIdRef.current.set(id, abs);
+      return /\n$/.test(chunk) ? `[IMAGE #${id}]
+` : `[IMAGE #${id}] `;
+    },
+    [cwd]
+  );
   const permissiveOnSubmit = (value) => {
     const trimmed = (value || "").trim();
+    const map = inlineImageByIdRef.current;
+    const resolved = resolveInlineImageLabels(value, map);
     if (isReadOnly) {
       if (trimmed.length > 0) {
-        uiEventBus.emit("user_overlay", { kind: "message", payload: trimmed, ts: Date.now() });
+        uiEventBus.emit("user_overlay", {
+          kind: "message",
+          payload: resolved.trim(),
+          ts: Date.now()
+        });
+        clearInlineImageSlots();
       }
       return;
     }
-    onSubmit(value);
+    if (trimmed.length > 0) {
+      onSubmit(resolved);
+      clearInlineImageSlots();
+    }
   };
   const { text, cursorPosition, setText } = useCustomInput({
     onSubmit: (value) => {
@@ -1080,8 +1741,48 @@ var InputPrompt = memo2(({
     },
     viewWidth,
     isReadOnly,
-    onInterrupt
+    onInterrupt,
+    transformInputChunk: !disableWhileProcessing ? transformInputChunk : void 0,
+    onChordPaste: !disableWhileProcessing ? (insertAtCursor) => {
+      void (async () => {
+        const padBefore = () => {
+          const t = textRef.current;
+          const c = cursorRef.current;
+          return t.length > 0 && c > 0 && t[c - 1] !== "\n" && !/\s/.test(t[c - 1]) ? " " : "";
+        };
+        const filePath = await readClipboardImageToTempFile();
+        if (filePath) {
+          const id = nextInlineImageIdRef.current++;
+          inlineImageByIdRef.current.set(id, filePath);
+          insertAtCursor(`${padBefore()}[IMAGE #${id}] `);
+          return;
+        }
+        try {
+          const { default: cb } = await import("clipboardy");
+          const pasted = await cb.read();
+          const t = pasted != null ? String(pasted).replace(/\r\n/g, "\n") : "";
+          if (t.length > 0) {
+            const abs = tryPasteChunkAsSingleImagePath(t, cwd);
+            if (abs) {
+              const id = nextInlineImageIdRef.current++;
+              inlineImageByIdRef.current.set(id, abs);
+              insertAtCursor(`${padBefore()}[IMAGE #${id}] `);
+              return;
+            }
+            insertAtCursor(`${padBefore()}${t}`);
+            return;
+          }
+        } catch {
+        }
+        setClipHint("Clipboard: empty or unreadable (GUI session; Linux: wl-clipboard/xclip).");
+        setTimeout(() => setClipHint(null), 4e3);
+      })();
+    } : void 0
   });
+  useLayoutEffect(() => {
+    textRef.current = text;
+    cursorRef.current = cursorPosition;
+  }, [text, cursorPosition]);
   const linesData = useMemo(() => {
     const lines = text.split("\n");
     let remainingChars = cursorPosition;
@@ -1148,7 +1849,6 @@ var InputPrompt = memo2(({
       delete globalThis.__BLUMA_FORCE_CURSOR_END__;
     }
   }, [text, setText]);
-  const cwd = process.cwd();
   const pathAutocomplete = useAtCompletion({ cwd, text, cursorPosition, setText });
   useInput2((input, key) => {
     if (key.backspace || key.delete || key.ctrl || key.meta) return;
@@ -1208,7 +1908,7 @@ var InputPrompt = memo2(({
       slashOpen && slashSuggestions.length > 0 && /* @__PURE__ */ jsx2(SlashSuggestions, { suggestions: slashSuggestions, selectedIndex: slashIndex })
     ] }) }),
     /* @__PURE__ */ jsx2(InputRuleLine, {}),
-    /* @__PURE__ */ jsx2(Footer, { isReadOnly })
+    /* @__PURE__ */ jsx2(Footer, { isReadOnly, clipHint })
   ] });
 });
 InputPrompt.displayName = "InputPrompt";
@@ -1266,7 +1966,7 @@ var InteractiveMenu = memo3(InteractiveMenuComponent);
 
 // src/app/ui/components/promptRenderers.tsx
 import { Box as Box5, Text as Text5 } from "ink";
-import path2 from "path";
+import path4 from "path";
 
 // src/app/ui/components/SimpleDiff.tsx
 import { Box as Box4, Text as Text4 } from "ink";
@@ -1312,7 +2012,7 @@ var SimpleDiff = ({ text, maxHeight }) => {
 // src/app/ui/components/promptRenderers.tsx
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var getBasePath = (filePath) => {
-  return path2.basename(filePath);
+  return path4.basename(filePath);
 };
 var renderShellCommand = ({ toolCall }) => {
   let command = "";
@@ -1526,6 +2226,25 @@ var promptRenderers = {
 
 // src/app/ui/theme/m3Layout.tsx
 import { Box as Box6, Text as Text6 } from "ink";
+
+// src/app/ui/utils/formatTurnDurationMs.ts
+function formatTurnDurationMs(ms) {
+  if (ms < 0) {
+    return "0s";
+  }
+  const secTotal = Math.round(ms / 1e3);
+  if (secTotal < 60) {
+    if (ms < 1e4) {
+      return `${(ms / 1e3).toFixed(1)}s`;
+    }
+    return `${secTotal}s`;
+  }
+  const min = Math.floor(secTotal / 60);
+  const sec = secTotal % 60;
+  return `${min}min \u25CF ${sec}s`;
+}
+
+// src/app/ui/theme/m3Layout.tsx
 import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function ChatBlock({
   children,
@@ -1533,6 +2252,24 @@ function ChatBlock({
 }) {
   return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", marginBottom, children });
 }
+function ChatUserImageBlock({
+  imageCount,
+  caption,
+  captionDim = false
+}) {
+  if (imageCount < 1) {
+    return null;
+  }
+  const cap = caption?.trim() ?? "";
+  const capLines = cap.length > 0 ? cap.split("\n") : [];
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 0, children: [
+    Array.from({ length: imageCount }, (_, i) => /* @__PURE__ */ jsx6(Text6, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: `[IMAGE #${i + 1}]` }, `img-${i}`)),
+    capLines.map((line, i) => /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: i === 0 ? "\u2514\u2500 " : "   " }),
+      captionDim ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, wrap: "wrap", children: line }) : /* @__PURE__ */ jsx6(Text6, { wrap: "wrap", children: line })
+    ] }, `cap-${i}`))
+  ] });
+}
 function ChatUserMessage({ children }) {
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", marginBottom: 1, flexWrap: "wrap", alignItems: "flex-start", children: [
     /* @__PURE__ */ jsxs6(Text6, { color: "white", bold: true, children: [
@@ -1554,13 +2291,10 @@ function ChatStatusRow({ children }) {
     children
   ] });
 }
-function ChatTurnDuration({ secondsFormatted }) {
+function ChatTurnDuration({ durationMs }) {
   return /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
     /* @__PURE__ */ jsx6(Text6, { color: BLUMA_TERMINAL.brandBlue, children: "\xB7 " }),
-    /* @__PURE__ */ jsxs6(Text6, { color: BLUMA_TERMINAL.brandMagenta, children: [
-      secondsFormatted,
-      "s"
-    ] })
+    /* @__PURE__ */ jsx6(Text6, { color: BLUMA_TERMINAL.brandMagenta, children: formatTurnDurationMs(durationMs) })
   ] }) });
 }
 var M3StatusStrip = ChatStatusRow;
@@ -1583,25 +2317,25 @@ var ConfirmationPrompt = memo4(ConfirmationPromptComponent);
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path17 from "path";
-import os11 from "os";
+import path19 from "path";
+import os14 from "os";
 
 // src/app/agent/tool_invoker.ts
-import { promises as fs9 } from "fs";
-import path11 from "path";
+import { promises as fs11 } from "fs";
+import path13 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/natives/edit.ts
-import path3 from "path";
-import os from "os";
-import { promises as fs2 } from "fs";
+import path5 from "path";
+import os4 from "os";
+import { promises as fs4 } from "fs";
 import { diffLines } from "diff";
 var MAX_DIFF_SIZE = 5e4;
 var MAX_FILE_SIZE = 10 * 1024 * 1024;
 function normalizePath(filePath) {
   try {
     filePath = filePath.trim();
-    if (os.platform() === "win32") {
+    if (os4.platform() === "win32") {
       const winDriveRegex = /^\/([a-zA-Z])[:/]/;
       const match = filePath.match(winDriveRegex);
       if (match) {
@@ -1611,7 +2345,7 @@ function normalizePath(filePath) {
       }
       filePath = filePath.replace(/\//g, "\\");
     }
-    return path3.normalize(path3.resolve(filePath));
+    return path5.normalize(path5.resolve(filePath));
   } catch (e) {
     throw new Error(`Failed to normalize path "${filePath}": ${e.message}`);
   }
@@ -1735,7 +2469,7 @@ async function calculateEdit(filePath, oldString, newString, expectedReplacement
   let normalizedOldString = oldString.replace(/\r\n/g, "\n");
   let occurrences = 0;
   try {
-    const stats = await fs2.stat(normalizedFilePath);
+    const stats = await fs4.stat(normalizedFilePath);
     if (stats.size > MAX_FILE_SIZE) {
       error = {
         display: `File too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum allowed: ${MAX_FILE_SIZE / 1024 / 1024}MB`,
@@ -1743,7 +2477,7 @@ async function calculateEdit(filePath, oldString, newString, expectedReplacement
       };
       return { currentContent, newContent: "", occurrences: 0, error, isNewFile };
     }
-    currentContent = await fs2.readFile(normalizedFilePath, "utf-8");
+    currentContent = await fs4.readFile(normalizedFilePath, "utf-8");
     currentContent = currentContent.replace(/\r\n/g, "\n");
   } catch (e) {
     if (e.code !== "ENOENT") {
@@ -1872,7 +2606,7 @@ async function editTool(args) {
       };
     }
     const cwd = process.cwd();
-    if (!normalizedFilePath.startsWith(cwd) && !path3.isAbsolute(file_path)) {
+    if (!normalizedFilePath.startsWith(cwd) && !path5.isAbsolute(file_path)) {
       return {
         success: false,
         error: `Invalid parameters: file_path must be within the current working directory or be an absolute path.`,
@@ -1893,11 +2627,11 @@ async function editTool(args) {
         file_path: normalizedFilePath
       };
     }
-    const dirPath = path3.dirname(normalizedFilePath);
-    await fs2.mkdir(dirPath, { recursive: true });
-    await fs2.writeFile(normalizedFilePath, editData.newContent, "utf-8");
-    const relativePath = path3.relative(process.cwd(), normalizedFilePath);
-    const filename = path3.basename(normalizedFilePath);
+    const dirPath = path5.dirname(normalizedFilePath);
+    await fs4.mkdir(dirPath, { recursive: true });
+    await fs4.writeFile(normalizedFilePath, editData.newContent, "utf-8");
+    const relativePath = path5.relative(process.cwd(), normalizedFilePath);
+    const filename = path5.basename(normalizedFilePath);
     if (editData.isNewFile) {
       return {
         success: true,
@@ -1951,8 +2685,8 @@ function message(args) {
 }
 
 // src/app/agent/tools/natives/ls.ts
-import { promises as fs3 } from "fs";
-import path4 from "path";
+import { promises as fs5 } from "fs";
+import path6 from "path";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ".git",
   ".gitignore",
@@ -1980,8 +2714,8 @@ async function ls(args) {
     max_depth
   } = args;
   try {
-    const basePath = path4.resolve(directory_path);
-    if (!(await fs3.stat(basePath)).isDirectory()) {
+    const basePath = path6.resolve(directory_path);
+    if (!(await fs5.stat(basePath)).isDirectory()) {
       throw new Error(`Directory '${directory_path}' not found.`);
     }
     const allIgnorePatterns = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore_patterns]);
@@ -1990,11 +2724,11 @@ async function ls(args) {
     const allDirs = [];
     const walk = async (currentDir, currentDepth) => {
       if (max_depth !== void 0 && currentDepth > max_depth) return;
-      const entries = await fs3.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs5.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         const entryName = entry.name;
-        const fullPath = path4.join(currentDir, entryName);
-        const posixPath = fullPath.split(path4.sep).join("/");
+        const fullPath = path6.join(currentDir, entryName);
+        const posixPath = fullPath.split(path6.sep).join("/");
         const isHidden = entryName.startsWith(".");
         if (allIgnorePatterns.has(entryName) || isHidden && !show_hidden) {
           continue;
@@ -2005,7 +2739,7 @@ async function ls(args) {
             await walk(fullPath, currentDepth + 1);
           }
         } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path4.extname(entryName).toLowerCase())) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path6.extname(entryName).toLowerCase())) {
             allFiles.push(posixPath);
           }
         }
@@ -2016,7 +2750,7 @@ async function ls(args) {
     allDirs.sort();
     return {
       success: true,
-      path: basePath.split(path4.sep).join("/"),
+      path: basePath.split(path6.sep).join("/"),
       recursive,
       total_files: allFiles.length,
       total_directories: allDirs.length,
@@ -2032,17 +2766,17 @@ async function ls(args) {
 }
 
 // src/app/agent/tools/natives/readLines.ts
-import { promises as fs4 } from "fs";
+import { promises as fs6 } from "fs";
 async function readLines(args) {
   const { filepath, start_line, end_line } = args;
   try {
-    if (!(await fs4.stat(filepath)).isFile()) {
+    if (!(await fs6.stat(filepath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     if (start_line < 1 || end_line < start_line) {
       throw new Error("Invalid line range. start_line must be >= 1 and end_line must be >= start_line.");
     }
-    const fileContent = await fs4.readFile(filepath, "utf-8");
+    const fileContent = await fs6.readFile(filepath, "utf-8");
     const lines = fileContent.split("\n");
     const total_lines = lines.length;
     const startIndex = start_line - 1;
@@ -2070,12 +2804,12 @@ async function readLines(args) {
 
 // src/app/agent/tools/natives/count_lines.ts
 import { createReadStream } from "fs";
-import { promises as fs5 } from "fs";
+import { promises as fs7 } from "fs";
 import readline from "readline";
 async function countLines(args) {
   const { filepath } = args;
   try {
-    if (!(await fs5.stat(filepath)).isFile()) {
+    if (!(await fs7.stat(filepath)).isFile()) {
       throw new Error(`File '${filepath}' not found or is not a file.`);
     }
     const fileStream = createReadStream(filepath);
@@ -2094,18 +2828,18 @@ async function countLines(args) {
 }
 
 // src/app/agent/tools/natives/todo.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 var taskStore = [];
 var nextId = 1;
 function getTodoFilePath() {
-  return path5.join(process.cwd(), ".bluma", "todo.json");
+  return path7.join(process.cwd(), ".bluma", "todo.json");
 }
 function loadTasksFromFile() {
   try {
     const filePath = getTodoFilePath();
-    if (fs6.existsSync(filePath)) {
-      const data = fs6.readFileSync(filePath, "utf-8");
+    if (fs8.existsSync(filePath)) {
+      const data = fs8.readFileSync(filePath, "utf-8");
       const parsed = JSON.parse(data);
       if (Array.isArray(parsed.tasks)) {
         taskStore = parsed.tasks;
@@ -2118,11 +2852,11 @@ function loadTasksFromFile() {
 function saveTasksToFile() {
   try {
     const filePath = getTodoFilePath();
-    const dir = path5.dirname(filePath);
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    const dir = path7.dirname(filePath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
     }
-    fs6.writeFileSync(filePath, JSON.stringify({
+    fs8.writeFileSync(filePath, JSON.stringify({
       tasks: taskStore,
       nextId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -2297,7 +3031,7 @@ async function todo(args) {
 }
 
 // src/app/agent/tools/natives/find_by_name.ts
-import path6 from "path";
+import path8 from "path";
 import { promises as fsPromises } from "fs";
 var DEFAULT_IGNORE_PATTERNS = [
   "node_modules",
@@ -2337,7 +3071,7 @@ function shouldIgnore(name, ignorePatterns, includeHidden) {
 }
 function matchesExtensions(filename, extensions) {
   if (!extensions || extensions.length === 0) return true;
-  const ext = path6.extname(filename).toLowerCase();
+  const ext = path8.extname(filename).toLowerCase();
   return extensions.some((e) => {
     const normalizedExt = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
     return ext === normalizedExt;
@@ -2359,8 +3093,8 @@ async function searchDirectory(dir, pattern, baseDir, options, results) {
     if (shouldIgnore(name, options.ignorePatterns, options.includeHidden)) {
       continue;
     }
-    const fullPath = path6.join(dir, name);
-    const relativePath = path6.relative(baseDir, fullPath);
+    const fullPath = path8.join(dir, name);
+    const relativePath = path8.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (pattern.test(name)) {
         results.push({
@@ -2416,7 +3150,7 @@ async function findByName(args) {
         error: "Pattern is required and must be a string"
       };
     }
-    const resolvedDir = path6.resolve(directory);
+    const resolvedDir = path8.resolve(directory);
     try {
       const stats = await fsPromises.stat(resolvedDir);
       if (!stats.isDirectory()) {
@@ -2477,7 +3211,7 @@ async function findByName(args) {
 }
 
 // src/app/agent/tools/natives/grep_search.ts
-import path7 from "path";
+import path9 from "path";
 import { promises as fsPromises2 } from "fs";
 var MAX_RESULTS3 = 100;
 var MAX_FILE_SIZE2 = 1024 * 1024;
@@ -2560,8 +3294,8 @@ var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   "Rakefile"
 ]);
 function isTextFile(filepath) {
-  const ext = path7.extname(filepath).toLowerCase();
-  const basename = path7.basename(filepath);
+  const ext = path9.extname(filepath).toLowerCase();
+  const basename = path9.basename(filepath);
   if (TEXT_EXTENSIONS.has(ext)) return true;
   if (TEXT_EXTENSIONS.has(basename)) return true;
   if (basename.startsWith(".") && !ext) return true;
@@ -2606,7 +3340,7 @@ async function searchFile(filepath, baseDir, pattern, contextLines, matches, max
     if (stats.size > MAX_FILE_SIZE2) return 0;
     const content = await fsPromises2.readFile(filepath, "utf-8");
     const lines = content.split("\n");
-    const relativePath = path7.relative(baseDir, filepath);
+    const relativePath = path9.relative(baseDir, filepath);
     for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
       const line = lines[i];
       pattern.lastIndex = 0;
@@ -2646,7 +3380,7 @@ async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextL
     if (matches.length >= maxResults) break;
     const name = entry.name;
     if (shouldIgnore2(name)) continue;
-    const fullPath = path7.join(dir, name);
+    const fullPath = path9.join(dir, name);
     if (entry.isDirectory()) {
       await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, matches, maxResults, stats);
     } else if (entry.isFile()) {
@@ -2695,7 +3429,7 @@ async function grepSearch(args) {
         error: "Search path is required"
       };
     }
-    const resolvedPath = path7.resolve(searchPath);
+    const resolvedPath = path9.resolve(searchPath);
     let stats;
     try {
       stats = await fsPromises2.stat(resolvedPath);
@@ -2743,7 +3477,7 @@ async function grepSearch(args) {
       );
     } else if (stats.isFile()) {
       searchStats.filesSearched = 1;
-      const found = await searchFile(resolvedPath, path7.dirname(resolvedPath), pattern, context_lines, matches, max_results);
+      const found = await searchFile(resolvedPath, path9.dirname(resolvedPath), pattern, context_lines, matches, max_results);
       if (found > 0) searchStats.filesWithMatches = 1;
     }
     return {
@@ -2772,7 +3506,7 @@ async function grepSearch(args) {
 }
 
 // src/app/agent/tools/natives/view_file_outline.ts
-import path8 from "path";
+import path10 from "path";
 import { promises as fsPromises3 } from "fs";
 var LANGUAGE_MAP = {
   ".ts": "typescript",
@@ -2886,7 +3620,7 @@ var PATTERNS = {
   ]
 };
 function detectLanguage(filepath) {
-  const ext = path8.extname(filepath).toLowerCase();
+  const ext = path10.extname(filepath).toLowerCase();
   return LANGUAGE_MAP[ext] || "unknown";
 }
 function determineItemType(line, language) {
@@ -2982,7 +3716,7 @@ async function viewFileOutline(args) {
         error: "file_path is required and must be a string"
       };
     }
-    const resolvedPath = path8.resolve(file_path);
+    const resolvedPath = path10.resolve(file_path);
     let content;
     try {
       content = await fsPromises3.readFile(resolvedPath, "utf-8");
@@ -3026,23 +3760,23 @@ async function viewFileOutline(args) {
 init_async_command();
 
 // src/app/agent/tools/natives/task_boundary.ts
-import path9 from "path";
-import { promises as fs7 } from "fs";
-import os3 from "os";
+import path11 from "path";
+import { promises as fs9 } from "fs";
+import os6 from "os";
 var currentTask = null;
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
-  const homeDir = os3.homedir();
-  const baseDir = path9.join(homeDir, ".bluma", "artifacts");
+  const homeDir = os6.homedir();
+  const baseDir = path11.join(homeDir, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-  artifactsDir = path9.join(baseDir, sessionId);
-  await fs7.mkdir(artifactsDir, { recursive: true });
+  artifactsDir = path11.join(baseDir, sessionId);
+  await fs9.mkdir(artifactsDir, { recursive: true });
   return artifactsDir;
 }
 async function updateTaskFile(task) {
   const dir = await getArtifactsDir();
-  const taskFile = path9.join(dir, "task.md");
+  const taskFile = path11.join(dir, "task.md");
   const content = `# ${task.taskName}
 
 **Mode:** ${task.mode}  
@@ -3054,7 +3788,7 @@ async function updateTaskFile(task) {
 ## Summary
 ${task.summary}
 `;
-  await fs7.writeFile(taskFile, content, "utf-8");
+  await fs9.writeFile(taskFile, content, "utf-8");
 }
 async function taskBoundary(args) {
   try {
@@ -3134,8 +3868,8 @@ async function createArtifact(args) {
       return { success: false, error: "content is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path9.join(dir, filename);
-    await fs7.writeFile(filepath, content, "utf-8");
+    const filepath = path11.join(dir, filename);
+    await fs9.writeFile(filepath, content, "utf-8");
     return {
       success: true,
       path: filepath
@@ -3154,8 +3888,8 @@ async function readArtifact(args) {
       return { success: false, error: "filename is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path9.join(dir, filename);
-    const content = await fs7.readFile(filepath, "utf-8");
+    const filepath = path11.join(dir, filename);
+    const content = await fs9.readFile(filepath, "utf-8");
     return {
       success: true,
       content
@@ -3524,9 +4258,9 @@ ${skill.content}`;
 }
 
 // src/app/agent/tools/natives/coding_memory.ts
-import * as fs8 from "fs";
-import * as path10 from "path";
-import os4 from "os";
+import * as fs10 from "fs";
+import * as path12 from "path";
+import os7 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
 var PROMPT_DEFAULT_PREVIEW = 500;
@@ -3534,14 +4268,14 @@ function readCodingMemoryForPrompt(options) {
   const maxTotal = options?.maxTotalChars ?? PROMPT_DEFAULT_MAX_TOTAL;
   const maxNotes = options?.maxNotes ?? PROMPT_DEFAULT_MAX_NOTES;
   const preview = options?.previewCharsPerNote ?? PROMPT_DEFAULT_PREVIEW;
-  const globalPath = path10.join(os4.homedir(), ".bluma", "coding_memory.json");
-  const legacyPath = path10.join(process.cwd(), ".bluma", "coding_memory.json");
+  const globalPath = path12.join(os7.homedir(), ".bluma", "coding_memory.json");
+  const legacyPath = path12.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
-    if (fs8.existsSync(globalPath)) {
-      raw = fs8.readFileSync(globalPath, "utf-8");
-    } else if (path10.resolve(globalPath) !== path10.resolve(legacyPath) && fs8.existsSync(legacyPath)) {
-      raw = fs8.readFileSync(legacyPath, "utf-8");
+    if (fs10.existsSync(globalPath)) {
+      raw = fs10.readFileSync(globalPath, "utf-8");
+    } else if (path12.resolve(globalPath) !== path12.resolve(legacyPath) && fs10.existsSync(legacyPath)) {
+      raw = fs10.readFileSync(legacyPath, "utf-8");
     }
   } catch {
     return "";
@@ -3579,10 +4313,10 @@ var memoryStore = [];
 var nextId2 = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path10.join(os4.homedir(), ".bluma", "coding_memory.json");
+  return path12.join(os7.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
-  return path10.join(process.cwd(), ".bluma", "coding_memory.json");
+  return path12.join(process.cwd(), ".bluma", "coding_memory.json");
 }
 function loadMemoryFromFile() {
   if (loaded) return;
@@ -3592,19 +4326,19 @@ function loadMemoryFromFile() {
   try {
     const filePath = getMemoryFilePath();
     const legacy = getLegacyMemoryFilePath();
-    const legacyDistinct = path10.resolve(legacy) !== path10.resolve(filePath);
+    const legacyDistinct = path12.resolve(legacy) !== path12.resolve(filePath);
     const readIntoStore = (p) => {
-      const raw = fs8.readFileSync(p, "utf-8");
+      const raw = fs10.readFileSync(p, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.entries)) {
         memoryStore = parsed.entries;
         nextId2 = typeof parsed.nextId === "number" ? parsed.nextId : memoryStore.length + 1;
       }
     };
-    if (fs8.existsSync(filePath)) {
+    if (fs10.existsSync(filePath)) {
       readIntoStore(filePath);
     }
-    if (memoryStore.length === 0 && legacyDistinct && fs8.existsSync(legacy)) {
+    if (memoryStore.length === 0 && legacyDistinct && fs10.existsSync(legacy)) {
       readIntoStore(legacy);
       if (memoryStore.length > 0) {
         saveMemoryToFile();
@@ -3618,16 +4352,16 @@ function loadMemoryFromFile() {
 function saveMemoryToFile() {
   try {
     const filePath = getMemoryFilePath();
-    const dir = path10.dirname(filePath);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    const dir = path12.dirname(filePath);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
     }
     const payload = {
       entries: memoryStore,
       nextId: nextId2,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs8.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+    fs10.writeFileSync(filePath, JSON.stringify(payload, null, 2));
   } catch {
   }
 }
@@ -3824,9 +4558,9 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const __filename = fileURLToPath(import.meta.url);
-      const __dirname2 = path11.dirname(__filename);
-      const configPath = path11.resolve(__dirname2, "config", "native_tools.json");
-      const fileContent = await fs9.readFile(configPath, "utf-8");
+      const __dirname2 = path13.dirname(__filename);
+      const configPath = path13.resolve(__dirname2, "config", "native_tools.json");
+      const fileContent = await fs11.readFile(configPath, "utf-8");
       const config2 = JSON.parse(fileContent);
       this.toolDefinitions = config2.nativeTools;
     } catch (error) {
@@ -3887,9 +4621,9 @@ var ToolInvoker = class {
 };
 
 // src/app/agent/tools/mcp/mcp_client.ts
-import { promises as fs10 } from "fs";
-import path12 from "path";
-import os5 from "os";
+import { promises as fs12 } from "fs";
+import path14 from "path";
+import os8 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -3916,9 +4650,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname2 = path12.dirname(__filename);
-    const defaultConfigPath = path12.resolve(__dirname2, "config", "bluma-mcp.json");
-    const userConfigPath = path12.join(os5.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname2 = path14.dirname(__filename);
+    const defaultConfigPath = path14.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path14.join(os8.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -3952,7 +4686,7 @@ var MCPClient = class {
   }
   async loadMcpConfig(configPath, configType) {
     try {
-      const fileContent = await fs10.readFile(configPath, "utf-8");
+      const fileContent = await fs12.readFile(configPath, "utf-8");
       const processedContent = this.replaceEnvPlaceholders(fileContent);
       return JSON.parse(processedContent);
     } catch (error) {
@@ -3971,7 +4705,7 @@ var MCPClient = class {
   async connectToStdioServer(serverName, config2) {
     let commandToExecute = config2.command;
     let argsToExecute = config2.args || [];
-    const isWindows = os5.platform() === "win32";
+    const isWindows = os8.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -4087,13 +4821,13 @@ var AdvancedFeedbackSystem = class {
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path16 from "path";
+import path18 from "path";
 import { v4 as uuidv43 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path13 from "path";
-import os6 from "os";
-import { promises as fs11 } from "fs";
+import path15 from "path";
+import os9 from "os";
+import { promises as fs13 } from "fs";
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -4129,13 +4863,13 @@ function debouncedSave(sessionFile, history, memory) {
 function expandHome(p) {
   if (!p) return p;
   if (p.startsWith("~")) {
-    return path13.join(os6.homedir(), p.slice(1));
+    return path15.join(os9.homedir(), p.slice(1));
   }
   return p;
 }
 function getPreferredAppDir() {
-  const fixed = path13.join(os6.homedir(), ".bluma");
-  return path13.resolve(expandHome(fixed));
+  const fixed = path15.join(os9.homedir(), ".bluma");
+  return path15.resolve(expandHome(fixed));
 }
 async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   let attempt = 0;
@@ -4143,10 +4877,10 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path13.dirname(dest);
-      await fs11.mkdir(dir, { recursive: true }).catch(() => {
+      const dir = path15.dirname(dest);
+      await fs13.mkdir(dir, { recursive: true }).catch(() => {
       });
-      await fs11.rename(src, dest);
+      await fs13.rename(src, dest);
       return;
     } catch (e) {
       lastErr = e;
@@ -4159,13 +4893,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
     }
   }
   try {
-    await fs11.access(src);
-    const data = await fs11.readFile(src);
-    const dir = path13.dirname(dest);
-    await fs11.mkdir(dir, { recursive: true }).catch(() => {
+    await fs13.access(src);
+    const data = await fs13.readFile(src);
+    const dir = path15.dirname(dest);
+    await fs13.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await fs11.writeFile(dest, data);
-    await fs11.unlink(src).catch(() => {
+    await fs13.writeFile(dest, data);
+    await fs13.unlink(src).catch(() => {
     });
     return;
   } catch (fallbackErr) {
@@ -4178,16 +4912,16 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path13.join(appDir, "sessions");
-  await fs11.mkdir(sessionDir, { recursive: true });
+  const sessionDir = path15.join(appDir, "sessions");
+  await fs13.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function loadOrcreateSession(sessionId) {
   const sessionDir = await ensureSessionDir();
-  const sessionFile = path13.join(sessionDir, `${sessionId}.json`);
+  const sessionFile = path15.join(sessionDir, `${sessionId}.json`);
   try {
-    await fs11.access(sessionFile);
-    const fileContent = await fs11.readFile(sessionFile, "utf-8");
+    await fs13.access(sessionFile);
+    const fileContent = await fs13.readFile(sessionFile, "utf-8");
     const sessionData = JSON.parse(fileContent);
     const memory = {
       historyAnchor: sessionData.history_anchor ?? null,
@@ -4200,7 +4934,7 @@ async function loadOrcreateSession(sessionId) {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       conversation_history: []
     };
-    await fs11.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
+    await fs13.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
     const emptyMemory = {
       historyAnchor: null,
       compressedTurnSliceCount: 0
@@ -4212,12 +4946,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path13.dirname(sessionFile);
-      await fs11.mkdir(dir, { recursive: true });
+      const dir = path15.dirname(sessionFile);
+      await fs13.mkdir(dir, { recursive: true });
     } catch {
     }
     try {
-      const fileContent = await fs11.readFile(sessionFile, "utf-8");
+      const fileContent = await fs13.readFile(sessionFile, "utf-8");
       sessionData = JSON.parse(fileContent);
     } catch (error) {
       const code = error && error.code;
@@ -4228,14 +4962,14 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path13.basename(sessionFile, ".json");
+      const sessionId = path15.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: []
       };
       try {
-        await fs11.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+        await fs13.writeFile(sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       } catch {
       }
     }
@@ -4251,7 +4985,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     }
     const tempSessionFile = `${sessionFile}.${Date.now()}.tmp`;
     try {
-      await fs11.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      await fs13.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
     } catch (writeError) {
       if (writeError instanceof Error) {
@@ -4260,7 +4994,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
         console.error(`An unknown fatal error occurred while saving session to ${sessionFile}:`, writeError);
       }
       try {
-        await fs11.unlink(tempSessionFile);
+        await fs13.unlink(tempSessionFile);
       } catch {
       }
     }
@@ -4277,15 +5011,15 @@ async function saveSessionHistory(sessionFile, history, memory) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os8 from "os";
-import fs13 from "fs";
-import path15 from "path";
+import os11 from "os";
+import fs15 from "fs";
+import path17 from "path";
 import { execSync } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
-import fs12 from "fs";
-import path14 from "path";
-import os7 from "os";
+import fs14 from "fs";
+import path16 from "path";
+import os10 from "os";
 var SkillLoader = class _SkillLoader {
   bundledSkillsDir;
   projectSkillsDir;
@@ -4293,8 +5027,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path14.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path14.join(os7.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path16.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path16.join(os10.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -4303,34 +5037,34 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path14.join(process.cwd(), "dist", "config", "skills");
+      return path16.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
-        const scriptDir = path14.dirname(path14.resolve(argv1));
-        candidates.push(path14.join(scriptDir, "config", "skills"));
+        const scriptDir = path16.dirname(path16.resolve(argv1));
+        candidates.push(path16.join(scriptDir, "config", "skills"));
       } catch {
       }
     }
     candidates.push(
-      path14.join(process.cwd(), "dist", "config", "skills"),
-      path14.join(process.cwd(), "node_modules", "@nomad-e", "bluma-cli", "dist", "config", "skills")
+      path16.join(process.cwd(), "dist", "config", "skills"),
+      path16.join(process.cwd(), "node_modules", "@nomad-e", "bluma-cli", "dist", "config", "skills")
     );
     if (typeof __dirname !== "undefined") {
       candidates.push(
-        path14.join(__dirname, "config", "skills"),
-        path14.join(__dirname, "..", "..", "..", "config", "skills")
+        path16.join(__dirname, "config", "skills"),
+        path16.join(__dirname, "..", "..", "..", "config", "skills")
       );
     }
     for (const c of candidates) {
-      const abs = path14.resolve(c);
-      if (fs12.existsSync(abs)) {
+      const abs = path16.resolve(c);
+      if (fs14.existsSync(abs)) {
         return abs;
       }
     }
-    return path14.join(process.cwd(), "dist", "config", "skills");
+    return path16.join(process.cwd(), "dist", "config", "skills");
   }
   /**
    * Lista skills disponíveis de todas as fontes.
@@ -4358,8 +5092,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path14.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path14.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path16.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path16.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -4367,20 +5101,20 @@ var SkillLoader = class _SkillLoader {
     }
   }
   listFromDir(dir, source) {
-    if (!fs12.existsSync(dir)) return [];
+    if (!fs14.existsSync(dir)) return [];
     try {
-      return fs12.readdirSync(dir).filter((d) => {
-        const fullPath = path14.join(dir, d);
-        return fs12.statSync(fullPath).isDirectory() && fs12.existsSync(path14.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path14.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+      return fs14.readdirSync(dir).filter((d) => {
+        const fullPath = path16.join(dir, d);
+        return fs14.statSync(fullPath).isDirectory() && fs14.existsSync(path16.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path16.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
   }
   loadMetadataFromPath(skillPath, skillName, source) {
-    if (!fs12.existsSync(skillPath)) return null;
+    if (!fs14.existsSync(skillPath)) return null;
     try {
-      const raw = fs12.readFileSync(skillPath, "utf-8");
+      const raw = fs14.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
       return {
         name: parsed.name || skillName,
@@ -4402,12 +5136,12 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path14.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path14.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path14.join(this.globalSkillsDir, name, "SKILL.md");
-    const existsBundled = fs12.existsSync(bundledPath);
-    const existsProject = fs12.existsSync(projectPath);
-    const existsGlobal = fs12.existsSync(globalPath);
+    const bundledPath = path16.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path16.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path16.join(this.globalSkillsDir, name, "SKILL.md");
+    const existsBundled = fs14.existsSync(bundledPath);
+    const existsProject = fs14.existsSync(projectPath);
+    const existsGlobal = fs14.existsSync(globalPath);
     if (existsBundled && (existsProject || existsGlobal)) {
       const conflictSource = existsProject ? "project" : "global";
       const conflictPath = existsProject ? projectPath : globalPath;
@@ -4446,9 +5180,9 @@ var SkillLoader = class _SkillLoader {
   }
   loadFromPath(skillPath, name, source) {
     try {
-      const raw = fs12.readFileSync(skillPath, "utf-8");
+      const raw = fs14.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path14.dirname(skillPath);
+      const skillDir = path16.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -4457,22 +5191,22 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path14.join(skillDir, "references")),
-        scripts: this.scanAssets(path14.join(skillDir, "scripts"))
+        references: this.scanAssets(path16.join(skillDir, "references")),
+        scripts: this.scanAssets(path16.join(skillDir, "scripts"))
       };
     } catch {
       return null;
     }
   }
   scanAssets(dir) {
-    if (!fs12.existsSync(dir)) return [];
+    if (!fs14.existsSync(dir)) return [];
     try {
-      return fs12.readdirSync(dir).filter((f) => {
-        const fp = path14.join(dir, f);
-        return fs12.statSync(fp).isFile();
+      return fs14.readdirSync(dir).filter((f) => {
+        const fp = path16.join(dir, f);
+        return fs14.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path14.resolve(dir, f)
+        path: path16.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -4529,10 +5263,10 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path14.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path14.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path14.join(this.globalSkillsDir, name, "SKILL.md");
-    return fs12.existsSync(bundledPath) || fs12.existsSync(projectPath) || fs12.existsSync(globalPath);
+    const bundledPath = path16.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path16.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path16.join(this.globalSkillsDir, name, "SKILL.md");
+    return fs14.existsSync(bundledPath) || fs14.existsSync(projectPath) || fs14.existsSync(globalPath);
   }
   /**
    * Retorna conflitos detetados (skills do utilizador com mesmo nome de nativas).
@@ -4591,10 +5325,10 @@ function getGitBranch(dir) {
 }
 function getPackageManager(dir) {
   try {
-    if (fs13.existsSync(path15.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs13.existsSync(path15.join(dir, "yarn.lock"))) return "yarn";
-    if (fs13.existsSync(path15.join(dir, "bun.lockb"))) return "bun";
-    if (fs13.existsSync(path15.join(dir, "package-lock.json"))) return "npm";
+    if (fs15.existsSync(path17.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs15.existsSync(path17.join(dir, "yarn.lock"))) return "yarn";
+    if (fs15.existsSync(path17.join(dir, "bun.lockb"))) return "bun";
+    if (fs15.existsSync(path17.join(dir, "package-lock.json"))) return "npm";
     return "unknown";
   } catch {
     return "unknown";
@@ -4602,9 +5336,9 @@ function getPackageManager(dir) {
 }
 function getProjectType(dir) {
   try {
-    const files = fs13.readdirSync(dir);
+    const files = fs15.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs13.readFileSync(path15.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs15.readFileSync(path17.join(dir, "package.json"), "utf-8"));
       if (pkg.dependencies?.next || pkg.devDependencies?.next) return "Next.js";
       if (pkg.dependencies?.react || pkg.devDependencies?.react) return "React";
       if (pkg.dependencies?.express || pkg.devDependencies?.express) return "Express";
@@ -4623,9 +5357,9 @@ function getProjectType(dir) {
 }
 function getTestFramework(dir) {
   try {
-    const pkgPath = path15.join(dir, "package.json");
-    if (fs13.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path17.join(dir, "package.json");
+    if (fs15.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -4634,7 +5368,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs13.existsSync(path15.join(dir, "pytest.ini")) || fs13.existsSync(path15.join(dir, "conftest.py"))) return "pytest";
+    if (fs15.existsSync(path17.join(dir, "pytest.ini")) || fs15.existsSync(path17.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -4642,9 +5376,9 @@ function getTestFramework(dir) {
 }
 function getTestCommand(dir) {
   try {
-    const pkgPath = path15.join(dir, "package.json");
-    if (fs13.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path17.join(dir, "package.json");
+    if (fs15.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return `npm test`;
       if (pkg.scripts?.["test:unit"]) return `npm run test:unit`;
     }
@@ -5121,12 +5855,12 @@ In sandbox mode you are a Python-focused, non-interactive, deterministic agent t
 function getUnifiedSystemPrompt(availableSkills) {
   const cwd = process.cwd();
   const env = {
-    os_type: os8.type(),
-    os_version: os8.release(),
-    architecture: os8.arch(),
+    os_type: os11.type(),
+    os_version: os11.release(),
+    architecture: os11.arch(),
     workdir: cwd,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os8.userInfo().username,
+    username: os11.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     is_git_repo: isGitRepo(cwd) ? "yes" : "no",
@@ -5311,8 +6045,8 @@ ${memorySnapshot.trim().length > 0 ? memorySnapshot : "(No entries yet. Use codi
 }
 function isGitRepo(dir) {
   try {
-    const gitPath = path15.join(dir, ".git");
-    return fs13.existsSync(gitPath) && fs13.lstatSync(gitPath).isDirectory();
+    const gitPath = path17.join(dir, ".git");
+    return fs15.existsSync(gitPath) && fs15.lstatSync(gitPath).isDirectory();
   } catch {
     return false;
   }
@@ -5521,21 +6255,9 @@ function partitionConversationIntoTurnSlices(conversationHistory) {
   }
   return turns;
 }
-var DEFAULT_TOKEN_BUDGET = 6e4;
-var DEFAULT_COMPRESS_THRESHOLD = 0.7;
-var DEFAULT_KEEP_RECENT_TURNS = 8;
-function readContextOptionInt(envKey, fallback) {
-  const raw = (process.env[envKey] ?? "").trim();
-  if (!raw) return fallback;
-  const n = Number(raw);
-  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
-}
-function readContextOptionFloat(envKey, fallback) {
-  const raw = (process.env[envKey] ?? "").trim();
-  if (!raw) return fallback;
-  const n = Number(raw);
-  return Number.isFinite(n) && n > 0 && n <= 1 ? n : fallback;
-}
+var CONTEXT_TOKEN_BUDGET = 24e4;
+var COMPRESS_THRESHOLD = 0.7;
+var KEEP_RECENT_TURNS = 10;
 function buildContextMessages(systemMessages, anchor, pendingRaw, recentFlat) {
   const anchorMsg = anchor ? [anchorToSystemMessage(anchor)] : [];
   return [...systemMessages, ...anchorMsg, ...pendingRaw, ...recentFlat];
@@ -5548,9 +6270,9 @@ async function createApiContextWindow(fullHistory, currentAnchor, compressedTurn
       newCompressedTurnSliceCount: compressedTurnSliceCount
     };
   }
-  const tokenBudget = options?.tokenBudget ?? readContextOptionInt("BLUMA_CONTEXT_TOKEN_BUDGET", DEFAULT_TOKEN_BUDGET);
-  const compressThreshold = options?.compressThreshold ?? readContextOptionFloat("BLUMA_COMPRESS_THRESHOLD", DEFAULT_COMPRESS_THRESHOLD);
-  const keepRecentTurns = options?.keepRecentTurns ?? readContextOptionInt("BLUMA_KEEP_RECENT_TURNS", DEFAULT_KEEP_RECENT_TURNS);
+  const tokenBudget = options?.tokenBudget ?? CONTEXT_TOKEN_BUDGET;
+  const compressThreshold = options?.compressThreshold ?? COMPRESS_THRESHOLD;
+  const keepRecentTurns = options?.keepRecentTurns ?? KEEP_RECENT_TURNS;
   const systemMessages = [];
   let historyStartIndex = 0;
   while (historyStartIndex < fullHistory.length && fullHistory[historyStartIndex].role === "system") {
@@ -5592,7 +6314,7 @@ async function createApiContextWindow(fullHistory, currentAnchor, compressedTurn
 }
 
 // src/app/agent/core/llm/llm.ts
-import os9 from "os";
+import os12 from "os";
 import OpenAI from "openai";
 function defaultBlumaUserContextInput(sessionId, userMessage) {
   const msg = String(userMessage || "").slice(0, 300);
@@ -5609,7 +6331,7 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
 }
 function getPreferredMacAddress() {
   try {
-    const ifaces = os9.networkInterfaces();
+    const ifaces = os12.networkInterfaces();
     for (const name of Object.keys(ifaces)) {
       const addrs = ifaces[name];
       if (!addrs) continue;
@@ -5624,7 +6346,7 @@ function getPreferredMacAddress() {
   } catch {
   }
   try {
-    return `host:${os9.hostname()}`;
+    return `host:${os12.hostname()}`;
   } catch {
     return "unknown";
   }
@@ -5634,7 +6356,7 @@ function defaultInteractiveCliUserContextInput(sessionId, userMessage) {
   const machineId = getPreferredMacAddress();
   let userName = null;
   try {
-    userName = os9.userInfo().username || null;
+    userName = os12.userInfo().username || null;
   } catch {
     userName = null;
   }
@@ -6072,6 +6794,12 @@ var BluMaAgent = class {
   getUiToolsDetailed() {
     return this.mcpClient.getAvailableToolsDetailed();
   }
+  listAvailableSkills() {
+    return this.skillLoader.listAvailable();
+  }
+  getSkillsDirs() {
+    return this.skillLoader.getSkillsDirs();
+  }
   async processTurn(userInput, userContextInput) {
     this.isInterrupted = false;
     this.factorRouterTurnClosed = false;
@@ -6082,7 +6810,8 @@ var BluMaAgent = class {
       turnId,
       sessionId: userContextInput.sessionId || this.sessionId
     };
-    this.history.push({ role: "user", content: inputText });
+    const userContent = buildUserMessageContent(inputText, process.cwd());
+    this.history.push({ role: "user", content: userContent });
     if (inputText === "/init") {
       this.eventBus.emit("dispatch", inputText);
     }
@@ -6235,7 +6964,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path16.basename(toolArgs.file_path);
+      const filename = path18.basename(toolArgs.file_path);
       return createDiff(filename, editData.currentContent || "", editData.newContent);
     } catch (e) {
       return `An unexpected error occurred while generating the edit preview: ${e.message}`;
@@ -6493,7 +7222,7 @@ import { v4 as uuidv45 } from "uuid";
 import { v4 as uuidv44 } from "uuid";
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os10 from "os";
+import os13 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -6656,12 +7385,12 @@ Rule Summary:
 function getInitPrompt() {
   const now = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os10.type(),
-    os_version: os10.release(),
-    architecture: os10.arch(),
+    os_type: os13.type(),
+    os_version: os13.release(),
+    architecture: os13.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os10.userInfo().username || "Unknown",
+    username: os13.userInfo().username || "Unknown",
     current_date: now.toISOString().split("T")[0],
     // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
@@ -6942,14 +7671,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path19, handler) {
-    this.routeHandlers.set(path19, handler);
+  registerRoute(path22, handler) {
+    this.routeHandlers.set(path22, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext } = payload;
-    for (const [path19, handler] of this.routeHandlers) {
-      if (inputText === path19 || inputText.startsWith(`${path19} `)) {
+    for (const [path22, handler] of this.routeHandlers) {
+      if (inputText === path22 || inputText.startsWith(`${path22} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -6958,7 +7687,7 @@ var RouteManager = class {
 };
 
 // src/app/agent/agent.ts
-var globalEnvPath = path17.join(os11.homedir(), ".bluma", ".env");
+var globalEnvPath = path19.join(os14.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -7069,6 +7798,13 @@ var Agent = class {
   getUiToolsDetailed() {
     return this.core.getUiToolsDetailed();
   }
+  /** Skills list for UI (/skills) — same source as system prompt & load_skill. */
+  listAvailableSkills() {
+    return this.core.listAvailableSkills();
+  }
+  getSkillsDirs() {
+    return this.core.getSkillsDirs();
+  }
   async processTurn(userInput, userContextInput) {
     const inputText = String(userInput.content || "").trim();
     const resolvedUserContext = userContextInput ?? defaultInteractiveCliUserContextInput(this.sessionId, inputText.slice(0, 300));
@@ -7175,12 +7911,12 @@ var renderShellCommand2 = ({ args }) => {
 };
 var renderLsTool2 = ({ args }) => {
   const parsed = parseArgs(args);
-  const path19 = parsed.directory_path || ".";
+  const path22 = parsed.directory_path || ".";
   return /* @__PURE__ */ jsxs9(Box9, { children: [
     /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "ls" }),
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " ",
-      path19
+      path22
     ] })
   ] });
 };
@@ -7316,7 +8052,7 @@ var renderFindByName = ({ args }) => {
 var renderGrepSearch = ({ args }) => {
   const parsed = parseArgs(args);
   const query = parsed.query || "";
-  const path19 = parsed.path || ".";
+  const path22 = parsed.path || ".";
   return /* @__PURE__ */ jsxs9(Box9, { children: [
     /* @__PURE__ */ jsx9(Text9, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: "grep" }),
     /* @__PURE__ */ jsxs9(Text9, { color: BLUMA_TERMINAL.brandMagenta, children: [
@@ -7326,7 +8062,7 @@ var renderGrepSearch = ({ args }) => {
     ] }),
     /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " ",
-      path19
+      path22
     ] })
   ] });
 };
@@ -7895,10 +8631,10 @@ var ToolResultDisplayComponent = ({ toolName, result }) => {
       ] }),
       matches.slice(0, 5).map((m, i) => {
         const row = m;
-        const path19 = row.file || row.path || row.name || m;
+        const path22 = row.file || row.path || row.name || m;
         const line = row.line;
         return /* @__PURE__ */ jsxs11(Text11, { dimColor: true, children: [
-          String(path19),
+          String(path22),
           line != null ? `:${line}` : ""
         ] }, i);
       }),
@@ -8030,8 +8766,18 @@ var SessionInfoConnectingMCP_default = SessionInfoConnectingMCP;
 
 // src/app/ui/components/SlashCommands.tsx
 import { Box as Box14, Text as Text13 } from "ink";
+
+// src/app/ui/constants/historyLayout.ts
+var HEADER_PANEL_HISTORY_ID = 0;
+
+// src/app/ui/components/SlashCommands.tsx
 import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs13 } from "react/jsx-runtime";
-var SlashCommands = ({ input, setHistory, agentRef }) => {
+var SlashCommands = ({
+  input,
+  setHistory,
+  agentRef,
+  onClearRecent
+}) => {
   const [cmd, ...args] = input.slice(1).trim().split(/\s+/);
   const outBox = (children) => /* @__PURE__ */ jsx14(ChatBlock, { marginBottom: 1, children: /* @__PURE__ */ jsx14(Box14, { paddingLeft: 1, flexDirection: "column", children }) });
   const render2 = () => {
@@ -8039,19 +8785,59 @@ var SlashCommands = ({ input, setHistory, agentRef }) => {
       return null;
     }
     if (cmd === "help") {
-      const cmds = getSlashCommands();
+      const lines = formatSlashHelpLines();
+      return outBox(
+        /* @__PURE__ */ jsxs13(Fragment2, { children: [
+          /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text13, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Slash commands" }),
+            /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: " \xB7 " }),
+            /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: "put .png/.jpg/.webp paths in a normal message to attach images (project dir or ~)" })
+          ] }),
+          /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx14(Text13, { dimColor: line.trim().length > 0, children: line || " " }, i)) })
+        ] })
+      );
+    }
+    if (cmd === "skills") {
+      const list = agentRef.current?.listAvailableSkills?.() || [];
+      const dirs = agentRef.current?.getSkillsDirs?.();
       return outBox(
         /* @__PURE__ */ jsxs13(Fragment2, { children: [
-          /* @__PURE__ */ jsx14(Box14, { marginBottom: 1, children: /* @__PURE__ */ jsx14(Text13, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Available Commands" }) }),
-          /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: cmds.map((c, i) => /* @__PURE__ */ jsxs13(Box14, { children: [
-            /* @__PURE__ */ jsx14(Text13, { color: BLUMA_TERMINAL.brandBlue, children: c.name.padEnd(12) }),
-            /* @__PURE__ */ jsx14(Text13, { dimColor: true, children: c.description })
+          /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text13, { bold: true, color: BLUMA_TERMINAL.brandMagenta, children: "Skills (load_skill)" }),
+            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              " \xB7 ",
+              list.length,
+              " available"
+            ] })
+          ] }),
+          dirs ? /* @__PURE__ */ jsxs13(Box14, { marginBottom: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              "bundled: ",
+              String(dirs.bundled || "")
+            ] }),
+            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              "project: ",
+              String(dirs.project || "")
+            ] }),
+            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              "global: ",
+              String(dirs.global || "")
+            ] })
+          ] }) : null,
+          list.length === 0 ? /* @__PURE__ */ jsx14(Text13, { color: "yellow", children: "No skills found (check bundled dist/config/skills)." }) : /* @__PURE__ */ jsx14(Box14, { flexDirection: "column", children: list.map((s, i) => /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", marginBottom: 1, children: [
+            /* @__PURE__ */ jsx14(Text13, { color: BLUMA_TERMINAL.brandBlue, bold: true, children: s.name }),
+            /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+              s.source,
+              " \u2014 ",
+              s.description || "\u2014"
+            ] })
           ] }, i)) })
         ] })
       );
     }
     if (cmd === "clear") {
-      setHistory((prev) => prev.filter((item) => item.id === 0 || item.id === 1));
+      onClearRecent?.();
+      setHistory((prev) => prev.filter((item) => item.id === HEADER_PANEL_HISTORY_ID));
       return outBox(
         /* @__PURE__ */ jsxs13(Box14, { children: [
           /* @__PURE__ */ jsx14(Text13, { color: "green", children: "[ok]" }),
@@ -8195,16 +8981,16 @@ var SlashCommands_default = SlashCommands;
 // src/app/agent/utils/update_check.ts
 import updateNotifier from "update-notifier";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import path18 from "path";
-import fs14 from "fs";
+import path20 from "path";
+import fs16 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
   for (let i = 0; i < 10; i++) {
-    const candidate = path18.join(dir, "package.json");
-    if (fs14.existsSync(candidate)) {
+    const candidate = path20.join(dir, "package.json");
+    if (fs16.existsSync(candidate)) {
       try {
-        const raw = fs14.readFileSync(candidate, "utf8");
+        const raw = fs16.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: parsed.version };
@@ -8212,7 +8998,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path18.dirname(dir);
+    const parent = path20.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -8225,12 +9011,12 @@ async function checkForUpdates() {
     }
     const binPath = process.argv?.[1];
     let pkg = null;
-    if (binPath && fs14.existsSync(binPath)) {
-      pkg = findBlumaPackageJson(path18.dirname(binPath));
+    if (binPath && fs16.existsSync(binPath)) {
+      pkg = findBlumaPackageJson(path20.dirname(binPath));
     }
     if (!pkg) {
       const __filename = fileURLToPath3(import.meta.url);
-      const __dirname2 = path18.dirname(__filename);
+      const __dirname2 = path20.dirname(__filename);
       pkg = findBlumaPackageJson(__dirname2);
     }
     if (!pkg) {
@@ -8460,7 +9246,42 @@ var SAFE_AUTO_APPROVE_TOOLS = [
   // Status de comandos (read-only)
   "command_status"
 ];
-var AppComponent = ({ eventBus, sessionId }) => {
+function trimRecentActivity(s, max = 72) {
+  const t = String(s ?? "").replace(/\s+/g, " ").trim();
+  if (!t) return "";
+  return t.length <= max ? t : `${t.slice(0, max - 1)}\u2026`;
+}
+function UserMessageWithOptionalImages({
+  raw,
+  variant
+}) {
+  if (variant === "slash-img") {
+    const pathStrs = collectImagePathStrings(raw);
+    const stripped2 = pathStrs.length > 0 ? stripImagePathStrings(raw, pathStrs) : raw;
+    const cap = stripped2.trim();
+    const capDisp = cap.length > 800 ? `${cap.slice(0, 800)}\u2026` : cap;
+    const fallbackDisp = raw.length > 800 ? `${raw.slice(0, 800)}\u2026` : raw;
+    return /* @__PURE__ */ jsx20(ChatUserMessage, { children: pathStrs.length > 0 ? /* @__PURE__ */ jsx20(
+      ChatUserImageBlock,
+      {
+        imageCount: pathStrs.length,
+        caption: cap.length > 0 ? capDisp : null,
+        captionDim: true
+      }
+    ) : /* @__PURE__ */ jsx20(Text19, { dimColor: true, wrap: "wrap", children: fallbackDisp }) });
+  }
+  const displayRaw = raw.length > 1e4 ? `${raw.substring(0, 1e4)}...` : raw;
+  const paths = collectImagePathStrings(displayRaw);
+  const stripped = paths.length > 0 ? stripImagePathStrings(displayRaw, paths) : displayRaw;
+  return /* @__PURE__ */ jsx20(ChatUserMessage, { children: paths.length > 0 ? /* @__PURE__ */ jsx20(
+    ChatUserImageBlock,
+    {
+      imageCount: paths.length,
+      caption: stripped.trim().length > 0 ? stripped : null
+    }
+  ) : /* @__PURE__ */ jsx20(Text19, { wrap: "wrap", children: displayRaw }) });
+}
+var AppComponent = ({ eventBus, sessionId, cliVersion }) => {
   const agentInstance = useRef5(null);
   const [history, setHistory] = useState6([]);
   const [statusMessage, setStatusMessage] = useState6(
@@ -8478,11 +9299,12 @@ var AppComponent = ({ eventBus, sessionId }) => {
     null
   );
   const [isInitAgentActive, setIsInitAgentActive] = useState6(false);
+  const [recentActivityLine, setRecentActivityLine] = useState6(null);
   const alwaysAcceptList = useRef5([]);
   const workdir = process.cwd();
   const updateCheckRan = useRef5(false);
   const turnStartedAtRef = useRef5(null);
-  const appendExpandPreviewToHistory = useCallback2(() => {
+  const appendExpandPreviewToHistory = useCallback3(() => {
     const p = peekLatestExpandable();
     setHistory((prev) => {
       const id = prev.length;
@@ -8510,7 +9332,27 @@ var AppComponent = ({ eventBus, sessionId }) => {
       expandPreviewHotkeyBus.off("expand", appendExpandPreviewToHistory);
     };
   }, [appendExpandPreviewToHistory]);
-  const handleInterrupt = useCallback2(() => {
+  useEffect7(() => {
+    setHistory((prev) => {
+      const tail = prev.filter((h) => h.id !== HEADER_PANEL_HISTORY_ID);
+      return [
+        {
+          id: HEADER_PANEL_HISTORY_ID,
+          component: /* @__PURE__ */ jsx20(
+            Header,
+            {
+              sessionId,
+              workdir,
+              cliVersion,
+              recentActivitySummary: recentActivityLine
+            }
+          )
+        },
+        ...tail
+      ];
+    });
+  }, [sessionId, workdir, cliVersion, recentActivityLine]);
+  const handleInterrupt = useCallback3(() => {
     if (!isProcessing) return;
     eventBus.emit("user_interrupt");
     turnStartedAtRef.current = null;
@@ -8523,15 +9365,41 @@ var AppComponent = ({ eventBus, sessionId }) => {
       }
     ]);
   }, [isProcessing, eventBus]);
-  const handleSubmit = useCallback2(
+  const handleSubmit = useCallback3(
     (text) => {
       if (!text || isProcessing || !agentInstance.current) return;
-      if (text.startsWith("/")) {
+      if (/^\/img\s+/i.test(text) || /^\/image\s+/i.test(text)) {
+        const payload = text.replace(/^\/img\s+/i, "").replace(/^\/image\s+/i, "").trim();
+        if (!payload) {
+          setHistory((prev) => [
+            ...prev,
+            {
+              id: prev.length,
+              component: /* @__PURE__ */ jsx20(ChatMeta, { children: "Usage: /img ./screenshot.png \u2014 optional text after the path is sent too" })
+            }
+          ]);
+          return;
+        }
+        setIsProcessing(true);
+        turnStartedAtRef.current = Date.now();
+        setHistory((prev) => [
+          ...prev,
+          {
+            id: prev.length,
+            component: /* @__PURE__ */ jsx20(UserMessageWithOptionalImages, { raw: payload, variant: "slash-img" })
+          }
+        ]);
+        setRecentActivityLine(`Prompt: ${trimRecentActivity(payload)}`);
+        agentInstance.current.processTurn({ content: payload });
+        return;
+      }
+      if (isSlashRoutingLine(text)) {
         const [cmd] = text.slice(1).trim().split(/\s+/);
         if (!cmd) {
           setIsProcessing(false);
           return;
         }
+        setRecentActivityLine(`You: ${trimRecentActivity(text)}`);
         if (cmd === "init") {
           setIsInitAgentActive(true);
           setIsProcessing(true);
@@ -8553,7 +9421,8 @@ var AppComponent = ({ eventBus, sessionId }) => {
               {
                 input: text,
                 setHistory,
-                agentRef: agentInstance
+                agentRef: agentInstance,
+                onClearRecent: () => setRecentActivityLine(null)
               }
             )
           }
@@ -8578,6 +9447,7 @@ var AppComponent = ({ eventBus, sessionId }) => {
             ] }) })
           }
         ]);
+        setRecentActivityLine(`Shell: ${trimRecentActivity(command)}`);
         Promise.resolve().then(() => (init_async_command(), async_command_exports)).then(async ({ runCommandAsync: runCommandAsync2 }) => {
           try {
             const result = await runCommandAsync2({ command, cwd: workdir });
@@ -8621,19 +9491,19 @@ Please use command_status to check the result and report back to the user.`;
       }
       setIsProcessing(true);
       turnStartedAtRef.current = Date.now();
-      const displayText = text.length > 1e4 ? text.substring(0, 1e4) + "..." : text;
       setHistory((prev) => [
         ...prev,
         {
           id: prev.length,
-          component: /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsx20(Text19, { children: displayText }) })
+          component: /* @__PURE__ */ jsx20(UserMessageWithOptionalImages, { raw: text, variant: "plain" })
         }
       ]);
+      setRecentActivityLine(`You: ${trimRecentActivity(text)}`);
       agentInstance.current.processTurn({ content: text });
     },
     [isProcessing]
   );
-  const handleConfirmation = useCallback2(
+  const handleConfirmation = useCallback3(
     (decision, toolCalls) => {
       if (!agentInstance.current) return;
       setPendingConfirmation(null);
@@ -8655,7 +9525,6 @@ Please use command_status to check the result and report back to the user.`;
     []
   );
   useEffect7(() => {
-    setHistory([{ id: 0, component: /* @__PURE__ */ jsx20(Header, { sessionId, workdir }) }]);
     const initializeAgent = async () => {
       try {
         agentInstance.current = new Agent(sessionId, eventBus);
@@ -8680,12 +9549,11 @@ Please use command_status to check the result and report back to the user.`;
           if (t == null) return;
           turnStartedAtRef.current = null;
           const ms = Date.now() - t;
-          const sec = ms < 1e4 ? (ms / 1e3).toFixed(1) : String(Math.round(ms / 1e3));
           setHistory((prev) => [
             ...prev,
             {
               id: prev.length,
-              component: /* @__PURE__ */ jsx20(ChatTurnDuration, { secondsFormatted: sec })
+              component: /* @__PURE__ */ jsx20(ChatTurnDuration, { durationMs: ms })
             }
           ]);
         };
@@ -8724,10 +9592,6 @@ Please use command_status to check the result and report back to the user.`;
           setToolsCount(parsed.tools);
           setMcpStatus("connected");
           setIsProcessing(false);
-          setHistory((prev) => {
-            const newHistory = [...prev];
-            return newHistory;
-          });
           if (!updateCheckRan.current) {
             updateCheckRan.current = true;
             Promise.resolve().then(() => checkForUpdates()).then((msg) => {
@@ -8766,7 +9630,9 @@ Please use command_status to check the result and report back to the user.`;
             }
           );
         } else if (parsed.type === "tool_call") {
-          const nextId3 = history.length;
+          if (parsed.tool_name) {
+            setRecentActivityLine(`Tool: ${String(parsed.tool_name)}`);
+          }
           newComponent = /* @__PURE__ */ jsx20(
             ToolCallDisplay,
             {
@@ -8784,6 +9650,11 @@ Please use command_status to check the result and report back to the user.`;
             }
           );
         } else if (parsed.type === "user_overlay") {
+          if (parsed.payload != null && String(parsed.payload).trim()) {
+            setRecentActivityLine(
+              `Context: ${trimRecentActivity(String(parsed.payload))}`
+            );
+          }
           newComponent = /* @__PURE__ */ jsx20(ChatUserMessage, { children: /* @__PURE__ */ jsx20(Text19, { dimColor: true, children: parsed.payload }) });
         } else if (parsed.type === "reasoning") {
           newComponent = /* @__PURE__ */ jsx20(ReasoningDisplay, { reasoning: parsed.content });
@@ -8806,10 +9677,9 @@ Please use command_status to check the result and report back to the user.`;
               if (t != null) {
                 turnStartedAtRef.current = null;
                 const ms = Date.now() - t;
-                const sec = ms < 1e4 ? (ms / 1e3).toFixed(1) : String(Math.round(ms / 1e3));
                 next.push({
                   id: next.length,
-                  component: /* @__PURE__ */ jsx20(ChatTurnDuration, { secondsFormatted: sec })
+                  component: /* @__PURE__ */ jsx20(ChatTurnDuration, { durationMs: ms })
                 });
               }
             }
@@ -8974,9 +9844,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs15.readFileSync(filePath, "utf-8");
+      rawPayload = fs17.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs15.readFileSync(0, "utf-8");
+      rawPayload = fs17.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeJsonl({
@@ -9142,6 +10012,16 @@ async function runAgentMode() {
     process.exit(1);
   }
 }
+function readCliPackageVersion() {
+  try {
+    const base = path21.dirname(fileURLToPath4(import.meta.url));
+    const pkgPath = path21.join(base, "..", "package.json");
+    const j = JSON.parse(fs17.readFileSync(pkgPath, "utf8"));
+    return String(j.version || "0.0.0");
+  } catch {
+    return "0.0.0";
+  }
+}
 function runCliMode() {
   const BLUMA_TITLE = process.env.BLUMA_TITLE || "BluMa - NomadEngenuity";
   startTitleKeeper(BLUMA_TITLE);
@@ -9149,7 +10029,8 @@ function runCliMode() {
   const sessionId = uuidv46();
   const props = {
     eventBus,
-    sessionId
+    sessionId,
+    cliVersion: readCliPackageVersion()
   };
   render(React12.createElement(App_default, props));
 }