very-happy-cli 0.2.159 → 0.2.160

package/dist/{AcpBackend-DUYFlyfN.cjs → AcpBackend-Bm2rdke8.cjs}

@@ -3,8 +3,10 @@
 var node_child_process = require('node:child_process');
 var sdk = require('@agentclientprotocol/sdk');
 var node_crypto = require('node:crypto');
-var persistence = require('./limits-BH5CV5vR.cjs');
-var index = require('./types-BbvK1Tr_.cjs');
+var logger = require('./logger-CS0mw3fa.cjs');
+var time = require('./time-DCuTyook.cjs');
+var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
+var _package = require('./package-BwMrPwqH.cjs');
 
 function acpImageBlocks(attachments, supportsImages) {
   return attachments.filter((file) => ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(file.mimeType)).map((file) => {
@@ -246,7 +248,7 @@ function handleAgentMessageChunk(update, ctx) {
       payload: { text, streaming: true }
     });
   } else {
-    persistence.logger.debug("[AcpBackend] Received message chunk:", index.contentLogMetadata(text));
+    logger.logger.debug("[AcpBackend] Received message chunk:", contentLogMetadata.contentLogMetadata(text));
     ctx.emit({
       type: "model-output",
       textDelta: text
@@ -255,10 +257,10 @@ function handleAgentMessageChunk(update, ctx) {
     const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
     ctx.setIdleTimeout(() => {
       if (ctx.activeToolCalls.size === 0) {
-        persistence.logger.debug("[AcpBackend] No more chunks received, emitting idle status");
+        logger.logger.debug("[AcpBackend] No more chunks received, emitting idle status");
         ctx.emitIdleStatus();
       } else {
-        persistence.logger.debug(`[AcpBackend] Delaying idle status - ${ctx.activeToolCalls.size} active tool calls`);
+        logger.logger.debug(`[AcpBackend] Delaying idle status - ${ctx.activeToolCalls.size} active tool calls`);
       }
     }, idleTimeoutMs);
   }
@@ -274,8 +276,8 @@ function handleAgentThoughtChunk(update, ctx) {
     return { handled: false };
   }
   if (ctx.activeToolCalls.size > 0) {
-    persistence.logger.debug("[AcpBackend] Thinking chunk received during active tool calls:", {
-      ...index.contentLogMetadata(text),
+    logger.logger.debug("[AcpBackend] Thinking chunk received during active tool calls:", {
+      ...contentLogMetadata.contentLogMetadata(text),
       activeToolCallCount: ctx.activeToolCalls.size
     });
   }
@@ -295,29 +297,29 @@ function startToolCall(toolCallId, toolKind, update, ctx, source) {
   ctx.toolCallIdToNameMap.set(toolCallId, realToolName);
   ctx.activeToolCalls.add(toolCallId);
   ctx.toolCallStartTimes.set(toolCallId, startTime);
-  persistence.logger.debug(`[AcpBackend] \u23F1\uFE0F Set startTime for ${toolCallId} at ${new Date(startTime).toISOString()} (from ${source})`);
-  persistence.logger.debug(`[AcpBackend] Tool call START: ${toolCallId}${isInvestigation ? " [INVESTIGATION TOOL]" : ""}`);
+  logger.logger.debug(`[AcpBackend] \u23F1\uFE0F Set startTime for ${toolCallId} at ${new Date(startTime).toISOString()} (from ${source})`);
+  logger.logger.debug(`[AcpBackend] Tool call START: ${toolCallId}${isInvestigation ? " [INVESTIGATION TOOL]" : ""}`);
   if (isInvestigation) {
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool detected - extended timeout (10min) will be used`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool detected - extended timeout (10min) will be used`);
   }
   const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
   if (!ctx.toolCallTimeouts.has(toolCallId)) {
     const timeout = setTimeout(() => {
       const duration = formatDuration(ctx.toolCallStartTimes.get(toolCallId));
-      persistence.logger.debug(`[AcpBackend] Tool call TIMEOUT (from ${source}): ${toolCallId} after ${(timeoutMs / 1e3).toFixed(0)}s - Duration: ${duration}, removing from active set`);
+      logger.logger.debug(`[AcpBackend] Tool call TIMEOUT (from ${source}): ${toolCallId} after ${(timeoutMs / 1e3).toFixed(0)}s - Duration: ${duration}, removing from active set`);
       ctx.activeToolCalls.delete(toolCallId);
       ctx.toolCallStartTimes.delete(toolCallId);
       ctx.toolCallTimeouts.delete(toolCallId);
       ctx.toolCallOutputs.delete(toolCallId);
       if (ctx.activeToolCalls.size === 0) {
-        persistence.logger.debug("[AcpBackend] No more active tool calls after timeout, emitting idle status");
+        logger.logger.debug("[AcpBackend] No more active tool calls after timeout, emitting idle status");
         ctx.emitIdleStatus();
       }
     }, timeoutMs);
     ctx.toolCallTimeouts.set(toolCallId, timeout);
-    persistence.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
+    logger.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
   } else {
-    persistence.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
+    logger.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
   }
   ctx.clearIdleTimeout();
   ctx.emit({ type: "status", status: "running" });
@@ -344,7 +346,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx, exitCode) {
     clearTimeout(timeout);
     ctx.toolCallTimeouts.delete(toolCallId);
   }
-  persistence.logger.debug(`[AcpBackend] Tool call COMPLETED: ${toolCallId} - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  logger.logger.debug(`[AcpBackend] Tool call COMPLETED: ${toolCallId} - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
   const output = ctx.toolCallOutputs.get(toolCallId);
   ctx.toolCallOutputs.delete(toolCallId);
   const bashResult = buildAcpBashResult(output, exitCode);
@@ -356,7 +358,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx, exitCode) {
   });
   if (ctx.activeToolCalls.size === 0) {
     ctx.clearIdleTimeout();
-    persistence.logger.debug("[AcpBackend] All tool calls completed, emitting idle status");
+    logger.logger.debug("[AcpBackend] All tool calls completed, emitting idle status");
     ctx.emitIdleStatus();
   }
 }
@@ -369,17 +371,17 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   if (isInvestigation) {
     const durationStr2 = formatDuration(startTime);
     const durationMinutes = formatDurationMinutes(startTime);
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool ${status.toUpperCase()} after ${durationMinutes} minutes (${durationStr2})`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool ${status.toUpperCase()} after ${durationMinutes} minutes (${durationStr2})`);
     if (duration) {
       const threeMinutes = 3 * 60 * 1e3;
       const tolerance = 5e3;
       if (Math.abs(duration - threeMinutes) < tolerance) {
-        persistence.logger.debug(`[AcpBackend] \u{1F50D} \u26A0\uFE0F Investigation tool failed at ~3 minutes - likely Gemini CLI timeout, not our timeout`);
+        logger.logger.debug(`[AcpBackend] \u{1F50D} \u26A0\uFE0F Investigation tool failed at ~3 minutes - likely Gemini CLI timeout, not our timeout`);
       }
     }
-    persistence.logger.debug("[AcpBackend] Investigation tool failed with content metadata:", index.contentLogMetadata(content));
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool timeout status BEFORE cleanup: ${hadTimeout ? "timeout was set" : "no timeout was set"}`);
-    persistence.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool startTime status BEFORE cleanup: ${startTime ? `set at ${new Date(startTime).toISOString()}` : "not set"}`);
+    logger.logger.debug("[AcpBackend] Investigation tool failed with content metadata:", contentLogMetadata.contentLogMetadata(content));
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool timeout status BEFORE cleanup: ${hadTimeout ? "timeout was set" : "no timeout was set"}`);
+    logger.logger.debug(`[AcpBackend] \u{1F50D} Investigation tool startTime status BEFORE cleanup: ${startTime ? `set at ${new Date(startTime).toISOString()}` : "not set"}`);
   }
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
@@ -388,17 +390,17 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   if (timeout) {
     clearTimeout(timeout);
     ctx.toolCallTimeouts.delete(toolCallId);
-    persistence.logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
+    logger.logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
   } else {
-    persistence.logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
+    logger.logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
   }
   const durationStr = formatDuration(startTime);
-  persistence.logger.debug(`[AcpBackend] Tool call ${status.toUpperCase()}: ${toolCallId} - Duration: ${durationStr}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  logger.logger.debug(`[AcpBackend] Tool call ${status.toUpperCase()}: ${toolCallId} - Duration: ${durationStr}. Active tool calls: ${ctx.activeToolCalls.size}`);
   const errorDetail = extractErrorDetail(content);
   if (errorDetail) {
-    persistence.logger.debug("[AcpBackend] Tool call error detail received:", index.contentLogMetadata(errorDetail));
+    logger.logger.debug("[AcpBackend] Tool call error detail received:", contentLogMetadata.contentLogMetadata(errorDetail));
   } else {
-    persistence.logger.debug(`[AcpBackend] \u274C Tool call ${status} but no error details in content`);
+    logger.logger.debug(`[AcpBackend] \u274C Tool call ${status} but no error details in content`);
   }
   ctx.emit({
     type: "tool-result",
@@ -408,7 +410,7 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   });
   if (ctx.activeToolCalls.size === 0) {
     ctx.clearIdleTimeout();
-    persistence.logger.debug("[AcpBackend] All tool calls completed/failed, emitting idle status");
+    logger.logger.debug("[AcpBackend] All tool calls completed/failed, emitting idle status");
     ctx.emitIdleStatus();
   }
 }
@@ -416,7 +418,7 @@ function handleToolCallUpdate(update, ctx) {
   const status = update.status;
   const toolCallId = update.toolCallId;
   if (!toolCallId) {
-    persistence.logger.debug("[AcpBackend] Tool call update without toolCallId:", index.contentLogMetadata(update));
+    logger.logger.debug("[AcpBackend] Tool call update without toolCallId:", contentLogMetadata.contentLogMetadata(update));
     return { handled: false };
   }
   const toolKind = update.kind || "unknown";
@@ -433,7 +435,7 @@ function handleToolCallUpdate(update, ctx) {
       toolCallCountSincePrompt++;
       startToolCall(toolCallId, toolKind, update, ctx, "tool_call_update");
     } else {
-      persistence.logger.debug(`[AcpBackend] Tool call ${toolCallId} already tracked, status: ${status}`);
+      logger.logger.debug(`[AcpBackend] Tool call ${toolCallId} already tracked, status: ${status}`);
     }
   } else if (status === "completed") {
     completeToolCall(toolCallId, toolKind, update.content, ctx, terminalMeta.exitCode);
@@ -445,14 +447,14 @@ function handleToolCallUpdate(update, ctx) {
 function handleToolCall(update, ctx) {
   const toolCallId = update.toolCallId;
   const status = update.status;
-  persistence.logger.debug(`[AcpBackend] Received tool_call: toolCallId=${toolCallId}, status=${status ?? "unknown"}`);
+  logger.logger.debug(`[AcpBackend] Received tool_call: toolCallId=${toolCallId}, status=${status ?? "unknown"}`);
   const isInProgress = !status || status === "in_progress" || status === "pending";
   if (!toolCallId || !isInProgress) {
-    persistence.logger.debug(`[AcpBackend] Tool call ${toolCallId} not in progress (status: ${status}), skipping`);
+    logger.logger.debug(`[AcpBackend] Tool call ${toolCallId} not in progress (status: ${status}), skipping`);
     return { handled: false };
   }
   if (ctx.activeToolCalls.has(toolCallId)) {
-    persistence.logger.debug(`[AcpBackend] Tool call ${toolCallId} already in active set, skipping`);
+    logger.logger.debug(`[AcpBackend] Tool call ${toolCallId} already in active set, skipping`);
     return { handled: true };
   }
   startToolCall(toolCallId, update.kind, update, ctx, "tool_call");
@@ -540,7 +542,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:", index.errorLogMetadata(err));
+            logger.logger.debug("[AcpBackend] Error writing to stdin:", contentLogMetadata.errorLogMetadata(err));
             reject(err);
           }
         });
@@ -569,7 +571,7 @@ function nodeToWebStreams(stdin, stdout) {
         controller.close();
       });
       stdout.on("error", (err) => {
-        persistence.logger.debug("[AcpBackend] Stdout error:", index.errorLogMetadata(err));
+        logger.logger.debug("[AcpBackend] Stdout error:", contentLogMetadata.errorLogMetadata(err));
         controller.error(err);
       });
     },
