@zonease/happy 0.6.38 → 0.6.40

package/dist/claudeLocal-CWNGpJ0-.mjs

@@ -0,0 +1,344 @@
+import { spawn } from 'node:child_process';
+import { resolve, join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { l as logger } from './persistence-DKfF81pd.mjs';
+import { homedir } from 'node:os';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { g as getBaseSystemPrompt } from './prompt-BsAZsPbo.mjs';
+
+function getProjectPath(workingDirectory) {
+  const projectId = resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "projects", projectId);
+}
+
+function claudeCheckSession(sessionId, path) {
+  const projectDir = getProjectPath(path);
+  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
+  }
+  const sessionData = readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v, index) => {
+    if (!v.trim()) return false;
+    try {
+      const parsed = JSON.parse(v);
+      return typeof parsed.uuid === "string" && parsed.uuid.length > 0 || // Claude Code 2.1.x
+      typeof parsed.messageId === "string" && parsed.messageId.length > 0 || // Older Claude Code
+      typeof parsed.leafUuid === "string" && parsed.leafUuid.length > 0;
+    } catch (e) {
+      logger.debug(`[claudeCheckSession] Malformed JSON at line ${index + 1}:`, e);
+      return false;
+    }
+  });
+  logger.debug(`[claudeCheckSession] Session ${sessionId}: ${hasGoodMessage ? "valid" : "invalid"}`);
+  return hasGoodMessage;
+}
+
+function claudeFindLastSession(workingDirectory) {
+  try {
+    const projectDir = getProjectPath(workingDirectory);
+    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const files = readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const sessionId = f.replace(".jsonl", "");
+      if (!uuidPattern.test(sessionId)) {
+        return null;
+      }
+      if (claudeCheckSession(sessionId, workingDirectory)) {
+        return {
+          name: f,
+          sessionId,
+          mtime: statSync(join(projectDir, f)).mtime.getTime()
+        };
+      }
+      return null;
+    }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
+    return files.length > 0 ? files[0].sessionId : null;
+  } catch (e) {
+    logger.debug("[claudeFindLastSession] Error finding sessions:", e);
+    return null;
+  }
+}
+
+const DEFAULT_COMMIT_ATTRIBUTION = [
+  "Generated with [Claude Code](https://claude.ai/code)",
+  "",
+  "Co-Authored-By: Claude <noreply@anthropic.com>"
+].join("\n");
+function getClaudeSettingsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "settings.json");
+}
+function readClaudeSettings() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!existsSync(settingsPath)) {
+      logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
+      return null;
+    }
+    const settingsContent = readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsContent);
+    logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
+    logger.debug(`[ClaudeSettings] attribution: ${JSON.stringify(settings.attribution)}, includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
+    return settings;
+  } catch (error) {
+    logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
+    return null;
+  }
+}
+function getCommitAttribution() {
+  const settings = readClaudeSettings();
+  if (!settings) return null;
+  if (settings.attribution?.commit !== void 0) {
+    return settings.attribution.commit || null;
+  }
+  if (settings.includeCoAuthoredBy === true) {
+    return DEFAULT_COMMIT_ATTRIBUTION;
+  }
+  return null;
+}
+
+const systemPrompt = (() => {
+  const base = getBaseSystemPrompt();
+  if (base === null) return "";
+  const attribution = getCommitAttribution();
+  if (!attribution) return base;
+  return base + "\n\n# Commit\n\nWhen making commit messages, add this footer:\n\n" + attribution;
+})();
+
+class ExitCodeError extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Process exited with code: ${exitCode}`);
+    this.name = "ExitCodeError";
+    this.exitCode = exitCode;
+  }
+}
+const claudeCliPath = resolve(join(projectPath(), "scripts", "claude_local_launcher.cjs"));
+async function claudeLocal(opts) {
+  const projectDir = getProjectPath(opts.path);
+  mkdirSync(projectDir, { recursive: true });
+  const hasContinueFlag = opts.claudeArgs?.includes("--continue");
+  const hasResumeFlag = opts.claudeArgs?.includes("--resume");
+  const hasUserSessionControl = hasContinueFlag || hasResumeFlag;
+  let startFrom = opts.sessionId;
+  const extractFlag = (flags, withValue = false) => {
+    if (!opts.claudeArgs) return { found: false };
+    for (const flag of flags) {
+      const index = opts.claudeArgs.indexOf(flag);
+      if (index !== -1) {
+        if (withValue && index + 1 < opts.claudeArgs.length) {
+          const nextArg = opts.claudeArgs[index + 1];
+          if (!nextArg.startsWith("-")) {
+            const value = nextArg;
+            opts.claudeArgs = opts.claudeArgs.filter((_, i) => i !== index && i !== index + 1);
+            return { found: true, value };
+          }
+        }
+        if (!withValue) {
+          opts.claudeArgs = opts.claudeArgs.filter((_, i) => i !== index);
+          return { found: true };
+        }
+        return { found: false };
+      }
+    }
+    return { found: false };
+  };
+  const sessionIdFlag = extractFlag(["--session-id"], true);
+  if (sessionIdFlag.found && sessionIdFlag.value) {
+    startFrom = null;
+    logger.debug(`[ClaudeLocal] Using explicit --session-id: ${sessionIdFlag.value}`);
+  }
+  if (!startFrom && !sessionIdFlag.value) {
+    const resumeFlag = extractFlag(["--resume", "-r"], true);
+    if (resumeFlag.found) {
+      if (resumeFlag.value) {
+        startFrom = resumeFlag.value;
+        logger.debug(`[ClaudeLocal] Using provided session ID from --resume: ${startFrom}`);
+      } else {
+        const lastSession = claudeFindLastSession(opts.path);
+        if (lastSession) {
+          startFrom = lastSession;
+          logger.debug(`[ClaudeLocal] --resume: Found last session: ${lastSession}`);
+        }
+      }
+    }
+  }
+  if (!startFrom && !sessionIdFlag.value) {
+    const continueFlag = extractFlag(["--continue", "-c"], false);
+    if (continueFlag.found) {
+      const lastSession = claudeFindLastSession(opts.path);
+      if (lastSession) {
+        startFrom = lastSession;
+        logger.debug(`[ClaudeLocal] --continue: Found last session: ${lastSession}`);
+      }
+    }
+  }
+  const explicitSessionId = sessionIdFlag.value || null;
+  let newSessionId = null;
+  let effectiveSessionId = startFrom;
+  if (!opts.hookSettingsPath) {
+    newSessionId = startFrom ? null : explicitSessionId || randomUUID();
+    effectiveSessionId = startFrom || newSessionId;
+    if (startFrom) {
+      logger.debug(`[ClaudeLocal] Resuming session: ${startFrom}`);
+      opts.onSessionFound(startFrom);
+    } else if (explicitSessionId) {
+      logger.debug(`[ClaudeLocal] Using explicit session ID: ${explicitSessionId}`);
+      opts.onSessionFound(explicitSessionId);
+    } else {
+      logger.debug(`[ClaudeLocal] Generated new session ID: ${newSessionId}`);
+      opts.onSessionFound(newSessionId);
+    }
+  } else {
+    if (startFrom) {
+      logger.debug(`[ClaudeLocal] Will resume existing session: ${startFrom}`);
+    } else if (hasUserSessionControl) {
+      logger.debug(`[ClaudeLocal] User passed ${hasContinueFlag ? "--continue" : "--resume"} flag, session ID will be determined by hook`);
+    } else {
+      logger.debug(`[ClaudeLocal] Fresh start, session ID will be provided by hook`);
+    }
+  }
+  let thinking = false;
+  let stopThinkingTimeout = null;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  try {
+    process.stdin.pause();
+    await new Promise((r, reject) => {
+      const args = [];
+      if (!opts.hookSettingsPath) {
+        const hasResumeFlag2 = opts.claudeArgs?.includes("--resume") || opts.claudeArgs?.includes("-r");
+        if (startFrom) {
+          args.push("--resume", startFrom);
+        } else if (!hasResumeFlag2 && newSessionId) {
+          args.push("--session-id", newSessionId);
+        }
+      } else {
+        if (startFrom) {
+          args.push("--resume", startFrom);
+        }
+      }
+      args.push("--append-system-prompt", systemPrompt);
+      if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+        args.push("--mcp-config", JSON.stringify({ mcpServers: opts.mcpServers }));
+      }
+      if (opts.allowedTools && opts.allowedTools.length > 0) {
+        args.push("--allowedTools", opts.allowedTools.join(","));
+      }
+      if (opts.claudeArgs) {
+        args.push(...opts.claudeArgs);
+      }
+      if (opts.hookSettingsPath) {
+        args.push("--settings", opts.hookSettingsPath);
+        logger.debug(`[ClaudeLocal] Using hook settings: ${opts.hookSettingsPath}`);
+      }
+      if (!claudeCliPath || !existsSync(claudeCliPath)) {
+        throw new Error("Claude local launcher not found. Please ensure HAPPY_PROJECT_ROOT is set correctly for development.");
+      }
+      const env = {
+        ...process.env,
+        ...opts.claudeEnvVars
+      };
+      logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
+      const child = spawn("node", [claudeCliPath, ...args], {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+        signal: opts.abort,
+        cwd: opts.path,
+        env
+      });
+      if (child.stdio[3]) {
+        const rl = createInterface({
+          input: child.stdio[3],
+          crlfDelay: Infinity
+        });
+        const activeFetches = /* @__PURE__ */ new Map();
+        rl.on("line", (line) => {
+          try {
+            const message = JSON.parse(line);
+            switch (message.type) {
+              case "fetch-start":
+                activeFetches.set(message.id, {
+                  hostname: message.hostname,
+                  path: message.path,
+                  startTime: message.timestamp
+                });
+                if (stopThinkingTimeout) {
+                  clearTimeout(stopThinkingTimeout);
+                  stopThinkingTimeout = null;
+                }
+                updateThinking(true);
+                break;
+              case "fetch-end":
+                activeFetches.delete(message.id);
+                if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
+                  stopThinkingTimeout = setTimeout(() => {
+                    if (activeFetches.size === 0) {
+                      updateThinking(false);
+                    }
+                    stopThinkingTimeout = null;
+                  }, 500);
+                }
+                break;
+              default:
+                logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
+            }
+          } catch (e) {
+            logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
+          }
+        });
+        rl.on("error", (err) => {
+          console.error("Error reading from fd 3:", err);
+        });
+        child.on("exit", () => {
+          if (stopThinkingTimeout) {
+            clearTimeout(stopThinkingTimeout);
+          }
+          updateThinking(false);
+        });
+      }
+      child.on("error", (error) => {
+      });
+      child.on("exit", (code, signal) => {
+        if (signal === "SIGTERM" && opts.abort.aborted) {
+          r();
+        } else if (signal) {
+          reject(new Error(`Process terminated with signal: ${signal}`));
+        } else if (code !== 0 && code !== null) {
+          reject(new ExitCodeError(code));
+        } else {
+          r();
+        }
+      });
+    });
+  } finally {
+    process.stdin.resume();
+    if (stopThinkingTimeout) {
+      clearTimeout(stopThinkingTimeout);
+      stopThinkingTimeout = null;
+    }
+    updateThinking(false);
+  }
+  return effectiveSessionId;
+}
+
+var claudeLocal$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ExitCodeError: ExitCodeError,
+    claudeCliPath: claudeCliPath,
+    claudeLocal: claudeLocal
+});
+
+export { ExitCodeError as E, claudeLocal as a, claudeCheckSession as b, claudeCliPath as c, claudeLocal$1 as d, getProjectPath as g, systemPrompt as s };

