@bike4mind/cli 0.2.6-fix-cli-mcp-type-mismatch.17119 → 0.2.7-feat-cli-rewind-command.17128

package/dist/index.js

@@ -79,8 +79,8 @@ import {
 } from "./chunk-PDX44BCA.js";
 
 // src/index.tsx
-import React13, { useState as useState4, useEffect as useEffect3, useCallback } from "react";
-import { render, Box as Box13, Text as Text12, useApp, useInput as useInput3 } from "ink";
+import React14, { useState as useState5, useEffect as useEffect3, useCallback, useRef } from "react";
+import { render, Box as Box14, Text as Text13, useApp, useInput as useInput4 } from "ink";
 import { v4 as uuidv49 } from "uuid";
 
 // src/components/App.tsx
@@ -389,6 +389,11 @@ var COMMANDS = [
     name: "clear",
     description: "Start a new session",
     aliases: ["new"]
+  },
+  {
+    name: "rewind",
+    description: "Rewind conversation to a previous point",
+    aliases: ["undo"]
   }
 ];
 
@@ -413,6 +418,202 @@ function searchCommands(query) {
   return results.map((result) => result.item);
 }
 
+// src/utils/imageDetector.ts
+import { readFileSync, existsSync, statSync as statSync2 } from "fs";
+import { extname as extname2 } from "path";
+var ImageInputDetector = class {
+  static {
+    this.MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+  }
+  static {
+    // 10MB
+    this.SUPPORTED_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+  }
+  /**
+   * Check if input contains image data
+   */
+  static containsImageData(input) {
+    if (input.includes("\x1B]1337;File=")) {
+      return true;
+    }
+    if (input.includes("\x1B_G")) {
+      return true;
+    }
+    if (input.includes("\x1BP")) {
+      return true;
+    }
+    if (input.match(/data:image\/(png|jpeg|jpg|gif|webp);base64,/)) {
+      return true;
+    }
+    if (this.looksLikeFilePath(input)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Extract image data from terminal input
+   */
+  static extractImageData(input) {
+    const iterm2 = this.extractITerm2Image(input);
+    if (iterm2) return iterm2;
+    const kitty = this.extractKittyImage(input);
+    if (kitty) return kitty;
+    const sixel = this.extractSixelImage(input);
+    if (sixel) return sixel;
+    const base64 = this.extractBase64Image(input);
+    if (base64) return base64;
+    const fileDrop = this.extractDroppedFile(input);
+    if (fileDrop) return fileDrop;
+    return null;
+  }
+  /**
+   * Extract iTerm2 inline image
+   * Format: ESC]1337;File=[args]:base64data^G
+   */
+  static extractITerm2Image(input) {
+    const match = input.match(/\x1b\]1337;File=([^:]*):([^\x07]+)\x07/);
+    if (!match) return null;
+    try {
+      const args = match[1];
+      const base64Data = match[2];
+      const data = Buffer.from(base64Data, "base64");
+      let format = "png";
+      const nameMatch = args.match(/name=([^;]+)/);
+      if (nameMatch) {
+        const ext = extname2(nameMatch[1]).substring(1).toLowerCase();
+        if (ext && this.SUPPORTED_EXTENSIONS.includes(`.${ext}`)) {
+          format = ext === "jpeg" ? "jpg" : ext;
+        }
+      }
+      return {
+        type: "paste",
+        data,
+        format,
+        protocol: "iterm2"
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract Kitty graphics protocol image
+   * Format: ESC_Ga=T,f=100;base64data ESC\
+   */
+  static extractKittyImage(input) {
+    const match = input.match(/\x1b_G([^;]*);([^\x1b]+)\x1b\\/);
+    if (!match) return null;
+    try {
+      const params = match[1];
+      const base64Data = match[2];
+      const data = Buffer.from(base64Data, "base64");
+      let format = "png";
+      const formatMatch = params.match(/f=(\d+)/);
+      if (formatMatch) {
+        const formatCode = parseInt(formatMatch[1], 10);
+        if (formatCode === 100) format = "jpg";
+      }
+      return {
+        type: "paste",
+        data,
+        format,
+        protocol: "kitty"
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract Sixel image
+   * Format: ESC P q ... ESC \
+   */
+  static extractSixelImage(input) {
+    const match = input.match(/\x1bP([^q]*q[^\x1b]+)\x1b\\/);
+    if (!match) return null;
+    return null;
+  }
+  /**
+   * Extract base64 data URL
+   * Format: data:image/png;base64,iVBORw0KGgo...
+   */
+  static extractBase64Image(input) {
+    const match = input.match(/data:image\/(png|jpeg|jpg|gif|webp);base64,([A-Za-z0-9+/=]+)/);
+    if (!match) return null;
+    try {
+      const format = match[1] === "jpeg" ? "jpg" : match[1];
+      const base64Data = match[2];
+      const data = Buffer.from(base64Data, "base64");
+      return {
+        type: "paste",
+        data,
+        format,
+        protocol: "base64"
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Extract dropped file path and read image
+   */
+  static extractDroppedFile(input) {
+    if (!this.looksLikeFilePath(input)) return null;
+    let filepath = input.trim();
+    filepath = filepath.replace(/^["']|["']$/g, "");
+    filepath = filepath.replace(/\\\s/g, " ");
+    if (!existsSync(filepath)) return null;
+    const stats = statSync2(filepath);
+    if (!stats.isFile()) return null;
+    const ext = extname2(filepath).toLowerCase();
+    if (!this.SUPPORTED_EXTENSIONS.includes(ext)) return null;
+    if (stats.size > this.MAX_IMAGE_SIZE) return null;
+    try {
+      const data = readFileSync(filepath);
+      const format = ext.substring(1) === "jpeg" ? "jpg" : ext.substring(1);
+      const filename = filepath.split("/").pop() || "image";
+      return {
+        type: "drop",
+        data,
+        format,
+        filename,
+        filepath
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Check if string looks like a file path
+   */
+  static looksLikeFilePath(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith("/") || trimmed.match(/^[a-zA-Z]:\\/)) {
+      return true;
+    }
+    if (trimmed.startsWith("~")) {
+      return true;
+    }
+    if (this.SUPPORTED_EXTENSIONS.some((ext) => trimmed.toLowerCase().endsWith(ext))) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Remove image data from input string, leaving only text
+   */
+  static stripImageData(input) {
+    let cleaned = input;
+    cleaned = cleaned.replace(/\x1b\]1337;File=[^:]*:[^\x07]+\x07/g, "");
+    cleaned = cleaned.replace(/\x1b_G[^;]*;[^\x1b]+\x1b\\/g, "");
+    cleaned = cleaned.replace(/\x1bP[^q]*q[^\x1b]+\x1b\\/g, "");
+    cleaned = cleaned.replace(/data:image\/(png|jpeg|jpg|gif|webp);base64,[A-Za-z0-9+/=]+/g, "");
+    const filepath = this.extractDroppedFile(cleaned);
+    if (filepath) {
+      cleaned = cleaned.replace(filepath.filepath, "");
+    }
+    return cleaned.trim();
+  }
+};
+
 // src/components/InputPrompt.tsx
 function findAtTrigger(value) {
   for (let i = value.length - 1; i >= 0; i--) {
@@ -429,12 +630,26 @@ function findAtTrigger(value) {
   }
   return null;
 }
-function InputPrompt({ onSubmit, disabled = false, history = [] }) {
+function InputPrompt({
+  onSubmit,
+  onImageDetected,
+  disabled = false,
+  history = [],
+  prefillInput,
+  onPrefillConsumed
+}) {
   const [value, setValue] = useState("");
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [historyIndex, setHistoryIndex] = useState(-1);
   const [tempInput, setTempInput] = useState("");
   const [inputKey, setInputKey] = useState(0);
+  useEffect(() => {
+    if (prefillInput) {
+      setValue(prefillInput);
+      setInputKey((prev) => prev + 1);
+      onPrefillConsumed?.();
+    }
+  }, [prefillInput, onPrefillConsumed]);
   const [fileAutocomplete, setFileAutocomplete] = useState(null);
   const [fileSelectedIndex, setFileSelectedIndex] = useState(0);
   const shouldShowCommandAutocomplete = value.startsWith("/") && !disabled && !fileAutocomplete?.active;
@@ -550,7 +765,16 @@ function InputPrompt({ onSubmit, disabled = false, history = [] }) {
     setHistoryIndex(-1);
     setFileAutocomplete(null);
   };
-  const handleChange = (newValue) => {
+  const handleChange = async (newValue) => {
+    if (ImageInputDetector.containsImageData(newValue)) {
+      const imageEvent = ImageInputDetector.extractImageData(newValue);
+      if (imageEvent && onImageDetected) {
+        const placeholder = await onImageDetected(imageEvent.data);
+        setValue(`${placeholder} `);
+        setInputKey((prev) => prev + 1);
+        return;
+      }
+    }
     setValue(newValue);
     if (historyIndex !== -1) {
       setHistoryIndex(-1);
@@ -1015,10 +1239,13 @@ function App({
   onMessage,
   onCommand,
   onPermissionResponse,
+  onImageDetected,
   commandHistory = [],
   config,
   availableModels = [],
-  onSaveConfig
+  onSaveConfig,
+  prefillInput,
+  onPrefillConsumed
 }) {
   const messages = useCliStore((state) => state.session?.messages || []);
   const sessionName = useCliStore((state) => state.session?.name || "New Session");
@@ -1034,7 +1261,7 @@ function App({
     async (input) => {
       const trimmed = input.trim();
       if (!trimmed) return;
-      if (trimmed.startsWith("/")) {
+      if (trimmed.startsWith("/") && !trimmed.match(/^\/[A-Z]/)) {
         const [command, ...args] = trimmed.slice(1).split(" ");
         await onCommand(command, args);
         return;
@@ -1076,7 +1303,17 @@ ${errorBlock}`;
       canBeTrusted: permissionPrompt.canBeTrusted,
       onResponse: onPermissionResponse
     }
-  )) : /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React9.createElement(Box9, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(MessageItem, { message }))), /* @__PURE__ */ React9.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React9.createElement(Box9, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React9.createElement(Box9, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React9.createElement(InputPrompt, { onSubmit: handleSubmit, disabled: isThinking, history: commandHistory }))));
+  )) : /* @__PURE__ */ React9.createElement(React9.Fragment, null, /* @__PURE__ */ React9.createElement(Static, { items: messages }, (message, index) => /* @__PURE__ */ React9.createElement(Box9, { key: index, flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React9.createElement(MessageItem, { message }))), /* @__PURE__ */ React9.createElement(AgentThinking, null), exitRequested && /* @__PURE__ */ React9.createElement(Box9, { paddingX: 1, marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, "Press Ctrl+C again to exit")), /* @__PURE__ */ React9.createElement(Box9, { borderStyle: "single", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React9.createElement(
+    InputPrompt,
+    {
+      onSubmit: handleSubmit,
+      onImageDetected,
+      disabled: isThinking,
+      history: commandHistory,
+      prefillInput,
+      onPrefillConsumed
+    }
+  ))));
 }
 function MessageItem({ message }) {
   return /* @__PURE__ */ React9.createElement(Box9, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Box9, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: message.role === "user" ? "cyan" : "green" }, message.role === "user" ? "\u{1F464} You" : "\u{1F916} Assistant"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " \u2022 ", new Date(message.timestamp).toLocaleTimeString())), /* @__PURE__ */ React9.createElement(Box9, { paddingLeft: 2 }, message.metadata?.permissionDenied ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u26A0\uFE0F ", message.content) : /* @__PURE__ */ React9.createElement(Text8, null, message.content)), message.metadata?.steps && message.metadata.steps.length > 0 && /* @__PURE__ */ React9.createElement(Box9, { paddingLeft: 2, marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, bold: true }, "\u{1F527} Agent Reasoning Trace (", message.metadata.steps.filter((s) => s.type === "action").length, " ", "tools used, ", message.metadata.steps.length, " total steps)", message.metadata.tokenUsage && ` \u2022 ${message.metadata.tokenUsage.total} tokens`), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "Step types: ", message.metadata.steps.map((s) => s.type).join(", ")), message.metadata.steps.map((step, idx) => {
@@ -1166,9 +1403,78 @@ function TrustLocationSelector({ inProject, onSelect, onCancel }) {
   ), /* @__PURE__ */ React11.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Ctrl+C to cancel")));
 }
 
+// src/components/RewindSelector.tsx
+import React12, { useState as useState3 } from "react";
+import { Box as Box12, Text as Text11, useInput as useInput3 } from "ink";
+import SelectInput3 from "ink-select-input";
+function RewindSelector({ messages, onSelect, onCancel }) {
+  const [step, setStep] = useState3("selection");
+  const [selectedMessageIndex, setSelectedMessageIndex] = useState3(null);
+  useInput3((input, key) => {
+    if (key.escape) {
+      if (step === "confirmation") {
+        setStep("selection");
+        setSelectedMessageIndex(null);
+      } else {
+        onCancel();
+      }
+    }
+  });
+  const userMessages = messages.map((msg, idx) => ({ msg, originalIndex: idx })).filter(({ msg }) => msg.role === "user");
+  const items = userMessages.map(({ msg, originalIndex }, index) => {
+    const preview = msg.content.length > 50 ? msg.content.substring(0, 50) + "..." : msg.content;
+    const timestamp = new Date(msg.timestamp).toLocaleString();
+    const position = index + 1;
+    return {
+      label: `[${position}] ${timestamp} - ${preview}`,
+      value: originalIndex
+    };
+  });
+  const handleSelectionSelect = (item) => {
+    setSelectedMessageIndex(item.value);
+    setStep("confirmation");
+  };
+  const handleConfirmationSelect = (item) => {
+    if (item.value === "confirm" && selectedMessageIndex !== null) {
+      onSelect(selectedMessageIndex);
+    } else {
+      setStep("selection");
+      setSelectedMessageIndex(null);
+    }
+  };
+  const messagesToRemove = selectedMessageIndex !== null && selectedMessageIndex >= 0 && selectedMessageIndex < messages.length ? messages.slice(selectedMessageIndex) : [];
+  const tokensToRemove = messagesToRemove.reduce((sum2, msg) => {
+    return sum2 + (msg.metadata?.tokenUsage?.total || 0);
+  }, 0);
+  if (step === "selection") {
+    return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Select a point to rewind to:")), /* @__PURE__ */ React12.createElement(
+      SelectInput3,
+      {
+        items,
+        onSelect: handleSelectionSelect,
+        itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React12.createElement(Box12, null, /* @__PURE__ */ React12.createElement(Text11, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+      }
+    ), /* @__PURE__ */ React12.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to cancel")));
+  }
+  const confirmationItems = [
+    { label: "Yes, rewind to this point", value: "confirm" },
+    { label: "No, go back to selection", value: "cancel" }
+  ];
+  const selectedMessage = selectedMessageIndex !== null && selectedMessageIndex >= 0 && selectedMessageIndex < messages.length ? messages[selectedMessageIndex] : null;
+  const selectedPreview = selectedMessage ? selectedMessage.content.length > 50 ? selectedMessage.content.substring(0, 50) + "..." : selectedMessage.content : "";
+  return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Confirm rewind operation:"), /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Message: ", selectedPreview), /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "This will remove ", messagesToRemove.length, " message(s) (", tokensToRemove.toLocaleString(), " tokens)"), /* @__PURE__ */ React12.createElement(Text11, { color: "cyan" }, "The selected message will be placed in your input for editing.")), /* @__PURE__ */ React12.createElement(
+    SelectInput3,
+    {
+      items: confirmationItems,
+      onSelect: handleConfirmationSelect,
+      itemComponent: ({ isSelected, label }) => /* @__PURE__ */ React12.createElement(Box12, null, /* @__PURE__ */ React12.createElement(Text11, { color: isSelected ? "cyan" : void 0 }, isSelected ? "\u276F " : "  ", label))
+    }
+  ), /* @__PURE__ */ React12.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select, Esc to go back")));
+}
+
 // src/components/LoginFlow.tsx
-import React12, { useState as useState3, useEffect as useEffect2 } from "react";
-import { Box as Box12, Text as Text11 } from "ink";
+import React13, { useState as useState4, useEffect as useEffect2 } from "react";
+import { Box as Box13, Text as Text12 } from "ink";
 import Spinner2 from "ink-spinner";
 import jwt from "jsonwebtoken";
 import open from "open";
@@ -1284,10 +1590,10 @@ var OAuthClient = class {
 
 // src/components/LoginFlow.tsx
 function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, onError }) {
-  const [status, setStatus] = useState3("initiating");
-  const [deviceFlow, setDeviceFlow] = useState3(null);
-  const [statusMessage, setStatusMessage] = useState3("Initiating device authorization...");
-  const [error, setError] = useState3(null);
+  const [status, setStatus] = useState4("initiating");
+  const [deviceFlow, setDeviceFlow] = useState4(null);
+  const [statusMessage, setStatusMessage] = useState4("Initiating device authorization...");
+  const [error, setError] = useState4(null);
   useEffect2(() => {
     const runLoginFlow = async () => {
       const oauth = new OAuthClient(apiUrl);
@@ -1331,15 +1637,15 @@ function LoginFlow({ apiUrl = "http://localhost:3000", configStore, onSuccess, o
     }
   }, [deviceFlow, status]);
   if (status === "initiating") {
-    return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Box12, null, /* @__PURE__ */ React12.createElement(Text11, { color: "cyan" }, /* @__PURE__ */ React12.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
+    return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Box13, null, /* @__PURE__ */ React13.createElement(Text12, { color: "cyan" }, /* @__PURE__ */ React13.createElement(Spinner2, { type: "dots" }), " Initiating device authorization...")));
   }
   if (status === "error") {
-    return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React12.createElement(Box12, null, /* @__PURE__ */ React12.createElement(Text11, { color: "red" }, error)));
+    return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "red", bold: true }, "\u2716 Authentication Failed")), /* @__PURE__ */ React13.createElement(Box13, null, /* @__PURE__ */ React13.createElement(Text12, { color: "red" }, error)));
   }
   if (status === "success") {
-    return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React12.createElement(Box12, null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "You can now use B4M CLI with your account.")));
+    return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "green", bold: true }, "\u2714 Successfully authenticated!")), /* @__PURE__ */ React13.createElement(Box13, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "You can now use B4M CLI with your account.")));
   }
-  return /* @__PURE__ */ React12.createElement(Box12, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1 }, /* @__PURE__ */ React12.createElement(Text11, null, "And enter this code when prompted:")), /* @__PURE__ */ React12.createElement(Box12, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React12.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "cyan" }, /* @__PURE__ */ React12.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React12.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
+  return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" }, /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "cyan", bold: true }, "\u{1F510} Device Authorization")), /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, null, "Opening browser automatically... If it doesn't open, please visit:")), /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React13.createElement(Text12, { color: "blue", bold: true }, deviceFlow?.verification_uri)), /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1 }, /* @__PURE__ */ React13.createElement(Text12, null, "And enter this code when prompted:")), /* @__PURE__ */ React13.createElement(Box13, { marginBottom: 1, paddingLeft: 2 }, /* @__PURE__ */ React13.createElement(Text12, { color: "yellow", bold: true }, deviceFlow?.user_code)), /* @__PURE__ */ React13.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "cyan" }, /* @__PURE__ */ React13.createElement(Spinner2, { type: "dots" }), " ", statusMessage)), /* @__PURE__ */ React13.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "Expires in ", deviceFlow ? Math.floor(deviceFlow.expires_in / 60) : 0, " minutes")));
 }
 
 // src/storage/SessionStore.ts
@@ -1461,7 +1767,7 @@ var SessionStore = class {
 };
 
 // src/storage/ConfigStore.ts
-import { promises as fs4, existsSync as existsSync2 } from "fs";
+import { promises as fs4, existsSync as existsSync3 } from "fs";
 import path4 from "path";
 import { homedir as homedir2 } from "os";
 import { v4 as uuidv4 } from "uuid";
@@ -1588,7 +1894,7 @@ function findProjectConfigDir(startDir = process.cwd()) {
   while (currentDir !== root) {
     const gitPath = path4.join(currentDir, ".git");
     try {
-      if (existsSync2(gitPath)) {
+      if (existsSync3(gitPath)) {
         return currentDir;
       }
     } catch {
@@ -2196,7 +2502,7 @@ var ReActAgent = class extends EventEmitter {
   /**
    * Run the agent to completion
    *
-   * @param query - The user's question or task
+   * @param query - The user's question or task (can be text or multimodal content with images)
    * @param options - Optional overrides for this run
    * @returns Agent result with final answer and all steps
    */
@@ -7673,7 +7979,7 @@ var planetVisibilityTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/fileRead/index.js
 import { promises as fs7 } from "fs";
-import { existsSync as existsSync3, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
 import path6 from "path";
 var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
 async function readFileContent(params) {
@@ -7684,10 +7990,10 @@ async function readFileContent(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot read files outside of current working directory`);
   }
-  if (!existsSync3(resolvedPath)) {
+  if (!existsSync4(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const stats = statSync3(resolvedPath);
+  const stats = statSync4(resolvedPath);
   if (stats.isDirectory()) {
     throw new Error(`Path is a directory, not a file: ${filePath}`);
   }
@@ -7730,7 +8036,7 @@ var fileReadTool = {
       context.logger.info("\u{1F4C4} FileRead: Reading file", { path: params.path });
       try {
         const content = await readFileContent(params);
-        const stats = statSync3(path6.resolve(process.cwd(), path6.normalize(params.path)));
+        const stats = statSync4(path6.resolve(process.cwd(), path6.normalize(params.path)));
         context.logger.info("\u2705 FileRead: Success", {
           path: params.path,
           size: stats.size,
@@ -7770,7 +8076,7 @@ var fileReadTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/createFile/index.js
 import { promises as fs8 } from "fs";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import path7 from "path";
 async function createFile(params) {
   const { path: filePath, content, createDirectories = true } = params;
@@ -7780,7 +8086,7 @@ async function createFile(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot create files outside of current working directory`);
   }
-  const fileExists = existsSync4(resolvedPath);
+  const fileExists = existsSync5(resolvedPath);
   const action = fileExists ? "overwritten" : "created";
   if (createDirectories) {
     const dir = path7.dirname(resolvedPath);
@@ -7798,7 +8104,7 @@ var createFileTool = {
   implementation: (context) => ({
     toolFn: async (value) => {
       const params = value;
-      const fileExists = existsSync4(path7.resolve(process.cwd(), path7.normalize(params.path)));
+      const fileExists = existsSync5(path7.resolve(process.cwd(), path7.normalize(params.path)));
       context.logger.info(`\u{1F4DD} CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
         path: params.path,
         size: params.content.length
@@ -7839,7 +8145,7 @@ var createFileTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/globFiles/index.js
 import { readdir } from "fs/promises";
-import { statSync as statSync4 } from "fs";
+import { statSync as statSync5 } from "fs";
 import path8 from "path";
 function matchGlob(filePath, pattern) {
   let regexPattern = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/\{([^}]+)\}/g, (_, options) => `(${options.split(",").join("|")})`).replace(/\[([^\]]+)\]/g, "[$1]");
@@ -7887,7 +8193,7 @@ async function listFiles(params) {
   for (const match of matches) {
     try {
       const fullPath = path8.join(targetCwd, match);
-      const stats = statSync4(fullPath);
+      const stats = statSync5(fullPath);
       filesInfo.push({
         path: match,
         size: stats.size,
@@ -7968,7 +8274,7 @@ var globFilesTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/grepSearch/index.js
 import { readdir as readdir2 } from "fs/promises";
-import { readFileSync as readFileSync2, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync3, statSync as statSync6 } from "fs";
 import path9 from "path";
 var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 function matchGlob2(filePath, pattern) {
@@ -8020,7 +8326,7 @@ async function searchFiles2(params) {
   for (const match of filesToSearch) {
     const fullPath = path9.join(targetCwd, match);
     try {
-      const stats = statSync5(fullPath);
+      const stats = statSync6(fullPath);
       if (stats.isDirectory() || stats.size > MAX_FILE_SIZE3) {
         continue;
       }
@@ -8044,7 +8350,7 @@ async function searchFiles2(params) {
     filesSearched++;
     const fullPath = path9.join(targetCwd, file);
     try {
-      const content = readFileSync2(fullPath, "utf-8");
+      const content = readFileSync3(fullPath, "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (matches.length >= maxResults) {
@@ -8178,7 +8484,7 @@ var grepSearchTool = {
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/deleteFile/index.js
 import { promises as fs9 } from "fs";
-import { existsSync as existsSync5, statSync as statSync6 } from "fs";
+import { existsSync as existsSync6, statSync as statSync7 } from "fs";
 import path10 from "path";
 async function deleteFile(params) {
   const { path: filePath, recursive = false } = params;
@@ -8188,10 +8494,10 @@ async function deleteFile(params) {
   if (!resolvedPath.startsWith(cwd)) {
     throw new Error(`Access denied: Cannot delete files outside of current working directory`);
   }
-  if (!existsSync5(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     throw new Error(`File or directory not found: ${filePath}`);
   }
-  const stats = statSync6(resolvedPath);
+  const stats = statSync7(resolvedPath);
   const isDirectory = stats.isDirectory();
   const size = stats.size;
   if (isDirectory && !recursive) {
@@ -8212,7 +8518,7 @@ var deleteFileTool = {
     toolFn: async (value) => {
       const params = value;
       const resolvedPath = path10.resolve(process.cwd(), path10.normalize(params.path));
-      const isDirectory = existsSync5(resolvedPath) && statSync6(resolvedPath).isDirectory();
+      const isDirectory = existsSync6(resolvedPath) && statSync7(resolvedPath).isDirectory();
       context.logger.info(`\u{1F5D1}\uFE0F  DeleteFile: Deleting ${isDirectory ? "directory" : "file"}`, {
         path: params.path,
         recursive: params.recursive
@@ -8502,10 +8808,10 @@ import jwt2 from "jsonwebtoken";
 // src/utils/diffPreview.ts
 import * as Diff from "diff";
 import { readFile } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 async function generateFileDiffPreview(args) {
   try {
-    if (!existsSync6(args.path)) {
+    if (!existsSync7(args.path)) {
       const lines2 = args.content.split("\n");
       const preview = lines2.slice(0, 20).join("\n");
       const hasMore = lines2.length > 20;
@@ -8535,7 +8841,7 @@ ${preview}${hasMore ? `
 }
 async function generateFileDeletePreview(args) {
   try {
-    if (!existsSync6(args.path)) {
+    if (!existsSync7(args.path)) {
       return `[File does not exist: ${args.path}]`;
     }
     const stats = await import("fs/promises").then((fs11) => fs11.stat(args.path));
@@ -9197,7 +9503,7 @@ var logger = Logger2.getInstance();
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
 import path12 from "path";
-import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
 var MCPClient = class {
   // Note: This class handles MCP server communication with repository filtering
   mcp;
@@ -9248,7 +9554,7 @@ var MCPClient = class {
           path12.join(root, `/b4m-core/packages/mcp/dist/src/${this.serverName}/index.js`),
           path12.join(root, "core", "mcp", "servers", this.serverName, "dist", "index.js")
         ];
-        const serverScriptPath = candidatePaths.find((p) => existsSync7(p));
+        const serverScriptPath = candidatePaths.find((p) => existsSync8(p));
         if (!serverScriptPath) {
           const getDirectories = (source) => readdirSync3(source, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
           console.error(`[MCP] Server script not found. Tried paths:`, candidatePaths);
@@ -9446,6 +9752,190 @@ var McpManager = class {
   }
 };
 
+// src/utils/imageRenderer.ts
+var ImageRenderer = class {
+  constructor() {
+    this.imageCounter = 0;
+    this.placeholderMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Generate placeholder for a new image
+   */
+  createPlaceholder(hash) {
+    const existing = this.placeholderMap.get(hash);
+    if (existing) {
+      return existing.placeholder;
+    }
+    this.imageCounter++;
+    const placeholder = `[Image ${this.imageCounter}]`;
+    this.placeholderMap.set(hash, {
+      hash,
+      number: this.imageCounter,
+      placeholder
+    });
+    return placeholder;
+  }
+  /**
+   * Get all image hashes from a message containing placeholders
+   */
+  extractImageHashes(message) {
+    const hashes = [];
+    const placeholderRegex = /\[Image \d+\]/g;
+    const matches = message.match(placeholderRegex);
+    if (!matches) return hashes;
+    for (const [hash, data] of this.placeholderMap.entries()) {
+      if (matches.includes(data.placeholder)) {
+        hashes.push(hash);
+      }
+    }
+    return hashes;
+  }
+  /**
+   * Get hash by placeholder text
+   */
+  getHashFromPlaceholder(placeholder) {
+    for (const [hash, data] of this.placeholderMap.entries()) {
+      if (data.placeholder === placeholder) {
+        return hash;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/messageBuilder.ts
+var MessageBuilder = class {
+  constructor(imageStore, imageRenderer) {
+    this.imageStore = imageStore;
+    this.imageRenderer = imageRenderer;
+  }
+  /**
+   * Build a multimodal message from user input
+   * Extracts image placeholders and creates proper message structure with base64-encoded images
+   */
+  async buildMessage(userInput, role = "user") {
+    const imageHashes = this.imageRenderer.extractImageHashes(userInput);
+    if (imageHashes.length === 0) {
+      return {
+        message: {
+          role,
+          content: userInput
+        },
+        uploadedImages: []
+      };
+    }
+    const content = [];
+    const parts = this.splitMessageByPlaceholders(userInput);
+    for (const part of parts) {
+      if (part.type === "text" && part.content.trim()) {
+        content.push({
+          type: "text",
+          text: part.content
+        });
+      } else if (part.type === "image") {
+        const hash = this.imageRenderer.getHashFromPlaceholder(part.content);
+        if (hash) {
+          const imageData = this.imageStore.readImage(hash);
+          const metadata = this.imageStore.getMetadata(hash);
+          if (imageData && metadata) {
+            const base64Data = imageData.toString("base64");
+            const mediaType = this.getMediaType(metadata.format);
+            content.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: mediaType,
+                data: base64Data
+              }
+            });
+          }
+        }
+      }
+    }
+    return {
+      message: {
+        role,
+        content
+      },
+      uploadedImages: []
+    };
+  }
+  /**
+   * Get MIME type for image format
+   */
+  getMediaType(format) {
+    switch (format.toLowerCase()) {
+      case "png":
+        return "image/png";
+      case "jpg":
+      case "jpeg":
+        return "image/jpeg";
+      case "gif":
+        return "image/gif";
+      case "webp":
+        return "image/webp";
+      default:
+        return "image/png";
+    }
+  }
+  /**
+   * Split message text by image placeholders
+   * Returns array of text and image parts in order
+   */
+  splitMessageByPlaceholders(message) {
+    const parts = [];
+    const placeholderRegex = /(\[Image \d+\])/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = placeholderRegex.exec(message)) !== null) {
+      if (match.index > lastIndex) {
+        const text = message.substring(lastIndex, match.index);
+        if (text) {
+          parts.push({ type: "text", content: text });
+        }
+      }
+      parts.push({ type: "image", content: match[0] });
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < message.length) {
+      const text = message.substring(lastIndex);
+      if (text) {
+        parts.push({ type: "text", content: text });
+      }
+    }
+    if (parts.length === 0) {
+      parts.push({ type: "text", content: message });
+    }
+    return parts;
+  }
+  /**
+   * Check if a message contains images
+   */
+  hasImages(message) {
+    return this.imageRenderer.extractImageHashes(message).length > 0;
+  }
+  /**
+   * Convert multimodal message back to simple string (for display/logging)
+   */
+  messageToString(message) {
+    if (typeof message.content === "string") {
+      return message.content;
+    }
+    return message.content.map((item) => {
+      if (item.type === "text") {
+        return item.text;
+      } else if (item.type === "image") {
+        if (item.source.type === "url") {
+          return `[Image: ${item.source.url}]`;
+        } else {
+          return `[Image: base64 ${item.source.media_type}]`;
+        }
+      }
+      return "";
+    }).join("");
+  }
+};
+
 // src/llm/ServerLlmBackend.ts
 import { createParser } from "eventsource-parser";
 import { isAxiosError } from "axios";
@@ -9863,7 +10353,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.6-fix-cli-mcp-type-mismatch.17119+0906e1e34",
+  version: "0.2.7-feat-cli-rewind-command.17128+8d4de110f",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -9924,6 +10414,7 @@ var package_default = {
     "async-mutex": "^0.5.0",
     axios: "^1.13.2",
     bcryptjs: "^2.4.3",
+    "better-sqlite3": "^12.5.0",
     cheerio: "1.0.0-rc.12",
     "csv-parse": "^5.5.6",
     dayjs: "^1.11.13",
@@ -9949,7 +10440,7 @@ var package_default = {
     "p-limit": "^6.2.0",
     qrcode: "^1.5.4",
     react: "^19.2.3",
-    sharp: "^0.32.6",
+    sharp: "^0.34.5",
     speakeasy: "^2.0.0",
     tiktoken: "^1.0.16",
     turndown: "^7.2.0",
@@ -9965,10 +10456,11 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.38.1-fix-cli-mcp-type-mismatch.17119+0906e1e34",
-    "@bike4mind/mcp": "1.20.1-fix-cli-mcp-type-mismatch.17119+0906e1e34",
-    "@bike4mind/services": "2.33.1-fix-cli-mcp-type-mismatch.17119+0906e1e34",
-    "@bike4mind/utils": "2.1.2-fix-cli-mcp-type-mismatch.17119+0906e1e34",
+    "@bike4mind/common": "2.38.1-feat-cli-rewind-command.17128+8d4de110f",
+    "@bike4mind/mcp": "1.20.1-feat-cli-rewind-command.17128+8d4de110f",
+    "@bike4mind/services": "2.33.1-feat-cli-rewind-command.17128+8d4de110f",
+    "@bike4mind/utils": "2.1.2-feat-cli-rewind-command.17128+8d4de110f",
+    "@types/better-sqlite3": "^7.6.12",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -9980,7 +10472,7 @@ var package_default = {
     typescript: "^5.9.3",
     vitest: "^3.2.4"
   },
-  gitHead: "0906e1e34709a52074b386d9b51a94776db1d33d"
+  gitHead: "8d4de110f7d8f55bff6bd26cb38b8ca1d4dbd996"
 };
 
 // src/config/constants.ts
@@ -10001,20 +10493,27 @@ var EXIT_TIMEOUT_MS = 2e3;
 var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
-  const [state, setState] = useState4({
+  const imageRenderer = new ImageRenderer();
+  const [state, setState] = useState5({
     session: null,
     sessionStore: new SessionStore(),
     configStore: new ConfigStore(),
     commandHistoryStore: new CommandHistoryStore(),
+    imageStore: null,
+    // Lazy-loaded on first use
+    imageRenderer,
+    messageBuilder: null,
     agent: null,
     mcpManager: null,
     permissionManager: null,
     permissionPrompt: null,
-    trustLocationSelector: null
+    trustLocationSelector: null,
+    rewindSelector: null
   });
-  const [isInitialized, setIsInitialized] = useState4(false);
-  const [initError, setInitError] = useState4(null);
-  const [commandHistory, setCommandHistory] = useState4([]);
+  const [isInitialized, setIsInitialized] = useState5(false);
+  const [initError, setInitError] = useState5(null);
+  const [commandHistory, setCommandHistory] = useState5([]);
+  const imageStoreInitPromise = useRef(null);
   const setStoreSession = useCliStore((state2) => state2.setSession);
   const setPermissionPrompt = useCliStore((state2) => state2.setPermissionPrompt);
   const setShowConfigEditor = useCliStore((state2) => state2.setShowConfigEditor);
@@ -10038,6 +10537,13 @@ function CliApp() {
     if (state.agent) {
       state.agent.removeAllListeners();
     }
+    if (state.imageStore) {
+      try {
+        state.imageStore.close();
+      } catch (err) {
+        logger.debug(`[CLEANUP] Image store close error: ${err}`);
+      }
+    }
     await Promise.race([
       Promise.all(cleanupTasks),
       new Promise((resolve3) => setTimeout(resolve3, 500))
@@ -10046,8 +10552,8 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent]);
-  useInput3((input, key) => {
+  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
+  useInput4((input, key) => {
     if (key.ctrl && input === "c") {
       const now = Date.now();
       if (exitTimestamp && now - exitTimestamp < EXIT_TIMEOUT_MS) {
@@ -10306,9 +10812,16 @@ Remember: Use context from previous messages to understand follow-up questions.`
       return;
     }
     try {
+      let messageContent = message;
+      let userMessageContent = message;
+      if (state.messageBuilder && state.messageBuilder.hasImages(message)) {
+        const { message: multimodalMessage } = await state.messageBuilder.buildMessage(message);
+        messageContent = multimodalMessage.content;
+        userMessageContent = message;
+      }
       const userMessage = {
         role: "user",
-        content: message,
+        content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const recentMessages = state.session.messages.slice(-20);
@@ -10316,7 +10829,7 @@ Remember: Use context from previous messages to understand follow-up questions.`
         role: msg.role,
         content: msg.content
       }));
-      const result = await state.agent.run(message, {
+      const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
@@ -10365,6 +10878,59 @@ Remember: Use context from previous messages to understand follow-up questions.`
       console.error("Error processing message:", error);
     }
   };
+  const handleImageDetected = async (imageData) => {
+    try {
+      let imageStore = state.imageStore;
+      if (!imageStore) {
+        if (!imageStoreInitPromise.current) {
+          imageStoreInitPromise.current = (async () => {
+            const { ImageStore: ImageStoreClass } = await import("./ImageStore-RQZ7OF7P.js");
+            const newImageStore = new ImageStoreClass();
+            setState((prev) => ({
+              ...prev,
+              imageStore: newImageStore,
+              messageBuilder: new MessageBuilder(newImageStore, prev.imageRenderer)
+            }));
+            return newImageStore;
+          })();
+        }
+        imageStore = await imageStoreInitPromise.current;
+      }
+      const imageRef = await imageStore.store(imageData);
+      const imagePlaceholder = state.imageRenderer.createPlaceholder(imageRef.hash);
+      console.log(`
+\u2713 Image detected and stored: ${imagePlaceholder}
+`);
+      return imagePlaceholder;
+    } catch (error) {
+      console.error("Error storing image:", error);
+      throw error;
+    }
+  };
+  const recalculateSessionMetadata = (messages) => {
+    let totalTokens = 0;
+    let totalCost = 0;
+    let toolCallCount = 0;
+    for (const msg of messages) {
+      if (msg.metadata) {
+        if (msg.metadata.tokenUsage) {
+          totalTokens += msg.metadata.tokenUsage.total || 0;
+        }
+        if (msg.metadata.cost) {
+          totalCost += msg.metadata.cost;
+        }
+        if (msg.metadata.steps) {
+          const observations = msg.metadata.steps.filter((s) => s.type === "observation");
+          toolCallCount += observations.length;
+        }
+      }
+    }
+    return {
+      totalTokens,
+      totalCost,
+      toolCallCount
+    };
+  };
   const handleCommand = async (command, args) => {
     switch (command) {
       case "help":
@@ -10373,6 +10939,7 @@ Available commands:
   /help - Show this help message
   /exit - Exit the CLI
   /clear - Start a new session
+  /rewind - Rewind conversation to a previous point
   /login - Authenticate with your B4M account
   /logout - Clear authentication and sign out
   /whoami - Show current authenticated user
@@ -10648,6 +11215,65 @@ Project Configuration:
 `);
         break;
       }
+      case "rewind":
+      case "undo": {
+        if (!state.session) {
+          console.log("No active session to rewind");
+          return;
+        }
+        if (state.session.messages.length === 0) {
+          console.log("\u26A0\uFE0F  Conversation is empty. Nothing to rewind.");
+          return;
+        }
+        const userMessages = state.session.messages.filter((msg) => msg.role === "user");
+        if (userMessages.length === 0) {
+          console.log("\u26A0\uFE0F  No user messages found. Nothing to rewind.");
+          return;
+        }
+        if (userMessages.length === 1) {
+          console.log("\u26A0\uFE0F  Only one exchange in the conversation. Use /clear to start a new session instead.");
+          return;
+        }
+        const handleRewindSelect = async (messageIndex) => {
+          setState((prev) => ({ ...prev, rewindSelector: null }));
+          if (messageIndex === null) {
+            console.log("\u274C Rewind operation cancelled");
+            return;
+          }
+          if (!state.session) {
+            console.log("\u274C No active session");
+            return;
+          }
+          const selectedMessage = state.session.messages[messageIndex];
+          const prefillContent = selectedMessage?.content || "";
+          const rewindedMessages = state.session.messages.slice(0, messageIndex);
+          const newMetadata = recalculateSessionMetadata(rewindedMessages);
+          const rewindedSession = {
+            ...state.session,
+            messages: rewindedMessages,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: newMetadata
+          };
+          setState((prev) => ({
+            ...prev,
+            session: rewindedSession,
+            prefillInput: prefillContent
+          }));
+          setStoreSession(rewindedSession);
+          await state.sessionStore.save(rewindedSession);
+          console.log("\u2705 Conversation rewound successfully");
+          console.log(`\u{1F4CA} Current state: ${rewindedMessages.length} messages, ${newMetadata.totalTokens} tokens`);
+          console.log(`\u{1F4DD} Your message has been placed in the input. Edit and send when ready.
+`);
+        };
+        setState((prev) => ({
+          ...prev,
+          rewindSelector: {
+            resolve: handleRewindSelect
+          }
+        }));
+        break;
+      }
       case "usage": {
         const usageAuthTokens = await state.configStore.getAuthTokens();
         if (!usageAuthTokens || new Date(usageAuthTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
@@ -10801,12 +11427,12 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     setState((prev) => ({ ...prev, config: updatedConfig }));
   };
   if (initError) {
-    return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Text12, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React13.createElement(Text12, null, initError), /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
+    return /* @__PURE__ */ React14.createElement(Box14, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React14.createElement(Text13, { color: "red", bold: true }, "\u274C Initialization Error"), /* @__PURE__ */ React14.createElement(Text13, null, initError), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, "\n", "Tip: Run /config to set up your API keys"));
   }
   if (state.trustLocationSelector) {
     const projectDir = state.configStore.getProjectConfigDir();
     const inProject = projectDir !== null;
-    return /* @__PURE__ */ React13.createElement(
+    return /* @__PURE__ */ React14.createElement(
       TrustLocationSelector,
       {
         inProject,
@@ -10823,9 +11449,27 @@ No usage data available for the last ${USAGE_DAYS} days.`);
       }
     );
   }
+  if (state.rewindSelector && state.session) {
+    return /* @__PURE__ */ React14.createElement(
+      RewindSelector,
+      {
+        messages: state.session.messages,
+        onSelect: (messageIndex) => {
+          if (state.rewindSelector) {
+            state.rewindSelector.resolve(messageIndex);
+          }
+        },
+        onCancel: () => {
+          if (state.rewindSelector) {
+            state.rewindSelector.resolve(null);
+          }
+        }
+      }
+    );
+  }
   if (state.showLoginFlow) {
     const loginApiUrl = getApiUrl(state.config?.apiConfig);
-    return /* @__PURE__ */ React13.createElement(
+    return /* @__PURE__ */ React14.createElement(
       LoginFlow,
       {
         apiUrl: loginApiUrl,
@@ -10848,17 +11492,22 @@ No usage data available for the last ${USAGE_DAYS} days.`);
     );
   }
   if (!isInitialized) {
-    return /* @__PURE__ */ React13.createElement(Box13, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React13.createElement(Text12, null, "\u{1F680} Initializing..."));
+    return /* @__PURE__ */ React14.createElement(Box14, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React14.createElement(Text13, null, "\u{1F680} Initializing..."));
   }
-  return /* @__PURE__ */ React13.createElement(
+  return /* @__PURE__ */ React14.createElement(
     App,
     {
       onMessage: handleMessage,
       onCommand: handleCommand,
+      onImageDetected: handleImageDetected,
       commandHistory,
       config: state.config,
       availableModels: state.availableModels,
       onSaveConfig: handleSaveConfig,
+      prefillInput: state.prefillInput,
+      onPrefillConsumed: () => {
+        setState((prev) => ({ ...prev, prefillInput: void 0 }));
+      },
       onPermissionResponse: (response) => {
         if (state.permissionPrompt) {
           state.permissionPrompt.resolve({ action: response });
@@ -10884,6 +11533,6 @@ var isDevMode = import.meta.url.includes("/src/") || process.env.NODE_ENV === "d
 if (isDevMode) {
   console.log("\u{1F527} Running in development mode (using TypeScript source)\n");
 }
-render(/* @__PURE__ */ React13.createElement(CliApp, null), {
+render(/* @__PURE__ */ React14.createElement(CliApp, null), {
   exitOnCtrlC: false
 });