@zonease/happy 0.6.38 → 0.6.40

package/dist/{runGemini-CVp-CEIh.cjs → runGemini-Xz2W1spn.cjs}

@@ -3,52 +3,69 @@
 var ink = require('ink');
 var React = require('react');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-DvTsFaqR.cjs');
-var loadableToolOutput = require('./loadableToolOutput-5vdQB98M.cjs');
-var index = require('./index-BbCDDvoB.cjs');
+var api = require('./api-C7FyJfZ1.cjs');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var loadableToolOutput = require('./loadableToolOutput-CbLGtvST.cjs');
+var run = require('./run-CURx7LhK.cjs');
+var downloadImage = require('./downloadImage-cQ1Z7hkC.cjs');
+var controlClient = require('./controlClient-B23M-WPp.cjs');
 var node_child_process = require('node:child_process');
 var sdk = require('@agentclientprotocol/sdk');
-var constants = require('./constants-B4x1K7by.cjs');
-var config = require('./config-0Xnc8ARM.cjs');
+var time = require('./time-Bj2HRkKH.cjs');
+var index = require('./index-CDTNgfUf.cjs');
+var constants = require('./constants-E_UWYTo3.cjs');
+var config = require('./config-CclB3QW9.cjs');
+var formatImageMessage = require('./formatImageMessage-CixDYY6G.cjs');
 require('axios');
-require('chalk');
-require('fs');
-require('node:fs');
-require('node:os');
-require('node:path');
 require('node:events');
 require('socket.io-client');
 require('zod');
-require('@paralleldrive/cuid2');
-require('tweetnacl');
+require('node:fs');
+require('node:path');
 require('node:fs/promises');
+require('node:os');
 require('node:util');
 require('child_process');
 require('util');
 require('fs/promises');
 require('path');
+require('./projectPath-ChLhdOyt.cjs');
 require('url');
 require('node:module');
 require('ws');
 require('crypto');
+require('tweetnacl');
 require('@stablelib/base64');
 require('node:readline');
 require('expo-server-sdk');
-require('./mcpToolSchemas-f-kttjFw.cjs');
-require('node:url');
-require('ps-list');
-require('cross-spawn');
+require('./sessionKeyCache-CDmexJ9p.cjs');
+require('chalk');
+require('fs');
 require('os');
 require('tmp');
+require('./auth-C7ZScWEw.cjs');
 require('qrcode-terminal');
+require('./browser-DzgO4oaD.cjs');
 require('open');
+require('./doctor-BQGLhrcI.cjs');
+require('./doctor-C08m5Z9f.cjs');
+require('ps-list');
+require('cross-spawn');
+require('./spawnHappyCLI-KiazE3kL.cjs');
+require('./deviceKeys-C540DcXl.cjs');
+require('./install-DSDufaPd.cjs');
+require('./trimIdent-4gvk9Wk6.cjs');
 require('fastify');
 require('fastify-type-provider-zod');
