@agentrix/cli 0.0.11 → 0.0.13

package/dist/{index-Dw2iFM1t.cjs → index-B_Hr2zCf.cjs}

@@ -6,8 +6,7 @@ var chalk = require('chalk');
 var shared = require('@agentrix/shared');
 var node_crypto = require('node:crypto');
 var axios = require('axios');
-var _package = require('./logger-BZKdzrRM.cjs');
-var fs$1 = require('node:fs');
+var _package = require('./logger-DzYRcKN1.cjs');
 var node_readline = require('node:readline');
 var fs = require('fs');
 var path = require('path');
@@ -15,21 +14,24 @@ var os = require('node:os');
 var open = require('open');
 var socket_ioClient = require('socket.io-client');
 var node_events = require('node:events');
+var fs$1 = require('node:fs');
 var path$1 = require('node:path');
 var child_process = require('child_process');
 var psList = require('ps-list');
 var spawn = require('cross-spawn');
+var sandboxRuntime = require('@xmz-ai/sandbox-runtime');
+var platform_js = require('@xmz-ai/sandbox-runtime/dist/utils/platform.js');
 var fastify = require('fastify');
 var zod = require('zod');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
 var require$$7 = require('url');
+var promises = require('node:stream/promises');
 var claudeAgentSdk = require('@anthropic-ai/claude-agent-sdk');
 var simpleGit = require('simple-git');
-var promises = require('node:fs/promises');
+var promises$1 = require('node:fs/promises');
 var require$$1 = require('crypto');
 var codexSdk = require('@openai/codex-sdk');
 var v3 = require('zod/v3');
-var promises$1 = require('node:stream/promises');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -64,22 +66,12 @@ async function daemonPost(path, body) {
       error: errorMessage
     };
   }