package/dist/codex/happyMcpStdioBridge.cjs

@@ -5,7 +5,10 @@ var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
 var z = require('zod');
-require('../mcpToolSchemas-f-kttjFw.cjs');
+require('../prompt-BTWDZZO0.cjs');
+require('../mcpToolSchemas-DK42yoZ_.cjs');
+require('../trimIdent-4gvk9Wk6.cjs');
+require('../common-CZvSRU4p.cjs');
 
 function parseArgs(argv) {
   let url = null;

package/dist/codex/happyMcpStdioBridge.mjs

@@ -3,7 +3,10 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { z } from 'zod';
-import '../mcpToolSchemas-CdPXJQmb.mjs';
+import '../prompt-BsAZsPbo.mjs';
+import '../mcpToolSchemas-CjeTfrAs.mjs';
+import '../trimIdent-BAjmv_TG.mjs';
+import '../common-BdNgghUJ.mjs';
 
 function parseArgs(argv) {
   let url = null;

package/dist/common-BdNgghUJ.mjs

@@ -0,0 +1,75 @@
+const ORCHESTRATOR_PROVIDERS = ["claude", "codex", "gemini"];
+const ORCHESTRATOR_ENV_KEYS = {
+  oneshot: "HAPPY_ORCH_ONESHOT",
+  executionId: "HAPPY_ORCH_EXECUTION_ID",
+  runId: "HAPPY_ORCH_RUN_ID",
+  taskId: "HAPPY_ORCH_TASK_ID",
+  executionType: "HAPPY_ORCH_EXECUTION_TYPE",
+  childSessionId: "HAPPY_ORCH_CHILD_SESSION_ID",
+  modelMode: "HAPPY_ORCH_MODEL_MODE",
+  promptB64: "HAPPY_ORCH_PROMPT_B64",
+  timeoutMs: "HAPPY_ORCH_TIMEOUT_MS",
+  workingDirectory: "HAPPY_ORCH_WORKING_DIRECTORY"
+};
+function isOrchestratorProvider(value) {
+  return typeof value === "string" && ORCHESTRATOR_PROVIDERS.includes(value);
+}
+function mapFinishStatus(reason) {
+  if (reason.watchdogTriggered) {
+    return "timeout";
+  }
+  if (reason.cancelRequested) {
+    return "cancelled";
+  }
+  if (reason.exitCode === 0) {
+    return "completed";
+  }
+  return "failed";
+}
+function encodePromptToBase64(prompt) {
+  return Buffer.from(prompt, "utf8").toString("base64");
+}
+function decodePromptFromBase64(promptB64) {
+  return Buffer.from(promptB64, "base64").toString("utf8");
+}
+function buildOrchestratorEnv(payload) {
+  const env = {
+    [ORCHESTRATOR_ENV_KEYS.oneshot]: "1",
+    [ORCHESTRATOR_ENV_KEYS.executionId]: payload.executionId,
+    [ORCHESTRATOR_ENV_KEYS.runId]: payload.runId,
+    [ORCHESTRATOR_ENV_KEYS.taskId]: payload.taskId,
+    [ORCHESTRATOR_ENV_KEYS.executionType]: payload.executionType,
+    [ORCHESTRATOR_ENV_KEYS.promptB64]: encodePromptToBase64(payload.prompt),
+    [ORCHESTRATOR_ENV_KEYS.timeoutMs]: String(payload.timeoutMs)
+  };
+  if (payload.childSessionId) {
+    env[ORCHESTRATOR_ENV_KEYS.childSessionId] = payload.childSessionId;
+  }
+  if (payload.workingDirectory) {
+    env[ORCHESTRATOR_ENV_KEYS.workingDirectory] = payload.workingDirectory;
+  }
+  if (payload.model) {
+    env[ORCHESTRATOR_ENV_KEYS.modelMode] = payload.model;
+  }
+  return env;
+}
+function appendOutputChunk(current, chunk, maxChars) {
+  const combined = `${current}${chunk}`;
+  if (combined.length <= maxChars) {
+    return combined;
+  }
+  return combined.slice(combined.length - maxChars);
+}
+function buildOutputSummary(stdout, stderr, maxChars = 400) {
+  const source = stdout.trim() ? stdout : stderr;
+  if (!source.trim()) {
+    return null;
+  }
+  const lastLine = source.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).at(-1) ?? source.trim();
+  if (lastLine.length <= maxChars) {
+    return lastLine;
+  }
+  return `${lastLine.slice(0, maxChars - 3)}...`;
+}
+
+export { ORCHESTRATOR_ENV_KEYS as O, buildOrchestratorEnv as a, buildOutputSummary as b, appendOutputChunk as c, decodePromptFromBase64 as d, isOrchestratorProvider as i, mapFinishStatus as m };

package/dist/common-CZvSRU4p.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+const ORCHESTRATOR_PROVIDERS = ["claude", "codex", "gemini"];
+const ORCHESTRATOR_ENV_KEYS = {
+  oneshot: "HAPPY_ORCH_ONESHOT",
+  executionId: "HAPPY_ORCH_EXECUTION_ID",
+  runId: "HAPPY_ORCH_RUN_ID",
+  taskId: "HAPPY_ORCH_TASK_ID",
+  executionType: "HAPPY_ORCH_EXECUTION_TYPE",
+  childSessionId: "HAPPY_ORCH_CHILD_SESSION_ID",
+  modelMode: "HAPPY_ORCH_MODEL_MODE",
+  promptB64: "HAPPY_ORCH_PROMPT_B64",
+  timeoutMs: "HAPPY_ORCH_TIMEOUT_MS",
+  workingDirectory: "HAPPY_ORCH_WORKING_DIRECTORY"
+};
+function isOrchestratorProvider(value) {
+  return typeof value === "string" && ORCHESTRATOR_PROVIDERS.includes(value);
+}
+function mapFinishStatus(reason) {
+  if (reason.watchdogTriggered) {
+    return "timeout";
+  }
+  if (reason.cancelRequested) {
+    return "cancelled";
+  }
+  if (reason.exitCode === 0) {
+    return "completed";
+  }
+  return "failed";
+}
+function encodePromptToBase64(prompt) {
+  return Buffer.from(prompt, "utf8").toString("base64");
+}
+function decodePromptFromBase64(promptB64) {
+  return Buffer.from(promptB64, "base64").toString("utf8");
+}
+function buildOrchestratorEnv(payload) {
+  const env = {
+    [ORCHESTRATOR_ENV_KEYS.oneshot]: "1",
+    [ORCHESTRATOR_ENV_KEYS.executionId]: payload.executionId,
+    [ORCHESTRATOR_ENV_KEYS.runId]: payload.runId,
+    [ORCHESTRATOR_ENV_KEYS.taskId]: payload.taskId,
+    [ORCHESTRATOR_ENV_KEYS.executionType]: payload.executionType,
+    [ORCHESTRATOR_ENV_KEYS.promptB64]: encodePromptToBase64(payload.prompt),
+    [ORCHESTRATOR_ENV_KEYS.timeoutMs]: String(payload.timeoutMs)
+  };
+  if (payload.childSessionId) {
+    env[ORCHESTRATOR_ENV_KEYS.childSessionId] = payload.childSessionId;
+  }
+  if (payload.workingDirectory) {
+    env[ORCHESTRATOR_ENV_KEYS.workingDirectory] = payload.workingDirectory;
+  }
+  if (payload.model) {
+    env[ORCHESTRATOR_ENV_KEYS.modelMode] = payload.model;
+  }
+  return env;
+}
+function appendOutputChunk(current, chunk, maxChars) {
+  const combined = `${current}${chunk}`;
+  if (combined.length <= maxChars) {
+    return combined;
+  }
+  return combined.slice(combined.length - maxChars);
+}
+function buildOutputSummary(stdout, stderr, maxChars = 400) {
+  const source = stdout.trim() ? stdout : stderr;
+  if (!source.trim()) {
+    return null;
+  }
+  const lastLine = source.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).at(-1) ?? source.trim();
+  if (lastLine.length <= maxChars) {
+    return lastLine;
+  }
+  return `${lastLine.slice(0, maxChars - 3)}...`;
+}
+
+exports.ORCHESTRATOR_ENV_KEYS = ORCHESTRATOR_ENV_KEYS;
+exports.appendOutputChunk = appendOutputChunk;
+exports.buildOrchestratorEnv = buildOrchestratorEnv;
+exports.buildOutputSummary = buildOutputSummary;
+exports.decodePromptFromBase64 = decodePromptFromBase64;
+exports.isOrchestratorProvider = isOrchestratorProvider;
+exports.mapFinishStatus = mapFinishStatus;