+require('./common-CZvSRU4p.cjs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('node:http');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 require('@modelcontextprotocol/sdk/types.js');
-require('http');
+require('./prompt-BTWDZZO0.cjs');
+require('./mcpToolSchemas-DK42yoZ_.cjs');
+require('./types-DWeB7aqh.cjs');
+require('@paralleldrive/cuid2');
 
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */
@@ -229,7 +246,7 @@ class GeminiTransport {
       const errorMessage = {
         type: "status",
         status: "error",
-        detail: `Model not found. Available models: ${persistence.GEMINI_MODEL_MODES.join(", ")}`
+        detail: `Model not found. Available models: ${index.GEMINI_MODEL_MODES.join(", ")}`
       };
       return { message: errorMessage };
     }
@@ -337,7 +354,7 @@ class GeminiTransport {
     }
     if (toolName === "other" || toolName === "Unknown tool") {
       const inputKeys = input && typeof input === "object" ? Object.keys(input) : [];
-      persistence.logger.debug(
+      logger.logger.debug(
         `[GeminiTransport] Unknown tool pattern - toolCallId: "${toolCallId}", toolName: "${toolName}", inputKeys: [${inputKeys.join(", ")}]. Consider adding a new pattern to GEMINI_TOOL_PATTERNS if this tool appears frequently.`
       );
     }
@@ -361,7 +378,7 @@ function nodeToWebStreams(stdin, stdout) {
       return new Promise((resolve, reject) => {
         const ok = stdin.write(chunk, (err) => {
           if (err) {
-            persistence.logger.debug(`[AcpBackend] Error writing to stdin:`, err);
+            logger.logger.debug(`[AcpBackend] Error writing to stdin:`, err);
             reject(err);
           }
         });
@@ -390,7 +407,7 @@ function nodeToWebStreams(stdin, stdout) {
         controller.close();
       });
       stdout.on("error", (err) => {
-        persistence.logger.debug(`[AcpBackend] Stdout error:`, err);
+        logger.logger.debug(`[AcpBackend] Stdout error:`, err);
         controller.error(err);
       });
     },
@@ -413,9 +430,9 @@ async function withRetry(operation, options) {
           options.baseDelayMs * Math.pow(2, attempt - 1),
           options.maxDelayMs
         );
-        persistence.logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
+        logger.logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
         options.onRetry?.(attempt, lastError);
-        await persistence.delay(delayMs);
+        await time.delay(delayMs);
       } else {
         break;
       }
@@ -467,7 +484,7 @@ class AcpBackend {
       try {
         listener(msg);
       } catch (error) {
-        persistence.logger.warn("[AcpBackend] Error in message handler:", error);
+        logger.logger.warn("[AcpBackend] Error in message handler:", error);
       }
     }
   }
@@ -479,7 +496,7 @@ class AcpBackend {
     this.emit({ type: "status", status: "starting" });
     let startupStatusErrorEmitted = false;
     try {
-      persistence.logger.debug(`[AcpBackend] Starting session: ${sessionId}`);
+      logger.logger.debug(`[AcpBackend] Starting session: ${sessionId}`);
       const args = this.options.args || [];
       if (process.platform === "win32") {
         const fullCommand = [this.options.command, ...args].join(" ");
@@ -528,9 +545,9 @@ class AcpBackend {
           hasActiveInvestigation
         };
         if (hasActiveInvestigation) {
-          persistence.logger.debug(`[AcpBackend] \u{1F50D} Agent stderr (during investigation): ${text.trim()}`);
+          logger.logger.debug(`[AcpBackend] \u{1F50D} Agent stderr (during investigation): ${text.trim()}`);
         } else {
-          persistence.logger.debug(`[AcpBackend] Agent stderr: ${text.trim()}`);
+          logger.logger.debug(`[AcpBackend] Agent stderr: ${text.trim()}`);
         }
         if (this.transport.handleStderr) {
           const result = this.transport.handleStderr(text, context);
@@ -541,14 +558,14 @@ class AcpBackend {
       });
       this.process.on("error", (err) => {
         signalStartupFailure(err);
-        persistence.logger.debug(`[AcpBackend] Process error:`, err);
+        logger.logger.debug(`[AcpBackend] Process error:`, err);
         startupStatusErrorEmitted = true;
         this.emit({ type: "status", status: "error", detail: err.message });
       });
       this.process.on("exit", (code, signal) => {
         if (!this.disposed && code !== 0 && code !== null) {
           signalStartupFailure(new Error(`Exit code: ${code}`));
-          persistence.logger.debug(`[AcpBackend] Process exited with code ${code}, signal ${signal}`);
+          logger.logger.debug(`[AcpBackend] Process exited with code ${code}, signal ${signal}`);
           this.emit({ type: "status", status: "stopped", detail: `Exit code: ${code}` });
         }
       });
@@ -581,7 +598,7 @@ class AcpBackend {
                   }
                 }
                 if (filteredCount > 0) {
-                  persistence.logger.debug(`[AcpBackend] Filtered out ${filteredCount} non-JSON lines from ${transport.agentName} stdout`);
+                  logger.logger.debug(`[AcpBackend] Filtered out ${filteredCount} non-JSON lines from ${transport.agentName} stdout`);
                 }
                 controller.close();
                 break;
@@ -602,7 +619,7 @@ class AcpBackend {
               }
             }
           } catch (error) {
-            persistence.logger.debug(`[AcpBackend] Error filtering stdout stream:`, error);
+            logger.logger.debug(`[AcpBackend] Error filtering stdout stream:`, error);
             controller.error(error);
           } finally {
             reader.releaseLock();
@@ -650,19 +667,19 @@ class AcpBackend {
           toolName = this.transport.determineToolName?.(toolName, toolCallId, input, context) ?? toolName;
           const originalToolName = toolCall?.toolName || rawKind || extendedParams.kind || "Unknown tool";
           if (toolName !== originalToolName) {
-            persistence.logger.debug(`[AcpBackend] Detected tool name: ${toolName} from toolCallId: ${toolCallId}`);
+            logger.logger.debug(`[AcpBackend] Detected tool name: ${toolName} from toolCallId: ${toolCallId}`);
           }
           if (this.options.normalizeToolName) {
             const normalized = this.options.normalizeToolName(toolName);
             if (normalized !== toolName) {
-              persistence.logger.debug(`[AcpBackend] Normalized tool name: ${toolName} \u2192 ${normalized}`);
+              logger.logger.debug(`[AcpBackend] Normalized tool name: ${toolName} \u2192 ${normalized}`);
               toolName = normalized;
             }
           }
           this.toolCallCountSincePrompt++;
           const options = extendedParams.options || [];
-          persistence.logger.debug(`[AcpBackend] Permission request: tool=${toolName}, toolCallId=${toolCallId}, input=`, JSON.stringify(input));
-          persistence.logger.debug(`[AcpBackend] Permission request params structure:`, JSON.stringify({
+          logger.logger.debug(`[AcpBackend] Permission request: tool=${toolName}, toolCallId=${toolCallId}, input=`, JSON.stringify(input));
+          logger.logger.debug(`[AcpBackend] Permission request params structure:`, JSON.stringify({
             hasToolCall: !!toolCall,
             toolCallKind: toolCall?.kind,
             toolCallId: toolCall?.toolCallId || toolCall?.id,
@@ -732,7 +749,7 @@ class AcpBackend {
               }
               return { outcome: { outcome: "selected", optionId } };
             } catch (error) {
-              persistence.logger.debug("[AcpBackend] Error in permission handler:", error);
+              logger.logger.debug("[AcpBackend] Error in permission handler:", error);
               return { outcome: { outcome: "selected", optionId: "cancel" } };
             }
           }
@@ -757,11 +774,11 @@ class AcpBackend {
         },
         clientInfo: {
           name: "happy-cli",
-          version: persistence.packageJson.version
+          version: logger.packageJson.version
         }
       };
       const initTimeout = this.transport.getInitTimeout();
-      persistence.logger.debug(`[AcpBackend] Initializing connection (timeout: ${initTimeout}ms)...`);
+      logger.logger.debug(`[AcpBackend] Initializing connection (timeout: ${initTimeout}ms)...`);
       const isNonRetryableStartupError = (error) => {
         const maybeErr = error;
         if (startupFailure && error === startupFailure) {
@@ -803,7 +820,7 @@ class AcpBackend {
           shouldRetry: (error) => !isNonRetryableStartupError(error)
         }
       );
-      persistence.logger.debug(`[AcpBackend] Initialize completed`);
+      logger.logger.debug(`[AcpBackend] Initialize completed`);
       const mcpServers = this.options.mcpServers ? Object.entries(this.options.mcpServers).map(([name, config]) => {
         if ("type" in config && config.type === "http") {
           return {
@@ -825,7 +842,7 @@ class AcpBackend {
         cwd: this.options.cwd,
         mcpServers
       };
-      persistence.logger.debug(`[AcpBackend] Creating new session...`);
+      logger.logger.debug(`[AcpBackend] Creating new session...`);
       const sessionResponse = await withRetry(
         async () => {
           let timeoutHandle = null;
@@ -861,7 +878,7 @@ class AcpBackend {
         }
       );
       this.acpSessionId = sessionResponse.sessionId;
-      persistence.logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
+      logger.logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
       this.emitInitialSessionMetadata(sessionResponse);
       this.emitIdleStatus();
       if (initialPrompt) {
@@ -869,19 +886,19 @@ class AcpBackend {
         const mcpDelay = hasHttpMcp ? MCP_DISCOVERY_DELAY_MS : 0;
         const sendInitialPrompt = async () => {
           if (mcpDelay > 0) {
-            persistence.logger.debug(`[AcpBackend] Waiting ${mcpDelay}ms for MCP discovery before first prompt`);
+            logger.logger.debug(`[AcpBackend] Waiting ${mcpDelay}ms for MCP discovery before first prompt`);
             await new Promise((r) => setTimeout(r, mcpDelay));
           }
           await this.sendPrompt(sessionId, initialPrompt);
         };
         sendInitialPrompt().catch((error) => {
-          persistence.logger.debug("[AcpBackend] Error sending initial prompt:", error);
+          logger.logger.debug("[AcpBackend] Error sending initial prompt:", error);
           this.emit({ type: "status", status: "error", detail: String(error) });
         });
       }
       return { sessionId };
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Error starting session:", error);
+      logger.logger.debug("[AcpBackend] Error starting session:", error);
       if (!startupStatusErrorEmitted) {
         this.emit({
           type: "status",
@@ -952,13 +969,13 @@ class AcpBackend {
     const notification = params;
     const update = notification.update;
     if (!update) {
-      persistence.logger.debug("[AcpBackend] Received session update without update field:", params);
+      logger.logger.debug("[AcpBackend] Received session update without update field:", params);
       return;
     }
     const sessionUpdateType = update.sessionUpdate;
     const updateType = sessionUpdateType;
     if (sessionUpdateType !== "agent_message_chunk") {
-      persistence.logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
+      logger.logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
         sessionUpdate: sessionUpdateType,
         toolCallId: update.toolCallId,
         status: update.status,
@@ -1036,7 +1053,7 @@ class AcpBackend {
       "current_mode_update"
     ];
     if (updateType && !handledTypes.includes(updateType) && !update.messageChunk && !update.plan && !update.thinking) {
-      persistence.logger.debug(`[AcpBackend] Unhandled session update type: ${updateType}`, JSON.stringify(update, null, 2));
+      logger.logger.debug(`[AcpBackend] Unhandled session update type: ${updateType}`, JSON.stringify(update, null, 2));
     }
   }
   // Promise resolver for waitForIdle - set when waiting for response to complete
@@ -1047,7 +1064,7 @@ class AcpBackend {
     this.toolCallCountSincePrompt = 0;
     this.recentPromptHadChangeTitle = promptHasChangeTitle;
     if (promptHasChangeTitle) {
-      persistence.logger.debug('[AcpBackend] Prompt contains change_title instruction - will auto-approve first "other" tool call if it matches pattern');
+      logger.logger.debug('[AcpBackend] Prompt contains change_title instruction - will auto-approve first "other" tool call if it matches pattern');
     }
     if (this.disposed) {
       throw new Error("Backend has been disposed");
@@ -1058,11 +1075,11 @@ class AcpBackend {
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
     try {
-      persistence.logger.debug(`[AcpBackend] Sending prompt (length: ${prompt.length}): ${prompt.substring(0, 100)}...`);
-      persistence.logger.debug(`[AcpBackend] Full prompt: ${prompt}`);
+      logger.logger.debug(`[AcpBackend] Sending prompt (length: ${prompt.length}): ${prompt.substring(0, 100)}...`);
+      logger.logger.debug(`[AcpBackend] Full prompt: ${prompt}`);
       const contentBlocks = [];
       if (options?.images && options.images.length > 0) {
-        persistence.logger.debug(`[AcpBackend] Including ${options.images.length} image(s) in prompt`);
+        logger.logger.debug(`[AcpBackend] Including ${options.images.length} image(s) in prompt`);
         for (const image of options.images) {
           contentBlocks.push({
             type: "image",
@@ -1079,11 +1096,11 @@ class AcpBackend {
         sessionId: this.acpSessionId,
         prompt: contentBlocks
       };
-      persistence.logger.debug(`[AcpBackend] Prompt request:`, JSON.stringify(promptRequest, null, 2).substring(0, 1e3));
+      logger.logger.debug(`[AcpBackend] Prompt request:`, JSON.stringify(promptRequest, null, 2).substring(0, 1e3));
       await this.connection.prompt(promptRequest);
-      persistence.logger.debug("[AcpBackend] Prompt request sent to ACP connection");
+      logger.logger.debug("[AcpBackend] Prompt request sent to ACP connection");
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Error sending prompt:", error);
+      logger.logger.debug("[AcpBackend] Error sending prompt:", error);
       this.waitingForResponse = false;
       let errorDetail;
       if (error instanceof Error) {
@@ -1154,7 +1171,7 @@ class AcpBackend {
       }
       return true;
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Failed to set session config option:", {
+      logger.logger.debug("[AcpBackend] Failed to set session config option:", {
         configId,
         value,
         error
@@ -1182,7 +1199,7 @@ class AcpBackend {
       });
       return true;
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Failed to set session mode:", { modeId, error });
+      logger.logger.debug("[AcpBackend] Failed to set session mode:", { modeId, error });
       return false;
     }
   }
@@ -1204,7 +1221,7 @@ class AcpBackend {
       });
       return true;
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Failed to set session model:", { modelId, error });
+      logger.logger.debug("[AcpBackend] Failed to set session model:", { modelId, error });
       return false;
     }
   }
@@ -1214,7 +1231,7 @@ class AcpBackend {
   emitIdleStatus() {
     this.emit({ type: "status", status: "idle" });
     if (this.idleResolver) {
-      persistence.logger.debug("[AcpBackend] Resolving idle waiter");
+      logger.logger.debug("[AcpBackend] Resolving idle waiter");
       this.idleResolver();
     }
   }
@@ -1226,11 +1243,11 @@ class AcpBackend {
       await this.connection.cancel({ sessionId: this.acpSessionId });
       this.emit({ type: "status", status: "stopped", detail: "Cancelled by user" });
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Error cancelling:", error);
+      logger.logger.debug("[AcpBackend] Error cancelling:", error);
     }
     this.waitingForResponse = false;
     if (this.idleResolver) {
-      persistence.logger.debug("[AcpBackend] Resolving idle waiter after cancel");
+      logger.logger.debug("[AcpBackend] Resolving idle waiter after cancel");
       this.idleResolver();
     }
   }
@@ -1250,12 +1267,12 @@ class AcpBackend {
    * @param approved - Whether the permission was granted
    */
   async respondToPermission(requestId, approved) {
-    persistence.logger.debug(`[AcpBackend] Permission response event (UI only): ${requestId} = ${approved}`);
+    logger.logger.debug(`[AcpBackend] Permission response event (UI only): ${requestId} = ${approved}`);
     this.emit({ type: "permission-response", id: requestId, approved });
   }
   async dispose() {
     if (this.disposed) return;
-    persistence.logger.debug("[AcpBackend] Disposing backend");
+    logger.logger.debug("[AcpBackend] Disposing backend");
     this.disposed = true;
     if (this.connection && this.acpSessionId) {
       try {
@@ -1265,7 +1282,7 @@ class AcpBackend {
           // 2s timeout for graceful shutdown
         ]);
       } catch (error) {
-        persistence.logger.debug("[AcpBackend] Error during graceful shutdown:", error);
+        logger.logger.debug("[AcpBackend] Error during graceful shutdown:", error);
       }
     }
     if (this.process) {
@@ -1273,7 +1290,7 @@ class AcpBackend {
       await new Promise((resolve) => {
         const timeout = setTimeout(() => {
           if (this.process) {
-            persistence.logger.debug("[AcpBackend] Force killing process");
+            logger.logger.debug("[AcpBackend] Force killing process");
             this.process.kill("SIGKILL");
           }
           resolve();
@@ -1306,7 +1323,7 @@ function createGeminiBackend(options) {
   const localConfig = config.readGeminiLocalConfig();
   let apiKey = options.cloudToken || localConfig.token || process.env[constants.GEMINI_API_KEY_ENV] || process.env[constants.GOOGLE_API_KEY_ENV] || options.apiKey;
   if (!apiKey) {
-    persistence.logger.warn(`[Gemini] No API key found. Run 'happy connect gemini' to authenticate via Google OAuth, or set ${constants.GEMINI_API_KEY_ENV} environment variable.`);
+    logger.logger.warn(`[Gemini] No API key found. Run 'happy connect gemini' to authenticate via Google OAuth, or set ${constants.GEMINI_API_KEY_ENV} environment variable.`);
   }
   const geminiCommand = "gemini";
   const model = config.determineGeminiModel(options.model, localConfig);
@@ -1317,9 +1334,9 @@ function createGeminiBackend(options) {
     const currentEmail = options.currentUserEmail;
     if (!storedEmail || storedEmail === currentEmail) {
       googleCloudProject = localConfig.googleCloudProject;
-      persistence.logger.debug(`[Gemini] Using Google Cloud Project: ${googleCloudProject}${storedEmail ? ` (for ${storedEmail})` : " (global)"}`);
+      logger.logger.debug(`[Gemini] Using Google Cloud Project: ${googleCloudProject}${storedEmail ? ` (for ${storedEmail})` : " (global)"}`);
     } else {
-      persistence.logger.debug(`[Gemini] Skipping stored Google Cloud Project (stored for ${storedEmail}, current user is ${currentEmail || "unknown"})`);
+      logger.logger.debug(`[Gemini] Skipping stored Google Cloud Project (stored for ${storedEmail}, current user is ${currentEmail || "unknown"})`);
     }
   }
   const backendOptions = {
@@ -1352,7 +1369,7 @@ function createGeminiBackend(options) {
     }
   };
   const modelSource = config.getGeminiModelSource(options.model, localConfig);
-  persistence.logger.debug("[Gemini] Creating ACP SDK backend with options:", {
+  logger.logger.debug("[Gemini] Creating ACP SDK backend with options:", {
     cwd: backendOptions.cwd,
     command: backendOptions.command,
     args: backendOptions.args,
@@ -1507,7 +1524,7 @@ const GeminiDisplay = ({ messageBuffer, logPath, currentModel, onExit }) => {
       alignItems: "center",
       flexDirection: "column"
     },
-    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "cyan", bold: true }, "\u2728 Gemini Agent Running \u2022 Ctrl-C to exit"), model && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Model: ", model)), persistence.isDebug() && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "cyan", bold: true }, "\u2728 Gemini Agent Running \u2022 Ctrl-C to exit"), model && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Model: ", model)), logger.isDebug() && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
   ));
 };
 
@@ -1534,7 +1551,7 @@ class GeminiPermissionHandler extends loadableToolOutput.BasePermissionHandler {
    */
   setPermissionMode(mode) {
     this.currentPermissionMode = mode;
-    persistence.logger.debug(`${this.getLogPrefix()} Permission mode set to: ${mode}`);
+    logger.logger.debug(`${this.getLogPrefix()} Permission mode set to: ${mode}`);
   }
   /**
    * Check if a tool should be auto-approved based on permission mode
@@ -1571,7 +1588,7 @@ class GeminiPermissionHandler extends loadableToolOutput.BasePermissionHandler {
    */
   async handleToolCall(toolCallId, toolName, input) {
     if (this.shouldAutoApprove(toolName, toolCallId, input)) {
-      persistence.logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
+      logger.logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
       return {
         decision: this.currentPermissionMode === "yolo" ? "approved_for_session" : "approved"
       };
@@ -1584,7 +1601,7 @@ class GeminiPermissionHandler extends loadableToolOutput.BasePermissionHandler {
         input
       });
       this.addPendingRequestToState(toolCallId, toolName, input);
-      persistence.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
+      logger.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
     });
   }
 }
@@ -1666,7 +1683,7 @@ class GeminiDiffProcessor {
    * Process an fs-edit event and check if it contains diff information
    */
   processFsEdit(path, description, diff) {
-    persistence.logger.debug(`[GeminiDiffProcessor] Processing fs-edit for path: ${path}`);
+    logger.logger.debug(`[GeminiDiffProcessor] Processing fs-edit for path: ${path}`);
     if (diff) {
       this.processDiff(path, diff, description);
     } else {
@@ -1681,7 +1698,7 @@ class GeminiDiffProcessor {
       const diff = result.diff || result.unified_diff || result.patch;
       const path = result.path || result.file;
       if (diff && path) {
-        persistence.logger.debug(`[GeminiDiffProcessor] Found diff in tool result: ${toolName} (${callId})`);
+        logger.logger.debug(`[GeminiDiffProcessor] Found diff in tool result: ${toolName} (${callId})`);
         this.processDiff(path, diff, result.description);
       } else if (result.changes && typeof result.changes === "object") {
         for (const [filePath, change] of Object.entries(result.changes)) {
@@ -1697,7 +1714,7 @@ class GeminiDiffProcessor {
   processDiff(path, unifiedDiff, description) {
     const previousDiff = this.previousDiffs.get(path);
     if (previousDiff !== unifiedDiff) {
-      persistence.logger.debug(`[GeminiDiffProcessor] Unified diff changed for ${path}, sending GeminiDiff tool call`);
+      logger.logger.debug(`[GeminiDiffProcessor] Unified diff changed for ${path}, sending GeminiDiff tool call`);
       const { files, stats, fileStats } = summarizeUnifiedDiff(unifiedDiff);
       if (!files.includes(path) && path) {
         files.unshift(path);
@@ -1705,7 +1722,7 @@ class GeminiDiffProcessor {
       const callId = node_crypto.randomUUID();
       if (this.sessionId) {
         const uniqueFiles = [...new Set(files)];
-        persistence.saveDiffRecords(this.sessionId, uniqueFiles.map((fp) => ({
+        api.saveDiffRecords(this.sessionId, uniqueFiles.map((fp) => ({
           callId,
           agent: "gemini",
           filePath: fp,
@@ -1734,13 +1751,13 @@ class GeminiDiffProcessor {
       this.onMessage?.(toolResult);
     }
     this.previousDiffs.set(path, unifiedDiff);
-    persistence.logger.debug(`[GeminiDiffProcessor] Updated stored diff for ${path}`);
+    logger.logger.debug(`[GeminiDiffProcessor] Updated stored diff for ${path}`);
   }
   /**
    * Reset the processor state (called on task_complete or turn_aborted)
    */
   reset() {
-    persistence.logger.debug("[GeminiDiffProcessor] Resetting diff state");
+    logger.logger.debug("[GeminiDiffProcessor] Resetting diff state");
     this.previousDiffs.clear();
   }
   /**
@@ -1816,7 +1833,7 @@ class ConversationHistory {
     if (!content.trim()) return;
     const trimmedContent = content.trim();
     if (this.isDuplicate("user", trimmedContent)) {
-      persistence.logger.debug(`[ConversationHistory] Skipping duplicate user message (${trimmedContent.length} chars)`);
+      logger.logger.debug(`[ConversationHistory] Skipping duplicate user message (${trimmedContent.length} chars)`);
       return;
     }
     this.messages.push({
@@ -1825,7 +1842,7 @@ class ConversationHistory {
       timestamp: Date.now()
     });
     this.trimHistory();
-    persistence.logger.debug(`[ConversationHistory] Added user message (${trimmedContent.length} chars), total: ${this.messages.length}`);
+    logger.logger.debug(`[ConversationHistory] Added user message (${trimmedContent.length} chars), total: ${this.messages.length}`);
   }
   /**
    * Add an assistant response to history
@@ -1835,7 +1852,7 @@ class ConversationHistory {
     if (!content.trim()) return;
     const trimmedContent = content.trim();
     if (this.isDuplicate("assistant", trimmedContent)) {
-      persistence.logger.debug(`[ConversationHistory] Skipping duplicate assistant message (${trimmedContent.length} chars)`);
+      logger.logger.debug(`[ConversationHistory] Skipping duplicate assistant message (${trimmedContent.length} chars)`);
       return;
     }
     this.messages.push({
@@ -1845,7 +1862,7 @@ class ConversationHistory {
       model: this.currentModel
     });
     this.trimHistory();
-    persistence.logger.debug(`[ConversationHistory] Added assistant message (${trimmedContent.length} chars), total: ${this.messages.length}`);
+    logger.logger.debug(`[ConversationHistory] Added assistant message (${trimmedContent.length} chars), total: ${this.messages.length}`);
   }
   /**
    * Get the number of messages in history
@@ -1864,7 +1881,7 @@ class ConversationHistory {
    */
   clear() {
     this.messages = [];
-    persistence.logger.debug("[ConversationHistory] History cleared");
+    logger.logger.debug("[ConversationHistory] History cleared");
   }
   /**
    * Get formatted context for injecting into a new session.
@@ -2030,10 +2047,10 @@ async function backfillGeminiSessionHistory(opts) {
   const maxMessages = opts.maxMessages ?? 200;
   const maxUserMessages = opts.maxUserMessages ?? 20;
   const maxBytes = opts.maxBytes ?? 3 * 1024 * 1024;
-  const allLines = await persistence.readGeminiSessionLog(opts.sessionId);
+  const allLines = await api.readGeminiSessionLog(opts.sessionId);
   const conversationLines = allLines.filter(isConversationLine);
   if (conversationLines.length === 0) {
-    persistence.logger.debug("[GEMINI-BACKFILL] No messages to backfill");
+    logger.logger.debug("[GEMINI-BACKFILL] No messages to backfill");
     return;
   }
   const selected = [];
@@ -2060,7 +2077,7 @@ async function backfillGeminiSessionHistory(opts) {
       callIdToName.set(line.callId, line.name);
     }
   }
-  persistence.logger.debug(`[GEMINI-BACKFILL] Backfilling ${selected.length} messages (users: ${userCount}, total: ${totalCount}, bytes: ${totalBytes})`);
+  logger.logger.debug(`[GEMINI-BACKFILL] Backfilling ${selected.length} messages (users: ${userCount}, total: ${totalCount}, bytes: ${totalBytes})`);
   const batch = [];
   for (const line of selected) {
     const content = buildMessageContent(line, callIdToName);
@@ -2075,26 +2092,26 @@ async function backfillGeminiSessionHistory(opts) {
 
 async function runGemini(opts) {
   const sessionTag = node_crypto.randomUUID();
-  persistence.connectionState.setBackend("Gemini");
-  const api = await persistence.ApiClient.create(opts.credentials);
-  const settings = await persistence.readSettings();
+  api.connectionState.setBackend("Gemini");
+  const api$1 = await api.ApiClient.create(opts.credentials);
+  const settings = await logger.readSettings();
   const machineId = settings?.machineId;
   if (!machineId) {
     console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/ZonEaseTech/happy-wfs/issues`);
     process.exit(1);
   }
-  persistence.logger.debug(`Using machineId: ${machineId}`);
-  await api.getOrCreateMachine({
+  logger.logger.debug(`Using machineId: ${machineId}`);
+  await api$1.getOrCreateMachine({
     machineId,
-    metadata: index.initialMachineMetadata
+    metadata: run.initialMachineMetadata
   });
   let cloudToken = void 0;
   let currentUserEmail = void 0;
   try {
-    const vendorToken = await api.getVendorToken("gemini");
+    const vendorToken = await api$1.getVendorToken("gemini");
     if (vendorToken?.oauth?.access_token) {
       cloudToken = vendorToken.oauth.access_token;
-      persistence.logger.debug("[Gemini] Using OAuth token from Happy cloud");
+      logger.logger.debug("[Gemini] Using OAuth token from Happy cloud");
       if (vendorToken.oauth.id_token) {
         try {
           const parts = vendorToken.oauth.id_token.split(".");
@@ -2102,24 +2119,24 @@ async function runGemini(opts) {
             const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
             if (payload.email) {
               currentUserEmail = payload.email;
-              persistence.logger.debug(`[Gemini] Current user email: ${currentUserEmail}`);
+              logger.logger.debug(`[Gemini] Current user email: ${currentUserEmail}`);
             }
           }
         } catch {
-          persistence.logger.debug("[Gemini] Failed to decode id_token for email");
+          logger.logger.debug("[Gemini] Failed to decode id_token for email");
         }
       }
     }
   } catch (error) {
-    persistence.logger.debug("[Gemini] Failed to fetch cloud token:", error);
+    logger.logger.debug("[Gemini] Failed to fetch cloud token:", error);
   }
   const { state, metadata } = loadableToolOutput.createSessionMetadata({
     flavor: "gemini",
     machineId,
     startedBy: opts.startedBy
   });
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
-  const sessionWriter = new persistence.GeminiSessionWriter(response?.id || sessionTag);
+  const response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+  const sessionWriter = new api.GeminiSessionWriter(response?.id || sessionTag);
   await sessionWriter.init({ model: config.getInitialGeminiModel(), cwd: process.cwd() });
   let session;
   let permissionHandler;
@@ -2127,7 +2144,7 @@ async function runGemini(opts) {
   let pendingSessionSwap = null;
   const applyPendingSessionSwap = () => {
     if (pendingSessionSwap) {
-      persistence.logger.debug("[gemini] Applying pending session swap");
+      logger.logger.debug("[gemini] Applying pending session swap");
       session = pendingSessionSwap;
       if (permissionHandler) {
         permissionHandler.updateSession(pendingSessionSwap);
@@ -2136,14 +2153,14 @@ async function runGemini(opts) {
     }
   };
   const { session: initialSession, reconnectionHandle } = loadableToolOutput.setupOfflineReconnection({
-    api,
+    api: api$1,
     sessionTag,
     metadata,
     state,
     response,
     onSessionSwap: (newSession) => {
       if (isProcessingMessage) {
-        persistence.logger.debug("[gemini] Session swap requested during message processing - queueing");
+        logger.logger.debug("[gemini] Session swap requested during message processing - queueing");
         pendingSessionSwap = newSession;
       } else {
         session = newSession;
@@ -2166,18 +2183,18 @@ async function runGemini(opts) {
   }
   if (response) {
     try {
-      persistence.logger.debug(`[START] Reporting session ${response.id} to daemon`);
-      const result = await index.notifyDaemonSessionStarted(response.id, metadata);
+      logger.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+      const result = await controlClient.notifyDaemonSessionStarted(response.id, metadata);
       if (result.error) {
-        persistence.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+        logger.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
       } else {
-        persistence.logger.debug(`[START] Reported session ${response.id} to daemon`);
+        logger.logger.debug(`[START] Reported session ${response.id} to daemon`);
       }
     } catch (error) {
-      persistence.logger.debug("[START] Failed to report to daemon (may not be running):", error);
+      logger.logger.debug("[START] Failed to report to daemon (may not be running):", error);
     }
   }
-  const messageQueue = new index.MessageQueue2((mode) => index.hashObject({
+  const messageQueue = new downloadImage.MessageQueue2((mode) => downloadImage.hashObject({
     permissionMode: mode.permissionMode,
     model: mode.model
   }));
@@ -2218,12 +2235,12 @@ async function runGemini(opts) {
         messagePermissionMode = message.meta.permissionMode;
         currentPermissionMode = messagePermissionMode;
         updatePermissionMode(messagePermissionMode);
-        persistence.logger.debug(`[Gemini] Permission mode updated from user message to: ${currentPermissionMode}`);
+        logger.logger.debug(`[Gemini] Permission mode updated from user message to: ${currentPermissionMode}`);
       } else {
-        persistence.logger.debug(`[Gemini] Invalid permission mode received: ${message.meta.permissionMode}`);
+        logger.logger.debug(`[Gemini] Invalid permission mode received: ${message.meta.permissionMode}`);
       }
     } else {
-      persistence.logger.debug(`[Gemini] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
+      logger.logger.debug(`[Gemini] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
     }
     if (currentPermissionMode === void 0) {
       currentPermissionMode = "default";
@@ -2241,7 +2258,7 @@ async function runGemini(opts) {
         if (previousModel !== messageModel) {
           updateDisplayedModel(messageModel, true);
           messageBuffer.addMessage(`Model changed to: ${messageModel}`, "system");
-          persistence.logger.debug(`[Gemini] Model changed from ${previousModel} to ${messageModel}`);
+          logger.logger.debug(`[Gemini] Model changed from ${previousModel} to ${messageModel}`);
         }
       }
     }
@@ -2249,7 +2266,7 @@ async function runGemini(opts) {
     const originalUserMessage = message.content.text;
     const images = isMixedContent && "images" in message.content ? message.content.images : [];
     if (images.length > 0) {
-      persistence.logger.debug(`[Gemini] Received mixed message with ${images.length} image(s)`);
+      logger.logger.debug(`[Gemini] Received mixed message with ${images.length} image(s)`);
     }
     let fullPrompt = originalUserMessage;
     if (isFirstMessage) {
@@ -2281,13 +2298,13 @@ async function runGemini(opts) {
   const sendReady = () => {
     session.sendSessionEvent({ type: "ready" });
     try {
-      api.push().sendToAllDevices(
+      api$1.push().sendToAllDevices(
         "It's ready!",
         "Gemini is waiting for your command",
         { sessionId: session.sessionId }
       );
     } catch (pushError) {
-      persistence.logger.debug("[Gemini] Failed to send ready push", pushError);
+      logger.logger.debug("[Gemini] Failed to send ready push", pushError);
     }
     session.flush().finally(() => {
       session.updateAgentState((state2) => ({
@@ -2320,7 +2337,7 @@ async function runGemini(opts) {
   let acpSessionId = null;
   let wasSessionCreated = false;
   async function handleAbort() {
-    persistence.logger.debug("[Gemini] Abort requested - stopping current task");
+    logger.logger.debug("[Gemini] Abort requested - stopping current task");
     abortRequested = true;
     thinking = false;
     session.keepAlive(thinking, "remote");
@@ -2341,17 +2358,17 @@ async function runGemini(opts) {
       if (geminiBackend && acpSessionId) {
         await geminiBackend.cancel(acpSessionId);
       }
-      persistence.logger.debug("[Gemini] Abort completed - session remains active");
+      logger.logger.debug("[Gemini] Abort completed - session remains active");
     } catch (error) {
-      persistence.logger.debug("[Gemini] Error during abort:", error);
+      logger.logger.debug("[Gemini] Error during abort:", error);
     } finally {
       abortController = new AbortController();
     }
   }
   const handleKillSession = async () => {
-    persistence.logger.debug("[Gemini] Kill session requested - terminating process");
+    logger.logger.debug("[Gemini] Kill session requested - terminating process");
     await handleAbort();
-    persistence.logger.debug("[Gemini] Abort completed, proceeding with termination");
+    logger.logger.debug("[Gemini] Abort completed, proceeding with termination");
     try {
       if (session) {
         session.updateMetadata((currentMetadata) => ({
@@ -2365,43 +2382,43 @@ async function runGemini(opts) {
         await session.flush();
         await session.close();
       }
-      index.stopCaffeinate();
+      run.stopCaffeinate();
       mcp.stop();
       if (geminiBackend) {
         await geminiBackend.dispose();
       }
-      persistence.logger.debug("[Gemini] Session termination complete, exiting");
+      logger.logger.debug("[Gemini] Session termination complete, exiting");
       process.exit(0);
     } catch (error) {
-      persistence.logger.debug("[Gemini] Error during session termination:", error);
+      logger.logger.debug("[Gemini] Error during session termination:", error);
       process.exit(1);
     }
   };
   session.rpcHandlerManager.registerHandler("abort", handleAbort);
-  index.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
-  const messageBuffer = new index.MessageBuffer();
+  downloadImage.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
+  const messageBuffer = new downloadImage.MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   let inkInstance = null;
   let displayedModel = config.getInitialGeminiModel();
   const localConfig = config.readGeminiLocalConfig();
-  persistence.logger.debug(`[gemini] Initial model setup: env[GEMINI_MODEL_ENV]=${process.env[constants.GEMINI_MODEL_ENV] || "not set"}, localConfig=${localConfig.model || "not set"}, displayedModel=${displayedModel}`);
+  logger.logger.debug(`[gemini] Initial model setup: env[GEMINI_MODEL_ENV]=${process.env[constants.GEMINI_MODEL_ENV] || "not set"}, localConfig=${localConfig.model || "not set"}, displayedModel=${displayedModel}`);
   const updateDisplayedModel = (model, saveToConfig = false) => {
     if (model === void 0) {
-      persistence.logger.debug(`[gemini] updateDisplayedModel called with undefined, skipping update`);
+      logger.logger.debug(`[gemini] updateDisplayedModel called with undefined, skipping update`);
       return;
     }
     const oldModel = displayedModel;
     displayedModel = model;
-    persistence.logger.debug(`[gemini] updateDisplayedModel called: oldModel=${oldModel}, newModel=${model}, saveToConfig=${saveToConfig}`);
+    logger.logger.debug(`[gemini] updateDisplayedModel called: oldModel=${oldModel}, newModel=${model}, saveToConfig=${saveToConfig}`);
     syncSessionModel(model);
     if (saveToConfig) {
       config.saveGeminiModelToConfig(model);
     }
     if (hasTTY && oldModel !== model) {
-      persistence.logger.debug(`[gemini] Adding model update message to buffer: [MODEL:${model}]`);
+      logger.logger.debug(`[gemini] Adding model update message to buffer: [MODEL:${model}]`);
       messageBuffer.addMessage(`[MODEL:${model}]`, "system");
     } else if (hasTTY) {
-      persistence.logger.debug(`[gemini] Model unchanged, skipping update message`);
+      logger.logger.debug(`[gemini] Model unchanged, skipping update message`);
     }
   };
   if (hasTTY) {
@@ -2410,10 +2427,10 @@ async function runGemini(opts) {
       const currentModelValue = displayedModel || "gemini-2.5-pro";
       return React.createElement(GeminiDisplay, {
         messageBuffer,
-        logPath: persistence.isDebug() ? persistence.logger.getLogPath() : void 0,
+        logPath: logger.isDebug() ? logger.logger.getLogPath() : void 0,
         currentModel: currentModelValue,
         onExit: async () => {
-          persistence.logger.debug("[gemini]: Exiting agent via Ctrl-C");
+          logger.logger.debug("[gemini]: Exiting agent via Ctrl-C");
           shouldExit = true;
           await handleAbort();
         }
@@ -2424,7 +2441,7 @@ async function runGemini(opts) {
       patchConsole: false
     });
     const initialModelName = displayedModel || "gemini-2.5-pro";
-    persistence.logger.debug(`[gemini] Sending initial model to UI: ${initialModelName}`);
+    logger.logger.debug(`[gemini] Sending initial model to UI: ${initialModelName}`);
     messageBuffer.addMessage(`[MODEL:${initialModelName}]`, "system");
   }
   if (hasTTY) {
@@ -2434,9 +2451,9 @@ async function runGemini(opts) {
     }
     process.stdin.setEncoding("utf8");
   }
-  const mcp = await index.createMcpContext(session);
+  const mcp = await downloadImage.createMcpContext(session);
   const mcpServers = mcp.configForHttp();
-  permissionHandler = new GeminiPermissionHandler(session, api.push());
+  permissionHandler = new GeminiPermissionHandler(session, api$1.push());
   const reasoningProcessor = new GeminiReasoningProcessor((message) => {
     session.sendAgentMessage("gemini", message);
   });
@@ -2453,12 +2470,12 @@ async function runGemini(opts) {
     async (payload) => {
       const mode = payload?.mode;
       if (!mode || !validPermissionModes.includes(mode)) {
-        persistence.logger.debug("[gemini] Invalid permission mode via rpc", { mode });
+        logger.logger.debug("[gemini] Invalid permission mode via rpc", { mode });
         return false;
       }
       currentPermissionMode = mode;
       updatePermissionMode(mode);
-      persistence.logger.debug(`[gemini] Permission mode updated via rpc to ${mode}`);
+      logger.logger.debug(`[gemini] Permission mode updated via rpc to ${mode}`);
       return true;
     }
   );
@@ -2477,19 +2494,19 @@ async function runGemini(opts) {
               messageBuffer.removeLastMessage("system");
               messageBuffer.addMessage(msg.textDelta, "assistant");
               isResponseInProgress = true;
-              persistence.logger.debug(`[gemini] Started new response, first chunk length: ${msg.textDelta.length}`);
+              logger.logger.debug(`[gemini] Started new response, first chunk length: ${msg.textDelta.length}`);
             } else {
               messageBuffer.updateLastMessage(msg.textDelta, "assistant");
-              persistence.logger.debug(`[gemini] Updated response, chunk length: ${msg.textDelta.length}, total accumulated: ${accumulatedResponse.length + msg.textDelta.length}`);
+              logger.logger.debug(`[gemini] Updated response, chunk length: ${msg.textDelta.length}, total accumulated: ${accumulatedResponse.length + msg.textDelta.length}`);
             }
             accumulatedResponse += msg.textDelta;
           }
           break;
         case "status":
           const statusDetail = msg.detail ? typeof msg.detail === "object" ? JSON.stringify(msg.detail) : String(msg.detail) : "";
-          persistence.logger.debug(`[gemini] Status changed: ${msg.status}${statusDetail ? ` - ${statusDetail}` : ""}`);
+          logger.logger.debug(`[gemini] Status changed: ${msg.status}${statusDetail ? ` - ${statusDetail}` : ""}`);
           if (msg.status === "error") {
-            persistence.logger.debug(`[gemini] \u26A0\uFE0F Error status received: ${statusDetail || "Unknown error"}`);
+            logger.logger.debug(`[gemini] \u26A0\uFE0F Error status received: ${statusDetail || "Unknown error"}`);
             if (abortRequested && !abortFeedbackSent) {
               abortFeedbackSent = true;
               session.sendAgentMessage("gemini", {
@@ -2542,9 +2559,9 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           hadToolCallInTurn = true;
           const toolArgs = msg.args ? JSON.stringify(msg.args).substring(0, 100) : "";
           const isInvestigationTool = msg.toolName === "codebase_investigator" || typeof msg.toolName === "string" && msg.toolName.includes("investigator");
-          persistence.logger.debug(`[gemini] \u{1F527} Tool call received: ${msg.toolName} (${msg.callId})${isInvestigationTool ? " [INVESTIGATION]" : ""}`);
+          logger.logger.debug(`[gemini] \u{1F527} Tool call received: ${msg.toolName} (${msg.callId})${isInvestigationTool ? " [INVESTIGATION]" : ""}`);
           if (isInvestigationTool && msg.args && typeof msg.args === "object" && "objective" in msg.args) {
-            persistence.logger.debug(`[gemini] \u{1F50D} Investigation objective: ${String(msg.args.objective).substring(0, 150)}...`);
+            logger.logger.debug(`[gemini] \u{1F50D} Investigation objective: ${String(msg.args.objective).substring(0, 150)}...`);
           }
           messageBuffer.addMessage(`Executing: ${msg.toolName}${toolArgs ? ` ${toolArgs}${toolArgs.length >= 100 ? "..." : ""}` : ""}`, "tool");
           session.sendAgentMessage("gemini", {
@@ -2559,23 +2576,23 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         case "tool-result":
           if (msg.toolName === "change_title" || msg.callId?.includes("change_title") || msg.toolName === "happy__change_title") {
             changeTitleCompleted = true;
-            persistence.logger.debug("[gemini] change_title completed");
+            logger.logger.debug("[gemini] change_title completed");
           }
           const isError = msg.result && typeof msg.result === "object" && "error" in msg.result;
           const resultText = typeof msg.result === "string" ? msg.result.substring(0, 200) : JSON.stringify(msg.result).substring(0, 200);
           const truncatedResult = resultText + (typeof msg.result === "string" && msg.result.length > 200 ? "..." : "");
           const resultSize = typeof msg.result === "string" ? msg.result.length : JSON.stringify(msg.result).length;
-          persistence.logger.debug(`[gemini] ${isError ? "\u274C" : "\u2705"} Tool result received: ${msg.toolName} (${msg.callId}) - Size: ${resultSize} bytes${isError ? " [ERROR]" : ""}`);
+          logger.logger.debug(`[gemini] ${isError ? "\u274C" : "\u2705"} Tool result received: ${msg.toolName} (${msg.callId}) - Size: ${resultSize} bytes${isError ? " [ERROR]" : ""}`);
           if (!isError) {
             diffProcessor.processToolResult(msg.toolName, msg.result, msg.callId);
           }
           if (isError) {
             const errorMsg = msg.result.error || "Tool call failed";
-            persistence.logger.debug(`[gemini] \u274C Tool call error: ${errorMsg.substring(0, 300)}`);
+            logger.logger.debug(`[gemini] \u274C Tool call error: ${errorMsg.substring(0, 300)}`);
             messageBuffer.addMessage(`Error: ${errorMsg}`, "status");
           } else {
             if (resultSize > 1e3) {
-              persistence.logger.debug(`[gemini] \u2705 Large tool result (${resultSize} bytes) - first 200 chars: ${truncatedResult}`);
+              logger.logger.debug(`[gemini] \u2705 Large tool result (${resultSize} bytes) - first 200 chars: ${truncatedResult}`);
             }
             messageBuffer.addMessage(`Result: ${truncatedResult}`, "result");
           }
@@ -2636,13 +2653,13 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           });
           break;
         case "permission-response":
-          persistence.logger.debug(`[gemini] Permission ${msg.approved ? "approved" : "denied"} for ${msg.toolName} (${msg.id})`);
+          logger.logger.debug(`[gemini] Permission ${msg.approved ? "approved" : "denied"} for ${msg.toolName} (${msg.id})`);
           break;
         case "exec-approval-request":
           const execApprovalMsg = msg;
           const callId = execApprovalMsg.call_id || execApprovalMsg.callId || node_crypto.randomUUID();
           const { call_id, type, ...inputs } = execApprovalMsg;
-          persistence.logger.debug(`[gemini] Exec approval request received: ${callId}`);
+          logger.logger.debug(`[gemini] Exec approval request received: ${callId}`);
           messageBuffer.addMessage(`Exec approval requested: ${callId}`, "tool");
           session.sendAgentMessage("gemini", {
             type: "tool-call",
@@ -2660,7 +2677,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           const changeCount = changes ? Object.keys(changes).length : 0;
           const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
           messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
-          persistence.logger.debug(`[gemini] Patch apply begin: ${patchCallId}, files: ${changeCount}`);
+          logger.logger.debug(`[gemini] Patch apply begin: ${patchCallId}, files: ${changeCount}`);
           const trimmedChanges = {};
           if (changes && typeof changes === "object") {
             for (const [filePath, change] of Object.entries(changes)) {
@@ -2693,7 +2710,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             const errorMsg = stderr || "Failed to modify files";
             messageBuffer.addMessage(`Error: ${errorMsg.substring(0, 200)}`, "result");
           }
-          persistence.logger.debug(`[gemini] Patch apply end: ${patchEndCallId}, success: ${success}`);
+          logger.logger.debug(`[gemini] Patch apply end: ${patchEndCallId}, success: ${success}`);
           session.sendAgentMessage("gemini", {
             type: "tool-result",
             callId: patchEndCallId,
@@ -2714,7 +2731,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             const thinkingText = thinkingPayload && typeof thinkingPayload === "object" && "text" in thinkingPayload ? String(thinkingPayload.text || "") : "";
             if (thinkingText) {
               reasoningProcessor.processChunk(thinkingText);
-              persistence.logger.debug(`[gemini] \u{1F4AD} Thinking chunk received: ${thinkingText.length} chars - Preview: ${thinkingText.substring(0, 100)}...`);
+              logger.logger.debug(`[gemini] \u{1F4AD} Thinking chunk received: ${thinkingText.length} chars - Preview: ${thinkingText.substring(0, 100)}...`);
               if (!thinkingText.startsWith("**")) {
                 const thinkingPreview = thinkingText.substring(0, 100);
                 messageBuffer.updateLastMessage(`[Thinking] ${thinkingPreview}...`, "system");
@@ -2733,14 +2750,14 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
   let resumeContextPrefix = "";
   if (geminiResumeSessionId) {
     try {
-      const resumeLines = await persistence.readGeminiSessionLog(geminiResumeSessionId);
+      const resumeLines = await api.readGeminiSessionLog(geminiResumeSessionId);
       if (resumeLines.length > 0) {
-        resumeContextPrefix = persistence.buildResumeContextFromSessionLog(resumeLines);
-        persistence.logger.debug(`[gemini] Loaded resume context from session ${geminiResumeSessionId} (${resumeContextPrefix.length} chars)`);
+        resumeContextPrefix = api.buildResumeContextFromSessionLog(resumeLines);
+        logger.logger.debug(`[gemini] Loaded resume context from session ${geminiResumeSessionId} (${resumeContextPrefix.length} chars)`);
         messageBuffer.addMessage("Resuming from previous session...", "status");
       }
     } catch (error) {
-      persistence.logger.debug(`[gemini] Failed to load resume session:`, error);
+      logger.logger.debug(`[gemini] Failed to load resume session:`, error);
     }
   }
   if (geminiResumeSessionId && ["1", "true", "yes"].includes(String(process.env.HAPPY_GEMINI_BACKFILL).toLowerCase())) {
@@ -2756,10 +2773,10 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           }
         });
       } else {
-        persistence.logger.debug("[gemini] Backfill skipped: socket not connected");
+        logger.logger.debug("[gemini] Backfill skipped: socket not connected");
       }
     } catch (error) {
-      persistence.logger.debug("[gemini] Backfill failed:", error);
+      logger.logger.debug("[gemini] Backfill failed:", error);
     }
   }
   let first = true;
@@ -2770,25 +2787,25 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       let message = pending;
       pending = null;
       if (!message) {
-        persistence.logger.debug("[gemini] Main loop: waiting for messages from queue...");
+        logger.logger.debug("[gemini] Main loop: waiting for messages from queue...");
         const waitSignal = abortController.signal;
         const batch = await messageQueue.waitForMessagesAndGetAsString(waitSignal);
         if (!batch) {
           if (waitSignal.aborted && !shouldExit) {
-            persistence.logger.debug("[gemini] Main loop: wait aborted, continuing...");
+            logger.logger.debug("[gemini] Main loop: wait aborted, continuing...");
             continue;
           }
-          persistence.logger.debug("[gemini] Main loop: no batch received, breaking...");
+          logger.logger.debug("[gemini] Main loop: no batch received, breaking...");
           break;
         }
-        persistence.logger.debug(`[gemini] Main loop: received message from queue (length: ${batch.message.length})`);
+        logger.logger.debug(`[gemini] Main loop: received message from queue (length: ${batch.message.length})`);
         message = batch;
       }
       if (!message) {
         break;
       }
-      if (index.parseClear(message.message).isClear) {
-        persistence.logger.debug("[Gemini] /clear command detected - resetting session");
+      if (downloadImage.parseClear(message.message).isClear) {
+        logger.logger.debug("[Gemini] /clear command detected - resetting session");
         messageBuffer.addMessage("Context was reset", "status");
         session.sendSessionEvent({ type: "message", message: "Context was reset" });
         if (geminiBackend) {
@@ -2807,12 +2824,12 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       }
       let injectHistoryContext = false;
       if (wasSessionCreated && currentModeHash && message.hash !== currentModeHash) {
-        persistence.logger.debug("[Gemini] Mode changed \u2013 restarting Gemini session");
+        logger.logger.debug("[Gemini] Mode changed \u2013 restarting Gemini session");
         messageBuffer.addMessage("\u2550".repeat(40), "status");
         if (conversationHistory.hasHistory()) {
           messageBuffer.addMessage(`Switching model (preserving ${conversationHistory.size()} messages of context)...`, "status");
           injectHistoryContext = true;
-          persistence.logger.debug(`[Gemini] Will inject conversation history: ${conversationHistory.getSummary()}`);
+          logger.logger.debug(`[Gemini] Will inject conversation history: ${conversationHistory.getSummary()}`);
         } else {
           messageBuffer.addMessage("Starting new Gemini session (mode changed)...", "status");
         }
@@ -2837,13 +2854,13 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         geminiBackend = backendResult.backend;
         setupGeminiMessageHandler(geminiBackend);
         const actualModel = backendResult.model;
-        persistence.logger.debug(`[gemini] Model change - modelToUse=${modelToUse}, actualModel=${actualModel} (from ${backendResult.modelSource})`);
+        logger.logger.debug(`[gemini] Model change - modelToUse=${modelToUse}, actualModel=${actualModel} (from ${backendResult.modelSource})`);
         conversationHistory.setCurrentModel(actualModel);
-        persistence.logger.debug("[gemini] Starting new ACP session with model:", actualModel);
+        logger.logger.debug("[gemini] Starting new ACP session with model:", actualModel);
         const { sessionId } = await geminiBackend.startSession();
         acpSessionId = sessionId;
-        persistence.logger.debug(`[gemini] New ACP session started: ${acpSessionId}`);
-        persistence.logger.debug(`[gemini] Calling updateDisplayedModel with: ${actualModel}`);
+        logger.logger.debug(`[gemini] New ACP session started: ${acpSessionId}`);
+        logger.logger.debug(`[gemini] Calling updateDisplayedModel with: ${actualModel}`);
         updateDisplayedModel(actualModel, false);
         updatePermissionMode(message.mode.permissionMode);
         wasSessionCreated = true;
@@ -2874,20 +2891,20 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             geminiBackend = backendResult.backend;
             setupGeminiMessageHandler(geminiBackend);
             const actualModel = backendResult.model;
-            persistence.logger.debug(`[gemini] Backend created, model will be: ${actualModel} (from ${backendResult.modelSource})`);
-            persistence.logger.debug(`[gemini] Calling updateDisplayedModel with: ${actualModel}`);
+            logger.logger.debug(`[gemini] Backend created, model will be: ${actualModel} (from ${backendResult.modelSource})`);
+            logger.logger.debug(`[gemini] Calling updateDisplayedModel with: ${actualModel}`);
             updateDisplayedModel(actualModel, false);
             conversationHistory.setCurrentModel(actualModel);
           }
           if (!acpSessionId) {
-            persistence.logger.debug("[gemini] Starting ACP session...");
+            logger.logger.debug("[gemini] Starting ACP session...");
             updatePermissionMode(message.mode.permissionMode);
             const { sessionId } = await geminiBackend.startSession();
             acpSessionId = sessionId;
-            persistence.logger.debug(`[gemini] ACP session started: ${acpSessionId}`);
+            logger.logger.debug(`[gemini] ACP session started: ${acpSessionId}`);
             wasSessionCreated = true;
             currentModeHash = message.hash;
-            persistence.logger.debug(`[gemini] Displaying model in UI: ${displayedModel || "gemini-2.5-pro"}, displayedModel: ${displayedModel}`);
+            logger.logger.debug(`[gemini] Displaying model in UI: ${displayedModel || "gemini-2.5-pro"}, displayedModel: ${displayedModel}`);
           }
         }
         if (!acpSessionId) {
@@ -2908,26 +2925,26 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         if (first && resumeContextPrefix) {
           promptToSend = resumeContextPrefix + promptToSend;
           resumeContextPrefix = "";
-          persistence.logger.debug(`[gemini] Injected resume context into first prompt`);
+          logger.logger.debug(`[gemini] Injected resume context into first prompt`);
         }
         if (injectHistoryContext && conversationHistory.hasHistory()) {
           const historyContext = conversationHistory.getContextForNewSession();
           promptToSend = historyContext + promptToSend;
-          persistence.logger.debug(`[gemini] Injected conversation history context (${historyContext.length} chars)`);
+          logger.logger.debug(`[gemini] Injected conversation history context (${historyContext.length} chars)`);
         }
-        persistence.logger.debug(`[gemini] Sending prompt to Gemini (length: ${promptToSend.length}): ${promptToSend.substring(0, 100)}...`);
-        persistence.logger.debug(`[gemini] Full prompt: ${promptToSend}`);
+        logger.logger.debug(`[gemini] Sending prompt to Gemini (length: ${promptToSend.length}): ${promptToSend.substring(0, 100)}...`);
+        logger.logger.debug(`[gemini] Full prompt: ${promptToSend}`);
         let promptImages;
         if (message.mode.images && message.mode.images.length > 0) {
-          persistence.logger.debug(`[gemini] Downloading ${message.mode.images.length} image(s) for prompt`);
-          const formattedContent = await index.formatMessageForGemini(promptToSend, message.mode.images);
+          logger.logger.debug(`[gemini] Downloading ${message.mode.images.length} image(s) for prompt`);
+          const formattedContent = await formatImageMessage.formatMessageForGemini(promptToSend, message.mode.images);
           promptImages = formattedContent.parts.filter(
             (part) => "inlineData" in part && part.inlineData !== void 0
           ).map((part) => ({
             data: part.inlineData.data,
             mimeType: part.inlineData.mimeType
           }));
-          persistence.logger.debug(`[gemini] Prepared ${promptImages.length} image(s) for ACP prompt`);
+          logger.logger.debug(`[gemini] Prepared ${promptImages.length} image(s) for ACP prompt`);
         }
         const MAX_RETRIES = 3;
         const RETRY_DELAY_MS = 2e3;
@@ -2935,10 +2952,10 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
           try {
             await geminiBackend.sendPrompt(acpSessionId, promptToSend, { images: promptImages });
-            persistence.logger.debug("[gemini] Prompt sent successfully");
+            logger.logger.debug("[gemini] Prompt sent successfully");
             if (geminiBackend.waitForResponseComplete) {
               await geminiBackend.waitForResponseComplete(12e4);
-              persistence.logger.debug("[gemini] Response complete");
+              logger.logger.debug("[gemini] Response complete");
             }
             break;
           } catch (promptError) {
@@ -2963,7 +2980,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             const isInternalError = errorCode === -32603;
             const isRetryable = isEmptyResponseError || isInternalError;
             if (isRetryable && attempt < MAX_RETRIES) {
-              persistence.logger.debug(`[gemini] Retryable error on attempt ${attempt}/${MAX_RETRIES}: ${errorDetails}`);
+              logger.logger.debug(`[gemini] Retryable error on attempt ${attempt}/${MAX_RETRIES}: ${errorDetails}`);
               messageBuffer.addMessage(`Gemini returned empty response, retrying (${attempt}/${MAX_RETRIES})...`, "status");
               await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS * attempt));
               continue;
@@ -2972,13 +2989,13 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           }
         }
         if (lastError && MAX_RETRIES > 1) {
-          persistence.logger.debug("[gemini] Prompt succeeded after retries");
+          logger.logger.debug("[gemini] Prompt succeeded after retries");
         }
         if (first) {
           first = false;
         }
       } catch (error) {
-        persistence.logger.debug("[gemini] Error in gemini session:", error);
+        logger.logger.debug("[gemini] Error in gemini session:", error);
         const isAbortError = error instanceof Error && error.name === "AbortError";
         const isUserAbort = isAbortError || abortRequested;
         if (isUserAbort && !abortFeedbackSent) {
@@ -3042,9 +3059,9 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
           let finalMessageText = messageText;
           if (options.length > 0) {
             finalMessageText = messageText + rawOptionsXml;
-            persistence.logger.debug(`[gemini] Found ${options.length} options in response:`, options);
+            logger.logger.debug(`[gemini] Found ${options.length} options in response:`, options);
           } else if (hasIncompleteOptions(accumulatedResponse)) {
-            persistence.logger.debug(`[gemini] Warning: Incomplete options block detected`);
+            logger.logger.debug(`[gemini] Warning: Incomplete options block detected`);
           }
           const messagePayload = {
             type: "message",
@@ -3052,7 +3069,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
             id: node_crypto.randomUUID(),
             ...options.length > 0 && { options }
           };
-          persistence.logger.debug(`[gemini] Sending complete message to mobile (length: ${finalMessageText.length}): ${finalMessageText.substring(0, 100)}...`);
+          logger.logger.debug(`[gemini] Sending complete message to mobile (length: ${finalMessageText.length}): ${finalMessageText.substring(0, 100)}...`);
           session.sendAgentMessage("gemini", messagePayload);
           accumulatedResponse = "";
           isResponseInProgress = false;
@@ -3083,13 +3100,13 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
         emitReadyIfIdle();
         isProcessingMessage = false;
         applyPendingSessionSwap();
-        persistence.logger.debug(`[gemini] Main loop: turn completed, continuing to next iteration (queue size: ${messageQueue.size()})`);
+        logger.logger.debug(`[gemini] Main loop: turn completed, continuing to next iteration (queue size: ${messageQueue.size()})`);
       }
     }
   } finally {
-    persistence.logger.debug("[gemini]: Final cleanup start");
+    logger.logger.debug("[gemini]: Final cleanup start");
     if (reconnectionHandle) {
-      persistence.logger.debug("[gemini]: Cancelling offline reconnection");
+      logger.logger.debug("[gemini]: Cancelling offline reconnection");
       reconnectionHandle.cancel();
     }
     try {
@@ -3097,7 +3114,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       await session.flush();
       await session.close();
     } catch (e) {
-      persistence.logger.debug("[gemini]: Error while closing session", e);
+      logger.logger.debug("[gemini]: Error while closing session", e);
     }
     if (geminiBackend) {
       await geminiBackend.dispose();
@@ -3120,7 +3137,7 @@ Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca`;
       inkInstance.unmount();
     }
     messageBuffer.clear();
-    persistence.logger.debug("[gemini]: Final cleanup completed");
+    logger.logger.debug("[gemini]: Final cleanup completed");
   }
 }