@@ -592,9 +594,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}). Retrying in ${delayMs}ms...`, index.errorLogMetadata(lastError));
+        logger.logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}). Retrying in ${delayMs}ms...`, contentLogMetadata.errorLogMetadata(lastError));
         options.onRetry?.(attempt, lastError);
-        await persistence.delay(delayMs);
+        await time.delay(delayMs);
       } else {
         break;
       }
@@ -648,7 +650,7 @@ class AcpBackend {
       try {
         listener(msg);
       } catch (error) {
-        persistence.logger.warn("[AcpBackend] Error in message handler:", index.errorLogMetadata(error));
+        logger.logger.warn("[AcpBackend] Error in message handler:", contentLogMetadata.errorLogMetadata(error));
       }
     }
   }
@@ -660,7 +662,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(" ");
@@ -708,9 +710,9 @@ class AcpBackend {
           activeToolCalls: this.activeToolCalls,
           hasActiveInvestigation
         };
-        persistence.logger.debug("[AcpBackend] Agent stderr received:", {
+        logger.logger.debug("[AcpBackend] Agent stderr received:", {
           investigationActive: hasActiveInvestigation,
-          ...index.contentLogMetadata(text)
+          ...contentLogMetadata.contentLogMetadata(text)
         });
         if (this.transport.handleStderr) {
           const result = this.transport.handleStderr(text, context);
@@ -721,14 +723,14 @@ class AcpBackend {
       });
       this.process.on("error", (err) => {
         signalStartupFailure(err);
-        persistence.logger.debug("[AcpBackend] Process error:", index.errorLogMetadata(err));
+        logger.logger.debug("[AcpBackend] Process error:", contentLogMetadata.errorLogMetadata(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}` });
         }
       });
@@ -761,7 +763,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;
@@ -782,7 +784,7 @@ class AcpBackend {
               }
             }
           } catch (error) {
-            persistence.logger.debug("[AcpBackend] Error filtering stdout stream:", index.errorLogMetadata(error));
+            logger.logger.debug("[AcpBackend] Error filtering stdout stream:", contentLogMetadata.errorLogMetadata(error));
             controller.error(error);
           } finally {
             reader.releaseLock();
@@ -808,15 +810,15 @@ class AcpBackend {
           };
           toolName = this.transport.determineToolName?.(toolName, toolCallId, input, context) ?? toolName;
           if (toolName !== (toolCall?.kind || toolCall?.toolName || extendedParams.kind || "Unknown tool")) {
-            persistence.logger.debug(`[AcpBackend] Inferred tool name for toolCallId: ${toolCallId}`);
+            logger.logger.debug(`[AcpBackend] Inferred tool name for toolCallId: ${toolCallId}`);
           }
           this.toolCallCountSincePrompt++;
           const options = extendedParams.options || [];
-          persistence.logger.debug("[AcpBackend] Permission request metadata:", {
+          logger.logger.debug("[AcpBackend] Permission request metadata:", {
             hasToolCall: !!toolCall,
             toolCallId,
             optionCount: options.length,
-            input: index.contentLogMetadata(input)
+            input: contentLogMetadata.contentLogMetadata(input)
           });
           this.emit({
             type: "permission-request",
@@ -879,7 +881,7 @@ class AcpBackend {
               }
               return { outcome: { outcome: "selected", optionId } };
             } catch (error) {
-              persistence.logger.debug("[AcpBackend] Error in permission handler:", index.errorLogMetadata(error));
+              logger.logger.debug("[AcpBackend] Error in permission handler:", contentLogMetadata.errorLogMetadata(error));
               return { outcome: { outcome: "selected", optionId: "cancel" } };
             }
           }
@@ -904,11 +906,11 @@ class AcpBackend {
         },
         clientInfo: {
           name: "happy-cli",
-          version: persistence.packageJson.version
+          version: _package.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) {
@@ -951,7 +953,7 @@ class AcpBackend {
           shouldRetry: (error) => !isNonRetryableStartupError(error)
         }
       );
-      persistence.logger.debug(`[AcpBackend] Initialize completed`);
+      logger.logger.debug(`[AcpBackend] Initialize completed`);
       if (this.options.verbose) {
         logAcpBackendMuted(
           `Incoming initialize response from ${this.options.agentName}: ${summarizeSessionMetadataPayload(initializeResponse)}`
@@ -967,7 +969,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;
@@ -1003,7 +1005,7 @@ class AcpBackend {
         }
       );
       this.acpSessionId = sessionResponse.sessionId;
-      persistence.logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
+      logger.logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
       if (this.options.verbose) {
         logAcpBackendMuted(
           `Incoming newSession response from ${this.options.agentName}: ${summarizeSessionMetadataPayload(sessionResponse)}`
@@ -1013,13 +1015,13 @@ class AcpBackend {
       this.emitIdleStatus();
       if (initialPrompt) {
         this.sendPrompt(sessionId, initialPrompt).catch((error) => {
-          persistence.logger.debug("[AcpBackend] Error sending initial prompt:", index.errorLogMetadata(error));
+          logger.logger.debug("[AcpBackend] Error sending initial prompt:", contentLogMetadata.errorLogMetadata(error));
           this.emit({ type: "status", status: "error", detail: String(error) });
         });
       }
       return { sessionId };
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Error starting session:", index.errorLogMetadata(error));
+      logger.logger.debug("[AcpBackend] Error starting session:", contentLogMetadata.errorLogMetadata(error));
       if (!startupStatusErrorEmitted) {
         this.emit({
           type: "status",
@@ -1091,13 +1093,13 @@ class AcpBackend {
     const notification = params;
     const update = notification.update;
     if (!update) {
-      persistence.logger.debug("[AcpBackend] Received session update without update field:", index.contentLogMetadata(params));
+      logger.logger.debug("[AcpBackend] Received session update without update field:", contentLogMetadata.contentLogMetadata(params));
       return;
     }
     const sessionUpdateType = update.sessionUpdate;
     const updateType = sessionUpdateType;
-    const updateMetadata = index.contentLogMetadata(update);
-    persistence.logger.debug(`[AcpBackend] Received session update type: ${sessionUpdateType ?? "unknown"}`, updateMetadata);
+    const updateMetadata = contentLogMetadata.contentLogMetadata(update);
+    logger.logger.debug(`[AcpBackend] Received session update type: ${sessionUpdateType ?? "unknown"}`, updateMetadata);
     if (this.options.verbose) {
       logAcpBackendMuted(
         `Incoming session update from ${this.options.agentName}: type=${sessionUpdateType ?? "unknown"} payloadBytes=${String(updateMetadata.payloadBytes ?? "unknown")}`
@@ -1170,7 +1172,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}`, index.contentLogMetadata(update));
+      logger.logger.debug(`[AcpBackend] Unhandled session update type: ${updateType}`, contentLogMetadata.contentLogMetadata(update));
     }
   }
   // Promise resolver for waitForIdle - set when waiting for response to complete
@@ -1185,7 +1187,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");
@@ -1196,9 +1198,9 @@ class AcpBackend {
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
     try {
-      persistence.logger.debug("[AcpBackend] Sending prompt:", {
+      logger.logger.debug("[AcpBackend] Sending prompt:", {
         sessionId,
-        ...index.contentLogMetadata(prompt)
+        ...contentLogMetadata.contentLogMetadata(prompt)
       });
       const contentBlock = {
         type: "text",
@@ -1208,7 +1210,7 @@ class AcpBackend {
         sessionId: this.acpSessionId,
         prompt: [contentBlock, ...acpImageBlocks(attachments, this.supportsImagePrompt)]
       };
-      persistence.logger.debug("[AcpBackend] Prompt request prepared:", {
+      logger.logger.debug("[AcpBackend] Prompt request prepared:", {
         sessionId: this.acpSessionId,
         blockCount: promptRequest.prompt.length
       });
@@ -1216,9 +1218,9 @@ class AcpBackend {
       if (response.usage) {
         this.emit({ type: "token-count", ...response.usage });
       }
-      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:", index.errorLogMetadata(error));
+      logger.logger.debug("[AcpBackend] Error sending prompt:", contentLogMetadata.errorLogMetadata(error));
       this.waitingForResponse = false;
       let errorDetail;
       if (error instanceof Error) {
@@ -1267,10 +1269,10 @@ 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: index.contentLogMetadata(value),
-        error: index.errorLogMetadata(error)
+        value: contentLogMetadata.contentLogMetadata(value),
+        error: contentLogMetadata.errorLogMetadata(error)
       });
       return false;
     }
@@ -1295,7 +1297,7 @@ class AcpBackend {
       });
       return true;
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Failed to set session mode:", { modeId, error: index.errorLogMetadata(error) });
+      logger.logger.debug("[AcpBackend] Failed to set session mode:", { modeId, error: contentLogMetadata.errorLogMetadata(error) });
       return false;
     }
   }
@@ -1317,7 +1319,7 @@ class AcpBackend {
       });
       return true;
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Failed to set session model:", { modelId, error: index.errorLogMetadata(error) });
+      logger.logger.debug("[AcpBackend] Failed to set session model:", { modelId, error: contentLogMetadata.errorLogMetadata(error) });
       return false;
     }
   }
@@ -1349,7 +1351,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();
     }
   }
