@trydecember/cli 0.4.4 → 0.4.5

package/dist/december.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@trydecember/cli",
-    version: "0.4.4",
+    version: "0.4.5",
     description: "a coding agent for terminal and cloud.",
     homepage: "https://trydecember.com",
     repository: {
@@ -84297,7 +84297,7 @@ var require_websocket = __commonJS(function(exports, module) {
   var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
   var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
 
-  class WebSocket extends EventEmitter {
+  class WebSocket2 extends EventEmitter {
     constructor(address, protocols, options) {
       super();
       this._binaryType = BINARY_TYPES[0];
@@ -84310,7 +84310,7 @@ var require_websocket = __commonJS(function(exports, module) {
       this._extensions = {};
       this._paused = false;
       this._protocol = "";
-      this._readyState = WebSocket.CONNECTING;
+      this._readyState = WebSocket2.CONNECTING;
       this._receiver = null;
       this._sender = null;
       this._socket = null;
@@ -84412,12 +84412,12 @@ var require_websocket = __commonJS(function(exports, module) {
       socket.on("data", socketOnData);
       socket.on("end", socketOnEnd);
       socket.on("error", socketOnError);
-      this._readyState = WebSocket.OPEN;
+      this._readyState = WebSocket2.OPEN;
       this.emit("open");
     }
     emitClose() {
       if (!this._socket) {
-        this._readyState = WebSocket.CLOSED;
+        this._readyState = WebSocket2.CLOSED;
         this.emit("close", this._closeCode, this._closeMessage);
         return;
       }
@@ -84425,24 +84425,24 @@ var require_websocket = __commonJS(function(exports, module) {
         this._extensions[PerMessageDeflate.extensionName].cleanup();
       }
       this._receiver.removeAllListeners();
-      this._readyState = WebSocket.CLOSED;
+      this._readyState = WebSocket2.CLOSED;
       this.emit("close", this._closeCode, this._closeMessage);
     }
     close(code, data) {
-      if (this.readyState === WebSocket.CLOSED)
+      if (this.readyState === WebSocket2.CLOSED)
         return;
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         const msg = "WebSocket was closed before the connection was established";
         abortHandshake(this, this._req, msg);
         return;
       }
-      if (this.readyState === WebSocket.CLOSING) {
+      if (this.readyState === WebSocket2.CLOSING) {
         if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
           this._socket.end();
         }
         return;
       }
-      this._readyState = WebSocket.CLOSING;
+      this._readyState = WebSocket2.CLOSING;
       this._sender.close(code, data, !this._isServer, (err) => {
         if (err)
           return;
@@ -84454,14 +84454,14 @@ var require_websocket = __commonJS(function(exports, module) {
       setCloseTimer(this);
     }
     pause() {
-      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+      if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
         return;
       }
       this._paused = true;
       this._socket.pause();
     }
     ping(data, mask, cb) {
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
       }
       if (typeof data === "function") {
@@ -84473,7 +84473,7 @@ var require_websocket = __commonJS(function(exports, module) {
       }
       if (typeof data === "number")
         data = data.toString();
-      if (this.readyState !== WebSocket.OPEN) {
+      if (this.readyState !== WebSocket2.OPEN) {
         sendAfterClose(this, data, cb);
         return;
       }
@@ -84482,7 +84482,7 @@ var require_websocket = __commonJS(function(exports, module) {
       this._sender.ping(data || EMPTY_BUFFER, mask, cb);
     }
     pong(data, mask, cb) {
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
       }
       if (typeof data === "function") {
@@ -84494,7 +84494,7 @@ var require_websocket = __commonJS(function(exports, module) {
       }
       if (typeof data === "number")
         data = data.toString();
-      if (this.readyState !== WebSocket.OPEN) {
+      if (this.readyState !== WebSocket2.OPEN) {
         sendAfterClose(this, data, cb);
         return;
       }
@@ -84503,7 +84503,7 @@ var require_websocket = __commonJS(function(exports, module) {
       this._sender.pong(data || EMPTY_BUFFER, mask, cb);
     }
     resume() {
-      if (this.readyState === WebSocket.CONNECTING || this.readyState === WebSocket.CLOSED) {
+      if (this.readyState === WebSocket2.CONNECTING || this.readyState === WebSocket2.CLOSED) {
         return;
       }
       this._paused = false;
@@ -84511,7 +84511,7 @@ var require_websocket = __commonJS(function(exports, module) {
         this._socket.resume();
     }
     send(data, options, cb) {
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
       }
       if (typeof options === "function") {
@@ -84520,7 +84520,7 @@ var require_websocket = __commonJS(function(exports, module) {
       }
       if (typeof data === "number")
         data = data.toString();
-      if (this.readyState !== WebSocket.OPEN) {
+      if (this.readyState !== WebSocket2.OPEN) {
         sendAfterClose(this, data, cb);
         return;
       }
@@ -84537,48 +84537,48 @@ var require_websocket = __commonJS(function(exports, module) {
       this._sender.send(data || EMPTY_BUFFER, opts, cb);
     }
     terminate() {
-      if (this.readyState === WebSocket.CLOSED)
+      if (this.readyState === WebSocket2.CLOSED)
         return;
-      if (this.readyState === WebSocket.CONNECTING) {
+      if (this.readyState === WebSocket2.CONNECTING) {
         const msg = "WebSocket was closed before the connection was established";
         abortHandshake(this, this._req, msg);
         return;
       }
       if (this._socket) {
-        this._readyState = WebSocket.CLOSING;
+        this._readyState = WebSocket2.CLOSING;
         this._socket.destroy();
       }
     }
   }
-  Object.defineProperty(WebSocket, "CONNECTING", {
+  Object.defineProperty(WebSocket2, "CONNECTING", {
     enumerable: true,
     value: readyStates.indexOf("CONNECTING")
   });
-  Object.defineProperty(WebSocket.prototype, "CONNECTING", {
+  Object.defineProperty(WebSocket2.prototype, "CONNECTING", {
     enumerable: true,
     value: readyStates.indexOf("CONNECTING")
   });
-  Object.defineProperty(WebSocket, "OPEN", {
+  Object.defineProperty(WebSocket2, "OPEN", {
     enumerable: true,
     value: readyStates.indexOf("OPEN")
   });
-  Object.defineProperty(WebSocket.prototype, "OPEN", {
+  Object.defineProperty(WebSocket2.prototype, "OPEN", {
     enumerable: true,
     value: readyStates.indexOf("OPEN")
   });
-  Object.defineProperty(WebSocket, "CLOSING", {
+  Object.defineProperty(WebSocket2, "CLOSING", {
     enumerable: true,
     value: readyStates.indexOf("CLOSING")
   });
-  Object.defineProperty(WebSocket.prototype, "CLOSING", {
+  Object.defineProperty(WebSocket2.prototype, "CLOSING", {
     enumerable: true,
     value: readyStates.indexOf("CLOSING")
   });
-  Object.defineProperty(WebSocket, "CLOSED", {
+  Object.defineProperty(WebSocket2, "CLOSED", {
     enumerable: true,
     value: readyStates.indexOf("CLOSED")
   });
-  Object.defineProperty(WebSocket.prototype, "CLOSED", {
+  Object.defineProperty(WebSocket2.prototype, "CLOSED", {
     enumerable: true,
     value: readyStates.indexOf("CLOSED")
   });
@@ -84591,10 +84591,10 @@ var require_websocket = __commonJS(function(exports, module) {
     "readyState",
     "url"
   ].forEach((property) => {
-    Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+    Object.defineProperty(WebSocket2.prototype, property, { enumerable: true });
   });
   ["open", "error", "close", "message"].forEach((method) => {
-    Object.defineProperty(WebSocket.prototype, `on${method}`, {
+    Object.defineProperty(WebSocket2.prototype, `on${method}`, {
       enumerable: true,
       get() {
         for (const listener of this.listeners(method)) {
@@ -84618,9 +84618,9 @@ var require_websocket = __commonJS(function(exports, module) {
       }
     });
   });
-  WebSocket.prototype.addEventListener = addEventListener;
-  WebSocket.prototype.removeEventListener = removeEventListener;
-  module.exports = WebSocket;
+  WebSocket2.prototype.addEventListener = addEventListener;
+  WebSocket2.prototype.removeEventListener = removeEventListener;
+  module.exports = WebSocket2;
   function initAsClient(websocket, address, protocols, options) {
     const opts = {
       allowSynchronousEvents: true,
@@ -84804,7 +84804,7 @@ var require_websocket = __commonJS(function(exports, module) {
     });
     req.on("upgrade", (res, socket, head) => {
       websocket.emit("upgrade", res);
-      if (websocket.readyState !== WebSocket.CONNECTING)
+      if (websocket.readyState !== WebSocket2.CONNECTING)
         return;
       req = websocket._req = null;
       const upgrade = res.headers.upgrade;
@@ -84880,7 +84880,7 @@ var require_websocket = __commonJS(function(exports, module) {
     }
   }
   function emitErrorAndClose(websocket, err) {
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     websocket._errorEmitted = true;
     websocket.emit("error", err);
     websocket.emitClose();
@@ -84897,7 +84897,7 @@ var require_websocket = __commonJS(function(exports, module) {
     return tls.connect(options);
   }
   function abortHandshake(websocket, stream, message) {
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     const err = new Error(message);
     Error.captureStackTrace(err, abortHandshake);
     if (stream.setHeader) {
@@ -84977,10 +84977,10 @@ var require_websocket = __commonJS(function(exports, module) {
   }
   function senderOnError(err) {
     const websocket = this[kWebSocket];
-    if (websocket.readyState === WebSocket.CLOSED)
+    if (websocket.readyState === WebSocket2.CLOSED)
       return;
-    if (websocket.readyState === WebSocket.OPEN) {
-      websocket._readyState = WebSocket.CLOSING;
+    if (websocket.readyState === WebSocket2.OPEN) {
+      websocket._readyState = WebSocket2.CLOSING;
       setCloseTimer(websocket);
     }
     this._socket.end();
@@ -84997,7 +84997,7 @@ var require_websocket = __commonJS(function(exports, module) {
     this.removeListener("close", socketOnClose);
     this.removeListener("data", socketOnData);
     this.removeListener("end", socketOnEnd);
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
       const chunk = this.read(this._readableState.length);
       websocket._receiver.write(chunk);
@@ -85019,7 +85019,7 @@ var require_websocket = __commonJS(function(exports, module) {
   }
   function socketOnEnd() {
     const websocket = this[kWebSocket];
-    websocket._readyState = WebSocket.CLOSING;
+    websocket._readyState = WebSocket2.CLOSING;
     websocket._receiver.end();
     this.end();
   }
@@ -85028,7 +85028,7 @@ var require_websocket = __commonJS(function(exports, module) {
     this.removeListener("error", socketOnError);
     this.on("error", NOOP);
     if (websocket) {
-      websocket._readyState = WebSocket.CLOSING;
+      websocket._readyState = WebSocket2.CLOSING;
       this.destroy();
     }
   }
@@ -85036,7 +85036,7 @@ var require_websocket = __commonJS(function(exports, module) {
 
 // ../../node_modules/.bun/ws@8.21.0/node_modules/ws/lib/stream.js
 var require_stream = __commonJS(function(exports, module) {
-  var WebSocket = require_websocket();
+  var WebSocket2 = require_websocket();
   var { Duplex } = __require("stream");
   function emitClose(stream) {
     stream.emit("close");
@@ -85191,7 +85191,7 @@ var require_websocket_server = __commonJS(function(exports, module) {
   var extension = require_extension();
   var PerMessageDeflate = require_permessage_deflate();
   var subprotocol = require_subprotocol();
-  var WebSocket = require_websocket();
+  var WebSocket2 = require_websocket();
   var { CLOSE_TIMEOUT, GUID, kWebSocket } = require_constants2();
   var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
   var RUNNING = 0;
@@ -85219,7 +85219,7 @@ var require_websocket_server = __commonJS(function(exports, module) {
         host: null,
         path: null,
         port: null,
-        WebSocket,
+        WebSocket: WebSocket2,
         ...options
       };
       if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
@@ -115360,20 +115360,28 @@ Examples:`);
     console.log("No API key provided. Operation cancelled.");
     return;
   }
-  await Promise.resolve().then(() => init_models5());
-  const defaultModel = getDefaultModelForProvider(provider);
+  const isSTTProvider = provider.toLowerCase() === "deepgram";
   const config = await loadConfig();
   config.providers = config.providers || {};
   config.providers[provider] = finalKey;
-  config.activeProvider = provider;
-  config.activeModel = defaultModel;
-  config.authPriority = "byok";
-  await saveConfig(config);
-  await Promise.resolve().then(() => init_models5());
-  fetchLiveProviderModels(provider, finalKey).catch(() => {});
-  console.log(`
+  if (!isSTTProvider) {
+    await Promise.resolve().then(() => init_models5());
+    const defaultModel = getDefaultModelForProvider(provider);
+    config.activeProvider = provider;
+    config.activeModel = defaultModel;
+    config.authPriority = "byok";
+    await saveConfig(config);
+    await Promise.resolve().then(() => init_models5());
+    fetchLiveProviderModels(provider, finalKey).catch(() => {});
+    console.log(`
 ${GREEN}Successfully saved API key for ${provider.toUpperCase()} (Model: ${defaultModel})!${RESET}
 `);
+  } else {
+    await saveConfig(config);
+    console.log(`
+${GREEN}Successfully saved API key for DEEPGRAM (Live Voice Dictation)!${RESET}
+`);
+  }
 }
 async function handleLoginCommand(options) {
   const targetProvider = (options?.provider || "december").toLowerCase().trim();
@@ -119419,7 +119427,7 @@ var init_browser = __esm(() => {
   });
   BrowserTool = {
     name: "browser",
-    description: "Use a basic HTTP client to fetch the HTML content of a URL. Strips out scripts and styles to return clean text. It also exposes a VNC stream for UI inspection.",
+    description: "Use an interactive browser engine to navigate to a URL, execute client-side JavaScript, extract rendered page content, and capture console or network errors.",
     inputSchema: browserSchema,
     execute: async ({ url }, context) => {
       try {
@@ -119431,6 +119439,20 @@ var init_browser = __esm(() => {
           return `Failed to fetch URL: ${result.error}`;
         }
         let output = truncateOutput(result.text, 25000, 100).text;
+        if (result.consoleErrors && result.consoleErrors.length > 0) {
+          output += `
+
+[CONSOLE ERRORS]
+` + result.consoleErrors.map((err) => `- ${err}`).join(`
+`);
+        }
+        if (result.networkErrors && result.networkErrors.length > 0) {
+          output += `
+
+[FAILED NETWORK REQUESTS]
+` + result.networkErrors.map((err) => `- ${err}`).join(`
+`);
+        }
         if (result.vncUrl) {
           output += `
 
@@ -119444,6 +119466,89 @@ var init_browser = __esm(() => {
   };
 });
 
+// ../../packages/tools/src/browser_action.ts
+var browserActionSchema, BrowserActionTool;
+var init_browser_action = __esm(() => {
+  init_src();
+  init_esm2();
+  browserActionSchema = Type2.Object({
+    action: Type2.Union([
+      Type2.Literal("navigate"),
+      Type2.Literal("click"),
+      Type2.Literal("type"),
+      Type2.Literal("screenshot"),
+      Type2.Literal("get_console_errors")
+    ], { description: "The interactive browser action to execute" }),
+    url: Type2.Optional(Type2.String({ description: 'URL to navigate to (required for action: "navigate")' })),
+    selector: Type2.Optional(Type2.String({ description: 'CSS selector or text target (for action: "click" or "type")' })),
+    text: Type2.Optional(Type2.String({ description: 'Text to input (required for action: "type")' })),
+    fullPage: Type2.Optional(Type2.Boolean({ description: 'Capture full scrollable page (for action: "screenshot")' }))
+  });
+  BrowserActionTool = {
+    name: "browser_action",
+    description: "Interact with a headless browser session. Supports navigating to URLs, clicking elements, typing into inputs, capturing screenshots, and inspecting console or network errors on localhost web apps.",
+    inputSchema: browserActionSchema,
+    execute: async (input, context) => {
+      try {
+        if (!context.operations.browser) {
+          return `Failed to execute browser action: Browser operations are not supported in this environment.`;
+        }
+        if (!context.operations.browser.action) {
+          if (input.action === "navigate" && input.url) {
+            const navResult = await context.operations.browser.navigate(input.url);
+            if (navResult.error) {
+              return `Failed to navigate: ${navResult.error}`;
+            }
+            let out = truncateOutput(navResult.text, 25000, 100).text;
+            if (navResult.consoleErrors && navResult.consoleErrors.length > 0) {
+              out += `
+
+[CONSOLE ERRORS]
+` + navResult.consoleErrors.map((err) => `- ${err}`).join(`
+`);
+            }
+            if (navResult.networkErrors && navResult.networkErrors.length > 0) {
+              out += `
+
+[FAILED NETWORK REQUESTS]
+` + navResult.networkErrors.map((err) => `- ${err}`).join(`
+`);
+            }
+            return out;
+          }
+          return `Browser interactive actions ('click', 'type', 'screenshot') require Chrome or Chromium to be installed.`;
+        }
+        const result = await context.operations.browser.action(input);
+        if (result.error) {
+          return `Failed to execute action "${input.action}": ${result.error}`;
+        }
+        let response = result.output || result.text || `Browser action "${input.action}" completed successfully.`;
+        if (result.screenshotPath) {
+          response += `
+[Screenshot saved: ${result.screenshotPath}]`;
+        }
+        if (result.consoleErrors && result.consoleErrors.length > 0) {
+          response += `
+
+[CONSOLE ERRORS]
+` + result.consoleErrors.map((err) => `- ${err}`).join(`
+`);
+        }
+        if (result.networkErrors && result.networkErrors.length > 0) {
+          response += `
+
+[FAILED NETWORK REQUESTS]
+` + result.networkErrors.map((err) => `- ${err}`).join(`
+`);
+        }
+        return response;
+      } catch (error) {
+        return `Failed to execute browser action: ${error.message}`;
+      }
+    }
+  };
+});
+
 // ../../packages/tools/src/code_intelligence.ts
 function formatDiagnostics(diags, path) {
   const target = path ? ` for ${path}` : "";
@@ -160892,7 +160997,7 @@ var require_websocket2 = __commonJS(function(exports, module) {
     return null;
   }
 
-  class WebSocket extends EventTarget {
+  class WebSocket2 extends EventTarget {
     #events = {
       open: null,
       error: null,
@@ -160968,11 +161073,11 @@ var require_websocket2 = __commonJS(function(exports, module) {
       this.#url = new URL(urlRecord.href);
       const client = environmentSettingsObject.settingsObject;
       this.#handler.controller = establishWebSocketConnection(urlRecord, protocols, client, this.#handler, options);
-      this.#handler.readyState = WebSocket.CONNECTING;
+      this.#handler.readyState = WebSocket2.CONNECTING;
       this.#binaryType = "blob";
     }
     close(code = undefined, reason = undefined) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       const prefix = "WebSocket.close";
       if (code !== undefined) {
         code = webidl.converters["unsigned short"](code, prefix, "code", webidl.attributes.Clamp);
@@ -160985,7 +161090,7 @@ var require_websocket2 = __commonJS(function(exports, module) {
       closeWebSocketConnection(this.#handler, code, reason, true);
     }
     send(data) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       const prefix = "WebSocket.send";
       webidl.argumentLengthCheck(arguments, 1, prefix);
       data = webidl.converters.WebSocketSendData(data, prefix, "data");
@@ -161019,31 +161124,31 @@ var require_websocket2 = __commonJS(function(exports, module) {
       }
     }
     get readyState() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#handler.readyState;
     }
     get bufferedAmount() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#bufferedAmount;
     }
     get url() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return URLSerializer(this.#url);
     }
     get extensions() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#extensions;
     }
     get protocol() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#protocol;
     }
     get onopen() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#events.open;
     }
     set onopen(fn) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       if (this.#events.open) {
         this.removeEventListener("open", this.#events.open);
       }
@@ -161056,11 +161161,11 @@ var require_websocket2 = __commonJS(function(exports, module) {
       }
     }
     get onerror() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#events.error;
     }
     set onerror(fn) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       if (this.#events.error) {
         this.removeEventListener("error", this.#events.error);
       }
@@ -161073,11 +161178,11 @@ var require_websocket2 = __commonJS(function(exports, module) {
       }
     }
     get onclose() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#events.close;
     }
     set onclose(fn) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       if (this.#events.close) {
         this.removeEventListener("close", this.#events.close);
       }
@@ -161090,11 +161195,11 @@ var require_websocket2 = __commonJS(function(exports, module) {
       }
     }
     get onmessage() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#events.message;
     }
     set onmessage(fn) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       if (this.#events.message) {
         this.removeEventListener("message", this.#events.message);
       }
@@ -161107,11 +161212,11 @@ var require_websocket2 = __commonJS(function(exports, module) {
       }
     }
     get binaryType() {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       return this.#binaryType;
     }
     set binaryType(type) {
-      webidl.brandCheck(this, WebSocket);
+      webidl.brandCheck(this, WebSocket2);
       if (type !== "blob" && type !== "arraybuffer") {
         this.#binaryType = "blob";
       } else {
@@ -161227,13 +161332,13 @@ var require_websocket2 = __commonJS(function(exports, module) {
       }
     }
   }
-  var { ping } = WebSocket;
-  Reflect.deleteProperty(WebSocket, "ping");
-  WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING;
-  WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN;
-  WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING;
-  WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED;
-  Object.defineProperties(WebSocket.prototype, {
+  var { ping } = WebSocket2;
+  Reflect.deleteProperty(WebSocket2, "ping");
+  WebSocket2.CONNECTING = WebSocket2.prototype.CONNECTING = states.CONNECTING;
+  WebSocket2.OPEN = WebSocket2.prototype.OPEN = states.OPEN;
+  WebSocket2.CLOSING = WebSocket2.prototype.CLOSING = states.CLOSING;
+  WebSocket2.CLOSED = WebSocket2.prototype.CLOSED = states.CLOSED;
+  Object.defineProperties(WebSocket2.prototype, {
     CONNECTING: staticPropertyDescriptors,
     OPEN: staticPropertyDescriptors,
     CLOSING: staticPropertyDescriptors,
@@ -161257,7 +161362,7 @@ var require_websocket2 = __commonJS(function(exports, module) {
       configurable: true
     }
   });
-  Object.defineProperties(WebSocket, {
+  Object.defineProperties(WebSocket2, {
     CONNECTING: staticPropertyDescriptors,
     OPEN: staticPropertyDescriptors,
     CLOSING: staticPropertyDescriptors,
@@ -161304,7 +161409,7 @@ var require_websocket2 = __commonJS(function(exports, module) {
     return webidl.converters.USVString(V);
   };
   module.exports = {
-    WebSocket,
+    WebSocket: WebSocket2,
     ping
   };
 });
@@ -162189,7 +162294,7 @@ function makeDispatcher(fn) {
     }, handler);
   };
 }
-var __filename = "/home/runner/work/december/december/node_modules/.bun/undici@7.28.0/node_modules/undici/index.js", Client, Dispatcher, Pool, BalancedPool, RoundRobinPool, Agent, ProxyAgent, Socks5ProxyAgent, EnvHttpProxyAgent, RetryAgent, H2CClient, errors2, util3, InvalidArgumentError, api, buildConnector, MockClient, MockCallHistory, MockCallHistoryLog, MockAgent, MockPool, SnapshotAgent, mockErrors, RetryHandler, getGlobalDispatcher, setGlobalDispatcher, DecoratorHandler, RedirectHandler, $interceptors, $cacheStores, SqliteCacheStore, fetchImpl, $Headers, $Response, $Request, $FormData, setGlobalOrigin, getGlobalOrigin, CacheStorage, kConstruct, $caches, deleteCookie, getCookies, getSetCookies, setCookie, parseCookie, parseMIMEType, serializeAMimeType, CloseEvent, ErrorEvent, MessageEvent, WebSocket2, ping, $WebSocketStream, $WebSocketError, $request, $stream, $pipeline, $connect, $upgrade, EventSource;
+var __filename = "/home/runner/work/december/december/node_modules/.bun/undici@7.28.0/node_modules/undici/index.js", Client, Dispatcher, Pool, BalancedPool, RoundRobinPool, Agent, ProxyAgent, Socks5ProxyAgent, EnvHttpProxyAgent, RetryAgent, H2CClient, errors2, util3, InvalidArgumentError, api, buildConnector, MockClient, MockCallHistory, MockCallHistoryLog, MockAgent, MockPool, SnapshotAgent, mockErrors, RetryHandler, getGlobalDispatcher, setGlobalDispatcher, DecoratorHandler, RedirectHandler, $interceptors, $cacheStores, SqliteCacheStore, fetchImpl, $Headers, $Response, $Request, $FormData, setGlobalOrigin, getGlobalOrigin, CacheStorage, kConstruct, $caches, deleteCookie, getCookies, getSetCookies, setCookie, parseCookie, parseMIMEType, serializeAMimeType, CloseEvent, ErrorEvent, MessageEvent, WebSocket3, ping, $WebSocketStream, $WebSocketError, $request, $stream, $pipeline, $connect, $upgrade, EventSource;
 var init_undici = __esm(() => {
   Client = require_client();
   Dispatcher = require_dispatcher();
@@ -162245,7 +162350,7 @@ var init_undici = __esm(() => {
   ({ deleteCookie, getCookies, getSetCookies, setCookie, parseCookie } = require_cookies());
   ({ parseMIMEType, serializeAMimeType } = require_data_url());
   ({ CloseEvent, ErrorEvent, MessageEvent } = require_events());
-  ({ WebSocket: WebSocket2, ping } = require_websocket2());
+  ({ WebSocket: WebSocket3, ping } = require_websocket2());
   $WebSocketStream = require_websocketstream().WebSocketStream;
   $WebSocketError = require_websocketerror().WebSocketError;
   $request = makeDispatcher(api.request);
@@ -162835,6 +162940,7 @@ var init_src4 = __esm(() => {
   init_ask_question();
   init_bash();
   init_browser();
+  init_browser_action();
   init_code_intelligence();
   init_deferred_registry();
   init_edit();
@@ -162862,6 +162968,7 @@ var init_src4 = __esm(() => {
   init_manage_task();
   init_manage_memory();
   init_browser();
+  init_browser_action();
   init_web_search();
   init_diff_preview();
   init_deferred_registry();
@@ -162881,11 +162988,26 @@ var init_src4 = __esm(() => {
     CodeIntelligenceTool,
     ManageMemoryTool
   ];
-  DEFERRED_TOOLS = [ManageTaskTool, BrowserTool, WebSearchTool];
+  DEFERRED_TOOLS = [ManageTaskTool, BrowserTool, BrowserActionTool, WebSearchTool];
   defaultDeferredRegistry.register(BrowserTool, {
     category: "web",
     keywords: ["browser", "render", "html", "scrape", "page", "url", "browse", "webpage"]
   });
+  defaultDeferredRegistry.register(BrowserActionTool, {
+    category: "web",
+    keywords: [
+      "browser_action",
+      "click",
+      "type",
+      "screenshot",
+      "dom",
+      "test",
+      "input",
+      "form",
+      "ui",
+      "localhost"
+    ]
+  });
   defaultDeferredRegistry.register(WebSearchTool, {
     category: "web",
     keywords: ["search", "google", "duckduckgo", "tavily", "internet", "docs", "websearch"]
@@ -169706,13 +169828,210 @@ var init_headless_runner = __esm(() => {
   };
 });
 
+// src/utils/workspace-trust.ts
+import { execSync as execSync2 } from "node:child_process";
+import fs25 from "node:fs";
+import os13 from "node:os";
+import path26 from "node:path";
+import readline3 from "node:readline";
+function resolveWorkspaceRoot(targetDir = process.cwd()) {
+  const resolved = path26.resolve(targetDir);
+  try {
+    const stdout = execSync2("git rev-parse --show-toplevel", {
+      cwd: resolved,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim();
+    if (stdout && fs25.existsSync(stdout)) {
+      return path26.resolve(stdout);
+    }
+  } catch {}
+  let current = resolved;
+  const homeDir = path26.resolve(os13.homedir());
+  while (true) {
+    if (fs25.existsSync(path26.join(current, ".git"))) {
+      return current;
+    }
+    const parent = path26.dirname(current);
+    if (parent === current || current === homeDir) {
+      break;
+    }
+    current = parent;
+  }
+  return resolved;
+}
+function isWorkspaceTrusted(workspaceRoot, config) {
+  const canonicalRoot = path26.resolve(workspaceRoot);
+  const homeDir = path26.resolve(os13.homedir());
+  const trustedList = (config.trustedWorkspaces || []).map((p) => path26.resolve(p));
+  for (const trustedPath of trustedList) {
+    if (canonicalRoot === trustedPath) {
+      return true;
+    }
+    if (trustedPath !== "/" && trustedPath !== homeDir) {
+      const rel = path26.relative(trustedPath, canonicalRoot);
+      if (!rel.startsWith("..") && !path26.isAbsolute(rel)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function addTrustedWorkspace(workspaceRoot) {
+  const config = await loadConfig();
+  const canonical = path26.resolve(workspaceRoot);
+  const existing = (config.trustedWorkspaces || []).map((p) => path26.resolve(p));
+  if (!existing.includes(canonical)) {
+    config.trustedWorkspaces = [...existing, canonical];
+    await saveConfig(config);
+  }
+}
+async function promptWorkspaceTrust(workspaceRoot) {
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+  const homeDir = path26.resolve(os13.homedir());
+  const isHomeOrRoot = workspaceRoot === homeDir || workspaceRoot === "/";
+  const BRAND = "\x1B[38;2;137;180;248m";
+  const TEXT = "\x1B[38;2;244;244;245m";
+  const MUTED = "\x1B[38;2;170;170;170m";
+  const GRAY = "\x1B[38;2;119;119;119m";
+  const YELLOW = "\x1B[38;2;253;214;99m";
+  const BOLD = "\x1B[1m";
+  const RESET = "\x1B[0m";
+  const options = isHomeOrRoot ? [
+    { label: "No, exit", value: false },
+    { label: "Yes, trust folder anyway", value: true }
+  ] : [
+    { label: "Yes, trust folder", value: true },
+    { label: "No, exit", value: false }
+  ];
+  return new Promise((resolve) => {
+    let selectedIndex = 0;
+    let renderedLineCount = 0;
+    const wasRaw = process.stdin.isRaw;
+    if (typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    readline3.emitKeypressEvents(process.stdin);
+    const cleanup = () => {
+      process.stdin.removeListener("keypress", onKeypress);
+      if (typeof process.stdin.setRawMode === "function" && !wasRaw) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+      process.stdout.write("\x1B[?25h");
+    };
+    const clearRenderedLines = () => {
+      if (renderedLineCount > 0) {
+        readline3.cursorTo(process.stdout, 0);
+        readline3.moveCursor(process.stdout, 0, -renderedLineCount);
+        readline3.clearScreenDown(process.stdout);
+      }
+    };
+    const render = () => {
+      clearRenderedLines();
+      const lines = [];
+      lines.push("");
+      lines.push(`  ${BOLD}${TEXT}Trust workspace?${RESET}`);
+      lines.push("");
+      lines.push(`  ${GRAY}Directory${RESET}   ${BOLD}${BRAND}${workspaceRoot}${RESET}`);
+      if (isHomeOrRoot) {
+        lines.push(`  ${YELLOW}Warning${RESET}     ${YELLOW}Home or system root directory. Gives access to all personal files.${RESET}`);
+      } else {
+        lines.push(`  ${GRAY}Permission${RESET}  ${TEXT}Read, edit, and run commands${RESET}`);
+      }
+      lines.push("");
+      for (let i = 0;i < options.length; i++) {
+        const opt = options[i];
+        if (i === selectedIndex) {
+          lines.push(`  ${BRAND}❭${RESET} ${BOLD}${TEXT}${opt.label}${RESET}`);
+        } else {
+          lines.push(`    ${MUTED}${opt.label}${RESET}`);
+        }
+      }
+      lines.push("");
+      lines.push(`  ${BRAND}Enter${RESET} ${MUTED}confirm${RESET} ${MUTED}·${RESET} ${BRAND}Esc${RESET} ${MUTED}cancel${RESET} ${MUTED}·${RESET} ${BRAND}↑↓${RESET} ${MUTED}navigate${RESET}`);
+      lines.push("");
+      renderedLineCount = lines.length;
+      process.stdout.write(lines.join(`
+`));
+    };
+    const onKeypress = (str, key) => {
+      if (!key && !str)
+        return;
+      const lowerStr = (str || "").toLowerCase();
+      const keyName = key?.name;
+      if (lowerStr === "y" || keyName === "y") {
+        cleanup();
+        clearRenderedLines();
+        resolve(true);
+        return;
+      }
+      if (lowerStr === "n" || keyName === "n") {
+        cleanup();
+        clearRenderedLines();
+        resolve(false);
+        return;
+      }
+      if (keyName === "up" || keyName === "k") {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        render();
+      } else if (keyName === "down" || keyName === "j" || keyName === "tab") {
+        selectedIndex = Math.min(options.length - 1, selectedIndex + 1);
+        render();
+      } else if (keyName === "return" || keyName === "enter") {
+        cleanup();
+        clearRenderedLines();
+        resolve(options[selectedIndex].value);
+      } else if (keyName === "escape" || key?.ctrl && keyName === "c") {
+        cleanup();
+        clearRenderedLines();
+        resolve(false);
+      }
+    };
+    process.stdout.write("\x1B[?25l");
+    process.stdin.on("keypress", onKeypress);
+    render();
+  });
+}
+async function ensureWorkspaceTrust(options = {}) {
+  const workspaceRoot = resolveWorkspaceRoot(options.targetDir || process.cwd());
+  const config = await loadConfig();
+  if (isWorkspaceTrusted(workspaceRoot, config)) {
+    return;
+  }
+  const isNonInteractive = Boolean(options.isHeadless) || !process.stdin.isTTY || Boolean(process.env.NON_INTERACTIVE) || Boolean(process.env.CI);
+  if (isNonInteractive) {
+    const RED = "\x1B[38;2;252;165;165m";
+    const RESET = "\x1B[0m";
+    console.error(`
+${RED}Error:${RESET} Workspace "${workspaceRoot}" is not trusted.`);
+    console.error(`Please run "december" interactively first to review and trust this workspace.
+`);
+    process.exit(1);
+  }
+  const trusted = await promptWorkspaceTrust(workspaceRoot);
+  if (!trusted) {
+    console.log(`
+Workspace untrusted. Exiting.
+`);
+    process.exit(0);
+  }
+  await addTrustedWorkspace(workspaceRoot);
+}
+var init_workspace_trust = __esm(() => {
+  init_config();
+});
+
 // src/file-session-repository.ts
 var exports_file_session_repository = {};
 __export(exports_file_session_repository, {
   FileSessionRepository: () => FileSessionRepository
 });
-import fs25 from "node:fs/promises";
-import path26 from "node:path";
+import fs26 from "node:fs/promises";
+import path27 from "node:path";
 
 class FileSessionRepository {
   sessionDir;
@@ -169722,22 +170041,22 @@ class FileSessionRepository {
     if (sessionDir) {
       this.sessionDir = sessionDir;
     } else {
-      this.sessionDir = path26.join(getConfigDir(), "sessions");
-      const legacyDir = path26.join(getLegacyConfigDir(), "sessions");
+      this.sessionDir = path27.join(getConfigDir(), "sessions");
+      const legacyDir = path27.join(getLegacyConfigDir(), "sessions");
       if (legacyDir !== this.sessionDir) {
         this.legacySessionDir = legacyDir;
       }
     }
   }
   async saveContext(sessionId, messages) {
-    await fs25.mkdir(this.sessionDir, { recursive: true });
-    const historyPath = path26.join(this.sessionDir, `${sessionId}.jsonl`);
+    await fs26.mkdir(this.sessionDir, { recursive: true });
+    const historyPath = path27.join(this.sessionDir, `${sessionId}.jsonl`);
     let existing = this.sessionCache[sessionId];
     if (!existing) {
       existing = {};
       this.sessionCache[sessionId] = existing;
       try {
-        const data = await fs25.readFile(historyPath, "utf-8");
+        const data = await fs26.readFile(historyPath, "utf-8");
         const lines = data.split(`
 `).filter((l) => l.trim().length > 0);
         for (const l of lines) {
@@ -169761,19 +170080,19 @@ class FileSessionRepository {
       }
     }
     if (appendContent) {
-      await fs25.appendFile(historyPath, appendContent, "utf-8");
+      await fs26.appendFile(historyPath, appendContent, "utf-8");
     }
   }
   async loadContext(sessionId) {
-    let historyPath = path26.join(this.sessionDir, `${sessionId}.jsonl`);
+    let historyPath = path27.join(this.sessionDir, `${sessionId}.jsonl`);
     try {
       let data;
       try {
-        data = await fs25.readFile(historyPath, "utf-8");
+        data = await fs26.readFile(historyPath, "utf-8");
       } catch (err) {
         if (this.legacySessionDir) {
-          const legacyPath = path26.join(this.legacySessionDir, `${sessionId}.jsonl`);
-          data = await fs25.readFile(legacyPath, "utf-8");
+          const legacyPath = path27.join(this.legacySessionDir, `${sessionId}.jsonl`);
+          data = await fs26.readFile(legacyPath, "utf-8");
           historyPath = legacyPath;
         } else {
           throw err;
@@ -169814,7 +170133,7 @@ class FileSessionRepository {
       if (msgs.length < lines.length) {
         const compacted = msgs.map((m) => JSON.stringify(m)).join(`
 `);
-        await fs25.writeFile(historyPath, compacted, "utf-8").catch(() => {});
+        await fs26.writeFile(historyPath, compacted, "utf-8").catch(() => {});
       }
       const cacheObj = {};
       for (const msg of msgs) {
@@ -169828,12 +170147,12 @@ class FileSessionRepository {
   }
   async listSessions() {
     try {
-      await fs25.mkdir(this.sessionDir, { recursive: true });
+      await fs26.mkdir(this.sessionDir, { recursive: true });
       const sessions = [];
       const seenIds = new Set;
       const processDirectory = async (dirPath) => {
         try {
-          const dirFiles = await fs25.readdir(dirPath);
+          const dirFiles = await fs26.readdir(dirPath);
           for (const file of dirFiles) {
             if (!file.endsWith(".jsonl"))
               continue;
@@ -169841,10 +170160,10 @@ class FileSessionRepository {
             if (seenIds.has(id))
               continue;
             seenIds.add(id);
-            const filePath = path26.join(dirPath, file);
+            const filePath = path27.join(dirPath, file);
             try {
-              const stat = await fs25.stat(filePath);
-              const data = await fs25.readFile(filePath, "utf-8");
+              const stat = await fs26.stat(filePath);
+              const data = await fs26.readFile(filePath, "utf-8");
               const lines = data.split(`
 `).filter((l) => l.trim().length > 0);
               let preview = "";
@@ -169878,20 +170197,20 @@ class FileSessionRepository {
     }
   }
   async deleteSession(sessionId) {
-    const historyPath = path26.join(this.sessionDir, `${sessionId}.jsonl`);
+    const historyPath = path27.join(this.sessionDir, `${sessionId}.jsonl`);
     try {
-      await fs25.unlink(historyPath);
+      await fs26.unlink(historyPath);
     } catch (e) {}
     if (this.legacySessionDir) {
       try {
-        await fs25.unlink(path26.join(this.legacySessionDir, `${sessionId}.jsonl`));
+        await fs26.unlink(path27.join(this.legacySessionDir, `${sessionId}.jsonl`));
       } catch {}
     }
   }
   async renameSession(oldSessionId, newSessionId) {
-    const oldPath = path26.join(this.sessionDir, `${oldSessionId}.jsonl`);
-    const newPath = path26.join(this.sessionDir, `${newSessionId}.jsonl`);
-    await fs25.rename(oldPath, newPath);
+    const oldPath = path27.join(this.sessionDir, `${oldSessionId}.jsonl`);
+    const newPath = path27.join(this.sessionDir, `${newSessionId}.jsonl`);
+    await fs26.rename(oldPath, newPath);
   }
 }
 var init_file_session_repository = __esm(() => {
@@ -175518,6 +175837,614 @@ var init_task_manager = __esm(() => {
   }
 });
 
+// src/utils/browser/detector.ts
+import { execSync as execSync3 } from "node:child_process";
+import fs27 from "node:fs/promises";
+import os14 from "node:os";
+import path28 from "node:path";
+async function isExecutable(filePath) {
+  try {
+    await fs27.access(filePath, fs27.constants.X_OK);
+    const stats = await fs27.stat(filePath);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function findSystemChrome() {
+  if (cachedChromePath !== undefined) {
+    return cachedChromePath;
+  }
+  const envVars = ["CHROME_PATH", "CHROME_BIN", "CHROMIUM_PATH", "PUPPETEER_EXECUTABLE_PATH"];
+  for (const envVar of envVars) {
+    const val = process.env[envVar];
+    if (val && await isExecutable(val)) {
+      cachedChromePath = val;
+      return val;
+    }
+  }
+  const platform = os14.platform();
+  const candidates = [];
+  if (platform === "linux") {
+    candidates.push("/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser", "/snap/bin/chromium", "/usr/bin/brave-browser", "/usr/bin/microsoft-edge", "/usr/bin/microsoft-edge-stable");
+  } else if (platform === "darwin") {
+    const home = os14.homedir();
+    candidates.push("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Chromium.app/Contents/MacOS/Chromium", "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge", path28.join(home, "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"), path28.join(home, "Applications/Chromium.app/Contents/MacOS/Chromium"));
+  } else if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || "";
+    const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
+    const programFilesX86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+    candidates.push(path28.join(programFiles, "Google\\Chrome\\Application\\chrome.exe"), path28.join(programFilesX86, "Google\\Chrome\\Application\\chrome.exe"), path28.join(localAppData, "Google\\Chrome\\Application\\chrome.exe"), path28.join(programFiles, "Microsoft\\Edge\\Application\\msedge.exe"), path28.join(programFilesX86, "Microsoft\\Edge\\Application\\msedge.exe"), path28.join(localAppData, "BraveSoftware\\Brave-Browser\\Application\\brave.exe"));
+  }
+  for (const candidate of candidates) {
+    if (await isExecutable(candidate)) {
+      cachedChromePath = candidate;
+      return candidate;
+    }
+  }
+  const binaryNames = platform === "win32" ? ["chrome.exe", "msedge.exe", "brave.exe"] : [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+    "brave-browser",
+    "microsoft-edge"
+  ];
+  const whichCmd = platform === "win32" ? "where" : "which";
+  for (const bin of binaryNames) {
+    try {
+      const out = execSync3(`${whichCmd} ${bin}`, {
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf-8"
+      }).trim();
+      const firstLine = out.split(`
+`)[0]?.trim();
+      if (firstLine && await isExecutable(firstLine)) {
+        cachedChromePath = firstLine;
+        return firstLine;
+      }
+    } catch {}
+  }
+  cachedChromePath = null;
+  return null;
+}
+var cachedChromePath = undefined;
+var init_detector = () => {};
+
+// src/utils/browser/cdp-client.ts
+import { spawn as spawn4 } from "node:child_process";
+import fs28 from "node:fs/promises";
+import os15 from "node:os";
+import path29 from "node:path";
+
+class CdpBrowserSession {
+  options;
+  chromeProc = null;
+  ws = null;
+  nextId = 1;
+  pendingCommands = new Map;
+  sessionId = null;
+  tmpProfileDir = null;
+  consoleErrors = [];
+  networkErrors = [];
+  isLoaded = false;
+  constructor(options) {
+    this.options = options;
+  }
+  async launch() {
+    this.tmpProfileDir = path29.join(os15.tmpdir(), `december-chrome-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    await fs28.mkdir(this.tmpProfileDir, { recursive: true });
+    const isHeadless = this.options.headless ?? (process.env.DECEMBER_HEADED !== "1" && process.env.HEADED !== "1");
+    const args = [
+      ...isHeadless ? ["--headless=new"] : [],
+      "--disable-gpu",
+      "--no-sandbox",
+      "--disable-dev-shm-usage",
+      "--remote-debugging-port=0",
+      "--hide-scrollbars",
+      "--window-size=1280,800",
+      `--user-data-dir=${this.tmpProfileDir}`,
+      "about:blank"
+    ];
+    const proc = spawn4(this.options.chromePath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.chromeProc = proc;
+    const wsUrl = await new Promise((resolve, reject) => {
+      let buffer = "";
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout waiting for Chrome DevTools WebSocket URL."));
+      }, this.options.timeoutMs || 15000);
+      const onData = (chunk) => {
+        buffer += chunk.toString();
+        const match = buffer.match(/DevTools listening on (ws:\/\/[^\s]+)/);
+        if (match && match[1]) {
+          clearTimeout(timeout);
+          proc.stderr?.off("data", onData);
+          resolve(match[1]);
+        }
+      };
+      proc.stderr?.on("data", onData);
+      proc.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+      proc.on("exit", (code) => {
+        clearTimeout(timeout);
+        reject(new Error(`Chrome exited prematurely with code ${code}.`));
+      });
+    });
+    await this.connectWs(wsUrl);
+    const createTargetRes = await this.sendCommand("Target.createTarget", {
+      url: "about:blank"
+    });
+    const targetId = createTargetRes.targetId;
+    const attachRes = await this.sendCommand("Target.attachToTarget", {
+      targetId,
+      flatten: true
+    });
+    this.sessionId = attachRes.sessionId;
+    await this.sendSessionCommand("Page.enable");
+    await this.sendSessionCommand("Runtime.enable");
+    await this.sendSessionCommand("Network.enable");
+  }
+  async connectWs(wsUrl) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      this.ws = ws;
+      ws.onopen = () => resolve();
+      ws.onerror = (err) => reject(err);
+      ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data.toString());
+          if (typeof msg.id === "number") {
+            const pending = this.pendingCommands.get(msg.id);
+            if (pending) {
+              this.pendingCommands.delete(msg.id);
+              if (msg.error) {
+                pending.reject(new Error(msg.error.message || "CDP Error"));
+              } else {
+                pending.resolve(msg.result);
+              }
+            }
+            return;
+          }
+          this.handleEvent(msg);
+        } catch {}
+      };
+    });
+  }
+  handleEvent(msg) {
+    const method = msg.method;
+    if (method === "Page.loadEventFired" || method === "Page.domContentEventFired") {
+      this.isLoaded = true;
+    } else if (method === "Runtime.exceptionThrown") {
+      const details = msg.params?.exceptionDetails;
+      const desc = details?.exception?.description || details?.text || "Unknown runtime exception";
+      this.consoleErrors.push(`Exception: ${desc}`);
+    } else if (method === "Runtime.consoleAPICalled") {
+      const type = msg.params?.type;
+      if (type === "error" || type === "warning") {
+        const args = (msg.params?.args || []).map((a) => a.value ?? a.description ?? "").join(" ");
+        this.consoleErrors.push(`[console.${type}] ${args}`);
+      }
+    } else if (method === "Network.responseReceived") {
+      const res = msg.params?.response;
+      if (res && typeof res.status === "number" && res.status >= 400) {
+        this.networkErrors.push(`HTTP ${res.status} ${res.statusText || ""} - ${res.url}`);
+      }
+    } else if (method === "Network.loadingFailed") {
+      const err = msg.params;
+      if (err) {
+        this.networkErrors.push(`Network failure: ${err.errorText || "Unknown error"} (${err.type || "request"})`);
+      }
+    }
+  }
+  sendCommand(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        return reject(new Error("WebSocket is not open"));
+      }
+      const id = this.nextId++;
+      this.pendingCommands.set(id, { resolve, reject });
+      this.ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+  sendSessionCommand(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+        return reject(new Error("WebSocket is not open"));
+      }
+      const id = this.nextId++;
+      this.pendingCommands.set(id, { resolve, reject });
+      const payload = { id, method, params };
+      if (this.sessionId) {
+        payload.sessionId = this.sessionId;
+      }
+      this.ws.send(JSON.stringify(payload));
+    });
+  }
+  async navigate(url, timeoutMs = 12000) {
+    this.consoleErrors = [];
+    this.networkErrors = [];
+    this.isLoaded = false;
+    await this.sendSessionCommand("Page.navigate", { url });
+    const startTime = Date.now();
+    while (!this.isLoaded && Date.now() - startTime < timeoutMs) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    await new Promise((r) => setTimeout(r, 300));
+    const evalRes = await this.sendSessionCommand("Runtime.evaluate", {
+      expression: '(function() { return document.body ? (document.body.innerText || document.documentElement.innerText || "") : ""; })()',
+      returnByValue: true
+    });
+    const text = evalRes?.result?.value || "";
+    return {
+      text: text.trim(),
+      consoleErrors: [...this.consoleErrors],
+      networkErrors: [...this.networkErrors]
+    };
+  }
+  async click(selector) {
+    const expression = `
+            (function(sel) {
+                var el = document.querySelector(sel);
+                if (!el) {
+                    var buttons = Array.from(document.querySelectorAll('button, a, input[type=button], input[type=submit], [role=button]'));
+                    el = buttons.find(function(b) {
+                        return (b.textContent || '').trim().toLowerCase() === sel.trim().toLowerCase();
+                    });
+                }
+                if (!el) {
+                    return { success: false, error: 'Could not find element matching: ' + sel };
+                }
+                el.scrollIntoView({ behavior: 'instant', block: 'center' });
+                el.click();
+                return {
+                    success: true,
+                    tagName: el.tagName,
+                    text: (el.textContent || '').trim().slice(0, 50)
+                };
+            })(${JSON.stringify(selector)})
+        `;
+    const evalRes = await this.sendSessionCommand("Runtime.evaluate", {
+      expression,
+      returnByValue: true
+    });
+    const result = evalRes?.result?.value;
+    if (!result || !result.success) {
+      return {
+        success: false,
+        output: "",
+        error: result?.error || `Element "${selector}" not found.`,
+        consoleErrors: [...this.consoleErrors],
+        networkErrors: [...this.networkErrors]
+      };
+    }
+    await new Promise((r) => setTimeout(r, 300));
+    return {
+      success: true,
+      output: `Clicked <${result.tagName}>: "${result.text || selector}"`,
+      consoleErrors: [...this.consoleErrors],
+      networkErrors: [...this.networkErrors]
+    };
+  }
+  async type(selector, text) {
+    const expression = `
+            (function(sel, val) {
+                var el = document.querySelector(sel);
+                if (!el) {
+                    var inputs = Array.from(document.querySelectorAll('input, textarea'));
+                    el = inputs.find(function(i) {
+                        return i.name === sel || i.id === sel || i.placeholder === sel;
+                    });
+                }
+                if (!el) {
+                    return { success: false, error: 'Could not find input element matching: ' + sel };
+                }
+                el.focus();
+                el.value = val;
+                el.dispatchEvent(new Event('input', { bubbles: true }));
+                el.dispatchEvent(new Event('change', { bubbles: true }));
+                return { success: true, tagName: el.tagName, value: el.value };
+            })(${JSON.stringify(selector)}, ${JSON.stringify(text)})
+        `;
+    const evalRes = await this.sendSessionCommand("Runtime.evaluate", {
+      expression,
+      returnByValue: true
+    });
+    const result = evalRes?.result?.value;
+    if (!result || !result.success) {
+      return {
+        success: false,
+        output: "",
+        error: result?.error || `Input element "${selector}" not found.`,
+        consoleErrors: [...this.consoleErrors],
+        networkErrors: [...this.networkErrors]
+      };
+    }
+    return {
+      success: true,
+      output: `Typed "${text}" into <${result.tagName}> (${selector})`,
+      consoleErrors: [...this.consoleErrors],
+      networkErrors: [...this.networkErrors]
+    };
+  }
+  async screenshot(fullPage = false, outputPath) {
+    const params = { format: "png" };
+    if (fullPage) {
+      params.captureBeyondViewport = true;
+    }
+    const res = await this.sendSessionCommand("Page.captureScreenshot", params);
+    const base64Data = res?.data;
+    if (!base64Data) {
+      return {
+        success: false,
+        output: "",
+        error: "Failed to capture screenshot data from Chrome."
+      };
+    }
+    const targetFile = outputPath || path29.join(os15.tmpdir(), `december-screenshot-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.png`);
+    await fs28.writeFile(targetFile, Buffer.from(base64Data, "base64"));
+    return {
+      success: true,
+      output: `Screenshot captured successfully.`,
+      screenshotPath: targetFile,
+      screenshotBase64: base64Data,
+      consoleErrors: [...this.consoleErrors],
+      networkErrors: [...this.networkErrors]
+    };
+  }
+  async getConsoleErrors() {
+    return {
+      consoleErrors: [...this.consoleErrors],
+      networkErrors: [...this.networkErrors]
+    };
+  }
+  async close() {
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {}
+      this.ws = null;
+    }
+    if (this.chromeProc) {
+      try {
+        this.chromeProc.kill("SIGTERM");
+        setTimeout(() => {
+          if (this.chromeProc && !this.chromeProc.killed) {
+            this.chromeProc.kill("SIGKILL");
+          }
+        }, 1000);
+      } catch {}
+      this.chromeProc = null;
+    }
+    if (this.tmpProfileDir) {
+      try {
+        await fs28.rm(this.tmpProfileDir, { recursive: true, force: true });
+      } catch {}
+      this.tmpProfileDir = null;
+    }
+  }
+}
+var init_cdp_client = () => {};
+
+// src/utils/browser/browser-runner.ts
+class BrowserRunner {
+  activeSession = null;
+  cleanupRegistered = false;
+  registerCleanup() {
+    if (this.cleanupRegistered)
+      return;
+    this.cleanupRegistered = true;
+    const cleanup = () => {
+      if (this.activeSession) {
+        this.activeSession.close().catch(() => {});
+        this.activeSession = null;
+      }
+    };
+    process.once("exit", cleanup);
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+  }
+  async getSession() {
+    if (this.activeSession) {
+      return this.activeSession;
+    }
+    const chromePath = await findSystemChrome();
+    if (!chromePath) {
+      return null;
+    }
+    try {
+      await Promise.resolve().then(() => init_config());
+      const config = await loadConfig().catch(() => null);
+      const hasDisplay = process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+      const isVisible = hasDisplay && config?.browserVisible !== false && process.env.HEADED !== "0" && process.env.DECEMBER_HEADED !== "0";
+      const session = new CdpBrowserSession({
+        chromePath,
+        headless: !isVisible
+      });
+      await session.launch();
+      this.activeSession = session;
+      this.registerCleanup();
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  async staticFallbackFetch(url) {
+    try {
+      const res = await fetch(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; DecemberAgent/1.0)"
+        }
+      });
+      const html = await res.text();
+      if (!res.ok) {
+        return {
+          text: "",
+          error: `HTTP Error (${res.status}): ${html}`,
+          networkErrors: [`HTTP ${res.status} - ${url}`]
+        };
+      }
+      const cleanText = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+      const notice = `
+
+[Note: Local Chrome/Chromium not detected. Displaying static HTML text. Install Chrome or Chromium for client-side JavaScript rendering and interactive actions.]`;
+      return {
+        text: cleanText + notice,
+        consoleErrors: [],
+        networkErrors: []
+      };
+    } catch (err) {
+      return {
+        text: "",
+        error: err.message,
+        networkErrors: [`Network request failed: ${err.message}`]
+      };
+    }
+  }
+  navigate = async (url) => {
+    const session = await this.getSession();
+    if (session) {
+      try {
+        return await session.navigate(url);
+      } catch {}
+    }
+    return this.staticFallbackFetch(url);
+  };
+  action = async (params) => {
+    const { action, url, selector, text, fullPage } = params;
+    if (action === "navigate") {
+      if (!url) {
+        return {
+          success: false,
+          action: "navigate",
+          error: 'Action "navigate" requires a valid "url" parameter.'
+        };
+      }
+      const navResult = await this.navigate(url);
+      if (navResult.error) {
+        return {
+          success: false,
+          action: "navigate",
+          error: navResult.error,
+          networkErrors: navResult.networkErrors
+        };
+      }
+      return {
+        success: true,
+        action: "navigate",
+        text: navResult.text,
+        consoleErrors: navResult.consoleErrors,
+        networkErrors: navResult.networkErrors
+      };
+    }
+    if (action === "get_console_errors") {
+      if (this.activeSession) {
+        const errors = await this.activeSession.getConsoleErrors();
+        const count = errors.consoleErrors.length + errors.networkErrors.length;
+        return {
+          success: true,
+          action: "get_console_errors",
+          output: count > 0 ? `Captured ${errors.consoleErrors.length} console error(s) and ${errors.networkErrors.length} network error(s).` : "No console or network errors detected.",
+          consoleErrors: errors.consoleErrors,
+          networkErrors: errors.networkErrors
+        };
+      }
+      return {
+        success: true,
+        action: "get_console_errors",
+        output: "No active browser session running."
+      };
+    }
+    const session = await this.getSession();
+    if (!session) {
+      return {
+        success: false,
+        action,
+        error: `Interactive browser action "${action}" requires Google Chrome or Chromium. Please install Chrome or Chromium, or set the CHROME_PATH environment variable.`
+      };
+    }
+    switch (action) {
+      case "click": {
+        if (!selector) {
+          return {
+            success: false,
+            action: "click",
+            error: 'Action "click" requires a "selector" parameter.'
+          };
+        }
+        const res = await session.click(selector);
+        return {
+          success: res.success,
+          action: "click",
+          output: res.output,
+          error: res.error,
+          consoleErrors: res.consoleErrors,
+          networkErrors: res.networkErrors
+        };
+      }
+      case "type": {
+        if (!selector) {
+          return {
+            success: false,
+            action: "type",
+            error: 'Action "type" requires a "selector" parameter.'
+          };
+        }
+        const res = await session.type(selector, text || "");
+        return {
+          success: res.success,
+          action: "type",
+          output: res.output,
+          error: res.error,
+          consoleErrors: res.consoleErrors,
+          networkErrors: res.networkErrors
+        };
+      }
+      case "screenshot": {
+        const res = await session.screenshot(Boolean(fullPage));
+        return {
+          success: res.success,
+          action: "screenshot",
+          output: res.output,
+          screenshotPath: res.screenshotPath,
+          screenshotBase64: res.screenshotBase64,
+          error: res.error,
+          consoleErrors: res.consoleErrors,
+          networkErrors: res.networkErrors
+        };
+      }
+      default:
+        return {
+          success: false,
+          action,
+          error: `Unsupported browser action: ${action}`
+        };
+    }
+  };
+  close = async () => {
+    if (this.activeSession) {
+      await this.activeSession.close();
+      this.activeSession = null;
+    }
+  };
+}
+var browserRunner;
+var init_browser_runner = __esm(() => {
+  init_cdp_client();
+  init_detector();
+  browserRunner = new BrowserRunner;
+});
+
+// src/utils/browser/index.ts
+var init_browser2 = __esm(() => {
+  init_detector();
+  init_cdp_client();
+  init_browser_runner();
+});
+
 // src/local-operations.ts
 var exports_local_operations = {};
 __export(exports_local_operations, {
@@ -175525,22 +176452,22 @@ __export(exports_local_operations, {
   localOperations: () => localOperations,
   setActiveScopeDir: () => setActiveScopeDir
 });
-import { exec as exec4, spawn as spawn4 } from "node:child_process";
+import { exec as exec4, spawn as spawn5 } from "node:child_process";
 import nodeFs from "node:fs";
-import fs26 from "node:fs/promises";
-import path27 from "node:path";
+import fs29 from "node:fs/promises";
+import path30 from "node:path";
 import { promisify as promisify4 } from "node:util";
 function setActiveScopeDir(dir) {
   activeScopeDir = dir;
 }
 function getScopedCwd() {
   if (activeScopeDir) {
-    return path27.resolve(process.cwd(), activeScopeDir);
+    return path30.resolve(process.cwd(), activeScopeDir);
   }
   return process.cwd();
 }
 function isTypeScriptProject(workspaceDir) {
-  return nodeFs.existsSync(path27.join(workspaceDir, "tsconfig.json")) || nodeFs.existsSync(path27.join(workspaceDir, "package.json"));
+  return nodeFs.existsSync(path30.join(workspaceDir, "tsconfig.json")) || nodeFs.existsSync(path30.join(workspaceDir, "package.json"));
 }
 async function getOrLaunchLspClient(customWorkspaceDir) {
   const workspaceDir = customWorkspaceDir || getScopedCwd();
@@ -175575,6 +176502,7 @@ var init_local_operations = __esm(() => {
   init_src();
   init_src4();
   init_task_manager();
+  init_browser2();
   import_fast_glob = __toESM(require_out4(), 1);
   execAsync2 = promisify4(exec4);
   localBashOps = createLocalBashOperations();
@@ -175587,7 +176515,7 @@ var init_local_operations = __esm(() => {
         const fallbackTimeoutMs = actualOptions.waitMsBeforeAsync ?? DEFAULT_BG_TIMEOUT_MS;
         const serverDelayMs = actualOptions.serverReadyDelayMs ?? DEFAULT_SERVER_READY_DELAY_MS;
         return new Promise((resolve, reject) => {
-          const child = spawn4(command, {
+          const child = spawn5(command, {
             cwd: targetCwd,
             detached: process.platform !== "win32",
             env: actualOptions.env ?? process.env,
@@ -175717,19 +176645,19 @@ Failed to start process: ${err?.message || err}
     fs: {
       readFile: async (filepath) => {
         const root = getScopedCwd();
-        const absolutePath = path27.isAbsolute(filepath) ? filepath : path27.resolve(root, filepath);
-        return fs26.readFile(absolutePath, "utf8");
+        const absolutePath = path30.isAbsolute(filepath) ? filepath : path30.resolve(root, filepath);
+        return fs29.readFile(absolutePath, "utf8");
       },
       writeFile: async (filepath, content) => {
         const root = getScopedCwd();
-        const absolutePath = path27.isAbsolute(filepath) ? filepath : path27.resolve(root, filepath);
-        await fs26.mkdir(path27.dirname(absolutePath), { recursive: true });
-        await fs26.writeFile(absolutePath, content, "utf8");
+        const absolutePath = path30.isAbsolute(filepath) ? filepath : path30.resolve(root, filepath);
+        await fs29.mkdir(path30.dirname(absolutePath), { recursive: true });
+        await fs29.writeFile(absolutePath, content, "utf8");
       },
       readdir: async (dirPath) => {
         const root = getScopedCwd();
-        const absolutePath = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
-        const entries = await fs26.readdir(absolutePath, { withFileTypes: true });
+        const absolutePath = path30.isAbsolute(dirPath) ? dirPath : path30.resolve(root, dirPath);
+        const entries = await fs29.readdir(absolutePath, { withFileTypes: true });
         const ignores = getWorkspaceIgnores(root);
         return entries.filter((entry) => !isPathIgnored(entry.name, ignores)).map((entry) => {
           const type = entry.isDirectory() ? "DIR " : "FILE";
@@ -175738,14 +176666,14 @@ Failed to start process: ${err?.message || err}
       },
       mkdir: async (dirPath, options) => {
         const root = getScopedCwd();
-        const absolutePath = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
-        await fs26.mkdir(absolutePath, options);
+        const absolutePath = path30.isAbsolute(dirPath) ? dirPath : path30.resolve(root, dirPath);
+        await fs29.mkdir(absolutePath, options);
       },
       exists: async (filepath) => {
         const root = getScopedCwd();
-        const absolutePath = path27.isAbsolute(filepath) ? filepath : path27.resolve(root, filepath);
+        const absolutePath = path30.isAbsolute(filepath) ? filepath : path30.resolve(root, filepath);
         try {
-          await fs26.access(absolutePath);
+          await fs29.access(absolutePath);
           return true;
         } catch {
           return false;
@@ -175755,7 +176683,7 @@ Failed to start process: ${err?.message || err}
     search: {
       find: async (dirPath, query) => {
         const root = getScopedCwd();
-        const targetDir = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
+        const targetDir = path30.isAbsolute(dirPath) ? dirPath : path30.resolve(root, dirPath);
         const ignores = getWorkspaceIgnores(root);
         const files = await import_fast_glob.default([query], {
           cwd: targetDir,
@@ -175767,7 +176695,7 @@ Failed to start process: ${err?.message || err}
       },
       grep: async (dirPath, query) => {
         const root = getScopedCwd();
-        const targetDir = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
+        const targetDir = path30.isAbsolute(dirPath) ? dirPath : path30.resolve(root, dirPath);
         const ignores = getWorkspaceIgnores(root);
         try {
           const escapedQuery = query.replace(/"/g, "\\\"");
@@ -175781,7 +176709,7 @@ Failed to start process: ${err?.message || err}
             if (!line.trim())
               return false;
             const rawPath = line.split(":")[0];
-            const relPath = path27.isAbsolute(rawPath) ? path27.relative(root, rawPath) : rawPath;
+            const relPath = path30.isAbsolute(rawPath) ? path30.relative(root, rawPath) : rawPath;
             return !isPathIgnored(relPath, ignores);
           });
           return filtered.join(`
@@ -175806,23 +176734,9 @@ Failed to start process: ${err?.message || err}
       }
     },
     browser: {
-      navigate: async (url) => {
-        try {
-          const res = await fetch(url, {
-            headers: {
-              "User-Agent": "Mozilla/5.0 (compatible; DecemberAgent/1.0)"
-            }
-          });
-          const html = await res.text();
-          if (!res.ok) {
-            return { text: "", error: `HTTP Error (${res.status}): ${html}` };
-          }
-          const cleanText = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-          return { text: cleanText };
-        } catch (error) {
-          return { text: "", error: error.message };
-        }
-      }
+      navigate: async (url) => browserRunner.navigate(url),
+      action: async (params) => browserRunner.action(params),
+      close: async () => browserRunner.close()
     },
     diagnostics: {
       getDiagnostics: async (filePath) => {
@@ -177515,7 +178429,7 @@ var init_environment = __esm(() => {
 
 // ../../node_modules/.bun/ansi-escapes@7.3.0/node_modules/ansi-escapes/base.js
 import process2 from "node:process";
-import os13 from "node:os";
+import os16 from "node:os";
 var ESC = "\x1B[", SEP = ";", isTerminalApp, isWindows2, isTmux, cwdFunction, cursorTo = (x, y) => {
   if (typeof x !== "number") {
     throw new TypeError("The `x` argument is required");
@@ -177537,7 +178451,7 @@ var ESC = "\x1B[", SEP = ";", isTerminalApp, isWindows2, isTmux, cwdFunction, cu
   if (isBrowser || !isWindows2) {
     return false;
   }
-  const parts = os13.release().split(".");
+  const parts = os16.release().split(".");
   const major = Number(parts[0]);
   const build = Number(parts[2] ?? 0);
   if (major < 10) {
@@ -180224,7 +181138,7 @@ var init_wrap_ansi = __esm(() => {
 // ../../node_modules/.bun/terminal-size@4.0.1/node_modules/terminal-size/index.js
 import process3 from "node:process";
 import { execFileSync } from "node:child_process";
-import fs27 from "node:fs";
+import fs30 from "node:fs";
 import tty from "node:tty";
 function terminalSize() {
   const { env, stdout, stderr } = process3;
@@ -180272,7 +181186,7 @@ var defaultColumns = 80, defaultRows = 24, exec6 = (command, arguments_, { shell
     return true;
   }
   try {
-    const statContents = fs27.readFileSync("/proc/self/stat", "utf8");
+    const statContents = fs30.readFileSync("/proc/self/stat", "utf8");
     const closingParenthesisIndex = statContents.lastIndexOf(") ");
     if (closingParenthesisIndex === -1) {
       return false;
@@ -180292,8 +181206,8 @@ var defaultColumns = 80, defaultRows = 24, exec6 = (command, arguments_, { shell
   }
 }, devTty = () => {
   try {
-    const flags = process3.platform === "darwin" ? fs27.constants.O_EVTONLY | fs27.constants.O_NONBLOCK : fs27.constants.O_NONBLOCK;
-    const { columns, rows } = tty.WriteStream(fs27.openSync("/dev/tty", flags));
+    const flags = process3.platform === "darwin" ? fs30.constants.O_EVTONLY | fs30.constants.O_NONBLOCK : fs30.constants.O_NONBLOCK;
+    const { columns, rows } = tty.WriteStream(fs30.openSync("/dev/tty", flags));
     return { columns, rows };
   } catch {}
 }, tput = () => {
@@ -210285,7 +211199,7 @@ var init_ansi_styles2 = __esm(() => {
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
 import process5 from "node:process";
-import os14 from "node:os";
+import os17 from "node:os";
 import tty2 from "node:tty";
 function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process5.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
@@ -210343,7 +211257,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process5.platform === "win32") {
-    const osRelease = os14.release().split(".");
+    const osRelease = os17.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -212495,7 +213409,7 @@ var init_Text = __esm(() => {
 });
 
 // ../../node_modules/.bun/ink@7.1.0+90ffd46201e3176f/node_modules/ink/build/components/ErrorOverview.js
-import * as fs28 from "node:fs";
+import * as fs31 from "node:fs";
 import { cwd } from "node:process";
 function ErrorOverview({ error }) {
   const stack = error.stack ? error.stack.split(`
@@ -212505,8 +213419,8 @@ function ErrorOverview({ error }) {
   let excerpt;
   let lineWidth = 0;
   const stackLineCounts = new Map;
-  if (filePath && origin?.line && fs28.existsSync(filePath)) {
-    const sourceCode = fs28.readFileSync(filePath, "utf8");
+  if (filePath && origin?.line && fs31.existsSync(filePath)) {
+    const sourceCode = fs31.readFileSync(filePath, "utf8");
     excerpt = dist_default4(sourceCode, origin.line);
     if (excerpt) {
       for (const { line } of excerpt) {
@@ -213937,7 +214851,7 @@ var init_render_to_string = __esm(async () => {
 });
 
 // ../../node_modules/.bun/ink@7.1.0+90ffd46201e3176f/node_modules/ink/build/components/Static.js
-function Static15(props) {
+function Static16(props) {
   const { items, children: render, style: customStyle } = props;
   const [index, setIndex] = import_react17.useState(0);
   const itemsToRender = import_react17.useMemo(() => {
@@ -215180,9 +216094,9 @@ var init_paste_manager = __esm(() => {
 });
 
 // ../../packages/tui/src/utils/prompt-history.ts
-import fs29 from "node:fs";
-import os15 from "node:os";
-import path28 from "node:path";
+import fs32 from "node:fs";
+import os18 from "node:os";
+import path31 from "node:path";
 
 class PromptHistory {
   historyPath;
@@ -215193,17 +216107,17 @@ class PromptHistory {
     if (customPath) {
       this.historyPath = customPath;
     } else {
-      const home = process.env.HOME || process.env.USERPROFILE || os15.homedir();
-      const canonicalPath = path28.join(home, ".december", "history");
-      const legacyPath = path28.join(home, ".config", "december", "history");
-      this.historyPath = fs29.existsSync(canonicalPath) || !fs29.existsSync(legacyPath) ? canonicalPath : legacyPath;
+      const home = process.env.HOME || process.env.USERPROFILE || os18.homedir();
+      const canonicalPath = path31.join(home, ".december", "history");
+      const legacyPath = path31.join(home, ".config", "december", "history");
+      this.historyPath = fs32.existsSync(canonicalPath) || !fs32.existsSync(legacyPath) ? canonicalPath : legacyPath;
     }
     this.load();
   }
   load() {
     try {
-      if (fs29.existsSync(this.historyPath)) {
-        const raw = fs29.readFileSync(this.historyPath, "utf8");
+      if (fs32.existsSync(this.historyPath)) {
+        const raw = fs32.readFileSync(this.historyPath, "utf8");
         this.entries = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
       }
     } catch {
@@ -215219,11 +216133,11 @@ class PromptHistory {
     this.cursor = this.entries.length;
     this.currentDraft = "";
     try {
-      const dir = path28.dirname(this.historyPath);
-      if (!fs29.existsSync(dir)) {
-        fs29.mkdirSync(dir, { recursive: true });
+      const dir = path31.dirname(this.historyPath);
+      if (!fs32.existsSync(dir)) {
+        fs32.mkdirSync(dir, { recursive: true });
       }
-      fs29.appendFileSync(this.historyPath, trimmed + `
+      fs32.appendFileSync(this.historyPath, trimmed + `
 `, "utf8");
     } catch {}
   }
@@ -215262,11 +216176,11 @@ var init_prompt_history = __esm(() => {
 
 // ../../packages/tui/src/utils/clipboard.ts
 import { spawnSync } from "child_process";
-import * as os16 from "os";
+import * as os19 from "os";
 function writeToClipboard(text) {
-  const platform = os16.platform();
+  const platform = os19.platform();
   try {
-    const isWsl = platform === "linux" && (!!process.env.WSL_DISTRO_NAME || os16.release().toLowerCase().includes("microsoft"));
+    const isWsl = platform === "linux" && (!!process.env.WSL_DISTRO_NAME || os19.release().toLowerCase().includes("microsoft"));
     if (platform === "darwin") {
       spawnSync("pbcopy", { input: text });
     } else if (platform === "win32") {
@@ -215287,16 +216201,16 @@ var init_clipboard = () => {};
 
 // ../../packages/tui/src/utils/handoff.ts
 import { exec as exec7 } from "node:child_process";
-import fs30 from "node:fs";
-import path29 from "node:path";
+import fs33 from "node:fs";
+import path32 from "node:path";
 import { promisify as promisify5 } from "node:util";
 function getHandoffExcludes(baseDir = process.cwd()) {
   const excludes = [...MANDATORY_HANDOFF_EXCLUDES];
   const readIgnoreFile = (fileName) => {
-    const filePath = path29.join(baseDir, fileName);
+    const filePath = path32.join(baseDir, fileName);
     try {
-      if (fs30.existsSync(filePath)) {
-        const lines = fs30.readFileSync(filePath, "utf8").split(`
+      if (fs33.existsSync(filePath)) {
+        const lines = fs33.readFileSync(filePath, "utf8").split(`
 `);
         for (const line of lines) {
           const trimmed = line.trim();
@@ -215365,9 +216279,9 @@ var init_handoff = __esm(() => {
 });
 
 // ../../packages/tui/src/components/command-menu/commands.tsx
-import fs31 from "node:fs";
-import os17 from "node:os";
-import path30 from "node:path";
+import fs34 from "node:fs";
+import os20 from "node:os";
+import path33 from "node:path";
 var COMMANDS;
 var init_commands2 = __esm(() => {
   init_clipboard();
@@ -215470,14 +216384,14 @@ var init_commands2 = __esm(() => {
       action: async (ctx) => {
         const archivePath = ".december-handoff.tar.gz";
         try {
-          const home = process.env.HOME || process.env.USERPROFILE || os17.homedir();
-          const canonicalConfigPath = path30.join(home, ".december", "config.json");
-          const legacyConfigPath = path30.join(home, ".config", "december", "config.json");
-          const configPath = fs31.existsSync(canonicalConfigPath) || !fs31.existsSync(legacyConfigPath) ? canonicalConfigPath : legacyConfigPath;
+          const home = process.env.HOME || process.env.USERPROFILE || os20.homedir();
+          const canonicalConfigPath = path33.join(home, ".december", "config.json");
+          const legacyConfigPath = path33.join(home, ".config", "december", "config.json");
+          const configPath = fs34.existsSync(canonicalConfigPath) || !fs34.existsSync(legacyConfigPath) ? canonicalConfigPath : legacyConfigPath;
           let config = {};
           try {
-            if (fs31.existsSync(configPath)) {
-              config = JSON.parse(fs31.readFileSync(configPath, "utf8"));
+            if (fs34.existsSync(configPath)) {
+              config = JSON.parse(fs34.readFileSync(configPath, "utf8"));
             }
           } catch {}
           if (!config.decemberToken) {
@@ -215512,7 +216426,7 @@ var init_commands2 = __esm(() => {
             headers: { Authorization: `Bearer ${config.decemberToken}` }
           });
           if (!urlRes.ok) {
-            await fs31.promises.unlink(archivePath).catch(() => {});
+            await fs34.promises.unlink(archivePath).catch(() => {});
             if (urlRes.status === 401) {
               ctx.toast.show({
                 variant: "error",
@@ -215533,7 +216447,7 @@ var init_commands2 = __esm(() => {
           const urlJson = await urlRes.json();
           const { uploadUrl, objectKey } = urlJson.data || urlJson;
           ctx.toast.show({ variant: "info", message: "Uploading to MinIO..." });
-          const fileData = await fs31.promises.readFile(archivePath);
+          const fileData = await fs34.promises.readFile(archivePath);
           const uploadRes = await fetch(uploadUrl, {
             method: "PUT",
             body: fileData
@@ -215557,11 +216471,11 @@ var init_commands2 = __esm(() => {
             const errJson = await sessionRes.json().catch(() => ({}));
             throw new Error(errJson.message || await sessionRes.text());
           }
-          await fs31.promises.unlink(archivePath).catch(() => {});
+          await fs34.promises.unlink(archivePath).catch(() => {});
           ctx.toast.show({ variant: "success", message: "Handoff complete! Exiting in 3s." });
           setTimeout(() => ctx.exit(), 3000);
         } catch (e) {
-          await fs31.promises.unlink(archivePath).catch(() => {});
+          await fs34.promises.unlink(archivePath).catch(() => {});
           ctx.toast.show({ variant: "error", message: `Handoff failed: ${e.message}` });
         }
       }
@@ -215633,6 +216547,12 @@ var init_commands2 = __esm(() => {
       description: "View quota usage",
       value: "/usage",
       action: (ctx) => {}
+    },
+    {
+      name: "voice",
+      description: "Dictate a prompt using your microphone (Deepgram)",
+      value: "/voice",
+      action: (ctx) => {}
     }
   ];
 });
@@ -216065,6 +216985,7 @@ function TextArea({
   onScrollUp,
   onScrollDown,
   placeholder = "",
+  placeholderColor,
   focus = true,
   disableHistoryNav = false
 }) {
@@ -216318,7 +217239,7 @@ function TextArea({
   });
   if (!value && placeholder) {
     return /* @__PURE__ */ jsx_runtime7.jsxs(Text3, {
-      color: THEME.colors.subtle,
+      color: placeholderColor || THEME.colors.subtle,
       wrap: "wrap",
       children: [
         focus ? /* @__PURE__ */ jsx_runtime7.jsx(Text3, {
@@ -216543,9 +217464,13 @@ var init_input_bar = __esm(async () => {
     queuedPrompts,
     tasks,
     onScrollUp,
-    onScrollDown
+    onScrollDown,
+    onStartVoice
   }) {
     const [value, setValue] = import_react42.useState("");
+    const [isVoiceActive, setIsVoiceActive] = import_react42.useState(false);
+    const [isTranscribing, setIsTranscribing] = import_react42.useState(false);
+    const voiceSessionRef = import_react42.useRef(null);
     const toast = useToast();
     const dialog = useDialog();
     const columns = useTerminalColumns();
@@ -216553,6 +217478,71 @@ var init_input_bar = __esm(async () => {
     const [allWorkspaceFiles, setAllWorkspaceFiles] = import_react42.useState([]);
     const activeToast = toasts && toasts.length > 0 ? toasts[toasts.length - 1] : toast.currentToast ? { message: toast.currentToast.message, variant: toast.currentToast.variant } : null;
     const handleContentChangeRef = import_react42.useRef(() => {});
+    const handleStopVoice = import_react42.useCallback(async (sendPrompt = false) => {
+      const session = voiceSessionRef.current;
+      if (!session) {
+        setIsVoiceActive(false);
+        setIsTranscribing(false);
+        return;
+      }
+      voiceSessionRef.current = null;
+      setIsVoiceActive(false);
+      if (sendPrompt) {
+        setIsTranscribing(true);
+        try {
+          const finalTranscript = await session.stop();
+          const promptToSend = (finalTranscript || value).trim();
+          setValue("");
+          handleContentChangeRef.current("");
+          if (promptToSend) {
+            onSubmit(promptToSend);
+          }
+        } finally {
+          setIsTranscribing(false);
+        }
+      } else {
+        session.cancel();
+        setValue("");
+        handleContentChangeRef.current("");
+        setIsTranscribing(false);
+      }
+    }, [onSubmit, value]);
+    const handleStartVoice = import_react42.useCallback(async () => {
+      if (!onStartVoice) {
+        onSubmit("/voice");
+        return;
+      }
+      setIsVoiceActive(true);
+      setValue("");
+      handleContentChangeRef.current("");
+      setIsTranscribing(false);
+      try {
+        const session = await onStartVoice({
+          onTranscript: (text) => {
+            setValue(text);
+            handleContentChangeRef.current(text);
+          },
+          onError: (err) => {
+            setIsVoiceActive(false);
+            setIsTranscribing(false);
+            voiceSessionRef.current = null;
+            toast.show({
+              variant: "error",
+              message: err.message || "Voice dictation error."
+            });
+          }
+        });
+        if (!session) {
+          setIsVoiceActive(false);
+          setIsTranscribing(false);
+          return;
+        }
+        voiceSessionRef.current = session;
+      } catch {
+        setIsVoiceActive(false);
+        setIsTranscribing(false);
+      }
+    }, [onStartVoice, onSubmit, toast]);
     const handleAutocompleteCommand = import_react42.useCallback((completedText) => {
       setValue(completedText);
       handleContentChangeRef.current(completedText);
@@ -216618,7 +217608,10 @@ var init_input_bar = __esm(async () => {
       handleContentChange,
       grillMode,
       onSubmit,
-      onCopy
+      onCopy,
+      isVoiceActive,
+      isTranscribing,
+      handleStopVoice
     });
     stateRef.current = {
       showFileMenu,
@@ -216628,11 +217621,26 @@ var init_input_bar = __esm(async () => {
       handleContentChange,
       grillMode,
       onSubmit,
-      onCopy
+      onCopy,
+      isVoiceActive,
+      isTranscribing,
+      handleStopVoice
     };
     const isCtrlW = import_react42.useRef(false);
     use_input_default((input, key) => {
       const state = stateRef.current;
+      if (key.escape) {
+        if (state.isVoiceActive || state.isTranscribing || voiceSessionRef.current) {
+          state.handleStopVoice(false);
+          return;
+        }
+        if (state.showFileMenu && state.matchingFiles.length > 0) {
+          const nextVal = state.value.replace(/@\S*$/, "");
+          setValue(nextVal);
+          state.handleContentChange(nextVal);
+          return;
+        }
+      }
       if (state.showFileMenu && state.matchingFiles.length > 0) {
         if (key.upArrow) {
           setSelectedFileIndex((prev) => Math.max(0, prev - 1));
@@ -216652,12 +217660,6 @@ var init_input_bar = __esm(async () => {
           }
           return;
         }
-        if (key.escape) {
-          const nextVal = state.value.replace(/@\S*$/, "");
-          setValue(nextVal);
-          state.handleContentChange(nextVal);
-          return;
-        }
       }
       if (key.ctrl && input === "w") {
         isCtrlW.current = true;
@@ -216748,6 +217750,12 @@ var init_input_bar = __esm(async () => {
         "/handoff",
         "/docs"
       ];
+      if (command.value === "/voice") {
+        setValue("");
+        handleContentChange("");
+        handleStartVoice();
+        return;
+      }
       if (forwardCommands.includes(command.value) || !command.action) {
         if (hasArguments) {
           onSubmit(currentValue);
@@ -216766,10 +217774,24 @@ var init_input_bar = __esm(async () => {
           onUpdateSuccess
         });
       }
-    }, [toast, dialog, agent, resetChat, onUpdateSuccess, handleContentChange, onSubmit, value]);
+    }, [
+      toast,
+      dialog,
+      agent,
+      resetChat,
+      onUpdateSuccess,
+      handleContentChange,
+      onSubmit,
+      value,
+      handleStartVoice
+    ]);
     const handleSubmit = import_react42.useCallback(async (text) => {
       if (disabled)
         return;
+      if (isVoiceActive || isTranscribing) {
+        await handleStopVoice(true);
+        return;
+      }
       if (showCommandMenu) {
         const command = resolveCommand(selectedIndex);
         handleCommand(command);
@@ -216781,6 +217803,12 @@ var init_input_bar = __esm(async () => {
       const rawTrimmed = text.trim();
       if (rawTrimmed.length === 0)
         return;
+      if (rawTrimmed === "/voice") {
+        setValue("");
+        handleContentChange("");
+        handleStartVoice();
+        return;
+      }
       const trimmed = expandPastes(rawTrimmed);
       defaultPromptHistory.append(trimmed);
       defaultPromptHistory.resetCursor();
@@ -216939,7 +217967,8 @@ var init_input_bar = __esm(async () => {
                     onHistoryDown: handleHistoryDown,
                     onScrollUp,
                     onScrollDown,
-                    placeholder: grillMode ? "" : planRefineMode ? "Enter feedback to refine plan (or Esc to cancel)..." : interactivePlanGoalMode ? "Enter your goal (e.g. add dark mode) or Esc to cancel..." : placeholder,
+                    placeholder: isTranscribing ? "Transcribing speech..." : isVoiceActive ? "Listening..." : grillMode ? "" : planRefineMode ? "Enter feedback to refine plan (or Esc to cancel)..." : interactivePlanGoalMode ? "Enter your goal (e.g. add dark mode) or Esc to cancel..." : placeholder,
+                    placeholderColor: isVoiceActive ? THEME.colors.brand : undefined,
                     focus: !disabled && !dialog.isOpen,
                     disableHistoryNav: showCommandMenu || showFileMenu || showShortcutsMenu
                   })
@@ -217254,7 +218283,7 @@ var init_scroll_viewport = __esm(async () => {
 });
 
 // ../../packages/tui/src/utils/terminal-link.ts
-import path31 from "node:path";
+import path34 from "node:path";
 function terminalLink(text, uri) {
   if (!uri)
     return text;
@@ -217263,7 +218292,7 @@ function terminalLink(text, uri) {
 function fileLink(displayPath, targetPath, line, col) {
   if (!targetPath)
     return displayPath;
-  const absPath = path31.isAbsolute(targetPath) ? targetPath : path31.resolve(process.cwd(), targetPath);
+  const absPath = path34.isAbsolute(targetPath) ? targetPath : path34.resolve(process.cwd(), targetPath);
   const lineFragment = line ? `#L${line}${col ? `:${col}` : ""}` : "";
   const uri = `file://${absPath}${lineFragment}`;
   return terminalLink(displayPath, uri);
@@ -217272,9 +218301,9 @@ function toRelativePath(filePath, cwd = process.cwd()) {
   if (!filePath)
     return "";
   const trimmed = filePath.trim();
-  if (!path31.isAbsolute(trimmed))
+  if (!path34.isAbsolute(trimmed))
     return trimmed;
-  const rel = path31.relative(cwd, trimmed);
+  const rel = path34.relative(cwd, trimmed);
   if (!rel || rel.startsWith("..")) {
     return trimmed;
   }
@@ -263642,27 +264671,27 @@ ${r}`;
 });
 
 // ../../packages/tui/src/components/header.tsx
-import fs32 from "node:fs";
+import fs35 from "node:fs";
 import { homedir } from "node:os";
-import path32 from "node:path";
+import path35 from "node:path";
 function getGitBranch(workspaceRoot = process.cwd()) {
   if (cachedBranch !== undefined) {
     return cachedBranch;
   }
   try {
-    const gitPath = path32.resolve(workspaceRoot, ".git");
-    if (fs32.existsSync(gitPath)) {
-      const stat = fs32.statSync(gitPath);
-      let headPath = path32.resolve(gitPath, "HEAD");
+    const gitPath = path35.resolve(workspaceRoot, ".git");
+    if (fs35.existsSync(gitPath)) {
+      const stat = fs35.statSync(gitPath);
+      let headPath = path35.resolve(gitPath, "HEAD");
       if (stat.isFile()) {
-        const content = fs32.readFileSync(gitPath, "utf-8").trim();
+        const content = fs35.readFileSync(gitPath, "utf-8").trim();
         if (content.startsWith("gitdir:")) {
           const gitDir = content.slice(7).trim();
-          headPath = path32.resolve(workspaceRoot, gitDir, "HEAD");
+          headPath = path35.resolve(workspaceRoot, gitDir, "HEAD");
         }
       }
-      if (fs32.existsSync(headPath)) {
-        const headContent = fs32.readFileSync(headPath, "utf-8").trim();
+      if (fs35.existsSync(headPath)) {
+        const headContent = fs35.readFileSync(headPath, "utf-8").trim();
         if (headContent.startsWith("ref: refs/heads/")) {
           cachedBranch = headContent.replace("ref: refs/heads/", "").trim();
           return cachedBranch;
@@ -263936,7 +264965,7 @@ var init_message_list = __esm(async () => {
       flexDirection: "column",
       width: "100%",
       children: [
-        staticMessages.length > 0 && /* @__PURE__ */ jsx_runtime20.jsx(Static15, {
+        staticMessages.length > 0 && /* @__PURE__ */ jsx_runtime20.jsx(Static16, {
           items: staticMessages,
           style: { width: "100%" },
           children: (msg, index) => renderSingleMessage(msg, index, staticMessages, cliVersion, latestVersion, userEmail, expandCommands, announcement)
@@ -264504,6 +265533,7 @@ function ByokKeyMenu(props) {
   const { selectedProvider, apiKey, setApiKey, handleKeySubmit, isStreaming, authError } = props;
   const formattedProvider = formatProviderName2(selectedProvider);
   const keyUrl = selectedProvider ? PROVIDER_KEY_URLS[selectedProvider] : undefined;
+  const keyNote = selectedProvider ? PROVIDER_KEY_NOTES[selectedProvider.toLowerCase().trim()] : undefined;
   return /* @__PURE__ */ jsx_runtime25.jsxs(Box_default, {
     flexDirection: "column",
     paddingX: THEME.padding.paddingX,
@@ -264528,7 +265558,8 @@ function ByokKeyMenu(props) {
               /* @__PURE__ */ jsx_runtime25.jsx(Text3, {
                 color: THEME.colors.brand,
                 children: keyUrl
-              })
+              }),
+              keyNote
             ]
           })
         ]
@@ -264573,7 +265604,7 @@ function ByokKeyMenu(props) {
     ]
   });
 }
-var jsx_runtime25, PROVIDER_NAMES, PROVIDER_KEY_URLS;
+var jsx_runtime25, PROVIDER_NAMES, PROVIDER_KEY_URLS, PROVIDER_KEY_NOTES;
 var init_byok_key_menu = __esm(async () => {
   init_theme();
   await __promiseAll([
@@ -264619,6 +265650,7 @@ var init_byok_key_menu = __esm(async () => {
     december: "December Cloud",
     december_proxy: "December Cloud",
     deepseek: "DeepSeek",
+    deepgram: "Deepgram",
     fireworks: "Fireworks AI",
     google: "Google",
     gemini: "Google AI Studio",
@@ -264737,6 +265769,7 @@ var init_byok_key_menu = __esm(async () => {
     deepinfra: "https://deepinfra.com/dash/api_keys",
     deepseek: "https://platform.deepseek.com/api_keys",
     digitalocean: "https://cloud.digitalocean.com/account/api/tokens",
+    deepgram: "https://console.deepgram.com",
     dinference: "https://dinference.com/",
     drun: "https://d.run/",
     ebcloud: "https://ebcloud.com/",
@@ -264910,6 +265943,9 @@ var init_byok_key_menu = __esm(async () => {
     zhipu: "https://open.bigmodel.cn/usercenter/apikeys",
     zhipuai: "https://open.bigmodel.cn/usercenter/apikeys"
   };
+  PROVIDER_KEY_NOTES = {
+    deepgram: " ($200 free credit on signup)"
+  };
 });
 
 // ../../packages/tui/src/components/menus/context-select-menu.tsx
@@ -266835,6 +267871,7 @@ function SettingsMainMenu(props) {
     settingsPathGuard = true,
     settingsSteeringMode = "all",
     settingsFollowUpMode = "all",
+    settingsBrowserVisible = true,
     handleSettingsMainSelect
   } = props;
   const providerKey = selectedProvider || activeProvider || "";
@@ -266873,6 +267910,10 @@ function SettingsMainMenu(props) {
     {
       label: `Follow-Up Mode           [${settingsFollowUpMode}]`,
       value: "followUpMode"
+    },
+    {
+      label: `Browser Window           [${settingsBrowserVisible !== false ? "on" : "off"}]`,
+      value: "browserVisible"
     }
   ];
   return /* @__PURE__ */ jsx_runtime34.jsxs(Box_default, {
@@ -269025,25 +270066,25 @@ var init_global_shortcuts = __esm(async () => {
 
 // ../../packages/tui/src/utils/pager.ts
 import * as cp3 from "node:child_process";
-import fs33 from "node:fs";
-import os18 from "node:os";
-import path33 from "node:path";
+import fs36 from "node:fs";
+import os21 from "node:os";
+import path36 from "node:path";
 function openPlanInPager(planText, title = "december-plan") {
   if (Boolean(process.env.BUN_TEST) || Boolean(process.env.VITEST)) {
     return Promise.resolve();
   }
   return new Promise((resolve) => {
     try {
-      const tmpFile = path33.join(os18.tmpdir(), `${title}-${Date.now()}.md`);
-      fs33.writeFileSync(tmpFile, planText, "utf8");
-      const pager = process.env.PAGER || process.env.EDITOR || (os18.platform() === "win32" ? "notepad" : "less -R");
+      const tmpFile = path36.join(os21.tmpdir(), `${title}-${Date.now()}.md`);
+      fs36.writeFileSync(tmpFile, planText, "utf8");
+      const pager = process.env.PAGER || process.env.EDITOR || (os21.platform() === "win32" ? "notepad" : "less -R");
       const child = cp3.spawn(pager, [tmpFile], {
         stdio: "inherit",
         shell: true
       });
       child.on("exit", () => {
         try {
-          fs33.unlinkSync(tmpFile);
+          fs36.unlinkSync(tmpFile);
         } catch {}
         resolve();
       });
@@ -269203,6 +270244,7 @@ function ChatApp({
     onSubmit: handleFormSubmit,
     onScrollUp: handleScrollUp,
     onScrollDown: handleScrollDown,
+    onStartVoice: session.onStartVoice,
     disabled: authMode !== "none" || Boolean(workflowUI) && !session.customInputMode,
     onCopy: () => {
       Promise.resolve().then(() => (init_clipboard(), {})).then((cb) => {
@@ -269579,6 +270621,8 @@ var init_store = __esm(() => {
     setSettingsSteeringMode: (settingsSteeringMode) => set({ settingsSteeringMode }),
     settingsFollowUpMode: "all",
     setSettingsFollowUpMode: (settingsFollowUpMode) => set({ settingsFollowUpMode }),
+    settingsBrowserVisible: true,
+    setSettingsBrowserVisible: (settingsBrowserVisible) => set({ settingsBrowserVisible }),
     tasksData: [],
     setTasksData: (tasksData) => set({ tasksData }),
     taskSelectedIndex: 0,
@@ -269612,9 +270656,9 @@ var init_store = __esm(() => {
 });
 
 // src/store/interceptors.ts
-import { execSync as execSync2 } from "node:child_process";
-import fs34 from "node:fs/promises";
-import path34 from "node:path";
+import { execSync as execSync4 } from "node:child_process";
+import fs37 from "node:fs/promises";
+import path37 from "node:path";
 async function computeToolCallDiff(toolCall) {
   if (toolCall.input?.diff) {
     return toolCall.input.diff;
@@ -269623,11 +270667,11 @@ async function computeToolCallDiff(toolCall) {
   if (!targetPath)
     return;
   const cwd = process.cwd();
-  const resolved = path34.resolve(cwd, targetPath);
-  const relative = path34.relative(cwd, resolved);
+  const resolved = path37.resolve(cwd, targetPath);
+  const relative = path37.relative(cwd, resolved);
   let oldContent = "";
   try {
-    oldContent = await fs34.readFile(resolved, "utf-8");
+    oldContent = await fs37.readFile(resolved, "utf-8");
   } catch {}
   if (toolCall.name === "write_to_file" || toolCall.name === "write") {
     const newContent = toolCall.input?.CodeContent ?? toolCall.input?.content ?? "";
@@ -269691,9 +270735,9 @@ function setupAgentInterceptors(agent, storeState) {
       ];
       if (fileTools.includes(toolCall.name)) {
         const cwd = process.cwd();
-        const resolved = path34.resolve(cwd, targetPath);
-        const relative = path34.relative(cwd, resolved);
-        const isOutside = relative.startsWith("..") || path34.isAbsolute(relative);
+        const resolved = path37.resolve(cwd, targetPath);
+        const relative = path37.relative(cwd, resolved);
+        const isOutside = relative.startsWith("..") || path37.isAbsolute(relative);
         if (!config.nonWorkspaceAccess && isOutside) {
           return {
             block: true,
@@ -269757,10 +270801,10 @@ function setupAgentInterceptors(agent, storeState) {
       const targetPath = toolCall.input?.TargetFile || toolCall.input?.AbsolutePath || toolCall.input?.filePath || toolCall.input?.path;
       if (targetPath) {
         const cwd = process.cwd();
-        const resolved = path34.resolve(cwd, targetPath);
-        const relative = path34.relative(cwd, resolved);
+        const resolved = path37.resolve(cwd, targetPath);
+        const relative = path37.relative(cwd, resolved);
         try {
-          execSync2(`git ls-files --error-unmatch "${relative}"`, {
+          execSync4(`git ls-files --error-unmatch "${relative}"`, {
             cwd,
             stdio: "pipe"
           });
@@ -269785,7 +270829,7 @@ var init_interceptors = __esm(() => {
 });
 
 // src/utils/direct-shell.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 function startDirectCommand(command, options = {}) {
   const { timeoutMs = 20000, serverReadyDelayMs = 2500, onData, onBackground } = options;
   let output = "";
@@ -269795,7 +270839,7 @@ function startDirectCommand(command, options = {}) {
   const isWindows = process.platform === "win32";
   const shellCmd = isWindows ? "cmd.exe" : "/bin/bash";
   const shellArgs = isWindows ? ["/d", "/s", "/c", command] : ["-c", command];
-  const child = spawn6(shellCmd, shellArgs, {
+  const child = spawn7(shellCmd, shellArgs, {
     cwd: process.cwd(),
     env: process.env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -269947,15 +270991,15 @@ var init_direct_shell = __esm(() => {
 });
 
 // src/utils/usage-tracker.ts
-import fs35 from "node:fs/promises";
-import path35 from "node:path";
+import fs38 from "node:fs/promises";
+import path38 from "node:path";
 function getUsageFilePath() {
-  return path35.join(getConfigDir(), "usage.json");
+  return path38.join(getConfigDir(), "usage.json");
 }
 async function loadUsageLedger() {
   const filePath = getUsageFilePath();
   try {
-    const raw = await fs35.readFile(filePath, "utf-8");
+    const raw = await fs38.readFile(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.version === 1 && parsed.days) {
       return parsed;
@@ -269968,8 +271012,8 @@ async function loadUsageLedger() {
 }
 async function saveUsageLedger(ledger) {
   const configDir = getConfigDir();
-  const filePath = path35.join(configDir, "usage.json");
-  const tmpPath = path35.join(configDir, `usage.json.tmp.${Date.now()}`);
+  const filePath = path38.join(configDir, "usage.json");
+  const tmpPath = path38.join(configDir, `usage.json.tmp.${Date.now()}`);
   const cutoffDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
   const prunedDays = {};
   for (const [dateKey, dayRecord] of Object.entries(ledger.days)) {
@@ -269979,12 +271023,12 @@ async function saveUsageLedger(ledger) {
   }
   ledger.days = prunedDays;
   try {
-    await fs35.mkdir(configDir, { recursive: true });
-    await fs35.writeFile(tmpPath, JSON.stringify(ledger, null, 2), "utf-8");
-    await fs35.rename(tmpPath, filePath);
+    await fs38.mkdir(configDir, { recursive: true });
+    await fs38.writeFile(tmpPath, JSON.stringify(ledger, null, 2), "utf-8");
+    await fs38.rename(tmpPath, filePath);
   } catch {
     try {
-      await fs35.unlink(tmpPath);
+      await fs38.unlink(tmpPath);
     } catch {}
   }
 }
@@ -271421,14 +272465,14 @@ function extractJsonArray(rawText) {
 }
 
 // src/utils/project-context.ts
-import fs36 from "node:fs";
-import path36 from "node:path";
+import fs39 from "node:fs";
+import path39 from "node:path";
 function getProjectContext(workspaceDir = process.cwd()) {
   const parts = [];
   try {
-    const pkgPath = path36.join(workspaceDir, "package.json");
-    if (fs36.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path39.join(workspaceDir, "package.json");
+    if (fs39.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs39.readFileSync(pkgPath, "utf8"));
       const deps = Object.keys(pkg.dependencies || {}).slice(0, 15).join(", ");
       const devDeps = Object.keys(pkg.devDependencies || {}).slice(0, 10).join(", ");
       parts.push(`Project: ${pkg.name || "Unnamed"}`);
@@ -271437,13 +272481,13 @@ function getProjectContext(workspaceDir = process.cwd()) {
       if (devDeps)
         parts.push(`DevDependencies: ${devDeps}`);
     }
-    const agentsPath = path36.join(workspaceDir, "AGENTS.md");
-    if (fs36.existsSync(agentsPath)) {
-      const content = fs36.readFileSync(agentsPath, "utf8");
+    const agentsPath = path39.join(workspaceDir, "AGENTS.md");
+    if (fs39.existsSync(agentsPath)) {
+      const content = fs39.readFileSync(agentsPath, "utf8");
       parts.push(`Guidelines (from AGENTS.md):
 ${content.slice(0, 500)}`);
     }
-    const entries = fs36.readdirSync(workspaceDir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.isDirectory() ? `${e.name}/` : e.name).slice(0, 20);
+    const entries = fs39.readdirSync(workspaceDir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.isDirectory() ? `${e.name}/` : e.name).slice(0, 20);
     if (entries.length > 0) {
       parts.push(`Workspace layout: ${entries.join(", ")}`);
     }
@@ -271598,14 +272642,14 @@ async function fetchProviderBalance(provider, apiKey, timeoutMs = 2000) {
 }
 
 // src/utils/formatters.ts
-import path37 from "node:path";
+import path40 from "node:path";
 function toRelativePath2(filePath, cwd = process.cwd()) {
   if (!filePath)
     return "";
   const trimmed = filePath.trim();
-  if (!path37.isAbsolute(trimmed))
+  if (!path40.isAbsolute(trimmed))
     return trimmed;
-  const rel = path37.relative(cwd, trimmed);
+  const rel = path40.relative(cwd, trimmed);
   if (!rel || rel.startsWith("..")) {
     return trimmed;
   }
@@ -272328,6 +273372,30 @@ ${formatSubscriptionCard(bundle, targetModel)}`
     if (!trimmedKey)
       return;
     const selectedProvider = useCliStore.getState().selectedProvider;
+    if (selectedProvider === "deepgram") {
+      setIsStreaming(true);
+      setAuthError(null);
+      try {
+        const res = await fetch("https://api.deepgram.com/v1/projects", {
+          headers: { Authorization: `Token ${trimmedKey}` }
+        });
+        if (!res.ok) {
+          throw new Error("Invalid Deepgram API key. Please check your key from console.deepgram.com.");
+        }
+        const config = await loadConfig();
+        config.providers = config.providers || {};
+        config.providers.deepgram = trimmedKey;
+        await saveConfig(config);
+        setApiKey("");
+        setAuthMode("none");
+        addToast("Saved Deepgram API key for voice dictation.", "success");
+      } catch (err) {
+        setAuthError(err.message || "Failed to verify Deepgram API key.");
+      } finally {
+        setIsStreaming(false);
+      }
+      return;
+    }
     setIsStreaming(true);
     setAuthError(null);
     let testProvider;
@@ -272684,6 +273752,8 @@ function useSettingsHandlers() {
     setSettingsSteeringMode,
     settingsFollowUpMode,
     setSettingsFollowUpMode,
+    settingsBrowserVisible,
+    setSettingsBrowserVisible,
     settingsAuthPriority,
     setSettingsAuthPriority,
     setAuthMethod,
@@ -272694,7 +273764,7 @@ function useSettingsHandlers() {
     setOllamaModels,
     agent,
     addToast
-  } = useCliStore();
+  } = useCliStore.getState();
   const handleSettingsMainSelect = async (item) => {
     const config = await loadConfig();
     let updated = false;
@@ -272802,6 +273872,15 @@ function useSettingsHandlers() {
         updated = true;
         break;
       }
+      case "browserVisible": {
+        const current = useCliStore.getState().settingsBrowserVisible;
+        const nextVal = !(current !== false);
+        config.browserVisible = nextVal;
+        setSettingsBrowserVisible(nextVal);
+        addToast(`Browser window set to ${nextVal ? "visible (on)" : "headless (off)"}`);
+        updated = true;
+        break;
+      }
       case "authPriority": {
         const priorities = [
           "subscription",
@@ -272858,6 +273937,503 @@ var init_use_settings_handlers = __esm(() => {
   init_provider_factory();
 });
 
+// src/utils/audio/detector.ts
+import { execSync as execSync5 } from "node:child_process";
+function checkBinary(name) {
+  try {
+    const isWindows = process.platform === "win32";
+    const checkCmd = isWindows ? `where ${name}` : `which ${name}`;
+    const stdout = execSync5(checkCmd, {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim();
+    return stdout ? stdout.split(`
+`)[0].trim() : null;
+  } catch {
+    return null;
+  }
+}
+function detectAudioBinary() {
+  const ffmpegPath = checkBinary("ffmpeg");
+  if (ffmpegPath) {
+    return { available: true, binary: "ffmpeg", path: ffmpegPath };
+  }
+  const soxPath = checkBinary("rec") || checkBinary("sox");
+  if (soxPath) {
+    return { available: true, binary: "sox", path: soxPath };
+  }
+  if (process.platform === "linux") {
+    const arecordPath = checkBinary("arecord");
+    if (arecordPath) {
+      return { available: true, binary: "arecord", path: arecordPath };
+    }
+  }
+  return {
+    available: false,
+    binary: null,
+    error: process.platform === "darwin" ? 'No audio recording binary found. Please install ffmpeg or sox (e.g. "brew install ffmpeg").' : process.platform === "linux" ? 'No audio recording binary found. Please install ffmpeg, sox, or alsa-utils (e.g. "sudo apt install ffmpeg").' : "No audio recording binary found. Please install ffmpeg or sox in your system PATH."
+  };
+}
+var init_detector2 = () => {};
+
+// src/utils/audio/recorder.ts
+import { spawn as spawn8 } from "node:child_process";
+import { EventEmitter as EventEmitter4 } from "node:events";
+var AudioRecorder;
+var init_recorder = __esm(() => {
+  init_detector2();
+  AudioRecorder = class AudioRecorder extends EventEmitter4 {
+    process = null;
+    isRecording = false;
+    start(options = {}) {
+      if (this.isRecording)
+        return true;
+      const detection = detectAudioBinary();
+      if (!detection.available || !detection.binary) {
+        this.emit("error", new Error(detection.error || "Audio recording binary not found."));
+        return false;
+      }
+      const sampleRate = options.sampleRate ?? 16000;
+      const channels = options.channels ?? 1;
+      try {
+        this.process = this.spawnRecorderProcess(detection.binary, sampleRate, channels);
+        this.isRecording = true;
+        this.process.stdout.on("data", (chunk) => {
+          this.emit("data", chunk);
+        });
+        this.process.stderr.on("data", (data) => {
+          const msg = data.toString();
+          if (msg.includes("No such device") || msg.includes("Device or resource busy")) {
+            this.emit("error", new Error(msg.trim()));
+          }
+        });
+        this.process.on("error", (err) => {
+          this.emit("error", err);
+          this.stop();
+        });
+        this.process.on("close", (code) => {
+          this.isRecording = false;
+          this.process = null;
+          this.emit("close", code);
+        });
+        return true;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.emit("error", error);
+        this.stop();
+        return false;
+      }
+    }
+    spawnRecorderProcess(binary, sampleRate, channels) {
+      if (binary === "ffmpeg") {
+        const isLinux = process.platform === "linux";
+        const isMac = process.platform === "darwin";
+        const isWindows = process.platform === "win32";
+        const args = [
+          "-loglevel",
+          "error",
+          "-fflags",
+          "nobuffer",
+          "-flags",
+          "low_delay"
+        ];
+        if (isLinux) {
+          args.push("-f", "pulse", "-i", "default");
+        } else if (isMac) {
+          args.push("-f", "avfoundation", "-i", ":default");
+        } else if (isWindows) {
+          args.push("-f", "dshow", "-i", "audio=default");
+        }
+        args.push("-ac", channels.toString(), "-ar", sampleRate.toString(), "-f", "s16le", "-flush_packets", "1", "-");
+        return spawn8("ffmpeg", args);
+      }
+      if (binary === "sox") {
+        const detection = detectAudioBinary();
+        const binaryName = detection.path?.endsWith("rec") ? "rec" : "sox";
+        const args = binaryName === "rec" ? [
+          "-q",
+          "-c",
+          channels.toString(),
+          "-r",
+          sampleRate.toString(),
+          "-b",
+          "16",
+          "-e",
+          "signed",
+          "-t",
+          "raw",
+          "-"
+        ] : [
+          "-d",
+          "-q",
+          "-c",
+          channels.toString(),
+          "-r",
+          sampleRate.toString(),
+          "-b",
+          "16",
+          "-e",
+          "signed",
+          "-t",
+          "raw",
+          "-"
+        ];
+        return spawn8(binaryName, args);
+      }
+      return spawn8("arecord", [
+        "-q",
+        "-c",
+        channels.toString(),
+        "-r",
+        sampleRate.toString(),
+        "-f",
+        "S16_LE",
+        "-t",
+        "raw"
+      ]);
+    }
+    stop() {
+      if (!this.isRecording && !this.process)
+        return;
+      this.isRecording = false;
+      if (this.process) {
+        try {
+          this.process.kill("SIGTERM");
+        } catch {}
+        this.process = null;
+      }
+    }
+    get recording() {
+      return this.isRecording;
+    }
+  };
+});
+
+// src/utils/audio/stt.ts
+import dns from "node:dns";
+async function resolveSTTKey() {
+  const envDeepgram = process.env.DEEPGRAM_API_KEY?.trim();
+  if (envDeepgram)
+    return { provider: "deepgram", key: envDeepgram };
+  const config = await loadConfig();
+  const configDeepgram = config.providers?.deepgram?.trim();
+  if (configDeepgram)
+    return { provider: "deepgram", key: configDeepgram };
+  return { provider: null, key: null };
+}
+function appendTranscript(base, next) {
+  const trimmedBase = base.trim();
+  const trimmedNext = next.trim();
+  if (!trimmedBase)
+    return trimmedNext;
+  if (!trimmedNext)
+    return trimmedBase;
+  if (/^[.,!?;:]/.test(trimmedNext)) {
+    return `${trimmedBase}${trimmedNext}`;
+  }
+  const baseWords = trimmedBase.split(/\s+/);
+  const nextWords = trimmedNext.split(/\s+/);
+  const maxOverlap = Math.min(3, baseWords.length, nextWords.length);
+  let overlapCount = 0;
+  const cleanWord = (w) => w.toLowerCase().replace(/[^a-z0-9]/g, "");
+  for (let count = maxOverlap;count >= 1; count--) {
+    const baseSlice = baseWords.slice(baseWords.length - count).map(cleanWord);
+    const nextSlice = nextWords.slice(0, count).map(cleanWord);
+    if (baseSlice.length === nextSlice.length && baseSlice.every((w, i) => w.length > 0 && w === nextSlice[i])) {
+      overlapCount = count;
+      break;
+    }
+  }
+  if (overlapCount > 0) {
+    const remainingNextWords = nextWords.slice(overlapCount);
+    if (remainingNextWords.length === 0) {
+      return trimmedBase;
+    }
+    return `${trimmedBase} ${remainingNextWords.join(" ")}`;
+  }
+  return `${trimmedBase} ${trimmedNext}`;
+}
+
+class STTSession {
+  key = null;
+  ws = null;
+  finalTranscript = "";
+  interimTranscript = "";
+  pendingChunks = [];
+  heartbeatTimer = null;
+  onTranscript;
+  onError;
+  isClosed = false;
+  constructor(options) {
+    this.onTranscript = options.onTranscript;
+    this.onError = options.onError;
+  }
+  async init() {
+    const resolved = await resolveSTTKey();
+    if (!resolved.key) {
+      this.onError(new Error("No Deepgram API key found. Set DEEPGRAM_API_KEY or configure via BYOK key menu."));
+      return false;
+    }
+    this.key = resolved.key;
+    return this.initDeepgram(this.key);
+  }
+  initDeepgram(key) {
+    return new Promise((resolve) => {
+      try {
+        const url = "wss://api.deepgram.com/v1/listen?model=nova-2&smart_format=true&interim_results=true&endpointing=300&encoding=linear16&sample_rate=16000&channels=1";
+        this.ws = new WebSocket(url, ["token", key]);
+        let isHandshakeComplete = false;
+        const handshakeTimeout = setTimeout(() => {
+          if (!isHandshakeComplete) {
+            isHandshakeComplete = true;
+            try {
+              if (this.ws && (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN)) {
+                this.ws.close();
+              }
+            } catch {}
+            this.ws = null;
+            this.onError(new Error("Deepgram WebSocket connection timed out. Check your internet connection."));
+            resolve(false);
+          }
+        }, 1e4);
+        this.ws.onopen = () => {
+          if (isHandshakeComplete)
+            return;
+          isHandshakeComplete = true;
+          clearTimeout(handshakeTimeout);
+          this.startHeartbeat();
+          this.flushPendingChunks();
+          resolve(true);
+        };
+        this.ws.onmessage = (event) => {
+          if (this.isClosed)
+            return;
+          try {
+            const data = typeof event.data === "string" ? JSON.parse(event.data) : null;
+            if (!data || data.type !== "Results")
+              return;
+            const alt = data.channel?.alternatives?.[0];
+            const transcript = alt?.transcript?.trim();
+            if (!transcript) {
+              if (data.is_final) {
+                this.interimTranscript = "";
+              }
+              return;
+            }
+            if (data.is_final) {
+              this.finalTranscript = appendTranscript(this.finalTranscript, transcript);
+              this.interimTranscript = "";
+              this.onTranscript(this.finalTranscript, true);
+            } else {
+              this.interimTranscript = transcript;
+              const fullText = appendTranscript(this.finalTranscript, this.interimTranscript);
+              this.onTranscript(fullText, false);
+            }
+          } catch {}
+        };
+        this.ws.onerror = (_err) => {
+          if (!isHandshakeComplete) {
+            isHandshakeComplete = true;
+            clearTimeout(handshakeTimeout);
+            this.onError(new Error("Deepgram WebSocket connection error."));
+            resolve(false);
+            return;
+          }
+          if (!this.isClosed) {
+            this.onError(new Error("Deepgram WebSocket connection error."));
+          }
+        };
+        this.ws.onclose = () => {
+          this.stopHeartbeat();
+        };
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.onError(error);
+        resolve(false);
+      }
+    });
+  }
+  sendAudioChunk(chunk) {
+    if (this.isClosed)
+      return;
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(chunk);
+    } else if (!this.ws || this.ws.readyState === WebSocket.CONNECTING) {
+      this.pendingChunks.push(chunk);
+    }
+  }
+  flushPendingChunks() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+      return;
+    while (this.pendingChunks.length > 0) {
+      const chunk = this.pendingChunks.shift();
+      if (chunk) {
+        try {
+          this.ws.send(chunk);
+        } catch {}
+      }
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.send(JSON.stringify({ type: "KeepAlive" }));
+        } catch {}
+      }
+    }, 4000);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  async finish() {
+    this.isClosed = true;
+    this.stopHeartbeat();
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify({ type: "CloseStream" }));
+      } catch {}
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      try {
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close();
+        }
+      } catch {}
+      this.ws = null;
+    } else if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {}
+      this.ws = null;
+    }
+    this.pendingChunks = [];
+    const fullText = appendTranscript(this.finalTranscript, this.interimTranscript);
+    return fullText.trim();
+  }
+  cancel() {
+    this.isClosed = true;
+    this.stopHeartbeat();
+    this.pendingChunks = [];
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {}
+      this.ws = null;
+    }
+    this.finalTranscript = "";
+    this.interimTranscript = "";
+  }
+}
+var init_stt = __esm(() => {
+  init_config();
+  try {
+    dns.setDefaultResultOrder?.("ipv4first");
+  } catch {}
+});
+
+// src/utils/audio/index.ts
+async function isVoiceConfigured() {
+  const binaryDetection = detectAudioBinary();
+  const sttConfig = await resolveSTTKey();
+  if (!binaryDetection.available) {
+    return {
+      available: false,
+      hasBinary: false,
+      hasKey: Boolean(sttConfig.key),
+      error: binaryDetection.error
+    };
+  }
+  if (!sttConfig.key) {
+    return {
+      available: false,
+      hasBinary: true,
+      hasKey: false,
+      binary: binaryDetection.binary,
+      error: "Deepgram API key not configured."
+    };
+  }
+  return {
+    available: true,
+    hasBinary: true,
+    hasKey: true,
+    binary: binaryDetection.binary,
+    provider: "deepgram"
+  };
+}
+function getVoiceSetupNotice(status) {
+  if (!status.hasBinary) {
+    return [
+      "Voice dictation requires an audio recording tool.",
+      "",
+      "Install:",
+      "  • macOS: brew install ffmpeg",
+      "  • Linux: sudo apt install ffmpeg"
+    ].join(`
+`);
+  }
+  return [
+    "Voice dictation requires a Deepgram API key for real-time live streaming.",
+    "",
+    "Get a free key ($200 credit) at https://console.deepgram.com",
+    "",
+    "Configure key:",
+    "  december key deepgram <key>"
+  ].join(`
+`);
+}
+async function startVoiceDictation(options) {
+  const configCheck = await isVoiceConfigured();
+  if (!configCheck.available) {
+    options.onError(new Error(configCheck.error || "Voice dictation is not available."));
+    return null;
+  }
+  const stt = new STTSession({
+    onTranscript: options.onTranscript,
+    onError: options.onError
+  });
+  const initialized = await stt.init();
+  if (!initialized) {
+    return null;
+  }
+  const recorder = new AudioRecorder;
+  recorder.on("data", (chunk) => {
+    stt.sendAudioChunk(chunk);
+  });
+  recorder.on("error", (err) => {
+    options.onError(err);
+    stt.cancel();
+  });
+  const started = recorder.start();
+  if (!started) {
+    stt.cancel();
+    return null;
+  }
+  return {
+    stop: async () => {
+      recorder.stop();
+      return await stt.finish();
+    },
+    cancel: () => {
+      recorder.stop();
+      stt.cancel();
+    },
+    get isRecording() {
+      return recorder.recording;
+    }
+  };
+}
+var init_audio2 = __esm(() => {
+  init_detector2();
+  init_recorder();
+  init_stt();
+  init_detector2();
+  init_recorder();
+});
+
 // src/hooks/use-agent-session.ts
 var exports_use_agent_session = {};
 __export(exports_use_agent_session, {
@@ -272993,7 +274569,9 @@ function useAgentSession({
     settingsSteeringMode,
     setSettingsSteeringMode,
     settingsFollowUpMode,
-    setSettingsFollowUpMode
+    setSettingsFollowUpMode,
+    settingsBrowserVisible,
+    setSettingsBrowserVisible
   } = state;
   const [expandCommands, setExpandCommands] = import_react71.useState(false);
   const toggleExpandCommands = import_react71.useCallback(() => {
@@ -274046,6 +275624,36 @@ ${decStatus}
       }
       return;
     }
+    if (text.trim() === "/voice") {
+      await Promise.resolve().then(() => init_audio2());
+      const status = await isVoiceConfigured();
+      if (!status.available) {
+        const userMsg = {
+          id: getNextMsgId(),
+          role: "user",
+          displayText: "/voice",
+          text: "/voice"
+        };
+        const noticeMsg = {
+          id: getNextMsgId(),
+          role: "assistant",
+          blocks: [
+            {
+              type: "text",
+              content: getVoiceSetupNotice(status)
+            }
+          ]
+        };
+        setStaticMessages((prev) => [
+          ...prev,
+          ...useCliStore.getState().activeMessages,
+          userMsg,
+          noticeMsg
+        ]);
+        setActiveMessages([]);
+        return;
+      }
+    }
     if (text.trim() === "/copy") {
       try {
         await init_src7();
@@ -274433,6 +276041,7 @@ ${decStatus}
         setSettingsThinkingLevel(config.thinkingLevel ?? "auto");
         setSettingsSteeringMode(config.steeringMode ?? "all");
         setSettingsFollowUpMode(config.followUpMode ?? "all");
+        setSettingsBrowserVisible(config.browserVisible !== false);
         setAuthMode("settings_main");
       });
       return;
@@ -274837,7 +276446,46 @@ If it doesn't open automatically, please click here:
     setStaticMessages
   ]);
   const handleContextSelect = () => {};
+  const handleStartVoice = import_react71.useCallback(async (callbacks) => {
+    await Promise.resolve().then(() => init_audio2());
+    const status = await isVoiceConfigured();
+    if (!status.hasBinary) {
+      const userMsg = {
+        id: getNextMsgId(),
+        role: "user",
+        displayText: "/voice",
+        text: "/voice"
+      };
+      const noticeMsg = {
+        id: getNextMsgId(),
+        role: "assistant",
+        blocks: [
+          {
+            type: "text",
+            content: getVoiceSetupNotice(status)
+          }
+        ]
+      };
+      setStaticMessages((prev) => [
+        ...prev,
+        ...useCliStore.getState().activeMessages,
+        userMsg,
+        noticeMsg
+      ]);
+      setActiveMessages([]);
+      return null;
+    }
+    if (!status.hasKey) {
+      useCliStore.getState().setSelectedProvider("deepgram");
+      useCliStore.getState().setApiKey("");
+      useCliStore.getState().setAuthError(null);
+      useCliStore.getState().setAuthMode("byok_key");
+      return null;
+    }
+    return await startVoiceDictation(callbacks);
+  }, [setStaticMessages, setActiveMessages]);
   return {
+    onStartVoice: handleStartVoice,
     currentPlannedPrompt,
     setCurrentPlannedPrompt,
     currentPlanText,
@@ -274932,6 +276580,8 @@ If it doesn't open automatically, please click here:
     setSettingsSteeringMode,
     settingsFollowUpMode,
     setSettingsFollowUpMode,
+    settingsBrowserVisible,
+    setSettingsBrowserVisible,
     handleSubmit,
     sessionRepository,
     handleSettingsMainSelect,
@@ -275008,7 +276658,7 @@ var init_use_agent_session = __esm(async () => {
 
 // src/index.ts
 init_package();
-import path38 from "node:path";
+import path41 from "node:path";
 
 // src/args.ts
 import { parseArgs } from "node:util";
@@ -275146,12 +276796,11 @@ Options:
 }
 // src/constants/release-highlights.json
 var release_highlights_default = {
-  version: "0.4.4",
-  title: "What's New in v0.4.4",
+  version: "0.4.5",
+  title: "What's New in v0.4.5",
   bullets: [
-    "*(agent)* Passive workspace memory ingestion and manage_memory tool",
-    "*(agent)* Lsp client integration for definition and reference navigation",
-    "*(tools)* Prefer non-import lines when resolving symbol definition in code_intelligence"
+    "*(cli,tui)* Add voice input dictation and workspace trust verification",
+    "*(tools,cli)* Interactive cdp browser engine and browser_action tool (#506, #509)"
   ],
   url: "https://trydecember.com/docs/changelog"
 };
@@ -275161,6 +276810,7 @@ init_env_sanitizer();
 init_env_sanitizer();
 init_commands();
 init_headless_runner();
+init_workspace_trust();
 purgeProjectEnvApiKeys();
 async function readPipedStdin() {
   if (process.stdin.isTTY)
@@ -275279,6 +276929,11 @@ To define project-specific instructions, create an AGENTS.md file in your projec
     }
     parsedArgs.prompt = question;
   }
+  await Promise.resolve().then(() => init_workspace_trust());
+  await ensureWorkspaceTrust({
+    targetDir: parsedArgs.scope,
+    isHeadless: Boolean(parsedArgs.prompt)
+  });
   if (parsedArgs.prompt) {
     const [
       { AgentHarness },
@@ -275352,7 +277007,7 @@ To define project-specific instructions, create an AGENTS.md file in your projec
       sessionRepository,
       sessionId,
       runtime: "cli",
-      workspaceDir: parsedArgs.scope ? path38.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
+      workspaceDir: parsedArgs.scope ? path41.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
       thinkingLevel: config.thinkingLevel || "auto",
       steeringMode: config.steeringMode || "all",
       followUpMode: config.followUpMode || "all"
@@ -275456,7 +277111,7 @@ Executing Headless Task: "${parsedArgs.prompt}"
     sessionRepository,
     sessionId,
     runtime: "cli",
-    workspaceDir: parsedArgs.scope ? path38.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
+    workspaceDir: parsedArgs.scope ? path41.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
     thinkingLevel: config.thinkingLevel || "auto",
     steeringMode: config.steeringMode || "all",
     followUpMode: config.followUpMode || "all"
@@ -275541,6 +277196,8 @@ Executing Headless Task: "${parsedArgs.prompt}"
 }
 main().catch(console.error);
 export {
+  addTrustedWorkspace,
+  ensureWorkspaceTrust,
   getHelpText,
   handleAuthCommand,
   handleDoctorCommand,
@@ -275550,9 +277207,11 @@ export {
   handleLogoutCommand,
   handleSwitchCommand,
   handleUpdateCommand,
+  isWorkspaceTrusted,
   parseCliArgs,
   purgeProjectEnvApiKeys,
   readPipedStdin,
+  resolveWorkspaceRoot,
   restoreConsole,
   runHeadlessTask,
   suppressConsole