package/dist/{config-0Xnc8ARM.cjs → config-CclB3QW9.cjs}

@@ -4,32 +4,19 @@ var fs = require('fs');
 var path = require('path');
 var os = require('os');
 var child_process = require('child_process');
-var persistence = require('./types-DvTsFaqR.cjs');
-var constants = require('./constants-B4x1K7by.cjs');
-require('axios');
-require('chalk');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var constants = require('./constants-E_UWYTo3.cjs');
+require('node:fs/promises');
 require('node:fs');
 require('node:os');
 require('node:path');
-require('node:events');
-require('socket.io-client');
 require('zod');
-require('@paralleldrive/cuid2');
 require('node:crypto');
 require('tweetnacl');
-require('node:child_process');
-require('node:fs/promises');
-require('node:util');
-require('util');
-require('fs/promises');
-require('url');
-require('node:module');
-require('ws');
-require('crypto');
-require('@stablelib/base64');
-require('node:readline');
-require('expo-server-sdk');
-require('./mcpToolSchemas-f-kttjFw.cjs');
+require('chalk');
+require('./prompt-BTWDZZO0.cjs');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('./common-CZvSRU4p.cjs');
 
 function readGeminiLocalConfig() {
   let token = null;
@@ -52,14 +39,14 @@ function readGeminiLocalConfig() {
           const foundToken = config.access_token || config.token || config.apiKey || config.GEMINI_API_KEY;
           if (foundToken && typeof foundToken === "string") {
             token = foundToken;
-            persistence.logger.debug(`[Gemini] Found token in ${configPath}`);
+            logger.logger.debug(`[Gemini] Found token in ${configPath}`);
           }
         }
         if (!model) {
           const foundModel = config.model || config.GEMINI_MODEL;
           if (foundModel && typeof foundModel === "string") {
             model = foundModel;
-            persistence.logger.debug(`[Gemini] Found model in ${configPath}: ${model}`);
+            logger.logger.debug(`[Gemini] Found model in ${configPath}: ${model}`);
           }
         }
         if (!googleCloudProject) {
@@ -69,11 +56,11 @@ function readGeminiLocalConfig() {
             if (config.googleCloudProjectEmail && typeof config.googleCloudProjectEmail === "string") {
               googleCloudProjectEmail = config.googleCloudProjectEmail;
             }
-            persistence.logger.debug(`[Gemini] Found Google Cloud Project in ${configPath}: ${googleCloudProject}${googleCloudProjectEmail ? ` (for ${googleCloudProjectEmail})` : ""}`);
+            logger.logger.debug(`[Gemini] Found Google Cloud Project in ${configPath}: ${googleCloudProject}${googleCloudProjectEmail ? ` (for ${googleCloudProjectEmail})` : ""}`);
           }
         }
       } catch (error) {
-        persistence.logger.debug(`[Gemini] Failed to read config from ${configPath}:`, error);
+        logger.logger.debug(`[Gemini] Failed to read config from ${configPath}:`, error);
       }
     }
   }
