@agentrix/cli 0.0.12 → 0.0.13

package/dist/{index-Dzjo3uhE.mjs → index-yYa7NL_3.mjs}

@@ -1,12 +1,10 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import chalk from 'chalk';
-import { encodeBase64, createKeyPairWithUit8Array, encryptMachineEncryptionKey, generateAESKey, decodeBase64, decryptWithEphemeralKey, createEventId, encryptFileContent, machineAuth, encryptSdkMessage, decryptSdkMessage, loadAgentConfig, getAgentContext, workerAuth } from '@agentrix/shared';
+import { encodeBase64, createKeyPairWithUit8Array, encryptMachineEncryptionKey, generateAESKey, decodeBase64, decryptWithEphemeralKey, createEventId, encryptFileContent, machineAuth, encryptSdkMessage, decryptSdkMessage, loadAgentConfig, getAgentContext, workerAuth, isAskUserResponseMessage } from '@agentrix/shared';
 import { randomBytes, randomUUID } from 'node:crypto';
 import axios from 'axios';
-import { m as machine, l as logger, p as projectPath, a as packageJson, c as createLogger, g as getLogPath, b as logger$1 } from './logger-D-ioMWe6.mjs';
-import * as fs from 'node:fs';
-import { existsSync, rmSync, createWriteStream, readdirSync, mkdirSync } from 'node:fs';
+import { m as machine, l as logger, p as projectPath, a as packageJson, c as createLogger, g as getLogPath, b as logger$1 } from './logger-BzpMLIL-.mjs';
 import { createInterface } from 'node:readline';
 import fs$1, { readFileSync, existsSync as existsSync$1 } from 'fs';
 import path$1, { join } from 'path';
@@ -14,11 +12,15 @@ import os, { homedir } from 'node:os';
 import open from 'open';
 import { io } from 'socket.io-client';
 import { EventEmitter } from 'node:events';
+import * as fs from 'node:fs';
+import { existsSync, createWriteStream, readdirSync, mkdirSync } from 'node:fs';
 import * as path from 'node:path';
 import { join as join$1, basename, extname, dirname } from 'node:path';
 import { spawn, execSync } from 'child_process';
 import psList from 'ps-list';
 import spawn$1 from 'cross-spawn';
+import { isSupportedPlatform, checkSandboxDependencies, NetworkManager, SandboxManager } from '@xmz-ai/sandbox-runtime';
+import { getPlatform } from '@xmz-ai/sandbox-runtime/dist/utils/platform.js';
 import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