-  try {
-    process.kill(state.pid, 0);
-  } catch (error) {
-    const errorMessage = "Daemon is not running, file is stale";
-    _package.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
-    return {
-      error: errorMessage
-    };
-  }
   try {
     const timeout = process.env.AGENTRIX_DAEMON_HTTP_TIMEOUT ? parseInt(process.env.AGENTRIX_DAEMON_HTTP_TIMEOUT) : 1e4;
-    const response = await fetch(`http://127.0.0.1:${state.port}${path}`, {
+    const response = await fetch(`http://agentrix-local.xmz.ai:${state.port}${path}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body || {}),
-      // Mostly increased for stress test
       signal: AbortSignal.timeout(timeout)
     });
     if (!response.ok) {
@@ -225,11 +217,8 @@ async function handleAuthLogout() {
         console.log(chalk.gray("Stopped daemon"));
       } catch {
       }
-      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`));
-      }
+      await _package.machine.clearCredentials();
+      console.log(chalk.gray(`Removed credentials`));
       console.log(chalk.green("\u2713 Successfully logged out"));
     } catch (error) {
       throw new Error(`Failed to logout: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -11885,7 +11874,7 @@ async function findAllAgentrixProcesses() {
 async function findRunawayAgentrixProcesses() {
   const allProcesses = await findAllAgentrixProcesses();
   return allProcesses.filter(
-    (p) => p.pid !== process.pid && (p.type === "daemon" || p.type === "worker")
+    (p) => p.pid !== process.pid && (p.type === "daemon" || p.type === "worker" || p.type === "upgrade-daemon")
   ).map((p) => ({ pid: p.pid, command: p.command }));
 }
 async function killRunawayAgentrixProcesses() {
@@ -11987,6 +11976,27 @@ async function runDoctorCommand(filter) {
     } catch (error) {
       console.log(chalk.red("\u274C Error reading credentials"));
     }
+    console.log(chalk.bold("\n\u{1F512} Sandbox Dependencies"));
+    const platform = platform_js.getPlatform();
+    if (sandboxRuntime.isSupportedPlatform(platform)) {
+      console.log(`Platform: ${chalk.green(platform)} (supported)`);
+      const depsOk = sandboxRuntime.checkSandboxDependencies();
+      if (depsOk) {
+        console.log(chalk.green("\u2713 All sandbox dependencies available"));
+      } else {
+        console.log(chalk.yellow("\u26A0\uFE0F  Some sandbox dependencies missing"));
+        if (platform === "linux") {
+          console.log(chalk.gray("   Required: bubblewrap, socat"));
+          console.log(chalk.gray("   Install: sudo apt install bubblewrap socat"));
+        } else if (platform === "macos") {
+          console.log(chalk.gray("   Required: ripgrep"));
+          console.log(chalk.gray("   Install: brew install ripgrep"));
+        }
+      }
+    } else {
+      console.log(`Platform: ${chalk.yellow(platform)} (not supported)`);
+      console.log(chalk.gray("  \u26A0\uFE0F  Sandbox will be disabled"));
+    }
   }
   console.log(chalk.bold("\n\u{1F916} Daemon Status"));
   try {
@@ -12211,9 +12221,11 @@ function createPromiseWithTimeout(options) {
 class TaskWorkerManager {
   pidToTrackedSession;
   pidToAwaiter;
-  constructor() {
+  sandboxPool;
+  constructor(sandboxPool) {
     this.pidToTrackedSession = /* @__PURE__ */ new Map();
     this.pidToAwaiter = /* @__PURE__ */ new Map();
+    this.sandboxPool = sandboxPool || null;
   }
   getCurrentSessions() {
     return Array.from(this.pidToTrackedSession.values());
@@ -12254,9 +12266,15 @@ class TaskWorkerManager {
     this.pidToTrackedSession.set(workerProcess.pid, tracked);
     workerProcess.on("exit", (code, signal) => {
       this.pidToTrackedSession.delete(workerProcess.pid);
+      if (this.sandboxPool) {
+        this.sandboxPool.disposeWorkerSandbox(data.taskId);
+      }
     });
     workerProcess.on("error", (error) => {
       this.pidToTrackedSession.delete(workerProcess.pid);
+      if (this.sandboxPool) {
+        this.sandboxPool.disposeWorkerSandbox(data.taskId);
+      }
     });
   }
   async startWorker(options) {
@@ -12281,14 +12299,53 @@ class TaskWorkerManager {
         "--idle-timeout",
         "120"
       ];
-      const workerProcess = spawnAgentrixCLI(args, {
-        cwd,
-        detached: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: {
-          ...process.env
+      let workerProcess;
+      if (this.sandboxPool?.isEnabled()) {
+        try {
+          const sandbox = await this.sandboxPool.createWorkerSandbox(
+            options.taskId,
+            options.userId,
+            cwd
+          );
+          if (!sandbox) {
+            throw new Error("Failed to create sandbox instance");
+          }
+          const { projectPath } = await Promise.resolve().then(function () { return require('./logger-DzYRcKN1.cjs'); }).then(function (n) { return n.machine$1; });
+          const { join } = await import('path');
+          const entrypoint = join(projectPath(), "dist", "index.mjs");
+          const nodeArgs = ["--no-warnings", "--no-deprecation", entrypoint, ...args];
+          const originalCommand = `"${process.execPath}" ${nodeArgs.map((a) => `"${a}"`).join(" ")}`;
+          const sandboxedCommand = await this.sandboxPool.wrapWorkerCommand(
+            options.taskId,
+            originalCommand
+          );
+          _package.logger.debug(`[SESSION] Sandboxed command for task ${options.taskId}: ${sandboxedCommand}`);
+          workerProcess = child_process.spawn(sandboxedCommand, {
+            shell: true,
+            cwd,
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+              ...process.env
+              // Environment variables controlled by SandboxManager
+            }
+          });
+          _package.logger.info(`[SESSION] Worker started with sandbox, PID: ${workerProcess.pid}`);
+        } catch (error) {
+          _package.logger.error(`[SESSION] Failed to setup sandbox for task ${options.taskId}:`, error);
+          ack.status = "failed";
+          ack.message = `Sandbox setup failed: ${error instanceof Error ? error.message : String(error)}`;
+          return ack;
         }
-      });
+      } else {
+        workerProcess = spawnAgentrixCLI(args, {
+          cwd,
+          detached: true,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: { ...process.env }
+        });
+        _package.logger.info(`[SESSION] Worker started without sandbox, PID: ${workerProcess.pid}`);
+      }
       if (process.env.DEBUG) {
         workerProcess.stdout?.on("data", (data) => {
           _package.logger.debug(`[Daemon] worker stdout: ${data.toString()}`);
@@ -12407,6 +12464,114 @@ function setupGracefulShutdown(options) {
   };
 }
 
+class SandboxPool {
+  networkManager = null;
+  workerSandboxes = /* @__PURE__ */ new Map();
+  settings = null;
+  platform;
+  constructor() {
+    this.platform = platform_js.getPlatform();
+  }
+  async initialize(settings) {
+    this.settings = settings;
+    if (!settings.enabled) {
+      _package.logger.info("[SANDBOX] Sandbox disabled via settings");
+      return false;
+    }
+    if (!sandboxRuntime.isSupportedPlatform(this.platform)) {
+      _package.logger.warn("[SANDBOX] Platform not supported, sandbox disabled");
+      return false;
+    }
+    try {
+      const apiHost = new URL(_package.machine.serverUrl).hostname;
+      const networkConfig = {
+        allowedDomains: [
+          apiHost,
+          ...settings.network.allowedDomains
+        ],
+        deniedDomains: settings.network.deniedDomains,
+        allowLocalBinding: false
+      };
+      this.networkManager = new sandboxRuntime.NetworkManager();
+      await this.networkManager.initialize(networkConfig);
+      _package.logger.info("[SANDBOX] Sandbox pool initialized successfully");
+      return true;
+    } catch (error) {
+      _package.logger.error("[SANDBOX] Failed to initialize:", error);
+      throw error;
+    }
+  }
+  async createWorkerSandbox(taskId, userId, workingDirectory) {
+    if (!this.networkManager || !this.settings?.enabled) {
+      return null;
+    }
+    try {
+      const taskDir = _package.machine.resolveTaskDir(userId, taskId);
+      const logsDir = _package.machine.getStatePaths().logsDir;
+      const baseFilesystem = this.settings.filesystem || {};
+      const baseEnv = this.settings.env || {};
+      const filesystemConfig = {
+        ...baseFilesystem,
+        allowWrite: [
+          ...baseFilesystem.allowWrite || [],
+          taskDir,
+          workingDirectory,
+          logsDir
+        ]
+      };
+      if (this.platform === "linux" && baseFilesystem.allowRead) {
+        filesystemConfig.allowRead = [
+          ...baseFilesystem.allowRead
+        ];
+      }
+      const instanceConfig = {
+        filesystem: filesystemConfig,
+        env: baseEnv
+      };
+      const sandbox = new sandboxRuntime.SandboxManager(this.networkManager, instanceConfig);
+      this.workerSandboxes.set(taskId, sandbox);
+      _package.logger.info(`[SANDBOX] Created sandbox for task ${taskId}`);
+      return sandbox;
+    } catch (error) {
+      _package.logger.error(`[SANDBOX] Failed to create sandbox for task ${taskId}:`, error);
+      return null;
+    }
+  }
+  async wrapWorkerCommand(taskId, command) {
+    const sandbox = this.workerSandboxes.get(taskId);
+    if (!sandbox) {
+      throw new Error(`No sandbox found for task ${taskId}`);
+    }
+    const wrapped = await sandbox.wrapWithSandbox(command);
+    _package.logger.debug(`[SANDBOX] Wrapped command for task ${taskId}`);
+    return wrapped;
+  }
+  disposeWorkerSandbox(taskId) {
+    const sandbox = this.workerSandboxes.get(taskId);
+    if (sandbox) {
+      sandbox.dispose();
+      this.workerSandboxes.delete(taskId);
+      _package.logger.debug(`[SANDBOX] Disposed sandbox for task ${taskId}`);
+    }
+  }
+  async shutdown() {
+    _package.logger.info("[SANDBOX] Shutting down sandbox pool");
+    for (const [taskId, sandbox] of this.workerSandboxes.entries()) {
+      sandbox.dispose();
+      _package.logger.debug(`[SANDBOX] Disposed sandbox for task ${taskId}`);
+    }
+    this.workerSandboxes.clear();
+    if (this.networkManager) {
+      await this.networkManager.shutdown();
+      this.networkManager = null;
+      _package.logger.info("[SANDBOX] Network manager shutdown complete");
+    }
+  }
+  isEnabled() {
+    return this.settings?.enabled === true;
+  }
+}
+
 async function startDaemon() {
   Object.assign(_package.logger, _package.createLogger({ type: "daemon" }));
   const { requestShutdown, shutdownPromise } = setupGracefulShutdown({
@@ -12435,7 +12600,9 @@ async function startDaemon() {
     }
     const credentials = await authAndSetupMachineIfNeeded();
     _package.logger.debug("[DAEMON RUN] Auth and machine setup complete");
-    const sessionManager = new TaskWorkerManager();
+    const sandboxPool = new SandboxPool();
+    await sandboxPool.initialize(_package.machine.getSandboxSettings());
+    const sessionManager = new TaskWorkerManager(sandboxPool);
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
       getChildren: () => sessionManager.getCurrentSessions(),
       stopSession: (id) => sessionManager.stopSession(id),
@@ -12483,6 +12650,7 @@ async function startDaemon() {
     const cleanupAndShutdown = async (source, errorMessage) => {
       await machineClient.disconnect();
       await stopControlServer();
+      await sandboxPool.shutdown();
       await cleanupDaemonState();
       await stopCaffeinate();
       await _package.machine.releaseDaemonLock(daemonLockHandle);
@@ -12599,14 +12767,6 @@ function createWorkerEventHandlers(context) {
           }
         }
       }
-    },
-    "require-permission-response": async (data) => {
-      if (data.taskId !== context.taskId) {
-        return;
-      }
-      if (context.onPermissionResponse) {
-        await context.onPermissionResponse(data);
-      }
     }
   };
 }
@@ -12647,7 +12807,6 @@ class WorkerClient {
       cwd: normalizedCwd,
       stopTask: options.stopTask,
       onTaskMessage: options.onTaskMessage,
-      onPermissionResponse: options.onPermissionResponse,
       onGitPush: options.onGitPush,
       dataEncryptionKey: config.dataEncryptionKey
     };
@@ -12676,26 +12835,32 @@ class WorkerClient {
     }
     this.client.disconnect();
   }
-  sendTaskMessage(message) {
-    const cwdWithSlash = this.context.cwd;
-    const cwdWithoutSlash = cwdWithSlash.slice(0, -1);
-    let content = JSON.stringify(message);
-    content = content.replaceAll(cwdWithSlash, "");
-    content = content.replaceAll(cwdWithoutSlash, ".");
-    let assistantMessage = JSON.parse(content);
+  sendTaskMessage(message, options) {
+    const { replaceCwd = true } = options || {};
+    let processedMessage = message;
+    if (replaceCwd) {
+      const cwdWithSlash = this.context.cwd;
+      const cwdWithoutSlash = cwdWithSlash.slice(0, -1);
+      let content = JSON.stringify(message);
+      content = content.replaceAll(cwdWithSlash, "");
+      content = content.replaceAll(cwdWithoutSlash, ".");
+      processedMessage = JSON.parse(content);
+    }
     let encryptedMessage;
     if (this.context.dataEncryptionKey) {
-      encryptedMessage = shared.encryptSdkMessage(assistantMessage, this.context.dataEncryptionKey);
-      assistantMessage = void 0;
+      encryptedMessage = shared.encryptSdkMessage(processedMessage, this.context.dataEncryptionKey);
+      processedMessage = void 0;
     }
+    const eventId = shared.createEventId();
     const payload = {
-      eventId: shared.createEventId(),
+      eventId,
       taskId: this.context.taskId,
       from: "worker",
-      message: assistantMessage,
+      message: processedMessage,
       encryptedMessage
     };
     this.client.send("task-message", payload);
+    return eventId;
   }
   sendWorkerInitializing() {
     const workerInitializingEvent = {
@@ -12706,12 +12871,13 @@ class WorkerClient {
     };
     this.client.send("worker-initializing", workerInitializingEvent);
   }
-  sendWorkerReady() {
+  sendWorkerReady(duration) {
     const workerReadyEvent = {
       eventId: shared.createEventId(),
       taskId: this.context.taskId,
       machineId: this.context.machineId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...duration !== void 0 && { duration }
     };
     this.client.send("worker-ready", workerReadyEvent);
   }
@@ -12769,17 +12935,13 @@ ${errorMessage}`,
     };
     this.sendTaskMessage(systemMessage);
   }