@@ -86,10 +73,10 @@ function readGeminiLocalConfig() {
       }).trim();
       if (gcloudToken && gcloudToken.length > 0) {
         token = gcloudToken;
-        persistence.logger.debug("[Gemini] Found token via gcloud Application Default Credentials");
+        logger.logger.debug("[Gemini] Found token via gcloud Application Default Credentials");
       }
     } catch (error) {
-      persistence.logger.debug("[Gemini] gcloud Application Default Credentials not available");
+      logger.logger.debug("[Gemini] gcloud Application Default Credentials not available");
     }
   }
   if (!googleCloudProject) {
@@ -97,7 +84,7 @@ function readGeminiLocalConfig() {
     if (envProject) {
       googleCloudProject = envProject;
       googleCloudProjectEmail = null;
-      persistence.logger.debug(`[Gemini] Found Google Cloud Project from env: ${googleCloudProject}`);
+      logger.logger.debug(`[Gemini] Found Google Cloud Project from env: ${googleCloudProject}`);
     }
   }
   return { token, model, googleCloudProject, googleCloudProjectEmail };
@@ -111,9 +98,9 @@ function determineGeminiModel(explicitModel, localConfig) {
     }
   } else {
     const envModel = process.env[constants.GEMINI_MODEL_ENV];
-    persistence.logger.debug(`[Gemini] Model selection: env[GEMINI_MODEL_ENV]=${envModel}, localConfig.model=${localConfig.model}, DEFAULT=${constants.DEFAULT_GEMINI_MODEL}`);
+    logger.logger.debug(`[Gemini] Model selection: env[GEMINI_MODEL_ENV]=${envModel}, localConfig.model=${localConfig.model}, DEFAULT=${constants.DEFAULT_GEMINI_MODEL}`);
     const model = envModel || localConfig.model || constants.DEFAULT_GEMINI_MODEL;
-    persistence.logger.debug(`[Gemini] Selected model: ${model}`);
+    logger.logger.debug(`[Gemini] Selected model: ${model}`);
     return model;
   }
 }