@@ -44,22 +46,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";
-    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) {
@@ -205,11 +197,8 @@ async function handleAuthLogout() {
         console.log(chalk.gray("Stopped daemon"));
       } catch {
       }
-      const paths = machine.getStatePaths();
-      if (existsSync(paths.rootDir)) {
-        rmSync(paths.rootDir, { recursive: true, force: true });
-        console.log(chalk.gray(`Removed agentrix home directory`));
-      }
+      await 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"}`);
@@ -11865,7 +11854,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() {
@@ -11967,6 +11956,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 = getPlatform();
+    if (isSupportedPlatform(platform)) {
+      console.log(`Platform: ${chalk.green(platform)} (supported)`);
+      const depsOk = 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 {
@@ -12191,9 +12201,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());
@@ -12234,9 +12246,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) {
@@ -12261,14 +12279,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 import('./logger-BzpMLIL-.mjs').then(function (n) { return n.d; });
+          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
+          );
+          logger.debug(`[SESSION] Sandboxed command for task ${options.taskId}: ${sandboxedCommand}`);
+          workerProcess = spawn(sandboxedCommand, {
+            shell: true,
+            cwd,
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+              ...process.env
+              // Environment variables controlled by SandboxManager
+            }
+          });
+          logger.info(`[SESSION] Worker started with sandbox, PID: ${workerProcess.pid}`);
+        } catch (error) {
+          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 }
+        });
+        logger.info(`[SESSION] Worker started without sandbox, PID: ${workerProcess.pid}`);
+      }
       if (process.env.DEBUG) {
         workerProcess.stdout?.on("data", (data) => {
           logger.debug(`[Daemon] worker stdout: ${data.toString()}`);
@@ -12387,6 +12444,114 @@ function setupGracefulShutdown(options) {
   };
 }
 
+class SandboxPool {
+  networkManager = null;
+  workerSandboxes = /* @__PURE__ */ new Map();
+  settings = null;
+  platform;
+  constructor() {
+    this.platform = getPlatform();
+  }
+  async initialize(settings) {
+    this.settings = settings;
+    if (!settings.enabled) {
+      logger.info("[SANDBOX] Sandbox disabled via settings");
+      return false;
+    }
+    if (!isSupportedPlatform(this.platform)) {
+      logger.warn("[SANDBOX] Platform not supported, sandbox disabled");
+      return false;
+    }
+    try {
+      const apiHost = new URL(machine.serverUrl).hostname;
+      const networkConfig = {
+        allowedDomains: [
+          apiHost,
+          ...settings.network.allowedDomains
+        ],
+        deniedDomains: settings.network.deniedDomains,
+        allowLocalBinding: false
+      };
+      this.networkManager = new NetworkManager();
+      await this.networkManager.initialize(networkConfig);
+      logger.info("[SANDBOX] Sandbox pool initialized successfully");
+      return true;
+    } catch (error) {
+      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 = machine.resolveTaskDir(userId, taskId);
+      const logsDir = 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 SandboxManager(this.networkManager, instanceConfig);
+      this.workerSandboxes.set(taskId, sandbox);
+      logger.info(`[SANDBOX] Created sandbox for task ${taskId}`);
+      return sandbox;
+    } catch (error) {
+      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);
+    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);
+      logger.debug(`[SANDBOX] Disposed sandbox for task ${taskId}`);
+    }
+  }
+  async shutdown() {
+    logger.info("[SANDBOX] Shutting down sandbox pool");
+    for (const [taskId, sandbox] of this.workerSandboxes.entries()) {
+      sandbox.dispose();
+      logger.debug(`[SANDBOX] Disposed sandbox for task ${taskId}`);
+    }
+    this.workerSandboxes.clear();
+    if (this.networkManager) {
+      await this.networkManager.shutdown();
+      this.networkManager = null;
+      logger.info("[SANDBOX] Network manager shutdown complete");
+    }
+  }
+  isEnabled() {
+    return this.settings?.enabled === true;
+  }
+}
+
 async function startDaemon() {
   Object.assign(logger, createLogger({ type: "daemon" }));
   const { requestShutdown, shutdownPromise } = setupGracefulShutdown({
@@ -12415,7 +12580,9 @@ async function startDaemon() {
     }
     const credentials = await authAndSetupMachineIfNeeded();
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
-    const sessionManager = new TaskWorkerManager();
+    const sandboxPool = new SandboxPool();
+    await sandboxPool.initialize(machine.getSandboxSettings());
+    const sessionManager = new TaskWorkerManager(sandboxPool);
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
       getChildren: () => sessionManager.getCurrentSessions(),
       stopSession: (id) => sessionManager.stopSession(id),
@@ -12463,6 +12630,7 @@ async function startDaemon() {
     const cleanupAndShutdown = async (source, errorMessage) => {
       await machineClient.disconnect();
       await stopControlServer();
+      await sandboxPool.shutdown();
       await cleanupDaemonState();
       await stopCaffeinate();
       await machine.releaseDaemonLock(daemonLockHandle);
@@ -12579,14 +12747,6 @@ function createWorkerEventHandlers(context) {
           }
         }
       }
-    },
-    "require-permission-response": async (data) => {
-      if (data.taskId !== context.taskId) {
-        return;
-      }
-      if (context.onPermissionResponse) {
-        await context.onPermissionResponse(data);
-      }
     }
   };
 }