@@ -1361,7 +1363,7 @@ class AcpBackend {
       await this.connection.cancel({ sessionId: this.acpSessionId });
       this.emit({ type: "status", status: "idle", detail: "Cancelled by user" });
     } catch (error) {
-      persistence.logger.debug("[AcpBackend] Error cancelling:", index.errorLogMetadata(error));
+      logger.logger.debug("[AcpBackend] Error cancelling:", contentLogMetadata.errorLogMetadata(error));
     }
   }
   /**
@@ -1380,12 +1382,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 {
@@ -1395,7 +1397,7 @@ class AcpBackend {
           // 2s timeout for graceful shutdown
         ]);
       } catch (error) {
-        persistence.logger.debug("[AcpBackend] Error during graceful shutdown:", index.errorLogMetadata(error));
+        logger.logger.debug("[AcpBackend] Error during graceful shutdown:", contentLogMetadata.errorLogMetadata(error));
       }
     }
     if (this.process) {
@@ -1403,7 +1405,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();

package/dist/{AcpBackend-VsfkZiVF.mjs → AcpBackend-mzv8Dhba.mjs}

@@ -1,8 +1,10 @@
 import { spawn } from 'node:child_process';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
 import { randomUUID } from 'node:crypto';
-import { l as logger, F as packageJson, g as delay } from './limits-CjRj8IX5.mjs';
-import { j as contentLogMetadata, i as errorLogMetadata } from './types-Dh-s4Lqs.mjs';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { d as delay } from './time-D0XyHOid.mjs';
+import { c as contentLogMetadata, e as errorLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
+import { p as packageJson } from './package-BhaKlnxz.mjs';
 
 function acpImageBlocks(attachments, supportsImages) {
   return attachments.filter((file) => ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(file.mimeType)).map((file) => {

package/dist/{AcpSessionManager-Bdv8LWXh.cjs → AcpSessionManager-BAY1Pggx.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var cuid2 = require('@paralleldrive/cuid2');
-var persistence = require('./limits-BH5CV5vR.cjs');
+var index = require('./index-DA7yINuk.cjs');
 
 function turnOptions(turnId, time) {
   return turnId ? { turn: turnId, time } : { time };
@@ -108,12 +108,12 @@ class AcpSessionManager {
     }
     const options = {
       ...turnOptions(this.currentTurnId, this.nextTime()),
-      ...key ? { streamKey: persistence.streamKeyOf(key.mid, key.idx) } : {}
+      ...key ? { streamKey: index.streamKeyOf(key.mid, key.idx) } : {}
     };
     if (type === "thinking") {
-      return [persistence.createEnvelope("agent", { t: "text", text, thinking: true }, options)];
+      return [index.createEnvelope("agent", { t: "text", text, thinking: true }, options)];
     }
-    return [persistence.createEnvelope("agent", { t: "text", text }, options)];
+    return [index.createEnvelope("agent", { t: "text", text }, options)];
   }
   startTurn() {
     if (this.currentTurnId) {
@@ -125,7 +125,7 @@ class AcpSessionManager {
     this.blockCursor = 0;
     return [
       ...flushed,
-      persistence.createEnvelope("agent", { t: "turn-start" }, { turn: this.currentTurnId, time: this.nextTime() })
+      index.createEnvelope("agent", { t: "turn-start" }, { turn: this.currentTurnId, time: this.nextTime() })
     ];
   }
   endTurn(status) {
@@ -138,7 +138,7 @@ class AcpSessionManager {
     this.acpCallToSessionCall.clear();
     return [
       ...flushed,
-      persistence.createEnvelope("agent", { t: "turn-end", status }, { turn: turnId, time: this.nextTime() })
+      index.createEnvelope("agent", { t: "turn-end", status }, { turn: turnId, time: this.nextTime() })
     ];
   }
   mapMessage(msg) {
@@ -156,7 +156,7 @@ class AcpSessionManager {
       }
       return [
         ...this.flush(),
-        persistence.createEnvelope("agent", { t: "text", text: trimmed, thinking: true }, turnOptions(this.currentTurnId, this.nextTime()))
+        index.createEnvelope("agent", { t: "text", text: trimmed, thinking: true }, turnOptions(this.currentTurnId, this.nextTime()))
       ];
     }
     if (msg.type === "status") {
@@ -174,7 +174,7 @@ class AcpSessionManager {
       const call = this.ensureSessionCallId(msg.callId);
       return [
         ...flushed,
-        persistence.createEnvelope("agent", {
+        index.createEnvelope("agent", {
           t: "tool-call-start",
           call,
           name: msg.toolName,
@@ -190,7 +190,7 @@ class AcpSessionManager {
       const result = toolCallEndResult(msg.result);
       return [
         ...flushed,
-        persistence.createEnvelope("agent", { t: "tool-call-end", call, ...result ? { result } : {} }, turnOptions(this.currentTurnId, this.nextTime()))
+        index.createEnvelope("agent", { t: "tool-call-end", call, ...result ? { result } : {} }, turnOptions(this.currentTurnId, this.nextTime()))
       ];
     }
     return [];

package/dist/{AcpSessionManager-rYtVb0kN.mjs → AcpSessionManager-CoMWFVw3.mjs}

@@ -1,5 +1,5 @@
 import { createId } from '@paralleldrive/cuid2';
-import { s as streamKeyOf, e as createEnvelope } from './limits-CjRj8IX5.mjs';
+import { s as streamKeyOf, e as createEnvelope } from './index-qdS1friN.mjs';
 
 function turnOptions(turnId, time) {
   return turnId ? { turn: turnId, time } : { time };