-  sendRequirePermission(toolName, toolInput) {
-    const eventId = shared.createEventId();
-    const permissionRequest = {
-      eventId,
-      taskId: this.context.taskId,
-      toolName,
-      toolInput
-    };
-    this.client.send("require-permission", permissionRequest);
-    _package.logger.info(`[AGENT] Permission requested for tool: ${toolName}`);
-    return eventId;
+  /**
+     * Send ask-user message to request user input
+     * @param questions - Array of questions (1-4)
+     * @returns eventId for tracking the request
+     */
+  sendAskUser(questions) {
+    return this.sendTaskMessage({ type: "ask_user", questions }, { replaceCwd: false });
   }
   sendUpdateTaskAgentSessionId(agentSessionId) {
     const updateSessionEvent = {
@@ -12834,7 +12996,108 @@ ${errorMessage}`,
     this.client.onEvent("cancel-task", handlers["cancel-task"]);
     this.client.onEvent("stop-task", handlers["stop-task"]);
     this.client.onEvent("task-message", handlers["task-message"]);
-    this.client.onEvent("require-permission-response", handlers["require-permission-response"]);
+  }
+}
+
+const MIME_TYPE_MAP = {
+  // Images
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  // Documents
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  // Text
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".ts": "application/typescript",
+  // Archives
+  ".zip": "application/zip",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip",
+  ".rar": "application/vnd.rar",
+  // Other
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".wav": "audio/wav",
+  ".avi": "video/x-msvideo"
+};
+function detectMimeType(extension) {
+  const normalized = extension.toLowerCase();
+  return MIME_TYPE_MAP[normalized] || "application/octet-stream";
+}
+function extractExtension(url) {
+  try {
+    const urlObj = new URL(url);
+    const pathExt = path$1.extname(urlObj.pathname);
+    if (pathExt) {
+      return pathExt;
+    }
+    const filenameParam = urlObj.searchParams.get("filename") || urlObj.searchParams.get("name") || urlObj.searchParams.get("file");
+    if (filenameParam) {
+      const paramExt = path$1.extname(filenameParam);
+      if (paramExt) {
+        return paramExt;
+      }
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+async function downloadFile(url, targetDir, preserveFilename = false) {
+  try {
+    const extension = extractExtension(url) || "";
+    let filename;
+    if (preserveFilename) {
+      try {
+        const urlPath = new URL(url).pathname;
+        const originalFilename = path$1.basename(urlPath);
+        filename = originalFilename && path$1.extname(originalFilename) ? originalFilename : `${node_crypto.randomUUID()}${extension || ".dat"}`;
+      } catch {
+        filename = `${node_crypto.randomUUID()}${extension || ".dat"}`;
+      }
+    } else {
+      filename = `${node_crypto.randomUUID()}${extension || ".dat"}`;
+    }
+    const filePath = path$1.join(targetDir, filename);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const contentType = response.headers.get("content-type");
+    const mimeType = contentType?.split(";")[0].trim() || detectMimeType(extension);
+    const nodeStream = response.body;
+    const fileStream = fs$1.createWriteStream(filePath);
+    await promises.pipeline(nodeStream, fileStream);
+    return {
+      filePath,
+      mimeType,
+      filename
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to download file from ${url}: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 }
 
@@ -12935,6 +13198,12 @@ async function hasUncommittedChanges(dir) {
   const status = await git.status();
   return !status.isClean();
 }
+async function gitStash(dir, message) {
+  const git = simpleGit(dir);
+  {
+    await git.stash(["push"]);
+  }
+}
 async function getCurrentCommitHash(dir) {
   const git = simpleGit(dir);
   const log = await git.log({ maxCount: 1 });
@@ -13024,6 +13293,30 @@ async function executeHook(hooks, hookName, input, logger) {
   }
 }
 
+async function checkUncommittedChanges(workingDirectory) {
+  const isRepo = await isGitRepository(workingDirectory);
+  if (!isRepo) {
+    return false;
+  }
+  return await hasUncommittedChanges(workingDirectory);
+}
+async function handleUncommittedChanges(workingDirectory, action) {
+  switch (action) {
+    case "Ignore":
+      console.log("[GIT] User chose to ignore uncommitted changes");
+      break;
+    case "Commit":
+      console.log("[GIT] Auto-committing uncommitted changes");
+      await autoCommit(workingDirectory, "WIP: Auto-commit before task");
+      break;
+    case "Stash":
+      console.log("[GIT] Stashing uncommitted changes");
+      await gitStash(workingDirectory);
+      break;
+    case "Abort":
+      throw new Error("Task aborted by user due to uncommitted changes");
+  }
+}
 function createTaskBranchName(taskId) {
   return `agentrix/${taskId}`;
 }
@@ -13063,17 +13356,6 @@ async function setupLocalWorkspace(workingDirectory, taskId, hooks) {
   const isRepo = await isGitRepository(workingDirectory);
   const isEmpty = isDirectoryEmpty(workingDirectory);
   if (isRepo) {
-    const hasChanges = await hasUncommittedChanges(workingDirectory);
-    if (hasChanges) {
-      throw new Error(
-        `Directory ${workingDirectory} has uncommitted changes.
-
-Please commit or stash your changes before starting:
-  git add . && git commit -m "WIP"
-or:
-  git stash`
-      );
-    }
     const hasCommits = await hasAnyCommits(workingDirectory);
     if (!hasCommits) {
       console.log("[GIT] Repository has no commits, creating initial commit");
@@ -13146,7 +13428,7 @@ async function generateAndSavePatch(workingDirectory, fromCommit, toCommit, data
     return void 0;
   }
   const patchPath = path$1.join(dataDir, "patch.diff");
-  await promises.writeFile(patchPath, patch);
+  await promises$1.writeFile(patchPath, patch);
   return patchPath;
 }
 async function handleGitState(workingDirectory, userId, taskId, commitMessage) {
@@ -13201,6 +13483,29 @@ async function markCommitAsSent(userId, taskId, commitHash) {
   await _package.machine.writeLastSentCommitHash(userId, taskId, commitHash);
 }
 
+function getDefaultPRPrompt(params) {
+  return `All changes have been pushed to branch "${params.branchName}".
+
+Commit range: ${params.initialCommitHash}..${params.currentCommitHash}
+
+Based on our conversation context, create a Pull Request:
+- Title: conventional commits format (feat/fix/docs/refactor/test/chore: description)
+- Description: what changed, why, and any important decisions
+
+Use mcp__agentrix__create_pr tool to create the PR.`;
+}
+function applyTemplateVariables(template, params) {
+  return template.replace(/\{\{initialCommitHash\}\}/g, params.initialCommitHash).replace(/\{\{currentCommitHash\}\}/g, params.currentCommitHash).replace(/\{\{branchName\}\}/g, params.branchName);
+}
+function buildPRPrompt(params, config) {
+  const defaultPrompt = getDefaultPRPrompt(params);
+  if (!config?.customTemplate) {
+    return defaultPrompt;
+  }
+  const customPrompt = applyTemplateVariables(config.customTemplate, params);
+  return config.mode === "replace" ? customPrompt : defaultPrompt + "\n\n" + customPrompt;
+}
+
 function executeCommandStreaming(command, cwd, callbacks, timeoutMs = 6e4) {
   return new Promise((resolve) => {
     const toolUseId = `shell_${require$$1.randomUUID().replace(/-/g, "")}`;
@@ -13318,6 +13623,7 @@ class MessageCoordinator {
   currentMessageId = null;
   messageIdCounter = 0;
   isStopped = false;
+  runStartTime = null;
   constructor(config) {
     this.config = config;
   }
@@ -13437,11 +13743,11 @@ class MessageCoordinator {
   async processBashCommand(envelope) {
     this.log("info", "COORDINATOR", `Processing bash command: ${envelope.content}`);
     await this.waitForState("idle");
-    this.workerState = "executing-command";
+    this.setWorkerState("running");
     try {
       await this.config.handlers.onBashCommand(envelope.content, envelope.originalMessage);
     } finally {
-      this.workerState = "idle";
+      this.setWorkerState("idle");
     }
   }
   /**
@@ -13450,11 +13756,11 @@ class MessageCoordinator {
   async processMergeRequest(envelope) {
     this.log("info", "COORDINATOR", "Processing merge-request command");
     await this.waitForState("idle");
-    this.workerState = "executing-command";
+    this.setWorkerState("running");
     try {
       await this.config.handlers.onMergeRequest(envelope.originalMessage);
     } finally {
-      this.workerState = "idle";
+      this.setWorkerState("idle");
     }
   }
   async waitForState(targetState) {
@@ -13474,11 +13780,24 @@ class MessageCoordinator {
   }
   /**
    * Set the worker state (called by worker when state changes)
+   * Automatically sends WebSocket events and tracks execution duration
    */
   setWorkerState(state) {
-    if (this.workerState !== state) {
-      this.log("info", "COORDINATOR", `Worker state: ${this.workerState} \u2192 ${state}`);
-      this.workerState = state;
+    if (this.workerState === state) return;
+    const prevState = this.workerState;
+    this.log("info", "COORDINATOR", `Worker state: ${prevState} \u2192 ${state}`);
+    this.workerState = state;
+    if (state === "running" && prevState === "idle") {
+      this.runStartTime = Date.now();
+      this.config.workClient.sendWorkRunning();
+    }
+    if (state === "idle" && prevState === "running") {
+      let duration;
+      if (this.runStartTime) {
+        duration = Date.now() - this.runStartTime;
+        this.runStartTime = null;
+      }
+      this.config.workClient.sendWorkerReady(duration);
     }
   }
   /**
@@ -13518,7 +13837,7 @@ class ClaudeWorker {
   messageQueue = [];
   messageResolverRef = { current: null };
   abortController = new AbortController();
-  permissionAwaiter = /* @__PURE__ */ new Map();
+  askUserAwaiter = /* @__PURE__ */ new Map();
   filteredToolUseIds = /* @__PURE__ */ new Set();
   timerManager;
   context;
@@ -13528,6 +13847,11 @@ class ClaudeWorker {
   dataEncryptionKey = null;
   coordinator;
   loadedHooks;
+  loadedAgentConfig;
+  // Pending permission requests: toolName -> Promise<'allow' | 'deny'> (to dedupe concurrent requests)
+  pendingPermissions = /* @__PURE__ */ new Map();
+  // Granted permissions cache: toolName -> true (to avoid repeated asks for same tool)
+  grantedPermissions = /* @__PURE__ */ new Set();
   async start() {
     try {
       await this.initialize();
@@ -13548,18 +13872,69 @@ class ClaudeWorker {
       if (this.timerManager) {
         this.timerManager.clearIdleTimer();
       }
+      if (this.logger) {
+        await new Promise((resolve) => {
+          this.logger.on("finish", resolve);
+          this.logger.end();
+        });
+      }
       process.exit(0);
     }
   }
   async initialize() {
     const taskId = this.options.input.taskId;
     const userId = this.options.input.userId;
-    let workingDirectory = process.cwd();
-    let initialCommitHash;
-    this.logger = await this.createLogger({ type: "worker", taskId });
+    this.logger = this.createWorkerLogger({ type: "worker", taskId });
     if (this.options.input.dataEncryptionKey && this.options.secretKey) {
       this.dataEncryptionKey = shared.decryptWithEphemeralKey(shared.decodeBase64(this.options.input.dataEncryptionKey), this.options.secretKey);
     }
+    if (this.options.input.encryptedMessage && this.dataEncryptionKey) {
+      this.options.input.message = shared.decryptSdkMessage(this.options.input.encryptedMessage, this.dataEncryptionKey) || void 0;
+    }
+    let workingDirectory = this.options.input.cwd ? this.options.input.cwd.replace(/^~/, os.homedir()) : process.cwd();
+    const idleTimeoutMs = Math.max(0, this.options.idleTimeoutSecond ?? 0) * 1e3;
+    this.timerManager = this.createIdleTimerManager(idleTimeoutMs, taskId);
+    const workerConfig = this.createWorkerClientConfig(userId, taskId, workingDirectory);
+    const workClient = new WorkerClient(workerConfig.config, workerConfig.handlers);
+    await workClient.connect();
+    workClient.sendWorkerInitializing();
+    this.context = {
+      credentials: this.credentials,
+      options: this.options,
+      workClient,
+      workingDirectory,
+      initialCommitHash: "",
+      // Will be set after setupWorkspace
+      logger: this.logger
+    };
+    this.coordinator = new MessageCoordinator({
+      workerType: "claude",
+      workClient,
+      handlers: {
+        onNormalMessage: async (message) => {
+          await this.enqueueMessage(message);
+        },
+        onBashCommand: async (command, _originalMessage) => {
+          await this.executeBashCommand(command);
+        },
+        onMergeRequest: async (_originalMessage) => {
+          await this.executeMergeRequest();
+        }
+      },
+      logger: (level, category, message) => {
+        const validLevel = level;
+        this.log(validLevel, category, message);
+      }
+    });
+    if (!this.options.input.gitUrl) {
+      const hasChanges = await checkUncommittedChanges(workingDirectory);
+      if (hasChanges) {
+        this.log("info", "GIT", "Detected uncommitted changes, asking user for action");
+        const action = await this.askUncommittedChangesAction();
+        await handleUncommittedChanges(workingDirectory, action);
+      }
+    }
+    let initialCommitHash;
     try {
       const hooks = await this.loadAgentHooks();
       const workspaceResult = await setupWorkspace({
@@ -13571,6 +13946,8 @@ class ClaudeWorker {
       }, hooks);
       workingDirectory = workspaceResult.workingDirectory;
       initialCommitHash = workspaceResult.initialCommitHash;
+      this.context.workingDirectory = workingDirectory;
+      this.context.initialCommitHash = initialCommitHash;
       await _package.machine.writeInitialCommitHash(userId, taskId, initialCommitHash);
       this.log("info", "GIT", `Initial commit: ${initialCommitHash}`);
       this.initialCommitHashForPR = initialCommitHash;
@@ -13578,20 +13955,10 @@ class ClaudeWorker {
       this.logGitStateResult(gitStateResult, "start");
     } catch (error) {
       this.log("error", "GIT", "Failed to setup workspace:", error);
-      const basicConfig = this.createBasicWorkerConfig(userId, taskId, workingDirectory);
       const errorMessage = error instanceof Error ? error.message : String(error);
-      await WorkerClient.sendErrorAndExit(
-        basicConfig,
-        `Failed to setup workspace: ${errorMessage}`
-      );
+      await workClient.sendErrorMessageAndExit(`Failed to setup workspace: ${errorMessage}`);
       process.exit(1);
     }
-    const idleTimeoutMs = Math.max(0, this.options.idleTimeoutSecond ?? 0) * 1e3;
-    this.timerManager = this.createIdleTimerManager(idleTimeoutMs, taskId);
-    const workerConfig = this.createWorkerClientConfig(userId, taskId, workingDirectory);
-    const workClient = new WorkerClient(workerConfig.config, workerConfig.handlers);
-    await workClient.connect();
-    workClient.sendWorkerInitializing();
     try {
       const metadata = {
         cwd: workingDirectory,
@@ -13608,35 +13975,6 @@ class ClaudeWorker {
     } catch (error) {
       this.log("warn", "DAEMON", "Failed to report session:", error);
     }
-    if (this.options.input.encryptedMessage && this.dataEncryptionKey) {
-      this.options.input.message = shared.decryptSdkMessage(this.options.input.encryptedMessage, this.dataEncryptionKey) || void 0;
-    }
-    this.context = {
-      credentials: this.credentials,
-      options: this.options,
-      workClient,
-      workingDirectory,
-      initialCommitHash,
-      logger: this.logger
-    };
-    this.coordinator = new MessageCoordinator({
-      workerType: "claude",
-      handlers: {
-        onNormalMessage: async (message) => {
-          await this.enqueueMessage(message);
-        },
-        onBashCommand: async (command, _originalMessage) => {
-          await this.executeBashCommand(command);
-        },
-        onMergeRequest: async (_originalMessage) => {
-          await this.executeMergeRequest();
-        }
-      },
-      logger: (level, category, message) => {
-        const validLevel = level;
-        this.log(validLevel, category, message);
-      }
-    });
   }
   async handleEvent() {
     if (this.options.input.message) {
@@ -13654,15 +13992,30 @@ class ClaudeWorker {
     }
     const hasChanges = await hasUncommittedChanges(this.context.workingDirectory);
     if (hasChanges) {
-      await autoCommit(this.context.workingDirectory, "Update task changes");
+      await autoCommit(this.context.workingDirectory, "Checkpoint for PR generation");
       this.log("info", "MERGE", "Auto-committed changes");
     }
+    const currentHash = await getCurrentCommitHash(this.context.workingDirectory);
+    const diffStats = await getDiffStats(this.context.workingDirectory, this.initialCommitHashForPR, currentHash);
+    if (diffStats.files.length === 0) {
+      const errorMessage = "No changes to create PR: no files changed since task started";
+      this.log("error", "MERGE", errorMessage);
+      this.context.workClient.sendSystemErrorMessage(errorMessage);
+      return;
+    }
+    this.log("info", "MERGE", `Found ${diffStats.files.length} files changed`);
     const branchName = await getCurrentBranch(this.context.workingDirectory);
     this.log("info", "MERGE", `Pushing branch ${branchName} to remote`);
     await gitPush(this.context.workingDirectory, branchName, false);
     this.log("info", "MERGE", "Successfully pushed branch to remote");
+    const prPrompt = buildPRPrompt(
+      { initialCommitHash: this.initialCommitHashForPR, currentCommitHash: currentHash, branchName },
+      this.loadedAgentConfig?.customPRPromptTemplate ? {
+        customTemplate: this.loadedAgentConfig.customPRPromptTemplate,
+        mode: this.loadedAgentConfig.prPromptMode
+      } : void 0
+    );
     this.inMergeRequest = true;
-    const prPrompt = await this.buildCreatePRPrompt();
     await this.enqueueMessage({
       type: "user",
       message: {
@@ -13691,53 +14044,8 @@ class ClaudeWorker {
       }
     );
     this.timerManager.startIdleTimer();
-    this.context.workClient.sendWorkerReady();
     this.log("info", "BASH", `Worker ready after command execution (exit code: ${exitCode})`);
   }
-  async buildCreatePRPrompt() {
-    if (!this.initialCommitHashForPR) {
-      return 'Forbidden create PR by yourself. Must use the mcp__agentrix__create_pr tool. All the changed has been pushed. Please analyze the changes and use the mcp__agentrix__create_pr tool to create a pull request with a title and description. Use conventional commits format for the title (e.g., "feat: add new feature").';
-    }
-    try {
-      const currentHash = await autoCommit(this.context.workingDirectory, "Checkpoint for PR generation");
-      const stats = await getDiffStats(
-        this.context.workingDirectory,
-        this.initialCommitHashForPR,
-        currentHash
-      );
-      const diff = await generateDiffPatch(
-        this.context.workingDirectory,
-        this.initialCommitHashForPR,
-        currentHash
-      );
-      const statsText = `Files changed: ${stats.files.length}, +${stats.totalInsertions}/-${stats.totalDeletions}
-
-Detailed changes:
-${stats.files.map((f) => `  ${f.path}: +${f.insertions}/-${f.deletions}`).join("\n")}`;
-      return `All the changed has been successfully pushed to the git branch. Please create a Pull Request by analyzing the changes below.
-
-Changes made:
-${statsText}
-
-Diff (first 5000 chars):
-\`\`\`
-${diff.substring(0, 5e3)}
-\`\`\`
-
-Requirements:
-- Title: Use conventional commits format (feat/fix/docs/refactor/test/chore: description), maximum 50 characters
-- Description: Provide a clear, detailed explanation of:
-  * What changed (the actual modifications made)
-  * Why these changes were necessary (the problem being solved)
-  * Any important technical decisions or trade-offs
-  * Impact on existing functionality
-
-Please must use the mcp__agentrix__create_pr tool to create the pull request with the generated title and description.Forbidden create PR by yourself.`;
-    } catch (error) {
-      this.log("warn", "GIT", "Failed to generate diff for PR prompt:", error);
-      return 'The code has been committed. Please use the mcp__agentrix__create_pr tool to create a pull request with a title and description. Use conventional commits format for the title (e.g., "feat: add new feature").';
-    }
-  }
   async runClaude() {
     this.log("info", "AGENT", `Starting Claude agent for task ${this.taskId}`);
     const agentSessionId = "agentSessionId" in this.options.input ? this.options.input.agentSessionId : void 0;
@@ -13748,12 +14056,12 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
     );
     const sdkMcpServer = this.createAgentrixMcpServer();
     const mcpServers = {
-      agentrix: sdkMcpServer,
-      ...agentConfig.customMcpServers
+      agentrix: sdkMcpServer
     };
     const allowedTools = [
       "mcp__agentrix__change_task_title",
       "mcp__agentrix__create_pr",
+      "mcp__agentrix__ask_user",
       ...agentConfig.customAllowedTools
     ];
     const messageConsumer = this.createMessageConsumer();
@@ -13773,6 +14081,7 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
         systemPrompt: finalSystemPrompt,
         mcpServers,
         allowedTools,
+        plugins: agentConfig.customPlugins,
         abortController: this.abortController,
         env: this.buildEnvironmentOverrides(),
         maxTurns: agentConfig.customMaxTurns ?? this.options.input.maxTurns ?? 50,
@@ -13782,18 +14091,16 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
       }
     });
     if (this.messageQueue.length > 0) {
-      this.context.workClient.sendWorkRunning();
-      this.coordinator.setWorkerState("processing-sdk");
+      this.coordinator.setWorkerState("running");
     } else {
       this.timerManager.startIdleTimer();
-      this.context.workClient.sendWorkerReady();
     }
     for await (const message of response) {
       this.timerManager.clearIdleTimer();
       this.context.logger.debug(`sdk message: ${JSON.stringify(message)}`);
       if (message.type === "system" && message.subtype === "init") {
         this.context.workClient.sendUpdateTaskAgentSessionId(message.session_id);
-        this.context.workClient.sendWorkRunning();
+        this.coordinator.setWorkerState("running");
         continue;
       }
       const filteredMessage = this.filterMessages(message);
@@ -13803,15 +14110,14 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
       if (message.type === "result") {
         this.coordinator.setWorkerState("idle");
         this.timerManager.startIdleTimer();
-        this.context.workClient.sendWorkerReady();
       } else {
-        this.coordinator.setWorkerState("processing-sdk");
+        this.coordinator.setWorkerState("running");
       }
     }
     this.log("info", "AGENT", `Claude agent finished for task ${this.taskId}`);
   }
   async enqueueMessage(message) {
-    const processedMessage = await this.processImageUrls(message);
+    const processedMessage = await this.processAttachments(message);
     if (this.messageResolverRef.current) {
       const resolver = this.messageResolverRef.current;
       this.messageResolverRef.current = null;
@@ -13820,10 +14126,14 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
       this.messageQueue.push(processedMessage);
     }
   }