@@ -12627,7 +12787,6 @@ class WorkerClient {
       cwd: normalizedCwd,
       stopTask: options.stopTask,
       onTaskMessage: options.onTaskMessage,
-      onPermissionResponse: options.onPermissionResponse,
       onGitPush: options.onGitPush,
       dataEncryptionKey: config.dataEncryptionKey
     };
@@ -12656,26 +12815,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 = encryptSdkMessage(assistantMessage, this.context.dataEncryptionKey);
-      assistantMessage = void 0;
+      encryptedMessage = encryptSdkMessage(processedMessage, this.context.dataEncryptionKey);
+      processedMessage = void 0;
     }
+    const eventId = createEventId();
     const payload = {
-      eventId: createEventId(),
+      eventId,
       taskId: this.context.taskId,
       from: "worker",
-      message: assistantMessage,
+      message: processedMessage,
       encryptedMessage
     };
     this.client.send("task-message", payload);
+    return eventId;
   }
   sendWorkerInitializing() {
     const workerInitializingEvent = {
@@ -12686,12 +12851,13 @@ class WorkerClient {
     };
     this.client.send("worker-initializing", workerInitializingEvent);
   }
-  sendWorkerReady() {
+  sendWorkerReady(duration) {
     const workerReadyEvent = {
       eventId: 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);
   }
@@ -12749,17 +12915,13 @@ ${errorMessage}`,
     };
     this.sendTaskMessage(systemMessage);
   }
-  sendRequirePermission(toolName, toolInput) {
-    const eventId = createEventId();
-    const permissionRequest = {
-      eventId,
-      taskId: this.context.taskId,
-      toolName,
-      toolInput
-    };
-    this.client.send("require-permission", permissionRequest);
-    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 = {
@@ -12814,7 +12976,6 @@ ${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"]);
   }
 }
 
@@ -13017,6 +13178,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 });
@@ -13106,6 +13273,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}`;
 }
@@ -13145,17 +13336,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");
@@ -13283,6 +13463,29 @@ async function markCommitAsSent(userId, taskId, commitHash) {
   await 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_${randomUUID$1().replace(/-/g, "")}`;
@@ -13400,6 +13603,7 @@ class MessageCoordinator {
   currentMessageId = null;
   messageIdCounter = 0;
   isStopped = false;
+  runStartTime = null;
   constructor(config) {
     this.config = config;
   }
@@ -13519,11 +13723,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");
     }
   }
   /**
@@ -13532,11 +13736,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) {
@@ -13556,11 +13760,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);
     }
   }
   /**
@@ -13600,7 +13817,7 @@ class ClaudeWorker {
   messageQueue = [];
   messageResolverRef = { current: null };
   abortController = new AbortController();
-  permissionAwaiter = /* @__PURE__ */ new Map();
+  askUserAwaiter = /* @__PURE__ */ new Map();
   filteredToolUseIds = /* @__PURE__ */ new Set();
   timerManager;
   context;
@@ -13610,6 +13827,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();
@@ -13630,18 +13852,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 = decryptWithEphemeralKey(decodeBase64(this.options.input.dataEncryptionKey), this.options.secretKey);
     }
+    if (this.options.input.encryptedMessage && this.dataEncryptionKey) {
+      this.options.input.message = decryptSdkMessage(this.options.input.encryptedMessage, this.dataEncryptionKey) || void 0;
+    }
+    let workingDirectory = this.options.input.cwd ? this.options.input.cwd.replace(/^~/, 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({
@@ -13653,6 +13926,8 @@ class ClaudeWorker {
       }, hooks);
       workingDirectory = workspaceResult.workingDirectory;
       initialCommitHash = workspaceResult.initialCommitHash;
+      this.context.workingDirectory = workingDirectory;
+      this.context.initialCommitHash = initialCommitHash;
       await machine.writeInitialCommitHash(userId, taskId, initialCommitHash);
       this.log("info", "GIT", `Initial commit: ${initialCommitHash}`);
       this.initialCommitHashForPR = initialCommitHash;
@@ -13660,20 +13935,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,
@@ -13690,35 +13955,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 = 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) {
@@ -13736,15 +13972,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: {
@@ -13773,53 +14024,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;
@@ -13830,12 +14036,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();
@@ -13855,6 +14061,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,
@@ -13864,18 +14071,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);
@@ -13885,9 +14090,8 @@ 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}`);
@@ -14047,33 +14251,117 @@ Type: ${mimeType}`
   }
   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 createSdkMcpServer({
       name: "agentrix",
@@ -14134,6 +14422,50 @@ URL: ${result.pullRequestUrl}`
               };
             }
           }
