@agentrix/cli 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -6,7 +6,7 @@ var chalk = require('chalk');
 var shared = require('@agentrix/shared');
 var node_crypto = require('node:crypto');
 var axios = require('axios');
-var logger = require('./logger-B7C5x_8c.cjs');
+var _package = require('./logger-BZmE9yGJ.cjs');
 var fs$1 = require('node:fs');
 var node_readline = require('node:readline');
 var fs = require('fs');
@@ -58,10 +58,10 @@ async function delay(ms) {
 }
 
 async function daemonPost(path, body) {
-  const state = await logger.machine.readDaemonState();
+  const state = await _package.machine.readDaemonState();
   if (!state?.port) {
     const errorMessage = "No daemon running, no state file found";
-    logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    _package.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
     return {
       error: errorMessage
     };
@@ -70,7 +70,7 @@ async function daemonPost(path, body) {
     process.kill(state.pid, 0);
   } catch (error) {
     const errorMessage = "Daemon is not running, file is stale";
-    logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    _package.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
     return {
       error: errorMessage
     };
@@ -86,7 +86,7 @@ async function daemonPost(path, body) {
     });
     if (!response.ok) {
       const errorMessage = `Request failed: ${path}, HTTP ${response.status}`;
-      logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+      _package.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
       return {
         error: errorMessage
       };
@@ -94,7 +94,7 @@ async function daemonPost(path, body) {
     return await response.json();
   } catch (error) {
     const errorMessage = `Request failed: ${path}, ${error instanceof Error ? error.message : "Unknown error"}`;
-    logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    _package.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
     return {
       error: errorMessage
     };
@@ -118,7 +118,7 @@ async function stopDaemonHttp() {
   await daemonPost("/stop");
 }
 async function checkIfDaemonRunningAndCleanupStaleState() {
-  const state = await logger.machine.readDaemonState();
+  const state = await _package.machine.readDaemonState();
   if (!state) {
     return false;
   }
@@ -126,60 +126,60 @@ async function checkIfDaemonRunningAndCleanupStaleState() {
     process.kill(state.pid, 0);
     return true;
   } catch {
-    logger.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    _package.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
     await cleanupDaemonState();
     return false;
   }
 }
 async function isLatestDaemonRunning() {
-  logger.logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  _package.logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
   const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
   if (!runningDaemon) {
-    logger.logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    _package.logger.debug("[DAEMON CONTROL] No daemon running, returning false");
     return false;
   }
-  const state = await logger.machine.readDaemonState();
+  const state = await _package.machine.readDaemonState();
   if (!state) {
-    logger.logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    _package.logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
     return false;
   }
   try {
-    const packageJsonPath = require$$1.join(logger.projectPath(), "package.json");
+    const packageJsonPath = require$$1.join(_package.projectPath(), "package.json");
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
     const currentCliVersion = packageJson.version;
-    logger.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.cliVersion}`);
+    _package.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.cliVersion}`);
     return currentCliVersion === state.cliVersion;
   } catch (error) {
-    logger.logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
+    _package.logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
   }
 }
 async function cleanupDaemonState() {
   try {
-    await logger.machine.clearDaemonState();
-    logger.logger.debug("[DAEMON RUN] Daemon state file removed");
+    await _package.machine.clearDaemonState();
+    _package.logger.debug("[DAEMON RUN] Daemon state file removed");
   } catch (error) {
-    logger.logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+    _package.logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
   }
 }
 async function stopDaemon() {
   try {
-    const state = await logger.machine.readDaemonState();
+    const state = await _package.machine.readDaemonState();
     if (!state) {
-      logger.logger.debug("No daemon state found");
+      _package.logger.debug("No daemon state found");
       return;
     }
-    logger.logger.debug(`Stopping daemon with PID ${state.pid}`);
+    _package.logger.debug(`Stopping daemon with PID ${state.pid}`);
     try {
       await stopDaemonHttp();
       await waitForProcessDeath(state.pid, 2e3);
       return;
     } catch (error) {
-      logger.logger.debug("HTTP stop failed, will force kill", error);
+      _package.logger.debug("HTTP stop failed, will force kill", error);
     }
     process.kill(state.pid, "SIGKILL");
   } catch (error) {
-    logger.logger.debug("Error stopping daemon", error);
+    _package.logger.debug("Error stopping daemon", error);
   }
 }
 async function waitForProcessDeath(pid, timeout) {
@@ -202,10 +202,10 @@ function generateWebAuthUrl(publicKey, machineId) {
   };
   const authDataJson = JSON.stringify(authData);
   const authDataBase64 = shared.encodeBase64(new TextEncoder().encode(authDataJson), "base64url");
-  return `${logger.machine.webappUrl}/terminal/connect?auth=${authDataBase64}`;
+  return `${_package.machine.webappUrl}/terminal/connect?auth=${authDataBase64}`;
 }
 async function handleAuthLogout() {
-  const credentials = await logger.machine.readCredentials();
+  const credentials = await _package.machine.readCredentials();
   if (!credentials) {
     console.log(chalk.yellow("Not currently authenticated"));
     return;
@@ -227,7 +227,7 @@ async function handleAuthLogout() {
         console.log(chalk.gray("Stopped daemon"));
       } catch {
       }
-      const paths = logger.machine.getStatePaths();
+      const paths = _package.machine.getStatePaths();
       if (fs$1.existsSync(paths.rootDir)) {
         fs$1.rmSync(paths.rootDir, { recursive: true, force: true });
         console.log(chalk.gray(`Removed agentrix home directory`));
@@ -241,7 +241,7 @@ async function handleAuthLogout() {
   }
 }
 async function handleAuthStatus() {
-  const credentials = await logger.machine.readCredentials();
+  const credentials = await _package.machine.readCredentials();
   console.log(chalk.bold("\nAuthentication Status\n"));
   if (!credentials) {
     console.log(chalk.red("\u2717 Not authenticated"));
@@ -258,7 +258,7 @@ async function handleAuthStatus() {
     console.log(chalk.yellow("\u26A0\uFE0F  Machine not registered"));
   }
   console.log(chalk.gray(`
-  Data directory: ${logger.machine.agentrixHomeDir}`));
+  Data directory: ${_package.machine.agentrixHomeDir}`));
   try {
     const running = await checkIfDaemonRunningAndCleanupStaleState();
     if (running) {
@@ -274,32 +274,32 @@ async function handleAuthStatus() {
 async function openBrowser(url) {
   try {
     if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
-      logger.logger.debug("[browser] Headless environment detected, skipping browser open");
+      _package.logger.debug("[browser] Headless environment detected, skipping browser open");
       return false;
     }
-    logger.logger.debug(`[browser] Attempting to open URL: ${url}`);
+    _package.logger.debug(`[browser] Attempting to open URL: ${url}`);
     await open(url);
-    logger.logger.debug("[browser] Browser opened successfully");
+    _package.logger.debug("[browser] Browser opened successfully");
     return true;
   } catch (error) {
-    logger.logger.debug("[browser] Failed to open browser:", error);
+    _package.logger.debug("[browser] Failed to open browser:", error);
     return false;
   }
 }
 
 async function doAuth() {
   console.clear();
-  const machineId = logger.machine.generateMachineId();
+  const machineId = _package.machine.generateMachineId();
   const secret = new Uint8Array(node_crypto.randomBytes(32));
   const keypair = await shared.createKeyPairWithUit8Array(secret);
   try {
-    console.log(`[AUTH] Sending auth request to: ${logger.machine.serverUrl}/v1/auth/machine`);
+    console.log(`[AUTH] Sending auth request to: ${_package.machine.serverUrl}/v1/auth/machine`);
     console.log(`[AUTH] Public key: ${shared.encodeBase64(keypair.publicKey).substring(0, 20)}...`);
     const requestBody = {
       machineId
     };
     await axios.post(
-      `${logger.machine.serverUrl}/v1/auth/machine`,
+      `${_package.machine.serverUrl}/v1/auth/machine`,
       requestBody
     );
     console.log(`[AUTH] Auth request sent successfully`);
@@ -344,7 +344,7 @@ async function waitForAuthentication(keypair, machineId) {
     while (!cancelled) {
       try {
         const response = await axios.get(
-          `${logger.machine.serverUrl}/v1/auth/machine?machineId=${machineId}`
+          `${_package.machine.serverUrl}/v1/auth/machine?machineId=${machineId}`
         );
         if (response.data.state === "authorized") {
           const token = response.data.token;
@@ -380,7 +380,7 @@ async function syncMachine(credentials, metadata, userPublicKey, keypair) {
       requestBody.dataEncryptionKey = shared.encryptMachineEncryptionKey(keypair.publicKey, shared.generateAESKey(), shared.decodeBase64(userPublicKey));
     }
     await axios.post(
-      `${logger.machine.serverUrl}/v1/machines/sync`,
+      `${_package.machine.serverUrl}/v1/machines/sync`,
       requestBody,
       {
         headers: {
@@ -398,9 +398,9 @@ async function syncMachine(credentials, metadata, userPublicKey, keypair) {
   }
 }
 async function authAndSetupMachineIfNeeded() {
-  const localCredentials = await logger.machine.readCredentials();
+  const localCredentials = await _package.machine.readCredentials();
   if (localCredentials) {
-    logger.logger.info("[AUTH] Using existing credentials");
+    _package.logger.info("[AUTH] Using existing credentials");
     return localCredentials;
   }
   const cloudAuthToken = process.env.CLOUD_AUTH_TOKEN;
@@ -413,7 +413,7 @@ async function authAndSetupMachineIfNeeded() {
       token: cloudAuthToken,
       machineId: cloudDeviceId
     };
-    logger.logger.info("[AUTH] Cloud mode detected, using CLOUD_AUTH_TOKEN");
+    _package.logger.info("[AUTH] Cloud mode detected, using CLOUD_AUTH_TOKEN");
   } else {
     const authResult = await doAuth();
     if (!authResult.credentials || !authResult.userPublicKey) {
@@ -423,9 +423,9 @@ async function authAndSetupMachineIfNeeded() {
     keypair = authResult.keypair;
     userPublicKey = authResult.userPublicKey;
   }
-  await logger.machine.writeCredentials(credentials);
-  await syncMachine(credentials, logger.machine.metadata(), userPublicKey, keypair);
-  logger.logger.info("[AUTH] Machine setup completed");
+  await _package.machine.writeCredentials(credentials);
+  await syncMachine(credentials, _package.machine.metadata(), userPublicKey, keypair);
+  _package.logger.info("[AUTH] Machine setup completed");
   return credentials;
 }
 
@@ -11522,32 +11522,32 @@ var mimeTypesExports = requireMimeTypes();
 
 async function decryptDataEncryptionKey(encryptedKey) {
   try {
-    const secretKey = await logger.machine.getSecretKey();
+    const secretKey = await _package.machine.getSecretKey();
     if (!secretKey) {
-      logger.logger.warn("[WORKSPACE] Machine secret key not available");
+      _package.logger.warn("[WORKSPACE] Machine secret key not available");
       return null;
     }
     const encryptedKeyBytes = shared.decodeBase64(encryptedKey);
     const decryptedKey = shared.decryptWithEphemeralKey(encryptedKeyBytes, secretKey);
     if (!decryptedKey) {
-      logger.logger.warn("[WORKSPACE] Failed to decrypt dataEncryptionKey");
+      _package.logger.warn("[WORKSPACE] Failed to decrypt dataEncryptionKey");
       return null;
     }
     return decryptedKey;
   } catch (error) {
-    logger.logger.warn("[WORKSPACE] Error decrypting dataEncryptionKey:", error);
+    _package.logger.warn("[WORKSPACE] Error decrypting dataEncryptionKey:", error);
     return null;
   }
 }
 function resolveFilePath(userId, taskId, relativePath) {
-  const workspaceBase = path__namespace.dirname(logger.machine.resolveProjectDir(void 0, userId, taskId));
+  const workspaceBase = path__namespace.dirname(_package.machine.resolveProjectDir(void 0, userId, taskId));
   return path__namespace.join(workspaceBase, relativePath);
 }
 function sendResponse(client, response) {
   if (client) {
     client.send("workspace-file-response", response);
   } else {
-    logger.logger.error("[WORKSPACE] Cannot send workspace-file-response: client not available");
+    _package.logger.error("[WORKSPACE] Cannot send workspace-file-response: client not available");
   }
 }
 function createErrorResponse(requestId, taskId, code, message) {
@@ -11560,7 +11560,7 @@ function createErrorResponse(requestId, taskId, code, message) {
   };
 }
 function handleNotModified(client, requestId, taskId, filePath) {
-  logger.logger.debug(`[WORKSPACE] File not modified: ${filePath}`);
+  _package.logger.debug(`[WORKSPACE] File not modified: ${filePath}`);
   sendResponse(client, {
     eventId: shared.createEventId(),
     requestId,
@@ -11600,7 +11600,7 @@ async function handleDirectory(client, requestId, taskId, filePath, stats, maxSi
   });
 }
 function handleFileTooLarge(client, requestId, taskId, filePath, stats, mimeType, maxSizeBytes) {
-  logger.logger.warn(`[WORKSPACE] File too large (${stats.size} bytes > ${maxSizeBytes} bytes): ${filePath}`);
+  _package.logger.warn(`[WORKSPACE] File too large (${stats.size} bytes > ${maxSizeBytes} bytes): ${filePath}`);
   sendResponse(client, {
     eventId: shared.createEventId(),
     requestId,
@@ -11649,13 +11649,13 @@ async function handleFile(client, requestId, taskId, filePath, stats, dataEncryp
 function workspaceFileRequestHandler(context) {
   return async (data) => {
     const { taskId, userId, relativePath, requestId, maxFileSizeMB, ifModifiedSince, dataEncryptionKey } = data;
-    logger.logger.debug(`[WORKSPACE] File request: taskId=${taskId}, userId=${userId}, relativePath=${relativePath}, maxFileSizeMB=${maxFileSizeMB}, ifModifiedSince=${ifModifiedSince}, hasEncryptionKey=${!!dataEncryptionKey}`);
+    _package.logger.debug(`[WORKSPACE] File request: taskId=${taskId}, userId=${userId}, relativePath=${relativePath}, maxFileSizeMB=${maxFileSizeMB}, ifModifiedSince=${ifModifiedSince}, hasEncryptionKey=${!!dataEncryptionKey}`);
     try {
       const maxSizeMB = maxFileSizeMB || 10;
       const maxSizeBytes = maxSizeMB * 1024 * 1024;
       const filePath = resolveFilePath(userId, taskId, relativePath);
       if (!fs__namespace.existsSync(filePath)) {
-        logger.logger.warn(`[WORKSPACE] File not found: ${filePath}`);
+        _package.logger.warn(`[WORKSPACE] File not found: ${filePath}`);
         sendResponse(context.client, createErrorResponse(requestId, taskId, "file_not_found", "File or directory not found"));
         return;
       }
@@ -11678,7 +11678,7 @@ function workspaceFileRequestHandler(context) {
         return;
       }
     } catch (error) {
-      logger.logger.error(`[WORKSPACE] Failed to handle workspace-file-request: ${error.message}`, error);
+      _package.logger.error(`[WORKSPACE] Failed to handle workspace-file-request: ${error.message}`, error);
       const errorCode = error.code === "ENOENT" ? "file_not_found" : error.code === "EACCES" ? "permission_denied" : "unknown_error";
       sendResponse(context.client, createErrorResponse(requestId, taskId, errorCode, error.message));
     }
@@ -11688,28 +11688,28 @@ function workspaceFileRequestHandler(context) {
 function createTaskHandler(context) {
   return async (data, callback) => {
     try {
-      logger.logger.info(`[EVENT HANDLER] create-task: ${data.taskId}, agentType=${data.agentType}, agentId=${data.agentId}`);
+      _package.logger.info(`[EVENT HANDLER] create-task: ${data.taskId}, agentType=${data.agentType}, agentId=${data.agentId}`);
       const result = await context.workerManager.startWorker(data);
       callback(result);
     } catch (error) {
-      logger.logger.warn(`[EVENT HANDLER] Failed to handle create-task ${data.taskId}`, error);
+      _package.logger.warn(`[EVENT HANDLER] Failed to handle create-task ${data.taskId}`, error);
     }
   };
 }
 function resumeTaskHandler(context) {
   return async (data, callback) => {
-    logger.logger.debug(`[EVENT HANDLER] resume-task: ${data.taskId}, agentSessionId=${data.agentSessionId}`);
+    _package.logger.debug(`[EVENT HANDLER] resume-task: ${data.taskId}, agentSessionId=${data.agentSessionId}`);
     try {
       const result = await context.workerManager.startWorker(data);
       callback(result);
     } catch (error) {
-      logger.logger.warn(`[EVENT HANDLER] Failed to handle resume-task ${data.taskId}`, error);
+      _package.logger.warn(`[EVENT HANDLER] Failed to handle resume-task ${data.taskId}`, error);
     }
   };
 }
 function shutdownMachineHandler(context) {
   return async (data) => {
-    logger.logger.info("[EVENT HANDLER] shutdown-machine received", data);
+    _package.logger.info("[EVENT HANDLER] shutdown-machine received", data);
     context.requestShutdown("agentrix-app", data.reason);
   };
 }
@@ -11770,16 +11770,16 @@ class MachineClient {
 
 let caffeinateProcess = null;
 function startCaffeinate() {
-  if (logger.machine.disableCaffeinate) {
-    logger.logger.debug("[caffeinate] Caffeinate disabled via AGENTRIX_DISABLE_CAFFEINATE environment variable");
+  if (_package.machine.disableCaffeinate) {
+    _package.logger.debug("[caffeinate] Caffeinate disabled via AGENTRIX_DISABLE_CAFFEINATE environment variable");
     return false;
   }
   if (process.platform !== "darwin") {
-    logger.logger.debug("[caffeinate] Not on macOS, skipping caffeinate");
+    _package.logger.debug("[caffeinate] Not on macOS, skipping caffeinate");
     return false;
   }
   if (caffeinateProcess && !caffeinateProcess.killed) {
-    logger.logger.debug("[caffeinate] Caffeinate already running");
+    _package.logger.debug("[caffeinate] Caffeinate already running");
     return true;
   }
   try {
@@ -11788,30 +11788,30 @@ function startCaffeinate() {
       detached: false
     });
     caffeinateProcess.on("error", (error) => {
-      logger.logger.debug("[caffeinate] Error starting caffeinate:", error);
+      _package.logger.debug("[caffeinate] Error starting caffeinate:", error);
       caffeinateProcess = null;
     });
     caffeinateProcess.on("exit", (code, signal) => {
-      logger.logger.debug(`[caffeinate] Process exited with code ${code}, signal ${signal}`);
+      _package.logger.debug(`[caffeinate] Process exited with code ${code}, signal ${signal}`);
       caffeinateProcess = null;
     });
-    logger.logger.info(`[caffeinate] Started with PID ${caffeinateProcess.pid}`);
+    _package.logger.info(`[caffeinate] Started with PID ${caffeinateProcess.pid}`);
     setupCleanupHandlers();
     return true;
   } catch (error) {
-    logger.logger.info("[caffeinate] Failed to start caffeinate:", error);
+    _package.logger.info("[caffeinate] Failed to start caffeinate:", error);
     return false;
   }
 }
 let isStopping = false;
 async function stopCaffeinate() {
   if (isStopping) {
-    logger.logger.info("[caffeinate] Already stopping, skipping");
+    _package.logger.info("[caffeinate] Already stopping, skipping");
     return;
   }
   if (caffeinateProcess && !caffeinateProcess.killed) {
     isStopping = true;
-    logger.logger.info(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
+    _package.logger.info(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
     try {
       caffeinateProcess.kill("SIGTERM");
       await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -11821,7 +11821,7 @@ async function stopCaffeinate() {
       caffeinateProcess = null;
       isStopping = false;
     } catch (error) {
-      logger.logger.info("[caffeinate] Error stopping caffeinate:", error);
+      _package.logger.info("[caffeinate] Error stopping caffeinate:", error);
       isStopping = false;
     }
   }
@@ -11841,11 +11841,11 @@ function setupCleanupHandlers() {
   process.on("SIGUSR1", cleanup);
   process.on("SIGUSR2", cleanup);
   process.on("uncaughtException", (error) => {
-    logger.logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
+    _package.logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
     cleanup();
   });
   process.on("unhandledRejection", (reason, promise) => {
-    logger.logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
+    _package.logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
     cleanup();
   });
 }
@@ -11927,9 +11927,9 @@ function getEnvironmentInfo() {
     DEBUG: process.env.DEBUG,
     workingDirectory: process.cwd(),
     processArgv: process.argv,
-    agentrixDir: logger.machine.agentrixHomeDir,
-    serverUrl: logger.machine.serverUrl,
-    logsDir: logger.machine.getStatePaths().logsDir,
+    agentrixDir: _package.machine.agentrixHomeDir,
+    serverUrl: _package.machine.serverUrl,
+    logsDir: _package.machine.getStatePaths().logsDir,
     processPid: process.pid,
     nodeVersion: process.version,
     platform: process.platform,
@@ -11947,12 +11947,12 @@ async function runDoctorCommand(filter) {
   console.log(chalk.bold.cyan("\n\u{1FA7A} Agentrix CLI Doctor\n"));
   if (filter === "all") {
     console.log(chalk.bold("\u{1F4CB} Basic Information"));
-    console.log(`Agentrix CLI Version: ${chalk.green(logger.packageJson.version)}`);
+    console.log(`Agentrix CLI Version: ${chalk.green(_package.packageJson.version)}`);
     console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
     console.log(`Node.js Version: ${chalk.green(process.version)}`);
     console.log("");
     console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
-    const projectRoot = logger.projectPath();
+    const projectRoot = _package.projectPath();
     const wrapperPath = path.join(projectRoot, "bin", "agentrix.mjs");
     const cliEntrypoint = path.join(projectRoot, "dist", "index.mjs");
     console.log(`Project Root: ${chalk.blue(projectRoot)}`);
@@ -11962,9 +11962,9 @@ async function runDoctorCommand(filter) {
     console.log(`CLI Exists: ${fs$1.existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
     console.log("");
     console.log(chalk.bold("\u2699\uFE0F  Configuration"));
-    console.log(`Agentrix Home: ${chalk.blue(logger.machine.agentrixHomeDir)}`);
-    console.log(`Server URL: ${chalk.blue(logger.machine.serverUrl)}`);
-    console.log(`Logs Dir: ${chalk.blue(logger.machine.getStatePaths().logsDir)}`);
+    console.log(`Agentrix Home: ${chalk.blue(_package.machine.agentrixHomeDir)}`);
+    console.log(`Server URL: ${chalk.blue(_package.machine.serverUrl)}`);
+    console.log(`Logs Dir: ${chalk.blue(_package.machine.getStatePaths().logsDir)}`);
     console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
     const env = getEnvironmentInfo();
     console.log(`AGENTRIX_HOME_DIR: ${env.AGENTRIX_HOME_DIR ? chalk.green(env.AGENTRIX_HOME_DIR) : chalk.gray("not set")}`);
@@ -11974,7 +11974,7 @@ async function runDoctorCommand(filter) {
     console.log(`NODE_ENV: ${env.NODE_ENV ? chalk.green(env.NODE_ENV) : chalk.gray("not set")}`);
     console.log(chalk.bold("\n\u{1F510} Authentication"));
     try {
-      const credentials = await logger.machine.readCredentials();
+      const credentials = await _package.machine.readCredentials();
       if (credentials) {
         console.log(chalk.green("\u2713 Authenticated (credentials found)"));
       } else {
@@ -11987,7 +11987,7 @@ async function runDoctorCommand(filter) {
   console.log(chalk.bold("\n\u{1F916} Daemon Status"));
   try {
     const isRunning = await checkIfDaemonRunningAndCleanupStaleState();
-    const state = await logger.machine.readDaemonState();
+    const state = await _package.machine.readDaemonState();
     if (isRunning && state) {
       console.log(chalk.green("\u2713 Daemon is running"));
       console.log(`  PID: ${state.pid}`);
@@ -12003,7 +12003,7 @@ async function runDoctorCommand(filter) {
     }
     if (state) {
       console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
-      const paths = logger.machine.getStatePaths();
+      const paths = _package.machine.getStatePaths();
       console.log(chalk.blue(`Location: ${paths.daemonStateFile}`));
       console.log(chalk.gray(JSON.stringify(state, null, 2)));
     }
@@ -12070,7 +12070,7 @@ function startDaemonControlServer({
       }
     }, async (request) => {
       const { sessionId, metadata } = request.body;
-      logger.logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
+      _package.logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
       registerSession(sessionId, metadata);
       return { status: "ok" };
     });
@@ -12088,7 +12088,7 @@ function startDaemonControlServer({
       }
     }, async () => {
       const children = getChildren();
-      logger.logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
+      _package.logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
       return {
         children: children.filter((child) => child.taskId !== void 0).map((child) => ({
           startedBy: child.startedBy,
@@ -12110,7 +12110,7 @@ function startDaemonControlServer({
       }
     }, async (request) => {
       const { sessionId } = request.body;
-      logger.logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
+      _package.logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
       const success = stopSession(sessionId);
       return { success };
     });
@@ -12123,25 +12123,25 @@ function startDaemonControlServer({
         }
       }
     }, async () => {
-      logger.logger.debug("[CONTROL SERVER] Stop daemon request received");
+      _package.logger.debug("[CONTROL SERVER] Stop daemon request received");
       setTimeout(() => {
-        logger.logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
+        _package.logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
         requestShutdown();
       }, 50);
       return { status: "stopping" };
     });
     app.listen({ port: 0, host: "127.0.0.1" }, (err, address) => {
       if (err) {
-        logger.logger.info("[CONTROL SERVER] Failed to start:", err);
+        _package.logger.info("[CONTROL SERVER] Failed to start:", err);
         throw err;
       }
       const port = parseInt(address.split(":").pop());
-      logger.logger.info(`[CONTROL SERVER] Started on port ${port}`);
+      _package.logger.info(`[CONTROL SERVER] Started on port ${port}`);
       resolve({
         port,
         stop: async () => {
           await app.close();
-          logger.logger.info("[CONTROL SERVER] Server stopped");
+          _package.logger.info("[CONTROL SERVER] Server stopped");
         }
       });
     });
@@ -12149,12 +12149,12 @@ function startDaemonControlServer({
 }
 
 function spawnAgentrixCLI(args, options = {}) {
-  const projectRoot = logger.projectPath();
+  const projectRoot = _package.projectPath();
   const entrypoint = path.join(projectRoot, "dist", "index.mjs");
   const nodeArgs = ["--no-warnings", "--no-deprecation", entrypoint, ...args];
   if (!fs$1.existsSync(entrypoint)) {
     const errorMessage = `Entrypoint ${entrypoint} does not exist`;
-    logger.logger.debug(`[SPAWN Agentrix CLI] ${errorMessage}`);
+    _package.logger.debug(`[SPAWN Agentrix CLI] ${errorMessage}`);
     throw new Error(errorMessage);
   }
   return child_process.spawn("node", nodeArgs, options);
@@ -12192,10 +12192,10 @@ class TaskWorkerManager {
   registerTaskWorker(taskId, sessionMetadata) {
     const pid = sessionMetadata.pid;
     if (!pid) {
-      logger.logger.warn(`[SESSION] Missing PID for task ${taskId}`);
+      _package.logger.warn(`[SESSION] Missing PID for task ${taskId}`);
       return;
     }
-    logger.logger.info(`[SESSION] Registered task ${taskId}, PID: ${pid}`);
+    _package.logger.info(`[SESSION] Registered task ${taskId}, PID: ${pid}`);
     const existingSession = this.pidToTrackedSession.get(pid);
     if (existingSession && existingSession.taskId === taskId) {
       const awaiter = this.pidToAwaiter.get(pid);
@@ -12234,8 +12234,8 @@ class TaskWorkerManager {
       opCode: options.eventId
     };
     try {
-      const cwd = logger.machine.resolveProjectDir(options.cwd, options.userId, options.taskId);
-      logger.machine.writeTaskInput(options);
+      const cwd = _package.machine.resolveProjectDir(options.cwd, options.userId, options.taskId);
+      _package.machine.writeTaskInput(options);
       const args = [
         "worker",
         "--type",
@@ -12259,10 +12259,10 @@ class TaskWorkerManager {
       });
       if (process.env.DEBUG) {
         workerProcess.stdout?.on("data", (data) => {
-          logger.logger.debug(`[Daemon] worker stdout: ${data.toString()}`);
+          _package.logger.debug(`[Daemon] worker stdout: ${data.toString()}`);
         });
         workerProcess.stderr?.on("data", (data) => {
-          logger.logger.debug(`[Daemon] worker stderr: ${data.toString()}`);
+          _package.logger.debug(`[Daemon] worker stderr: ${data.toString()}`);
         });
       }
       if (!workerProcess.pid) {
@@ -12270,7 +12270,7 @@ class TaskWorkerManager {
         ack.message = "Failed to start worker - no PID";
         return ack;
       }
-      logger.logger.info(`[SESSION] Worker started, PID: ${workerProcess.pid}`);
+      _package.logger.info(`[SESSION] Worker started, PID: ${workerProcess.pid}`);
       this.trackWorkerProcess(options, workerProcess);
       const [promise, resolver] = createPromiseWithTimeout({
         timeoutMs: 15e3,
@@ -12297,14 +12297,14 @@ class TaskWorkerManager {
       try {
         const target = session.childProcess ? session.childProcess : { kill: (sig) => process.kill(pid, sig) };
         target.kill("SIGTERM");
-        logger.logger.info(`[SESSION] Task ${taskId} stopped`);
+        _package.logger.info(`[SESSION] Task ${taskId} stopped`);
       } catch (error) {
-        logger.logger.warn(`[SESSION] Failed to stop task ${taskId}:`, error);
+        _package.logger.warn(`[SESSION] Failed to stop task ${taskId}:`, error);
       }
       this.pidToTrackedSession.delete(pid);
       return true;
     }
-    logger.logger.warn(`[SESSION] Task ${taskId} not found`);
+    _package.logger.warn(`[SESSION] Task ${taskId} not found`);
     return false;
   }
   pruneStaleSessions() {
@@ -12317,7 +12317,7 @@ class TaskWorkerManager {
     }
   }
   shutdown() {
-    logger.logger.info("[SESSION] Shutting down all sessions");
+    _package.logger.info("[SESSION] Shutting down all sessions");
     for (const [pid, session] of this.pidToTrackedSession.entries()) {
       try {
         if (session.startedBy === "daemon" && session.childProcess) {
@@ -12326,7 +12326,7 @@ class TaskWorkerManager {
           process.kill(pid, "SIGTERM");
         }
       } catch (error) {
-        logger.logger.warn(`[SESSION] Failed to stop PID ${pid}:`, error);
+        _package.logger.warn(`[SESSION] Failed to stop PID ${pid}:`, error);
       }
     }
     this.pidToTrackedSession.clear();
@@ -12340,7 +12340,7 @@ function setupGracefulShutdown(options) {
   let requestShutdown;
   const shutdownPromise = new Promise((resolve) => {
     requestShutdown = (source, errorMessage) => {
-      logger.logger.info(`${prefix} Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
+      _package.logger.info(`${prefix} Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
       if (onShutdownRequest) {
         onShutdownRequest(source, errorMessage);
       }
@@ -12356,18 +12356,18 @@ function setupGracefulShutdown(options) {
   registerSignalHandler("SIGINT");
   registerSignalHandler("SIGTERM");
   process.on("uncaughtException", (error) => {
-    logger.logger.info(`${prefix} FATAL: Uncaught exception`, error);
-    logger.logger.info(`${prefix} Stack trace: ${error.stack}`);
+    _package.logger.info(`${prefix} FATAL: Uncaught exception`, error);
+    _package.logger.info(`${prefix} Stack trace: ${error.stack}`);
     requestShutdown("exception", error.message);
   });
   process.on("unhandledRejection", (reason) => {
-    logger.logger.info(`${prefix} FATAL: Unhandled promise rejection`, reason);
+    _package.logger.info(`${prefix} FATAL: Unhandled promise rejection`, reason);
     const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${reason}`);
-    logger.logger.info(`${prefix} Stack trace: ${error.stack}`);
+    _package.logger.info(`${prefix} Stack trace: ${error.stack}`);
     requestShutdown("exception", error.message);
   });
   process.on("exit", (code) => {
-    logger.logger.info(`${prefix} Process exiting with code: ${code}`);
+    _package.logger.info(`${prefix} Process exiting with code: ${code}`);
   });
   return {
     requestShutdown,
@@ -12376,33 +12376,33 @@ function setupGracefulShutdown(options) {
 }
 
 async function startDaemon() {
-  Object.assign(logger.logger, logger.createLogger({ type: "daemon" }));
+  Object.assign(_package.logger, _package.createLogger({ type: "daemon" }));
   const { requestShutdown, shutdownPromise } = setupGracefulShutdown({
     processType: "daemon"
   });
   console.log("[DAEMON RUN] Starting daemon process...");
-  logger.logger.debug("[DAEMON RUN] Environment", getEnvironmentInfo());
+  _package.logger.debug("[DAEMON RUN] Environment", getEnvironmentInfo());
   const running = await isLatestDaemonRunning();
   if (running) {
     console.log("Daemon already running...");
     process.exit(0);
   }
-  let daemonLockHandle = await logger.machine.acquireDaemonLock(5, 200);
+  let daemonLockHandle = await _package.machine.acquireDaemonLock(5, 200);
   while (!daemonLockHandle) {
     await stopDaemon();
-    daemonLockHandle = await logger.machine.acquireDaemonLock(5, 200);
+    daemonLockHandle = await _package.machine.acquireDaemonLock(5, 200);
     if (!daemonLockHandle) {
-      logger.logger.debug("[DAEMON RUN] cannot acquire daemon lock...");
+      _package.logger.debug("[DAEMON RUN] cannot acquire daemon lock...");
       process.exit(1);
     }
   }
   try {
     const caffeinateStarted = startCaffeinate();
     if (caffeinateStarted) {
-      logger.logger.debug("[DAEMON RUN] Sleep prevention enabled");
+      _package.logger.debug("[DAEMON RUN] Sleep prevention enabled");
     }
     const credentials = await authAndSetupMachineIfNeeded();
-    logger.logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    _package.logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const sessionManager = new TaskWorkerManager();
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
       getChildren: () => sessionManager.getCurrentSessions(),
@@ -12414,15 +12414,15 @@ async function startDaemon() {
       pid: process.pid,
       port: controlPort,
       startTime: (/* @__PURE__ */ new Date()).toLocaleString(),
-      cliVersion: logger.packageJson.version,
-      logPath: logger.getLogPath({ type: "daemon" })
+      cliVersion: _package.packageJson.version,
+      logPath: _package.getLogPath({ type: "daemon" })
     };
-    logger.machine.writeDaemonState(fileState);
-    logger.logger.debug("[DAEMON RUN] Daemon state written");
+    _package.machine.writeDaemonState(fileState);
+    _package.logger.debug("[DAEMON RUN] Daemon state written");
     const machineClient = new MachineClient(
       {
         machineId: credentials.machineId,
-        serverUrl: logger.machine.serverUrl.replace(/^http/, "ws"),
+        serverUrl: _package.machine.serverUrl.replace(/^http/, "ws"),
         path: "/v1/ws",
         auth: shared.machineAuth(credentials.token, credentials.machineId),
         keepAliveConfig: {
@@ -12439,32 +12439,32 @@ async function startDaemon() {
           intervalMs: 3e4,
           timeoutMs: 5e3
         },
-        logger: (message, ...args) => logger.logger.debug(`[DAEMON SOCKET] ${message}`, ...args)
+        logger: (message, ...args) => _package.logger.debug(`[DAEMON SOCKET] ${message}`, ...args)
       },
       sessionManager,
       { requestShutdown }
     );
     await machineClient.connect();
-    logger.logger.info("[DAEMON RUN] Machine client connected to server");
+    _package.logger.info("[DAEMON RUN] Machine client connected to server");
     const cleanupAndShutdown = async (source, errorMessage) => {
       await machineClient.disconnect();
       await stopControlServer();
       await cleanupDaemonState();
       await stopCaffeinate();
-      await logger.machine.releaseDaemonLock(daemonLockHandle);
-      logger.logger.info("[DAEMON RUN] Cleanup completed, exiting process");
+      await _package.machine.releaseDaemonLock(daemonLockHandle);
+      _package.logger.info("[DAEMON RUN] Cleanup completed, exiting process");
       process.exit(0);
     };
-    logger.logger.info("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
+    _package.logger.info("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
     const shutdownRequest = await shutdownPromise;
     await cleanupAndShutdown(shutdownRequest.source, shutdownRequest.errorMessage);
   } catch (error) {
-    logger.logger.info("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
+    _package.logger.info("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
     process.exit(1);
   }
 }
 
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(logger.logger$1);
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(_package.logger$1);
 
 const VALID_HOOK_NAMES = [
   // SDK native hooks
@@ -12528,14 +12528,14 @@ function createWorkerEventHandlers(context) {
       if (data.taskId !== context.taskId) {
         return;
       }
-      logger.logger.info(`[WORKER] Task ${context.taskId} cancelled`);
+      _package.logger.info(`[WORKER] Task ${context.taskId} cancelled`);
       await context.stopTask();
     },
     "stop-task": async (data) => {
       if (data.taskId !== context.taskId) {
         return;
       }
-      logger.logger.info(`[WORKER] Task ${context.taskId} stopped: ${data.reason || "no reason"}`);
+      _package.logger.info(`[WORKER] Task ${context.taskId} stopped: ${data.reason || "no reason"}`);
       await context.stopTask();
     },
     "task-message": async (data) => {
@@ -12674,7 +12674,7 @@ class WorkerClient {
       toolInput
     };
     this.client.send("require-permission", permissionRequest);
-    logger.logger.info(`[AGENT] Permission requested for tool: ${toolName}`);
+    _package.logger.info(`[AGENT] Permission requested for tool: ${toolName}`);
     return eventId;
   }
   sendUpdateTaskAgentSessionId(agentSessionId) {
@@ -12692,7 +12692,7 @@ class WorkerClient {
       title
     };
     this.client.send("change-task-title", event);
-    logger.logger.info(`[AGENT] Title changed to: ${title}`);
+    _package.logger.info(`[AGENT] Title changed to: ${title}`);
   }
   sendTaskArtifactsUpdated(commitHash, stats) {
     const event = {
@@ -12703,7 +12703,7 @@ class WorkerClient {
       stats
     };
     this.client.send("task-artifacts-updated", event);
-    logger.logger.info(`[AGENT] Task artifacts updated, commit: ${commitHash}, +${stats.totalInsertions}/-${stats.totalDeletions}`);
+    _package.logger.info(`[AGENT] Task artifacts updated, commit: ${commitHash}, +${stats.totalInsertions}/-${stats.totalDeletions}`);
   }
   // sendGitPushResponse removed in new flow
   async sendMergeRequest(summary, description) {
@@ -12713,12 +12713,12 @@ class WorkerClient {
       summary,
       description
     };
-    logger.logger.info(`[MERGE] Sending merge-request event for task ${this.context.taskId}`);
+    _package.logger.info(`[MERGE] Sending merge-request event for task ${this.context.taskId}`);
     const ack = await this.client.sendWithAck("merge-request", event);
     if (!ack.success) {
       throw new Error(`Failed to create pull request: ${ack.error || "Unknown error"}`);
     }
-    logger.logger.info(`[MERGE] Pull request created: #${ack.data.pullRequestNumber}`);
+    _package.logger.info(`[MERGE] Pull request created: #${ack.data.pullRequestNumber}`);
     return {
       pullRequestNumber: ack.data.pullRequestNumber,
       pullRequestUrl: ack.data.pullRequestUrl
@@ -12953,7 +12953,7 @@ async function setupWorkspace(options, hooks) {
       shouldManageGit: false
     };
   }
-  const workingDirectory = logger.machine.resolveProjectDir(cwd, userId, taskId);
+  const workingDirectory = _package.machine.resolveProjectDir(cwd, userId, taskId);
   if (gitUrl) {
     const initialCommitHash = await setupGitRepository(
       workingDirectory,
@@ -13013,11 +13013,11 @@ async function handleGitState(workingDirectory, userId, taskId, commitMessage) {
     hadUncommittedChanges = true;
   }
   const currentCommitHash = await getCurrentCommitHash(workingDirectory);
-  const initialHash = await logger.machine.readInitialCommitHash(userId, taskId);
+  const initialHash = await _package.machine.readInitialCommitHash(userId, taskId);
   if (!initialHash) {
     throw new Error(`Initial commit hash not found for task ${taskId}`);
   }
-  const dataDir = logger.machine.resolveDataDir(userId, taskId);
+  const dataDir = _package.machine.resolveDataDir(userId, taskId);
   const patchPath = await generateAndSavePatch(
     workingDirectory,
     initialHash,
@@ -13400,7 +13400,7 @@ class ClaudeWorker {
     if (this.options.input.dataEncryptionKey && this.options.secretKey) {
       this.dataEncryptionKey = shared.decryptWithEphemeralKey(shared.decodeBase64(this.options.input.dataEncryptionKey), this.options.secretKey);
     }
-    const logger$1 = this.createLogger({ type: "worker", taskId });
+    const logger = this.createLogger({ type: "worker", taskId });
     try {
       const hooks = await this.loadAgentHooks();
       const workspaceResult = await setupWorkspace({
@@ -13414,7 +13414,7 @@ class ClaudeWorker {
       shouldManageGit = workspaceResult.shouldManageGit;
       initialCommitHash = workspaceResult.initialCommitHash;
       if (initialCommitHash) {
-        await logger.machine.writeInitialCommitHash(userId, taskId, initialCommitHash);
+        await _package.machine.writeInitialCommitHash(userId, taskId, initialCommitHash);
         this.log("info", "GIT", `Initial commit: ${initialCommitHash}`);
         this.initialCommitHashForPR = initialCommitHash;
       }
@@ -13471,7 +13471,7 @@ class ClaudeWorker {
       workingDirectory,
       shouldManageGit,
       initialCommitHash,
-      logger: logger$1
+      logger
     };
     this.coordinator = new MessageCoordinator({
       workerType: "claude",
@@ -14047,7 +14047,7 @@ URL: ${result.pullRequestUrl}`
       taskId,
       machineId: this.credentials.machineId,
       cwd,
-      serverUrl: logger.machine.serverUrl.replace(/^http/, "ws"),
+      serverUrl: _package.machine.serverUrl.replace(/^http/, "ws"),
       path: "/v1/ws",
       auth: shared.workerAuth(this.credentials.token, this.credentials.machineId, taskId),
       dataEncryptionKey: this.dataEncryptionKey
@@ -15821,8 +15821,8 @@ class CodexWorker {
     let workingDirectory = process.cwd();
     let shouldManageGit = false;
     let initialCommitHash;
-    const logger$1 = this.createLogger({ type: "worker", taskId });
-    this.context = { ...this.context, logger: logger$1 };
+    const logger = this.createLogger({ type: "worker", taskId });
+    this.context = { ...this.context, logger };
     try {
       const workspaceResult = await setupWorkspace({
         gitUrl: this.options.input.gitUrl,
@@ -15835,7 +15835,7 @@ class CodexWorker {
       shouldManageGit = workspaceResult.shouldManageGit;
       initialCommitHash = workspaceResult.initialCommitHash;
       if (initialCommitHash) {
-        await logger.machine.writeInitialCommitHash(userId, taskId, initialCommitHash);
+        await _package.machine.writeInitialCommitHash(userId, taskId, initialCommitHash);
         this.log("info", "GIT", `Initial commit: ${initialCommitHash}`);
         this.initialCommitHashForPR = initialCommitHash;
       }
@@ -15891,7 +15891,7 @@ class CodexWorker {
       workingDirectory,
       shouldManageGit,
       initialCommitHash,
-      logger: logger$1
+      logger
     };
     this.coordinator = new MessageCoordinator({
       workerType: "codex",
@@ -16300,7 +16300,7 @@ URL: ${result.pullRequestUrl}`);
         } else if (block.type === "image" && block.source && block.source.url) {
           const url = block.source.url;
           try {
-            const attachmentsDir = logger.machine.resolveAttachmentsDir(
+            const attachmentsDir = _package.machine.resolveAttachmentsDir(
               this.options.input.userId,
               this.taskId
             );
@@ -16440,7 +16440,7 @@ URL: ${result.pullRequestUrl}`);
       taskId,
       machineId: this.credentials.machineId,
       cwd,
-      serverUrl: logger.machine.serverUrl.replace(/^http/, "ws"),
+      serverUrl: _package.machine.serverUrl.replace(/^http/, "ws"),
       path: "/v1/ws",
       auth: shared.workerAuth(this.credentials.token, this.credentials.machineId, taskId),
       dataEncryptionKey: this.dataEncryptionKey
@@ -16562,7 +16562,7 @@ const workerTypes = ["claude", "codex"];
 const workerRegistry = {
   claude: {
     async run({ credentials, startedBy, userId, taskId, idleTimeoutSecond, secretKey }) {
-      const input = logger.machine.readTaskInput(userId, taskId);
+      const input = _package.machine.readTaskInput(userId, taskId);
       const options = {
         startedBy,
         idleTimeoutSecond,
@@ -16574,7 +16574,7 @@ const workerRegistry = {
   },
   codex: {
     async run({ credentials, startedBy, userId, taskId, idleTimeoutSecond, secretKey }) {
-      const input = logger.machine.readTaskInput(userId, taskId);
+      const input = _package.machine.readTaskInput(userId, taskId);
       const options = {
         startedBy,
         idleTimeoutSecond,
@@ -16586,13 +16586,138 @@ const workerRegistry = {
   }
 };
 
-const cli = yargs(helpers.hideBin(process.argv)).scriptName("agentrix").version(logger.packageJson.version).usage("$0 <command> [options]").option("debug", {
+async function checkForUpgrades() {
+  const currentVersion = _package.packageJson.version;
+  try {
+    const output = child_process.execSync("npm view @agentrix/cli version", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      // Suppress stderr
+      timeout: 5e3
+      // 5 second timeout
+    }).trim();
+    const latestVersion = output;
+    const hasUpgrade = compareVersions(latestVersion, currentVersion) > 0;
+    return {
+      hasUpgrade,
+      currentVersion,
+      latestVersion
+    };
+  } catch (error) {
+    return {
+      hasUpgrade: false,
+      currentVersion,
+      latestVersion: null
+    };
+  }
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 > part2) return 1;
+    if (part1 < part2) return -1;
+  }
+  return 0;
+}
+function displayUpgradeNotification(result) {
+  if (!result.hasUpgrade || !result.latestVersion) {
+    return;
+  }
+  console.log("");
+  console.log(chalk.yellow("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk.yellow("\u2502") + "  " + chalk.bold("Upgrade Available") + "                             " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + "                                                    " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + `  Current: ${chalk.dim(result.currentVersion)}  \u2192  Latest: ${chalk.green.bold(result.latestVersion)}     ` + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + "                                                    " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + "  Run " + chalk.cyan.bold("agentrix upgrade") + " to upgrade              " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + "                                                    " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + "  To enable auto-upgrade, set:                     " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2502") + "  " + chalk.dim("AGENTRIX_DISABLE_AUTO_UPGRADE=false") + "             " + chalk.yellow("\u2502"));
+  console.log(chalk.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  console.log("");
+}
+function isAutoUpgradeDisabled() {
+  return process.env.AGENTRIX_DISABLE_AUTO_UPGRADE === "true";
+}
+async function performAutoUpgrade() {
+  try {
+    const { execSync: execSync2 } = await import('child_process');
+    console.log("");
+    console.log(chalk.blue("\u{1F504} Auto-upgrading Agentrix CLI..."));
+    let packageManager = "npm";
+    try {
+      execSync2("yarn --version", { stdio: "ignore" });
+      packageManager = "yarn";
+    } catch {
+    }
+    console.log(chalk.dim(`   Using ${packageManager}...`));
+    if (packageManager === "yarn") {
+      execSync2("yarn global upgrade @agentrix/cli", { stdio: "inherit" });
+    } else {
+      execSync2("npm update -g @agentrix/cli", { stdio: "inherit" });
+    }
+    console.log(chalk.green("\u2713 Upgrade complete"));
+    console.log("");
+    return true;
+  } catch (error) {
+    console.log("");
+    console.log(chalk.yellow("\u26A0\uFE0F  Auto-upgrade failed"));
+    console.log(chalk.dim("   You can upgrade manually with: agentrix upgrade"));
+    console.log("");
+    return false;
+  }
+}
+
+const cli = yargs(helpers.hideBin(process.argv)).scriptName("agentrix").version(_package.packageJson.version).usage("$0 <command> [options]").option("debug", {
   alias: "d",
   type: "boolean",
   describe: "Use local-debug mode (plaintext, for debugging)",
   global: true
 }).help("help").alias("h", "help").alias("v", "version").strict().epilog("For more information, visit https://github.com/xmz-ai/agentrix-cli");
-void logger.machine.getStatePaths;
+void _package.machine.getStatePaths;
+cli.command("upgrade", "Upgrade CLI to the latest version", {}, async (argv) => {
+  console.log(chalk.dim(`Current version: ${_package.packageJson.version}`));
+  const daemonRunning = await checkIfDaemonRunningAndCleanupStaleState();
+  const upgraded = await performAutoUpgrade();
+  if (!upgraded) {
+    process.exit(1);
+  }
+  if (daemonRunning) {
+    console.log(chalk.blue("Restarting daemon..."));
+    await stopDaemon();
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    const daemonProcess = spawnAgentrixCLI(["daemon"], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    });
+    daemonProcess.unref();
+    let started = false;
+    for (let i = 0; i < 50; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      if (await checkIfDaemonRunningAndCleanupStaleState()) {
+        started = true;
+        break;
+      }
+    }
+    if (started) {
+      console.log(chalk.green("\u2713 Daemon restarted successfully"));
+    } else {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon may still be starting. Run 'agentrix status' to check."));
+    }
+  }
+  try {
+    const { version } = await Promise.resolve().then(function () { return require('./logger-BZmE9yGJ.cjs'); }).then(function (n) { return n._package; });
+    console.log(chalk.green(`
+\u2713 Now running version: ${version}`));
+  } catch {
+    console.log(chalk.dim("\nRun 'agentrix --version' to see the new version"));
+  }
+  process.exit(0);
+});
 cli.command("doctor", "System diagnostics & troubleshooting", {}, async (argv) => {
   await runDoctorCommand();
   process.exit(0);
@@ -16716,7 +16841,7 @@ cli.command(
       }
       const startedBy = argv["started-by"];
       const credentials = await authAndSetupMachineIfNeeded();
-      const secretKey = await logger.machine.getSecretKey();
+      const secretKey = await _package.machine.getSecretKey();
       const userId = argv["user-id"];
       const taskId = argv["task-id"];
       const idleTimeoutSecond = argv["idle-timeout"];
@@ -16744,6 +16869,41 @@ cli.command(
       }
       process.exit(1);
     }
+    const skipUpgradeCheck = process.env.AGENTRIX_SKIP_UPGRADE_CHECK === "true";
+    const autoUpgradeDisabled = isAutoUpgradeDisabled();
+    let upgradeResult = {
+      hasUpgrade: false,
+      currentVersion: "",
+      latestVersion: null
+    };
+    if (!skipUpgradeCheck) {
+      upgradeResult = await checkForUpgrades();
+    }
+    if (upgradeResult.hasUpgrade) {
+      if (autoUpgradeDisabled) {
+        displayUpgradeNotification(upgradeResult);
+      } else {
+        const upgraded = await performAutoUpgrade();
+        if (upgraded) {
+          console.log(chalk.green("\u2713 Restarting with new version..."));
+          console.log("");
+          const { execSync } = await import('child_process');
+          try {
+            execSync("agentrix start", {
+              stdio: "inherit",
+              env: {
+                ...process.env,
+                // Set flag to prevent infinite upgrade loop
+                AGENTRIX_SKIP_UPGRADE_CHECK: "true"
+              }
+            });
+            process.exit(0);
+          } catch (error) {
+            console.log(chalk.yellow("\u26A0\uFE0F  Failed to restart, continuing with upgrade..."));
+          }
+        }
+      }
+    }
     const wasRunning = await isLatestDaemonRunning();
     if (!wasRunning) {
       console.log("Starting Agentrix background service...");