-  async processImageUrls(message) {
+  async processAttachments(message) {
     if (!Array.isArray(message.message.content)) {
       return message;
     }
+    const attachmentsDir = _package.machine.resolveAttachmentsDir(
+      this.options.input.userId,
+      this.taskId
+    );
     const processedContent = await Promise.all(
       message.message.content.map(async (block) => {
         if (block.type === "image" && block.source?.type === "url" && block.source?.url) {
@@ -13859,6 +14169,24 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
             return block;
           }
         }
+        if (block.type === "document" && block.source?.type === "url" && block.source?.url) {
+          try {
+            const url = block.source.url;
+            this.log("info", "DOCUMENT", `Downloading document from: ${url}`);
+            const { filePath, mimeType, filename } = await downloadFile(url, attachmentsDir, true);
+            this.log("info", "DOCUMENT", `Document downloaded to: ${filePath}`);
+            const title = block.title || filename;
+            return {
+              type: "text",
+              text: `Document: ${filePath}
+Title: ${title}
+Type: ${mimeType}`
+            };
+          } catch (error) {
+            this.log("error", "DOCUMENT", `Error processing document: ${error}`);
+            return block;
+          }
+        }
         return block;
       })
     );
@@ -13943,33 +14271,117 @@ Please must use the mcp__agentrix__create_pr tool to create the pull request wit
   }
   createPermissionHandler() {
     return async (toolName, input) => {
-      const eventId = this.context.workClient.sendRequirePermission(toolName, input);
-      const timeoutMs = 3e4;
-      const permissionResponse = await new Promise(
-        (resolve, reject) => {
-          const timeout = setTimeout(() => {
-            this.permissionAwaiter.delete(eventId);
-            reject(new Error(`Permission request timeout for tool ${toolName}`));
-          }, timeoutMs);
-          this.permissionAwaiter.set(eventId, (response) => {
-            clearTimeout(timeout);
-            resolve(response);
-          });
+      if (this.grantedPermissions.has(toolName)) {
+        this.log("info", "PERMISSION", `Tool "${toolName}" already granted, skipping`);
+        return { behavior: "allow", updatedInput: input };
+      }
+      const pending = this.pendingPermissions.get(toolName);
+      if (pending) {
+        this.log("info", "PERMISSION", `Tool "${toolName}" has pending request, waiting...`);
+        const decision = await pending;
+        if (decision === "allow") {
+          return { behavior: "allow", updatedInput: input };
+        } else {
+          return { behavior: "deny", message: "Permission denied by user" };
         }
-      );
-      if (permissionResponse.behavior === "allow") {
-        return {
-          behavior: "allow",
-          updatedInput: input
-        };
-      } else {
-        return {
-          behavior: "deny",
-          message: permissionResponse.message || "Permission denied"
-        };
+      }
+      this.log("info", "PERMISSION", `Requesting permission for "${toolName}"`);
+      let resolveDecision;
+      const permissionPromise = new Promise((resolve) => {
+        resolveDecision = resolve;
+      });
+      this.pendingPermissions.set(toolName, permissionPromise);
+      try {
+        const decision = await this.requestToolPermission(toolName);
+        resolveDecision(decision);
+        if (decision === "allow") {
+          this.grantedPermissions.add(toolName);
+          return { behavior: "allow", updatedInput: input };
+        } else {
+          return { behavior: "deny", message: "Permission denied by user" };
+        }
+      } catch (error) {
+        resolveDecision("deny");
+        return { behavior: "deny", message: "Permission request failed" };
+      } finally {
+        this.pendingPermissions.delete(toolName);
       }
     };
   }
+  async requestToolPermission(toolName) {
+    const questions = [{
+      question: `Tool "${toolName}" is requesting permission to execute. Allow this operation?`,
+      header: "Permission",
+      multiSelect: false,
+      options: [
+        { label: "Allow", description: "Allow this tool to execute" },
+        { label: "Deny", description: "Deny this tool execution" }
+      ]
+    }];
+    try {
+      const response = await this.askUser(questions);
+      const answer = response.answers[0];
+      return answer === "Allow" ? "allow" : "deny";
+    } catch (error) {
+      this.log("warn", "PERMISSION", `Permission request failed: ${error}`);
+      return "deny";
+    }
+  }
+  /**
+   * Ask user questions and wait for response
+   * Sends ask_user message via task-message and waits for ask_user_response
+   * @param questions - Array of questions (1-4)
+   * @returns Promise resolving to user's response
+   */
+  async askUser(questions) {
+    const eventId = this.context.workClient.sendAskUser(questions);
+    const timeoutMs = 3e5;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.askUserAwaiter.delete(eventId);
+        reject(new Error("Ask user request timed out"));
+      }, timeoutMs);
+      this.askUserAwaiter.set(eventId, (response) => {
+        clearTimeout(timeout);
+        resolve(response);
+      });
+    });
+  }
+  /**
+   * Ask user how to handle uncommitted changes
+   * @returns The action to take: ignore, commit, stash, or abort
+   */
+  async askUncommittedChangesAction() {
+    const questions = [{
+      question: "Uncommitted changes detected in the working directory. How would you like to proceed?",
+      header: "Git Status",
+      multiSelect: false,
+      options: [
+        { label: "Ignore", description: "Keep changes and continue with the task" },
+        { label: "Commit", description: "Commit current changes before starting" },
+        { label: "Stash", description: "Stash changes (git stash) before starting" },
+        { label: "Abort", description: "Cancel the task, do nothing" }
+      ]
+    }];
+    try {
+      const response = await this.askUser(questions);
+      const answer = response.answers[0];
+      if (answer.startsWith("other:")) {
+        this.log("info", "GIT", `User provided custom input: ${answer}, defaulting to Abort`);
+        return "Abort";
+      }
+      const labelToAction = {
+        "Ignore": "Ignore",
+        "Commit": "Commit",
+        "Stash": "Stash",
+        "Abort": "Abort"
+      };
+      return labelToAction[answer] || "Abort";
+    } catch (error) {
+      this.log("warn", "GIT", `Failed to get user response for uncommitted changes: ${error}`);
+      return "Abort";
+    }
+  }
   createAgentrixMcpServer() {
     return claudeAgentSdk.createSdkMcpServer({
       name: "agentrix",
@@ -14030,6 +14442,50 @@ URL: ${result.pullRequestUrl}`
               };
             }
           }
+        ),
+        claudeAgentSdk.tool(
+          "ask_user",
+          'Ask the user questions when you need clarification or user input. Supports 1-4 questions with 2-4 options each. Use this when you need user decisions or additional information. An "Other" option with free text input is automatically added.',
+          {
+            questions: zod.z.array(zod.z.object({
+              question: zod.z.string().describe("The complete question to ask the user"),
+              header: zod.z.string().max(12).describe("Short label displayed as a chip/tag (max 12 chars)"),
+              multiSelect: zod.z.boolean().describe("Set to true to allow multiple option selections"),
+              options: zod.z.array(zod.z.object({
+                label: zod.z.string().describe("Option label (1-5 words)"),
+                description: zod.z.string().describe("Explanation of what this option means")
+              })).min(2).max(4).describe("Available choices (2-4 options)")
+            })).min(1).max(4).describe("Questions to ask (1-4 questions)")
+          },
+          async (args) => {
+            try {
+              const questionsWithOther = args.questions.map((q) => ({
+                ...q,
+                options: [...q.options, { label: "Other", description: "" }]
+              }));
+              const result = await this.askUser(questionsWithOther);
+              const answerText = result.answers.map((answer) => {
+                if (answer.startsWith("other:")) {
+                  return `Other: "${answer.slice(6)}"`;
+                }
+                return answer;
+              }).join("\n");
+              return {
+                content: [{ type: "text", text: `User answers:
+${answerText}` }]
+              };
+            } catch (error) {
+              this.log("error", "ASK_USER", "Failed to get user response:", error);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Failed to get user response: ${error instanceof Error ? error.message : "Unknown error"}`
+                  }
+                ]
+              };
+            }
+          }
         )
       ]
     });