@@ -129,15 +116,15 @@ function saveGeminiModelToConfig(model) {
       try {
         config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
       } catch (error) {
-        persistence.logger.debug(`[Gemini] Failed to read existing config, creating new one`);
+        logger.logger.debug(`[Gemini] Failed to read existing config, creating new one`);
         config = {};
       }
     }
     config.model = model;
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-    persistence.logger.debug(`[Gemini] Saved model "${model}" to ${configPath}`);
+    logger.logger.debug(`[Gemini] Saved model "${model}" to ${configPath}`);
   } catch (error) {
-    persistence.logger.debug(`[Gemini] Failed to save model to config:`, error);
+    logger.logger.debug(`[Gemini] Failed to save model to config:`, error);
   }
 }
 function saveGoogleCloudProjectToConfig(projectId, email) {
@@ -160,9 +147,9 @@ function saveGoogleCloudProjectToConfig(projectId, email) {
       config.googleCloudProjectEmail = email;
     }
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-    persistence.logger.debug(`[Gemini] Saved Google Cloud Project "${projectId}"${email ? ` for ${email}` : ""} to ${configPath}`);
+    logger.logger.debug(`[Gemini] Saved Google Cloud Project "${projectId}"${email ? ` for ${email}` : ""} to ${configPath}`);
   } catch (error) {
-    persistence.logger.debug(`[Gemini] Failed to save Google Cloud Project to config:`, error);
+    logger.logger.debug(`[Gemini] Failed to save Google Cloud Project to config:`, error);
     throw error;
   }
 }