+        ),
+        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: z.array(z.object({
+              question: z.string().describe("The complete question to ask the user"),
+              header: z.string().max(12).describe("Short label displayed as a chip/tag (max 12 chars)"),
+              multiSelect: z.boolean().describe("Set to true to allow multiple option selections"),
+              options: z.array(z.object({
+                label: z.string().describe("Option label (1-5 words)"),
+                description: 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"}`
+                  }
+                ]
+              };
+            }
+          }
         )
       ]
     });
@@ -14149,7 +14481,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;
@@ -14190,38 +14522,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 {
@@ -14329,18 +14668,20 @@ URL: ${result.pullRequestUrl}`
           this.timerManager.stopTask("event");
         },
         onTaskMessage: async (message) => {
-          if (message.type === "user") {
+          if (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);
-          }
         }
       }
     };
@@ -14379,8 +14720,7 @@ URL: ${result.pullRequestUrl}`
       this.log("info", "GIT", `Patch: ${gitStateResult.patchPath}`);
     }
   }
-  async createLogger(options) {
-    const { createLogger } = await import('./logger-D-ioMWe6.mjs').then(function (n) { return n.b; });
+  createWorkerLogger(options) {
     return createLogger(options);
   }
   log(level, category, message, ...args) {
@@ -16119,6 +16459,7 @@ class CodexWorker {
     };
     this.coordinator = new MessageCoordinator({
       workerType: "codex",
+      workClient,
       handlers: {
         onNormalMessage: async (message) => {
           const input = await this.convertSDKMessageToCodexInput(message);
@@ -16191,7 +16532,6 @@ class CodexWorker {
       }
     );
     this.timerManager.startIdleTimer();
-    this.context.workClient.sendWorkerReady();
     this.log("info", "BASH", `Worker ready after command execution (exit code: ${exitCode})`);
   }
   async buildCreatePRPrompt() {
@@ -16248,8 +16588,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;
@@ -16261,7 +16600,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();
       }
@@ -16271,7 +16609,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}`);
@@ -16307,7 +16645,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) {
@@ -16598,7 +16936,7 @@ Type: ${mimeType}`
   }
   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") {
@@ -16690,14 +17028,15 @@ Type: ${mimeType}`
           this.timerManager.stopTask("event");
         },
         onTaskMessage: async (message) => {
-          if (message.type === "user") {
+          if (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}`);
         }
       }
     };
@@ -17052,7 +17391,7 @@ cli.command("upgrade", "Upgrade CLI to the latest version", {}, async (argv) =>
     }
   }
   try {
-    const { version } = await import('./logger-D-ioMWe6.mjs').then(function (n) { return n._; });
+    const { version } = await import('./logger-BzpMLIL-.mjs').then(function (n) { return n._; });
     console.log(chalk.green(`
 \u2713 Now running version: ${version}`));
   } catch {
@@ -17234,7 +17573,7 @@ cli.command(
   },
   async (argv) => {
     try {
-      const { testCommand } = await import('./index-D1ipaIV_.mjs');
+      const { testCommand } = await import('./index-DNDJMHW8.mjs');
       await testCommand(argv);
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Test mode failed");