@@ -14045,7 +14501,7 @@ URL: ${result.pullRequestUrl}`
     } catch (error) {
       this.log("warn", "GIT", "Failed to handle git state on worker stop:", error);
     }
-    this.context.workClient.sendWorkerReady();
+    this.coordinator.setWorkerState("idle");
   }
   filterMessages(message) {
     const msg = message;
@@ -14086,38 +14542,45 @@ URL: ${result.pullRequestUrl}`
         return this.createDefaultAgentConfig();
       }
       const claudeConfig = agentConfig.claude;
-      const customMcpServers = Object.fromEntries(
-        Object.entries(claudeConfig.mcpServers).map(([name, server]) => [name, server.instance])
-      );
-      this.log("info", "AGENT", `Agent ${this.options.input.agentId} loaded successfully`);
-      return {
+      const customPlugins = claudeConfig.plugins.map((path) => ({
+        type: "local",
+        path
+      }));
+      this.log("info", "AGENT", `Agent ${this.options.input.agentId} loaded successfully (${customPlugins.length} plugins)`);
+      const config = {
         customSystemPrompt: claudeConfig.systemPrompt,
-        // Loaded string content
         customModel: claudeConfig.config.model,
         customFallbackModel: claudeConfig.config.fallbackModel,
         customMaxTurns: claudeConfig.config.maxTurns,
         customExtraArgs: claudeConfig.config.extraArgs,
         customPermissionMode: claudeConfig.config.settings?.permissionMode,
-        customMcpServers,
         customAllowedTools: claudeConfig.config.settings?.allowedTools || [],
+        customPlugins,
         systemPromptMode: claudeConfig.config.systemPrompt?.mode ?? "append",
-        hooks: this.loadedHooks
-        // Use cached hooks
+        hooks: this.loadedHooks,
+        customPRPromptTemplate: claudeConfig.prPromptTemplate,
+        prPromptMode: claudeConfig.config.pullRequestPrompt?.mode ?? "append"
       };
+      this.loadedAgentConfig = config;
+      return config;
     } catch (error) {
       this.log("error", "AGENT", `Failed to load agent: ${error instanceof Error ? error.message : String(error)}`);
       return this.createDefaultAgentConfig();
     }
   }
   createDefaultAgentConfig() {
-    return {
+    const config = {
       customSystemPrompt: void 0,
       customModel: void 0,
       customMaxTurns: void 0,
-      customMcpServers: {},
       customAllowedTools: [],
-      systemPromptMode: "append"
+      customPlugins: [],
+      systemPromptMode: "append",
+      customPRPromptTemplate: void 0,
+      prPromptMode: "append"
     };
+    this.loadedAgentConfig = config;
+    return config;
   }
   buildEnvironmentOverrides() {
     return {
@@ -14225,18 +14688,20 @@ URL: ${result.pullRequestUrl}`
           this.timerManager.stopTask("event");
         },
         onTaskMessage: async (message) => {
-          if (message.type === "user") {
+          if (shared.isAskUserResponseMessage(message)) {
+            const [eventId, awaiter] = this.askUserAwaiter.entries().next().value || [];
+            if (eventId && awaiter) {
+              this.askUserAwaiter.delete(eventId);
+              awaiter(message);
+            }
+            this.timerManager.clearIdleTimer();
+            return;
+          }
+          if ("type" in message && message.type === "user") {
             const userMessage = message;
             await this.coordinator.enqueue(userMessage);
             this.timerManager.clearIdleTimer();
           }
-        },
-        onPermissionResponse: async (response) => {
-          const awaiter = this.permissionAwaiter.get(response.opCode);
-          if (awaiter) {
-            this.permissionAwaiter.delete(response.opCode);
-            awaiter(response);
-          }
         }
       }
     };
@@ -14275,9 +14740,8 @@ URL: ${result.pullRequestUrl}`
       this.log("info", "GIT", `Patch: ${gitStateResult.patchPath}`);
     }
   }
-  async createLogger(options) {
-    const { createLogger } = await Promise.resolve().then(function () { return require('./logger-BZKdzrRM.cjs'); }).then(function (n) { return n.logger$1; });
-    return createLogger(options);
+  createWorkerLogger(options) {
+    return _package.createLogger(options);
   }
   log(level, category, message, ...args) {
     if (this.logger) {
@@ -15900,28 +16364,6 @@ Example response format:
 CRITICAL: Respond with ONLY the JSON object, no additional text before or after. Now analyze the changes and provide your response:`;
 }
 
-async function downloadImage(url, targetDir) {
-  try {
-    const urlPath = new URL(url).pathname;
-    const extension = path$1.extname(urlPath) || ".jpg";
-    const filename = `${node_crypto.randomUUID()}${extension}`;
-    const filePath = path$1.join(targetDir, filename);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    const nodeStream = response.body;
-    const fileStream = fs$1.createWriteStream(filePath);
-    await promises$1.pipeline(nodeStream, fileStream);
-    return filePath;
-  } catch (error) {
-    throw new Error(`Failed to download image from ${url}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
 class CodexWorker {
   constructor(credentials, options) {
     this.credentials = credentials;
@@ -16037,6 +16479,7 @@ class CodexWorker {
     };
     this.coordinator = new MessageCoordinator({
       workerType: "codex",
+      workClient,
       handlers: {
         onNormalMessage: async (message) => {
           const input = await this.convertSDKMessageToCodexInput(message);
@@ -16109,7 +16552,6 @@ class CodexWorker {
       }
     );
     this.timerManager.startIdleTimer();
-    this.context.workClient.sendWorkerReady();
     this.log("info", "BASH", `Worker ready after command execution (exit code: ${exitCode})`);
   }
   async buildCreatePRPrompt() {
@@ -16166,8 +16608,7 @@ ${stats.files.map((f) => `  ${f.path}: +${f.insertions}/-${f.deletions}`).join("
         skipGitRepoCheck: true
       });
     }
-    this.context.workClient.sendWorkRunning();
-    this.coordinator.setWorkerState("processing-sdk");
+    this.coordinator.setWorkerState("running");
     while (!this.isStopping) {
       this.log("debug", "AGENT", `Loop iteration: turnCount=${this.turnCount}, queueLength=${this.messageQueue.length}`);
       let userInput = null;
@@ -16179,7 +16620,6 @@ ${stats.files.map((f) => `  ${f.path}: +${f.insertions}/-${f.deletions}`).join("
         await this.reportGitState("idle");
         this.coordinator.setWorkerState("idle");
         this.timerManager.startIdleTimer();
-        this.context.workClient.sendWorkerReady();
         this.log("info", "AGENT", "Sent worker-ready, waiting for next message");
         userInput = await this.waitForNextMessage();
       }
@@ -16189,7 +16629,7 @@ ${stats.files.map((f) => `  ${f.path}: +${f.insertions}/-${f.deletions}`).join("
       }
       try {
         this.timerManager.clearIdleTimer();
-        this.coordinator.setWorkerState("processing-sdk");
+        this.coordinator.setWorkerState("running");
         await this.processUserInput(userInput);
         this.turnCount++;
         this.log("debug", "AGENT", `Message processed, turnCount now ${this.turnCount}`);
@@ -16225,7 +16665,7 @@ ${stats.files.map((f) => `  ${f.path}: +${f.insertions}/-${f.deletions}`).join("
     const turnOptions = this.inMergeRequest ? { outputSchema: getPROutputSchema() } : {};
     this.log("debug", "AGENT", "Calling thread.runStreamed");
     const { events } = await this.thread.runStreamed(input, turnOptions);
-    this.context.workClient.sendWorkRunning();
+    this.coordinator.setWorkerState("running");
     this.log("debug", "AGENT", "Starting to process events");
     for await (const event of events) {
       if (this.isStopping) {
@@ -16400,8 +16840,8 @@ URL: ${result.pullRequestUrl}`);
   }
   /**
    * Convert SDKUserMessage to Codex Input format
-   * Handles both text-only messages and messages with images
-   * Downloads images from URLs to local attachments directory
+   * Handles both text-only messages and messages with images and documents
+   * Downloads images and documents from URLs to local attachments directory
    */
   async convertSDKMessageToCodexInput(message) {
     const content = message.message.content;
@@ -16410,6 +16850,10 @@ URL: ${result.pullRequestUrl}`);
     }
     if (Array.isArray(content)) {
       const userInputs = [];
+      const attachmentsDir = _package.machine.resolveAttachmentsDir(
+        this.options.input.userId,
+        this.taskId
+      );
       for (const block of content) {
         if (block.type === "text" && block.text) {
           userInputs.push({
@@ -16419,19 +16863,30 @@ URL: ${result.pullRequestUrl}`);
         } else if (block.type === "image" && block.source && block.source.url) {
           const url = block.source.url;
           try {
-            const attachmentsDir = _package.machine.resolveAttachmentsDir(
-              this.options.input.userId,
-              this.taskId
-            );
-            const localPath = await downloadImage(url, attachmentsDir);
-            this.log("info", "IMAGE", `Downloaded image from ${url} to ${localPath}`);
+            const { filePath } = await downloadFile(url, attachmentsDir, false);
+            this.log("info", "IMAGE", `Downloaded image from ${url} to ${filePath}`);
             userInputs.push({
               type: "local_image",
-              path: localPath
+              path: filePath
             });
           } catch (error) {
             this.log("error", "IMAGE", `Failed to download image from ${url}:`, error);
           }
+        } else if (block.type === "document" && block.source && block.source.url) {
+          const url = block.source.url;
+          try {
+            const { filePath, mimeType, filename } = await downloadFile(url, attachmentsDir, true);
+            this.log("info", "DOCUMENT", `Downloaded document from ${url} to ${filePath}`);
+            const title = block.title || filename;
+            userInputs.push({
+              type: "text",
+              text: `Document: ${filePath}
+Title: ${title}
+Type: ${mimeType}`
+            });
+          } catch (error) {
+            this.log("error", "DOCUMENT", `Failed to download document from ${url}:`, error);
+          }
         }
       }
       if (userInputs.length === 1 && userInputs[0].type === "text") {
@@ -16501,7 +16956,7 @@ URL: ${result.pullRequestUrl}`);
   }
   async handleStopHook() {
     await this.reportGitState("stop");
-    this.context.workClient.sendWorkerReady();
+    this.coordinator.setWorkerState("idle");
   }
   async loadAgentConfiguration() {
     if (!this.options.input.agentId || this.options.input.agentId === "default") {
@@ -16593,14 +17048,15 @@ URL: ${result.pullRequestUrl}`);
           this.timerManager.stopTask("event");
         },
         onTaskMessage: async (message) => {
-          if (message.type === "user") {
+          if (shared.isAskUserResponseMessage(message)) {
+            this.log("debug", "AGENT", "Received ask_user_response (not used by Codex)");
+            return;
+          }
+          if ("type" in message && message.type === "user") {
             const userMessage = message;
             await this.coordinator.enqueue(userMessage);
             this.timerManager.clearIdleTimer();
           }
-        },
-        onPermissionResponse: async (response) => {
-          this.log("debug", "AGENT", `Permission response received: ${response.behavior}`);
         }
       }
     };
@@ -16955,7 +17411,7 @@ cli.command("upgrade", "Upgrade CLI to the latest version", {}, async (argv) =>
     }
   }
   try {
-    const { version } = await Promise.resolve().then(function () { return require('./logger-BZKdzrRM.cjs'); }).then(function (n) { return n._package; });
+    const { version } = await Promise.resolve().then(function () { return require('./logger-DzYRcKN1.cjs'); }).then(function (n) { return n._package; });
     console.log(chalk.green(`
 \u2713 Now running version: ${version}`));
   } catch {
@@ -17137,7 +17593,7 @@ cli.command(
   },
   async (argv) => {
     try {
-      const { testCommand } = await Promise.resolve().then(function () { return require('./index-DuBvuZ3A.cjs'); });
+      const { testCommand } = await Promise.resolve().then(function () { return require('./index-Cs99FGLe.cjs'); });
       await testCommand(argv);
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Test mode failed");