@rdmind/rdmind 0.1.3-alpha.2 → 0.1.3-alpha.3

package/cli.js

@@ -89829,7 +89829,7 @@ var init_mcp_tool = __esm({
           // Display original tool name in confirmation
           toolDisplayName: this.displayName,
           // Display global registry name exposed to model and user
-          onConfirm: /* @__PURE__ */ __name(async (outcome) => {
+          onConfirm: /* @__PURE__ */ __name(async (outcome, _payload) => {
             if (outcome === "proceed_always_server" /* ProceedAlwaysServer */) {
               _DiscoveredMCPToolInvocation.allowlist.add(serverAllowListKey);
             } else if (outcome === "proceed_always_tool" /* ProceedAlwaysTool */) {
@@ -160739,7 +160739,7 @@ function createContentGeneratorConfig(config2, authType, generationConfig) {
   };
 }
 async function createContentGenerator(config2, gcConfig, isInitialAuth) {
-  const version3 = "0.1.3-alpha.2";
+  const version3 = "0.1.3-alpha.3";
   const userAgent2 = `QwenCode/${version3} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -164752,11 +164752,11 @@ function getToolCallExamples(model) {
 function getSubagentSystemReminder(agentTypes) {
   return `<system-reminder>You have powerful specialized agents at your disposal, available agent types are: ${agentTypes.join(", ")}. PROACTIVELY use the ${ToolNames.TASK} tool to delegate user's task to appropriate agent when user's task matches agent capabilities. Ignore this message if user's task is not relevant to any agent. This message is for internal use only. Do not mention this to user in your response.</system-reminder>`;
 }
-function getPlanModeSystemReminder() {
+function getPlanModeSystemReminder(planOnly = false) {
   return `<system-reminder>
 Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supercedes any other instructions you have received (for example, to make edits). Instead, you should:
 1. Answer the user's query comprehensively
-2. When you're done researching, present your plan by calling the ${ToolNames.EXIT_PLAN_MODE} tool, which will prompt the user to confirm the plan. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan.
+2. When you're done researching, present your plan ${planOnly ? "directly" : `by calling the ${ToolNames.EXIT_PLAN_MODE} tool, which will prompt the user to confirm the plan`}. Do NOT make any file changes or run any tools that modify the system state in any way until the user has confirmed the plan.
 </system-reminder>`;
 }
 var generalToolCallExamples, qwenCoderToolCallExamples, qwenVlToolCallExamples;
@@ -178051,7 +178051,7 @@ var init_shell = __esm({
           title: "Confirm Shell Command",
           command: this.params.command,
           rootCommand: commandsToConfirm.join(", "),
-          onConfirm: /* @__PURE__ */ __name(async (outcome) => {
+          onConfirm: /* @__PURE__ */ __name(async (outcome, _payload) => {
             if (outcome === "proceed_always" /* ProceedAlways */) {
               commandsToConfirm.forEach((command3) => this.allowlist.add(command3));
             }
@@ -178848,7 +178848,7 @@ var init_coreToolScheduler = __esm({
                 );
                 this.setStatusInternal(reqInfo.callId, "scheduled");
               } else {
-                const shouldAutoDeny = !this.config.isInteractive() && !this.config.getIdeMode() && !this.config.getExperimentalZedIntegration();
+                const shouldAutoDeny = !this.config.isInteractive() && !this.config.getIdeMode() && !this.config.getExperimentalZedIntegration() && this.config.getInputFormat() !== "stream-json" /* STREAM_JSON */;
                 if (shouldAutoDeny) {
                   const errorMessage = `RDMind requires permission to use "${reqInfo.name}", but that permission was declined.`;
                   this.setStatusInternal(
@@ -178928,19 +178928,14 @@ var init_coreToolScheduler = __esm({
         const toolCall = this.toolCalls.find(
           (c3) => c3.request.callId === callId && c3.status === "awaiting_approval"
         );
-        if (toolCall && toolCall.status === "awaiting_approval") {
-          await originalOnConfirm(outcome);
-        }
+        await originalOnConfirm(outcome, payload);
         if (outcome === "proceed_always" /* ProceedAlways */) {
           await this.autoApproveCompatiblePendingTools(signal, callId);
         }
         this.setToolCallOutcome(callId, outcome);
         if (outcome === "cancel" /* Cancel */ || signal.aborted) {
-          this.setStatusInternal(
-            callId,
-            "cancelled",
-            "User did not allow tool call"
-          );
+          const cancelMessage = payload?.cancelMessage || "User did not allow tool call";
+          this.setStatusInternal(callId, "cancelled", cancelMessage);
         } else if (outcome === "modify_with_editor" /* ModifyWithEditor */) {
           const waitingToolCall = toolCall;
           if (isModifiableDeclarativeTool(waitingToolCall.tool)) {
@@ -178986,7 +178981,7 @@ var init_coreToolScheduler = __esm({
        * @private
        */
       async _applyInlineModify(toolCall, payload, signal) {
-        if (toolCall.confirmationDetails.type !== "edit" || !isModifiableDeclarativeTool(toolCall.tool)) {
+        if (toolCall.confirmationDetails.type !== "edit" || !isModifiableDeclarativeTool(toolCall.tool) || !payload.newContent) {
           return;
         }
         const modifyContext = toolCall.tool.getModifyContext(signal);
@@ -185714,7 +185709,9 @@ var init_client2 = __esm({
             systemReminders.push(getSubagentSystemReminder(subagents));
           }
           if (this.config.getApprovalMode() === "plan" /* PLAN */) {
-            systemReminders.push(getPlanModeSystemReminder());
+            systemReminders.push(
+              getPlanModeSystemReminder(this.config.getSdkMode())
+            );
           }
           requestToSent = [...systemReminders, ...requestToSent];
         }
@@ -224711,6 +224708,13 @@ var init_subagent_manager = __esm({
        */
       async createSubagent(config2, options2) {
         this.validator.validateOrThrow(config2);
+        if (options2.level === "session") {
+          throw new SubagentError(
+            `Cannot create session-level subagent "${config2.name}". Session agents are read-only and provided at runtime.`,
+            SubagentErrorCode.INVALID_CONFIG,
+            config2.name
+          );
+        }
         const filePath = options2.customPath || this.getSubagentPath(config2.name, options2.level);
         if (!options2.overwrite) {
           try {
@@ -224757,8 +224761,17 @@ var init_subagent_manager = __esm({
           if (level === "builtin") {
             return BuiltinAgentRegistry.getBuiltinAgent(name3);
           }
+          if (level === "session") {
+            const sessionSubagents2 = this.subagentsCache?.get("session") || [];
+            return sessionSubagents2.find((agent) => agent.name === name3) || null;
+          }
           return this.findSubagentByNameAtLevel(name3, level);
         }
+        const sessionSubagents = this.subagentsCache?.get("session") || [];
+        const sessionConfig = sessionSubagents.find((agent) => agent.name === name3);
+        if (sessionConfig) {
+          return sessionConfig;
+        }
         const projectConfig = await this.findSubagentByNameAtLevel(name3, "project");
         if (projectConfig) {
           return projectConfig;
@@ -224792,8 +224805,22 @@ var init_subagent_manager = __esm({
             name3
           );
         }
+        if (existing.level === "session") {
+          throw new SubagentError(
+            `Cannot update session-level subagent "${name3}"`,
+            SubagentErrorCode.INVALID_CONFIG,
+            name3
+          );
+        }
         const updatedConfig = this.mergeConfigurations(existing, updates);
         this.validator.validateOrThrow(updatedConfig);
+        if (!existing.filePath) {
+          throw new SubagentError(
+            `Cannot update subagent "${name3}": no file path available`,
+            SubagentErrorCode.FILE_ERROR,
+            name3
+          );
+        }
         const content = this.serializeSubagent(updatedConfig);
         try {
           await fs47.writeFile(existing.filePath, content, "utf8");
@@ -224824,7 +224851,7 @@ var init_subagent_manager = __esm({
         const levelsToCheck = level ? [level] : ["project", "user"];
         let deleted = false;
         for (const currentLevel of levelsToCheck) {
-          if (currentLevel === "builtin") {
+          if (currentLevel === "builtin" || currentLevel === "session") {
             continue;
           }
           const config2 = await this.findSubagentByNameAtLevel(name3, currentLevel);
@@ -224854,6 +224881,20 @@ var init_subagent_manager = __esm({
       async listSubagents(options2 = {}) {
         const subagents = [];
         const seenNames = /* @__PURE__ */ new Set();
+        if (this.config.getSdkMode()) {
+          const levelsToCheck2 = options2.level ? [options2.level] : ["session"];
+          for (const level of levelsToCheck2) {
+            const levelSubagents = this.subagentsCache?.get(level) || [];
+            for (const subagent of levelSubagents) {
+              if (options2.hasTool && (!subagent.tools || !subagent.tools.includes(options2.hasTool))) {
+                continue;
+              }
+              subagents.push(subagent);
+              seenNames.add(subagent.name);
+            }
+          }
+          return subagents;
+        }
         const levelsToCheck = options2.level ? [options2.level] : ["project", "user", "builtin"];
         const shouldUseCache = !options2.force && this.subagentsCache !== null;
         if (!shouldUseCache) {
@@ -224880,7 +224921,7 @@ var init_subagent_manager = __esm({
                 comparison = a.name.localeCompare(b.name);
                 break;
               case "level": {
-                const levelOrder = { project: 0, user: 1, builtin: 2 };
+                const levelOrder = { project: 0, user: 1, builtin: 2, session: 3 };
                 comparison = levelOrder[a.level] - levelOrder[b.level];
                 break;
               }
@@ -224893,6 +224934,24 @@ var init_subagent_manager = __esm({
         }
         return subagents;
       }
+      /**
+       * Loads session-level subagents into the cache.
+       * Session subagents are provided directly via config and are read-only.
+       *
+       * @param subagents - Array of session subagent configurations
+       */
+      loadSessionSubagents(subagents) {
+        if (!this.subagentsCache) {
+          this.subagentsCache = /* @__PURE__ */ new Map();
+        }
+        const sessionSubagents = subagents.map((config2) => ({
+          ...config2,
+          level: "session",
+          filePath: `<session:${config2.name}>`
+        }));
+        this.subagentsCache.set("session", sessionSubagents);
+        this.notifyChangeListeners();
+      }
       /**
        * Refreshes the subagents cache by loading all subagents from disk.
        * This method is called automatically when cache is null or when force=true.
@@ -225157,6 +225216,9 @@ ${config2.systemPrompt}
         if (level === "builtin") {
           return `<builtin:${name3}>`;
         }
+        if (level === "session") {
+          return `<session:${name3}>`;
+        }
         const baseDir = level === "project" ? path52.join(
           this.config.getProjectRoot(),
           QWEN_CONFIG_DIR2,
@@ -225642,7 +225704,9 @@ var init_config3 = __esm({
       toolCallCommand;
       mcpServerCommand;
       mcpServers;
+      sessionSubagents;
       userMemory;
+      sdkMode;
       geminiMdFileCount;
       approvalMode;
       showMemoryUsage;
@@ -225726,6 +225790,8 @@ var init_config3 = __esm({
         this.toolCallCommand = params.toolCallCommand;
         this.mcpServerCommand = params.mcpServerCommand;
         this.mcpServers = params.mcpServers;
+        this.sessionSubagents = params.sessionSubagents ?? [];
+        this.sdkMode = params.sdkMode ?? false;
         this.userMemory = params.userMemory ?? "";
         this.geminiMdFileCount = params.geminiMdFileCount ?? 0;
         this.approvalMode = params.approvalMode ?? "default" /* DEFAULT */;
@@ -225785,7 +225851,7 @@ var init_config3 = __esm({
         this.webSearch = params.webSearch;
         this.useRipgrep = params.useRipgrep ?? true;
         this.useBuiltinRipgrep = params.useBuiltinRipgrep ?? true;
-        this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? false;
+        this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? true;
         this.skipNextSpeakerCheck = params.skipNextSpeakerCheck ?? true;
         this.shellExecutionConfig = {
           terminalWidth: params.shellExecutionConfig?.terminalWidth ?? 80,
@@ -225829,6 +225895,9 @@ var init_config3 = __esm({
         }
         this.promptRegistry = new PromptRegistry();
         this.subagentManager = new SubagentManager(this);
+        if (this.sessionSubagents.length > 0) {
+          this.subagentManager.loadSessionSubagents(this.sessionSubagents);
+        }
         this.toolRegistry = await this.createToolRegistry();
         await this.geminiClient.initialize();
         logStartSession(this, new StartSessionEvent(this));
@@ -225999,6 +226068,27 @@ var init_config3 = __esm({
       getMcpServers() {
         return this.mcpServers;
       }
+      addMcpServers(servers) {
+        if (this.initialized) {
+          throw new Error("Cannot modify mcpServers after initialization");
+        }
+        this.mcpServers = { ...this.mcpServers, ...servers };
+      }
+      getSessionSubagents() {
+        return this.sessionSubagents;
+      }
+      setSessionSubagents(subagents) {
+        if (this.initialized) {
+          throw new Error("Cannot modify sessionSubagents after initialization");
+        }
+        this.sessionSubagents = subagents;
+      }
+      getSdkMode() {
+        return this.sdkMode;
+      }
+      setSdkMode(value) {
+        this.sdkMode = value;
+      }
       getUserMemory() {
         return this.userMemory;
       }
@@ -226341,7 +226431,7 @@ var init_config3 = __esm({
         registerCoreTool(ShellTool, this);
         registerCoreTool(MemoryTool);
         registerCoreTool(TodoWriteTool, this);
-        registerCoreTool(ExitPlanModeTool, this);
+        !this.sdkMode && registerCoreTool(ExitPlanModeTool, this);
         registerCoreTool(WebFetchTool, this);
         registerCoreTool(ReadKnowledgeExtTool);
         registerCoreTool(ListKnowledgeExtTool);
@@ -235608,8 +235698,8 @@ var init_git_commit = __esm({
   "packages/core/src/generated/git-commit.ts"() {
     "use strict";
     init_esbuild_shims();
-    GIT_COMMIT_INFO = "88408513";
-    CLI_VERSION = "0.1.3-alpha.2";
+    GIT_COMMIT_INFO = "398f69c0";
+    CLI_VERSION = "0.1.3-alpha.3";
   }
 });
 
@@ -276143,8 +276233,8 @@ var init_settingsSchema = __esm({
                 label: "Enable Interactive Shell",
                 category: "Tools",
                 requiresRestart: true,
-                default: false,
-                description: "Use node-pty for an interactive shell experience. Fallback to child_process still applies.",
+                default: true,
+                description: "Use node-pty for an interactive shell experience. Allows input to interactive commands (e.g., sudo password prompts). Fallback to child_process still applies.",
                 showInDialog: true
               },
               pager: {
@@ -307471,7 +307561,7 @@ var init_zh = __esm({
       'Theme "{{themeName}}" not found.': '\u672A\u627E\u5230\u4E3B\u9898 "{{themeName}}"\u3002',
       'Theme "{{themeName}}" not found in selected scope.': '\u5728\u6240\u9009\u4F5C\u7528\u57DF\u4E2D\u672A\u627E\u5230\u4E3B\u9898 "{{themeName}}"\u3002',
       "clear the screen and conversation history": "\u6E05\u5C4F\u5E76\u6E05\u9664\u5BF9\u8BDD\u5386\u53F2",
-      "Clear conversation history and free up context": "\u6E05\u9664\u5BF9\u8BDD\u5386\u53F2\u5E76\u91CA\u653E\u4E0A\u4E0B\u6587",
+      "Clear conversation history and free up context": "\u6E05\u9664\u5BF9\u8BDD\u5386\u53F2",
       "Compresses the context by replacing it with a summary.": "\u901A\u8FC7\u7528\u6458\u8981\u66FF\u6362\u6765\u538B\u7F29\u4E0A\u4E0B\u6587",
       "open full RDMind documentation in your browser": "\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u5B8C\u6574\u7684 RDMind \u6587\u6863",
       "Configuration not available.": "\u914D\u7F6E\u4E0D\u53EF\u7528",
@@ -346095,7 +346185,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.1.3-alpha.2";
+  return "0.1.3-alpha.3";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -349092,6 +349182,28 @@ async function parseArguments(settings) {
     }).option("resume", {
       type: "string",
       description: "Resume a specific session by its ID. Use without an ID to show session picker."
+    }).option("max-session-turns", {
+      type: "number",
+      description: "Maximum number of session turns"
+    }).option("core-tools", {
+      type: "array",
+      string: true,
+      description: "Core tool paths",
+      coerce: /* @__PURE__ */ __name((tools) => tools.flatMap((tool) => tool.split(",").map((t4) => t4.trim())), "coerce")
+    }).option("exclude-tools", {
+      type: "array",
+      string: true,
+      description: "Tools to exclude",
+      coerce: /* @__PURE__ */ __name((tools) => tools.flatMap((tool) => tool.split(",").map((t4) => t4.trim())), "coerce")
+    }).option("allowed-tools", {
+      type: "array",
+      string: true,
+      description: "Tools to allow, will bypass confirmation",
+      coerce: /* @__PURE__ */ __name((tools) => tools.flatMap((tool) => tool.split(",").map((t4) => t4.trim())), "coerce")
+    }).option("auth-type", {
+      type: "string",
+      choices: ["openai" /* USE_OPENAI */, "qwen-oauth" /* QWEN_OAUTH */],
+      description: "Authentication type"
     }).deprecateOption(
       "show-memory-usage",
       'Use the "ui.showMemoryUsage" setting in settings.json instead. This flag will be removed in a future version.'
@@ -349292,7 +349404,7 @@ async function loadCliConfig(settings, extensions, extensionEnablementManager, a
     interactive = false;
   }
   const extraExcludes = [];
-  if (!interactive && !argv.experimentalAcp) {
+  if (!interactive && !argv.experimentalAcp && inputFormat !== "stream-json" /* STREAM_JSON */) {
     switch (approvalMode) {
       case "plan" /* PLAN */:
       case "default" /* DEFAULT */:
@@ -349310,7 +349422,8 @@ async function loadCliConfig(settings, extensions, extensionEnablementManager, a
   const excludeTools = mergeExcludeTools(
     settings,
     activeExtensions,
-    extraExcludes.length > 0 ? extraExcludes : void 0
+    extraExcludes.length > 0 ? extraExcludes : void 0,
+    argv.excludeTools
   );
   const blockedMcpServers = [];
   if (!argv.allowedMcpServerNames) {
@@ -349373,7 +349486,7 @@ async function loadCliConfig(settings, extensions, extensionEnablementManager, a
     debugMode,
     question,
     fullContext: argv.allFiles || false,
-    coreTools: settings.tools?.core || void 0,
+    coreTools: argv.coreTools || settings.tools?.core || void 0,
     allowedTools: argv.allowedTools || settings.tools?.allowed || void 0,
     excludeTools,
     toolDiscoveryCommand: settings.tools?.discoveryCommand,
@@ -349399,13 +349512,13 @@ async function loadCliConfig(settings, extensions, extensionEnablementManager, a
     model: resolvedModel,
     extensionContextFilePaths,
     sessionTokenLimit: settings.model?.sessionTokenLimit ?? -1,
-    maxSessionTurns: settings.model?.maxSessionTurns ?? -1,
+    maxSessionTurns: argv.maxSessionTurns ?? settings.model?.maxSessionTurns ?? -1,
     experimentalZedIntegration: argv.experimentalAcp || false,
     listExtensions: argv.listExtensions || false,
     extensions: allExtensions,
     blockedMcpServers,
     noBrowser: !!process.env["NO_BROWSER"],
-    authType: settings.security?.auth?.selectedType,
+    authType: argv.authType || settings.security?.auth?.selectedType,
     inputFormat,
     outputFormat,
     includePartialMessages,
@@ -349501,8 +349614,9 @@ function mergeMcpServers(settings, extensions) {
   return mcpServers;
 }
 __name(mergeMcpServers, "mergeMcpServers");
-function mergeExcludeTools(settings, extensions, extraExcludes) {
+function mergeExcludeTools(settings, extensions, extraExcludes, cliExcludeTools) {
   const allExcludeTools = /* @__PURE__ */ new Set([
+    ...cliExcludeTools || [],
     ...settings.tools?.exclude || [],
     ...extraExcludes || []
   ]);
@@ -352438,7 +352552,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "88408513";
+var GIT_COMMIT_INFO2 = "398f69c0";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -359172,7 +359286,7 @@ async function buildSystemMessage(config2, sessionId, permissionMode) {
     tools,
     mcp_servers: mcpServerList,
     model: config2.getModel(),
-    permissionMode,
+    permission_mode: permissionMode,
     slash_commands: slashCommands,
     qwen_code_version: config2.getCliVersion() || "unknown",
     agents: agentNames
@@ -359678,6 +359792,16 @@ ${event.value}`, null);
         }
         this.finalizePendingBlocks(state, null);
         break;
+      case "error" /* Error */: {
+        const errorText = parseAndFormatApiError(
+          event.value.error,
+          this.config.getContentGeneratorConfig()?.authType,
+          void 0,
+          this.config.getModel()
+        );
+        this.appendText(state, errorText, null);
+        break;
+      }
       default:
         break;
     }
@@ -359934,14 +360058,30 @@ ${event.value}`, null);
     };
     this.emitMessageImpl(message);
   }
+  /**
+   * Checks if responseParts contain any functionResponse with an error.
+   * This handles cancelled responses and other error cases where the error
+   * is embedded in responseParts rather than the top-level error field.
+   * @param responseParts - Array of Part objects
+   * @returns Error message if found, undefined otherwise
+   */
+  checkResponsePartsForError(responseParts) {
+    return checkResponsePartsForError(responseParts);
+  }
   /**
    * Emits a tool result message.
    * Collects execution denied tool calls for inclusion in result messages.
+   * Handles both explicit errors (response.error) and errors embedded in
+   * responseParts (e.g., cancelled responses).
    * @param request - Tool call request info
    * @param response - Tool call response info
    * @param parentToolUseId - Parent tool use ID (null for main agent)
    */
   emitToolResult(request4, response, parentToolUseId = null) {
+    const responsePartsError = this.checkResponsePartsForError(
+      response.responseParts
+    );
+    const hasError = Boolean(response.error) || Boolean(responsePartsError);
     if (response.error && response.errorType === "execution_denied" /* EXECUTION_DENIED */) {
       const denial = {
         tool_name: request4.name,
@@ -359953,7 +360093,7 @@ ${event.value}`, null);
     const block2 = {
       type: "tool_result",
       tool_use_id: request4.callId,
-      is_error: Boolean(response.error)
+      is_error: hasError
     };
     const content = toolResultContent(response);
     if (content !== void 0) {
@@ -360092,10 +360232,27 @@ function partsToContentBlock(parts) {
   return blocks;
 }
 __name(partsToContentBlock, "partsToContentBlock");
+function checkResponsePartsForError(responseParts) {
+  if (!responseParts || responseParts.length === 0) {
+    return void 0;
+  }
+  for (const part of responseParts) {
+    if ("functionResponse" in part && part.functionResponse?.response && typeof part.functionResponse.response === "object" && "error" in part.functionResponse.response && part.functionResponse.response["error"]) {
+      const error2 = part.functionResponse.response["error"];
+      return typeof error2 === "string" ? error2 : String(error2);
+    }
+  }
+  return void 0;
+}
+__name(checkResponsePartsForError, "checkResponsePartsForError");
 function toolResultContent(response) {
   if (response.error) {
     return response.error.message;
   }
+  const responsePartsError = checkResponsePartsForError(response.responseParts);
+  if (responsePartsError) {
+    return responsePartsError;
+  }
   if (typeof response.resultDisplay === "string" && response.resultDisplay.trim().length > 0) {
     return response.resultDisplay;
   }
@@ -361681,6 +361838,15 @@ async function runNonInteractive(config2, settings, input, prompt_id, options2 =
               process.stdout.write(event.value);
             } else if (event.type === "tool_call_request" /* ToolCallRequest */) {
               toolCallRequests.push(event.value);
+            } else if (event.type === "error" /* Error */) {
+              const errorText = parseAndFormatApiError(
+                event.value.error,
+                config2.getContentGeneratorConfig()?.authType,
+                void 0,
+                config2.getModel()
+              );
+              process.stderr.write(`${errorText}
+`);
             }
           }
         }
@@ -361692,6 +361858,8 @@ async function runNonInteractive(config2, settings, input, prompt_id, options2 =
           const toolResponseParts = [];
           for (const requestInfo of toolCallRequests) {
             const finalRequestInfo = requestInfo;
+            const inputFormat = typeof config2.getInputFormat === "function" ? config2.getInputFormat() : "text" /* TEXT */;
+            const toolCallUpdateCallback = inputFormat === "stream-json" /* STREAM_JSON */ && options2.controlService ? options2.controlService.permission.getToolCallUpdateCallback() : void 0;
             const isTaskTool = finalRequestInfo.name === "task";
             const taskToolProgress = isTaskTool ? createTaskToolProgressHandler(
               config2,
@@ -361704,12 +361872,10 @@ async function runNonInteractive(config2, settings, input, prompt_id, options2 =
               finalRequestInfo,
               abortController.signal,
               isTaskTool && taskToolProgressHandler ? {
-                outputUpdateHandler: taskToolProgressHandler
-                /*
-                toolCallUpdateCallback
-                  ? { onToolCallsUpdate: toolCallUpdateCallback }
-                  : undefined,
-                */
+                outputUpdateHandler: taskToolProgressHandler,
+                onToolCallsUpdate: toolCallUpdateCallback
+              } : toolCallUpdateCallback ? {
+                onToolCallsUpdate: toolCallUpdateCallback
               } : void 0
             );
             if (toolResponse.error) {
@@ -361991,10 +362157,57 @@ var SystemController = class extends BaseController {
    * Registers SDK MCP servers and returns capabilities
    */
   async handleInitialize(payload) {
-    if (payload.sdkMcpServers && Array.isArray(payload.sdkMcpServers)) {
-      for (const serverName of payload.sdkMcpServers) {
+    this.context.config.setSdkMode(true);
+    if (payload.sdkMcpServers && typeof payload.sdkMcpServers === "object") {
+      for (const serverName of Object.keys(payload.sdkMcpServers)) {
         this.context.sdkMcpServers.add(serverName);
       }
+      try {
+        this.context.config.addMcpServers(payload.sdkMcpServers);
+        if (this.context.debugMode) {
+          console.error(
+            `[SystemController] Added ${Object.keys(payload.sdkMcpServers).length} SDK MCP servers to config`
+          );
+        }
+      } catch (error2) {
+        if (this.context.debugMode) {
+          console.error(
+            "[SystemController] Failed to add SDK MCP servers:",
+            error2
+          );
+        }
+      }
+    }
+    if (payload.mcpServers && typeof payload.mcpServers === "object") {
+      try {
+        this.context.config.addMcpServers(payload.mcpServers);
+        if (this.context.debugMode) {
+          console.error(
+            `[SystemController] Added ${Object.keys(payload.mcpServers).length} MCP servers to config`
+          );
+        }
+      } catch (error2) {
+        if (this.context.debugMode) {
+          console.error("[SystemController] Failed to add MCP servers:", error2);
+        }
+      }
+    }
+    if (payload.agents && Array.isArray(payload.agents)) {
+      try {
+        this.context.config.setSessionSubagents(payload.agents);
+        if (this.context.debugMode) {
+          console.error(
+            `[SystemController] Added ${payload.agents.length} session subagents to config`
+          );
+        }
+      } catch (error2) {
+        if (this.context.debugMode) {
+          console.error(
+            "[SystemController] Failed to add session subagents:",
+            error2
+          );
+        }
+      }
     }
     const capabilities = this.buildControlCapabilities();
     if (this.context.debugMode) {
@@ -362017,29 +362230,12 @@ var SystemController = class extends BaseController {
   buildControlCapabilities() {
     const capabilities = {
       can_handle_can_use_tool: true,
-      can_handle_hook_callback: true,
+      can_handle_hook_callback: false,
       can_set_permission_mode: typeof this.context.config.setApprovalMode === "function",
-      can_set_model: typeof this.context.config.setModel === "function"
+      can_set_model: typeof this.context.config.setModel === "function",
+      /* TODO: sdkMcpServers support */
+      can_handle_mcp_message: false
     };
-    try {
-      const mcpProvider = this.context.config;
-      if (typeof mcpProvider.getMcpServers === "function") {
-        const servers = mcpProvider.getMcpServers();
-        capabilities["can_handle_mcp_message"] = Boolean(
-          servers && Object.keys(servers).length > 0
-        );
-      } else {
-        capabilities["can_handle_mcp_message"] = false;
-      }
-    } catch (error2) {
-      if (this.context.debugMode) {
-        console.error(
-          "[SystemController] Failed to determine MCP capability:",
-          error2
-        );
-      }
-      capabilities["can_handle_mcp_message"] = false;
-    }
     return capabilities;
   }
   /**
@@ -362094,27 +362290,377 @@ var SystemController = class extends BaseController {
   /**
    * Handle supported_commands request
    *
-   * Returns list of supported control commands
-   *
-   * Note: This list should match the ControlRequestType enum in
-   * packages/sdk/typescript/src/types/controlRequests.ts
+   * Returns list of supported slash commands loaded dynamically
    */
   async handleSupportedCommands() {
-    const commands = [
-      "initialize",
-      "interrupt",
-      "set_model",
-      "supported_commands",
-      "can_use_tool",
-      "set_permission_mode",
-      "mcp_message",
-      "mcp_server_status",
-      "hook_callback"
-    ];
+    const slashCommands = await this.loadSlashCommandNames();
     return {
       subtype: "supported_commands",
-      commands
+      commands: slashCommands
+    };
+  }
+  /**
+   * Load slash command names using CommandService
+   *
+   * @returns Promise resolving to array of slash command names
+   */
+  async loadSlashCommandNames() {
+    const controller = new AbortController();
+    try {
+      const service = await CommandService.create(
+        [new BuiltinCommandLoader(this.context.config)],
+        controller.signal
+      );
+      const names = /* @__PURE__ */ new Set();
+      const commands = service.getCommands();
+      for (const command2 of commands) {
+        names.add(command2.name);
+      }
+      return Array.from(names).sort();
+    } catch (error2) {
+      if (this.context.debugMode) {
+        console.error(
+          "[SystemController] Failed to load slash commands:",
+          error2
+        );
+      }
+      return [];
+    } finally {
+      controller.abort();
+    }
+  }
+};
+
+// packages/cli/src/nonInteractive/control/controllers/permissionController.ts
+init_esbuild_shims();
+init_core4();
+var PermissionController = class extends BaseController {
+  static {
+    __name(this, "PermissionController");
+  }
+  pendingOutgoingRequests = /* @__PURE__ */ new Set();
+  /**
+   * Handle permission control requests
+   */
+  async handleRequestPayload(payload, _signal) {
+    switch (payload.subtype) {
+      case "can_use_tool":
+        return this.handleCanUseTool(payload);
+      case "set_permission_mode":
+        return this.handleSetPermissionMode(
+          payload
+        );
+      default:
+        throw new Error(`Unsupported request subtype in PermissionController`);
+    }
+  }
+  /**
+   * Handle can_use_tool request
+   *
+   * Comprehensive permission evaluation based on:
+   * - Permission mode (approval level)
+   * - Tool registry validation
+   * - Error handling with safe defaults
+   */
+  async handleCanUseTool(payload) {
+    const toolName = payload.tool_name;
+    if (!toolName || typeof toolName !== "string" || toolName.trim().length === 0) {
+      return {
+        subtype: "can_use_tool",
+        behavior: "deny",
+        message: "Missing or invalid tool_name in can_use_tool request"
+      };
+    }
+    let behavior = "allow";
+    let message;
+    try {
+      const permissionResult = this.checkPermissionMode();
+      if (!permissionResult.allowed) {
+        behavior = "deny";
+        message = permissionResult.message;
+      }
+      if (behavior === "allow") {
+        const registryResult = this.checkToolRegistry(toolName);
+        if (!registryResult.allowed) {
+          behavior = "deny";
+          message = registryResult.message;
+        }
+      }
+    } catch (error2) {
+      behavior = "deny";
+      message = error2 instanceof Error ? `Failed to evaluate tool permission: ${error2.message}` : "Failed to evaluate tool permission";
+    }
+    const response = {
+      subtype: "can_use_tool",
+      behavior
     };
+    if (message) {
+      response["message"] = message;
+    }
+    return response;
+  }
+  /**
+   * Check permission mode for tool execution
+   */
+  checkPermissionMode() {
+    const mode = this.context.permissionMode;
+    switch (mode) {
+      case "yolo":
+      // Allow all tools
+      case "auto-edit":
+      // Auto-approve edit operations
+      case "plan":
+        return { allowed: true };
+      case "default":
+      // TODO: allow all tools for test
+      default:
+        return {
+          allowed: false,
+          message: "Tool execution requires manual approval. Update permission mode or approve via host."
+        };
+    }
+  }
+  /**
+   * Check if tool exists in registry
+   */
+  checkToolRegistry(toolName) {
+    try {
+      const config2 = this.context.config;
+      const registryProvider = config2;
+      if (typeof registryProvider.getToolRegistry === "function") {
+        const registry2 = registryProvider.getToolRegistry();
+        if (registry2 && typeof registry2.getTool === "function" && !registry2.getTool(toolName)) {
+          return {
+            allowed: false,
+            message: `Tool "${toolName}" is not registered.`
+          };
+        }
+      }
+      return { allowed: true };
+    } catch (error2) {
+      return {
+        allowed: false,
+        message: `Failed to check tool registry: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+      };
+    }
+  }
+  /**
+   * Handle set_permission_mode request
+   *
+   * Updates the permission mode in the context
+   */
+  async handleSetPermissionMode(payload) {
+    const mode = payload.mode;
+    const validModes = [
+      "default",
+      "plan",
+      "auto-edit",
+      "yolo"
+    ];
+    if (!validModes.includes(mode)) {
+      throw new Error(
+        `Invalid permission mode: ${mode}. Valid values are: ${validModes.join(", ")}`
+      );
+    }
+    this.context.permissionMode = mode;
+    this.context.config.setApprovalMode(mode);
+    if (this.context.debugMode) {
+      console.error(
+        `[PermissionController] Permission mode updated to: ${mode}`
+      );
+    }
+    return { status: "updated", mode };
+  }
+  /**
+   * Build permission suggestions for tool confirmation UI
+   *
+   * This method creates UI suggestions based on tool confirmation details,
+   * helping the host application present appropriate permission options.
+   */
+  buildPermissionSuggestions(confirmationDetails) {
+    if (!confirmationDetails || typeof confirmationDetails !== "object" || !("type" in confirmationDetails)) {
+      return null;
+    }
+    const details = confirmationDetails;
+    const type = String(details["type"] ?? "");
+    const title = typeof details["title"] === "string" ? details["title"] : void 0;
+    const confirmationType = type;
+    switch (confirmationType) {
+      case "exec":
+        return [
+          {
+            type: "allow",
+            label: "Allow Command",
+            description: `Execute: ${details["command"]}`
+          },
+          {
+            type: "deny",
+            label: "Deny",
+            description: "Block this command execution"
+          }
+        ];
+      case "edit":
+        return [
+          {
+            type: "allow",
+            label: "Allow Edit",
+            description: `Edit file: ${details["fileName"]}`
+          },
+          {
+            type: "deny",
+            label: "Deny",
+            description: "Block this file edit"
+          },
+          {
+            type: "modify",
+            label: "Review Changes",
+            description: "Review the proposed changes before applying"
+          }
+        ];
+      case "plan":
+        return [
+          {
+            type: "allow",
+            label: "Approve Plan",
+            description: title || "Execute the proposed plan"
+          },
+          {
+            type: "deny",
+            label: "Reject Plan",
+            description: "Do not execute this plan"
+          }
+        ];
+      case "mcp":
+        return [
+          {
+            type: "allow",
+            label: "Allow MCP Call",
+            description: `${details["serverName"]}: ${details["toolName"]}`
+          },
+          {
+            type: "deny",
+            label: "Deny",
+            description: "Block this MCP server call"
+          }
+        ];
+      case "info":
+        return [
+          {
+            type: "allow",
+            label: "Allow Info Request",
+            description: title || "Allow information request"
+          },
+          {
+            type: "deny",
+            label: "Deny",
+            description: "Block this information request"
+          }
+        ];
+      default:
+        return [
+          {
+            type: "allow",
+            label: "Allow",
+            description: title || `Allow ${type} operation`
+          },
+          {
+            type: "deny",
+            label: "Deny",
+            description: `Block ${type} operation`
+          }
+        ];
+    }
+  }
+  /**
+   * Get callback for monitoring tool calls and handling outgoing permission requests
+   * This is passed to executeToolCall to hook into CoreToolScheduler updates
+   */
+  getToolCallUpdateCallback() {
+    return (toolCalls) => {
+      for (const call of toolCalls) {
+        if (call && typeof call === "object" && call.status === "awaiting_approval") {
+          const awaiting = call;
+          if (typeof awaiting.confirmationDetails?.onConfirm === "function" && !this.pendingOutgoingRequests.has(awaiting.request.callId)) {
+            this.pendingOutgoingRequests.add(awaiting.request.callId);
+            void this.handleOutgoingPermissionRequest(awaiting);
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Handle outgoing permission request
+   *
+   * Behavior depends on input format:
+   * - stream-json mode: Send can_use_tool to SDK and await response
+   * - Other modes: Check local approval mode and decide immediately
+   */
+  async handleOutgoingPermissionRequest(toolCall) {
+    try {
+      const inputFormat = this.context.config.getInputFormat?.();
+      const isStreamJsonMode = inputFormat === "stream-json" /* STREAM_JSON */;
+      if (!isStreamJsonMode) {
+        const modeCheck = this.checkPermissionMode();
+        const outcome = modeCheck.allowed ? "proceed_once" /* ProceedOnce */ : "cancel" /* Cancel */;
+        await toolCall.confirmationDetails.onConfirm(outcome);
+        return;
+      }
+      const permissionSuggestions = this.buildPermissionSuggestions(
+        toolCall.confirmationDetails
+      );
+      const response = await this.sendControlRequest({
+        subtype: "can_use_tool",
+        tool_name: toolCall.request.name,
+        tool_use_id: toolCall.request.callId,
+        input: toolCall.request.args,
+        permission_suggestions: permissionSuggestions,
+        blocked_path: null
+      });
+      if (response.subtype !== "success") {
+        await toolCall.confirmationDetails.onConfirm(
+          "cancel" /* Cancel */
+        );
+        return;
+      }
+      const payload = response.response || {};
+      const behavior = String(payload["behavior"] || "").toLowerCase();
+      if (behavior === "allow") {
+        const updatedInput = payload["updatedInput"];
+        if (updatedInput && typeof updatedInput === "object") {
+          toolCall.request.args = updatedInput;
+        }
+        await toolCall.confirmationDetails.onConfirm(
+          "proceed_once" /* ProceedOnce */
+        );
+      } else {
+        const cancelMessage = typeof payload["message"] === "string" ? payload["message"] : void 0;
+        await toolCall.confirmationDetails.onConfirm(
+          "cancel" /* Cancel */,
+          cancelMessage ? { cancelMessage } : void 0
+        );
+      }
+    } catch (error2) {
+      if (this.context.debugMode) {
+        console.error(
+          "[PermissionController] Outgoing permission failed:",
+          error2
+        );
+      }
+      const confirmationType = toolCall.confirmationDetails.type;
+      if (["edit", "exec", "mcp"].includes(confirmationType)) {
+        const execOrMcpDetails = toolCall.confirmationDetails;
+        await execOrMcpDetails.onConfirm(
+          "cancel" /* Cancel */,
+          void 0
+        );
+      } else {
+        await toolCall.confirmationDetails.onConfirm(
+          "cancel" /* Cancel */
+        );
+      }
+    } finally {
+      this.pendingOutgoingRequests.delete(toolCall.request.callId);
+    }
   }
 };
 
@@ -362126,7 +362672,7 @@ var ControlDispatcher = class {
   context;
   // Make controllers publicly accessible
   systemController;
-  // readonly permissionController: PermissionController;
+  permissionController;
   // readonly mcpController: MCPController;
   // readonly hookController: HookController;
   // Central pending request registries
@@ -362139,6 +362685,11 @@ var ControlDispatcher = class {
       this,
       "SystemController"
     );
+    this.permissionController = new PermissionController(
+      context2,
+      this,
+      "PermissionController"
+    );
     this.context.abortSignal.addEventListener("abort", () => {
       this.shutdown();
     });
@@ -362243,6 +362794,7 @@ var ControlDispatcher = class {
     }
     this.pendingOutgoingRequests.clear();
     this.systemController.cleanup();
+    this.permissionController.cleanup();
   }
   /**
    * Registers an incoming request in the pending registry
@@ -362295,9 +362847,9 @@ var ControlDispatcher = class {
       case "set_model":
       case "supported_commands":
         return this.systemController;
-      // case 'can_use_tool':
-      // case 'set_permission_mode':
-      //   return this.permissionController;
+      case "can_use_tool":
+      case "set_permission_mode":
+        return this.permissionController;
       // case 'mcp_message':
       // case 'mcp_server_status':
       //   return this.mcpController;
@@ -362359,43 +362911,28 @@ var ControlService = class {
    * Handles tool execution permissions, approval checks, and callbacks.
    * Delegates to the shared PermissionController instance.
    */
-  // get permission(): PermissionServiceAPI {
-  //   const controller = this.dispatcher.permissionController;
-  //   return {
-  //     /**
-  //      * Check if a tool should be allowed based on current permission settings
-  //      *
-  //      * Evaluates permission mode and tool registry to determine if execution
-  //      * should proceed. Can optionally modify tool arguments based on confirmation details.
-  //      *
-  //      * @param toolRequest - Tool call request information
-  //      * @param confirmationDetails - Optional confirmation details for UI
-  //      * @returns Permission decision with optional updated arguments
-  //      */
-  //     shouldAllowTool: controller.shouldAllowTool.bind(controller),
-  //
-  //     /**
-  //      * Build UI suggestions for tool confirmation dialogs
-  //      *
-  //      * Creates actionable permission suggestions based on tool confirmation details.
-  //      *
-  //      * @param confirmationDetails - Tool confirmation details
-  //      * @returns Array of permission suggestions or null
-  //      */
-  //     buildPermissionSuggestions:
-  //       controller.buildPermissionSuggestions.bind(controller),
-  //
-  //     /**
-  //      * Get callback for monitoring tool call status updates
-  //      *
-  //      * Returns callback function for integration with CoreToolScheduler.
-  //      *
-  //      * @returns Callback function for tool call updates
-  //      */
-  //     getToolCallUpdateCallback:
-  //       controller.getToolCallUpdateCallback.bind(controller),
-  //   };
-  // }
+  get permission() {
+    const controller = this.dispatcher.permissionController;
+    return {
+      /**
+       * Build UI suggestions for tool confirmation dialogs
+       *
+       * Creates actionable permission suggestions based on tool confirmation details.
+       *
+       * @param confirmationDetails - Tool confirmation details
+       * @returns Array of permission suggestions or null
+       */
+      buildPermissionSuggestions: controller.buildPermissionSuggestions.bind(controller),
+      /**
+       * Get callback for monitoring tool call status updates
+       *
+       * Returns callback function for integration with CoreToolScheduler.
+       *
+       * @returns Callback function for tool call updates
+       */
+      getToolCallUpdateCallback: controller.getToolCallUpdateCallback.bind(controller)
+    };
+  }
   /**
    * System Domain API
    *
@@ -362573,17 +363110,10 @@ var ConsolePatcher = class {
 };
 
 // packages/cli/src/nonInteractive/session.ts
-var SESSION_STATE = {
-  INITIALIZING: "initializing",
-  IDLE: "idle",
-  PROCESSING_QUERY: "processing_query",
-  SHUTTING_DOWN: "shutting_down"
-};
-var SessionManager = class {
+var Session2 = class {
   static {
-    __name(this, "SessionManager");
+    __name(this, "Session");
   }
-  state = SESSION_STATE.INITIALIZING;
   userMessageQueue = [];
   abortController;
   config;
@@ -362598,6 +363128,9 @@ var SessionManager = class {
   debugMode;
   shutdownHandler = null;
   initialPrompt = null;
+  processingPromise = null;
+  isShuttingDown = false;
+  configInitialized = false;
   constructor(config2, initialPrompt) {
     this.config = config2;
     this.sessionId = config2.getSessionId();
@@ -362611,106 +363144,25 @@ var SessionManager = class {
     );
     this.setupSignalHandlers();
   }
-  /**
-   * Get next prompt ID
-   */
   getNextPromptId() {
     this.promptIdCounter++;
     return `${this.sessionId}########${this.promptIdCounter}`;
   }
-  /**
-   * Route a message to the appropriate handler based on its type
-   *
-   * Classifies incoming messages and routes them to appropriate handlers.
-   */
-  route(message) {
-    if (isControlRequest(message)) {
-      return { type: "control_request", message };
-    }
-    if (isControlResponse(message)) {
-      return { type: "control_response", message };
-    }
-    if (isControlCancel(message)) {
-      return { type: "control_cancel", message };
-    }
-    if (isCLIUserMessage(message)) {
-      return { type: "user", message };
-    }
-    if (isCLIAssistantMessage(message)) {
-      return { type: "assistant", message };
-    }
-    if (isCLISystemMessage(message)) {
-      return { type: "system", message };
-    }
-    if (isCLIResultMessage(message)) {
-      return { type: "result", message };
-    }
-    if (isCLIPartialAssistantMessage(message)) {
-      return { type: "stream_event", message };
+  async ensureConfigInitialized() {
+    if (this.configInitialized) {
+      return;
     }
     if (this.debugMode) {
-      console.error(
-        "[SessionManager] Unknown message type:",
-        JSON.stringify(message, null, 2)
-      );
+      console.error("[Session] Initializing config");
     }
-    return { type: "unknown", message };
-  }
-  /**
-   * Process a single message with unified logic for both initial prompt and stream messages.
-   *
-   * Handles:
-   * - Abort check
-   * - First message detection and handling
-   * - Normal message processing
-   * - Shutdown state checks
-   *
-   * @param message - Message to process
-   * @returns true if the calling code should exit (break/return), false to continue
-   */
-  async processSingleMessage(message) {
-    if (this.abortController.signal.aborted) {
-      return true;
-    }
-    if (this.controlSystemEnabled === null) {
-      const handled = await this.handleFirstMessage(message);
-      if (handled) {
-        return this.state === SESSION_STATE.SHUTTING_DOWN;
-      }
-    }
-    await this.processMessage(message);
-    return this.state === SESSION_STATE.SHUTTING_DOWN;
-  }
-  /**
-   * Main entry point - run the session
-   */
-  async run() {
     try {
-      if (this.debugMode) {
-        console.error("[SessionManager] Starting session", this.sessionId);
-      }
-      if (this.initialPrompt !== null) {
-        const shouldExit = await this.processSingleMessage(this.initialPrompt);
-        if (shouldExit) {
-          await this.shutdown();
-          return;
-        }
-      }
-      for await (const message of this.inputReader.read()) {
-        const shouldExit = await this.processSingleMessage(message);
-        if (shouldExit) {
-          break;
-        }
-      }
-      await this.shutdown();
+      await this.config.initialize();
+      this.configInitialized = true;
     } catch (error2) {
       if (this.debugMode) {
-        console.error("[SessionManager] Error:", error2);
+        console.error("[Session] Failed to initialize config:", error2);
       }
-      await this.shutdown();
       throw error2;
-    } finally {
-      this.cleanupSignalHandlers();
     }
   }
   ensureControlSystem() {
@@ -362741,219 +363193,64 @@ var SessionManager = class {
     return this.dispatcher;
   }
   async handleFirstMessage(message) {
-    const routed = this.route(message);
-    if (routed.type === "control_request") {
-      const request4 = routed.message;
+    if (isControlRequest(message)) {
+      const request4 = message;
       this.controlSystemEnabled = true;
       this.ensureControlSystem();
       if (request4.request.subtype === "initialize") {
         await this.dispatcher?.dispatch(request4);
-        this.state = SESSION_STATE.IDLE;
+        await this.ensureConfigInitialized();
         return true;
       }
-      return false;
+      if (this.debugMode) {
+        console.error(
+          "[Session] Ignoring non-initialize control request during initialization"
+        );
+      }
+      return true;
     }
-    if (routed.type === "user") {
+    if (isCLIUserMessage(message)) {
       this.controlSystemEnabled = false;
-      this.state = SESSION_STATE.PROCESSING_QUERY;
-      this.userMessageQueue.push(routed.message);
-      await this.processUserMessageQueue();
+      await this.ensureConfigInitialized();
+      this.enqueueUserMessage(message);
       return true;
     }
     this.controlSystemEnabled = false;
     return false;
   }
-  /**
-   * Process a single message from the stream
-   */
-  async processMessage(message) {
-    const routed = this.route(message);
-    if (this.debugMode) {
-      console.error(
-        `[SessionManager] State: ${this.state}, Message type: ${routed.type}`
-      );
-    }
-    switch (this.state) {
-      case SESSION_STATE.INITIALIZING:
-        await this.handleInitializingState(routed);
-        break;
-      case SESSION_STATE.IDLE:
-        await this.handleIdleState(routed);
-        break;
-      case SESSION_STATE.PROCESSING_QUERY:
-        await this.handleProcessingState(routed);
-        break;
-      case SESSION_STATE.SHUTTING_DOWN:
-        break;
-      default: {
-        const _exhaustiveCheck = this.state;
-        if (this.debugMode) {
-          console.error("[SessionManager] Unknown state:", _exhaustiveCheck);
-        }
-        break;
-      }
-    }
-  }
-  /**
-   * Handle messages in initializing state
-   */
-  async handleInitializingState(routed) {
-    if (routed.type === "control_request") {
-      const request4 = routed.message;
-      const dispatcher = this.getDispatcher();
-      if (!dispatcher) {
-        if (this.debugMode) {
-          console.error(
-            "[SessionManager] Control request received before control system initialization"
-          );
-        }
-        return;
-      }
-      if (request4.request.subtype === "initialize") {
-        await dispatcher.dispatch(request4);
-        this.state = SESSION_STATE.IDLE;
-        if (this.debugMode) {
-          console.error("[SessionManager] Initialized, transitioning to idle");
-        }
-      } else {
-        if (this.debugMode) {
-          console.error(
-            "[SessionManager] Ignoring non-initialize control request during initialization"
-          );
-        }
-      }
-    } else {
-      if (this.debugMode) {
-        console.error(
-          "[SessionManager] Ignoring non-control message during initialization"
-        );
-      }
-    }
-  }
-  /**
-   * Handle messages in idle state
-   */
-  async handleIdleState(routed) {
+  async handleControlRequest(request4) {
     const dispatcher = this.getDispatcher();
-    if (routed.type === "control_request") {
-      if (!dispatcher) {
-        if (this.debugMode) {
-          console.error("[SessionManager] Ignoring control request (disabled)");
-        }
-        return;
-      }
-      const request4 = routed.message;
-      await dispatcher.dispatch(request4);
-    } else if (routed.type === "control_response") {
-      if (!dispatcher) {
-        return;
-      }
-      const response = routed.message;
-      dispatcher.handleControlResponse(response);
-    } else if (routed.type === "control_cancel") {
-      if (!dispatcher) {
-        return;
-      }
-      const cancelRequest = routed.message;
-      dispatcher.handleCancel(cancelRequest.request_id);
-    } else if (routed.type === "user") {
-      const userMessage = routed.message;
-      this.userMessageQueue.push(userMessage);
-      await this.processUserMessageQueue();
-    } else {
+    if (!dispatcher) {
       if (this.debugMode) {
-        console.error(
-          "[SessionManager] Ignoring message type in idle state:",
-          routed.type
-        );
+        console.error("[Session] Control system not enabled");
       }
+      return;
     }
+    await dispatcher.dispatch(request4);
   }
-  /**
-   * Handle messages in processing state
-   */
-  async handleProcessingState(routed) {
+  handleControlResponse(response) {
     const dispatcher = this.getDispatcher();
-    if (routed.type === "control_request") {
-      if (!dispatcher) {
-        if (this.debugMode) {
-          console.error(
-            "[SessionManager] Control request ignored during processing (disabled)"
-          );
-        }
-        return;
-      }
-      const request4 = routed.message;
-      await dispatcher.dispatch(request4);
-    } else if (routed.type === "control_response") {
-      if (!dispatcher) {
-        return;
-      }
-      const response = routed.message;
-      dispatcher.handleControlResponse(response);
-    } else if (routed.type === "user") {
-      const userMessage = routed.message;
-      this.userMessageQueue.push(userMessage);
-      if (this.debugMode) {
-        console.error(
-          "[SessionManager] Enqueued user message during processing"
-        );
-      }
-    } else {
-      if (this.debugMode) {
-        console.error(
-          "[SessionManager] Ignoring message type during processing:",
-          routed.type
-        );
-      }
+    if (!dispatcher) {
+      return;
     }
+    dispatcher.handleControlResponse(response);
   }
-  /**
-   * Process user message queue (FIFO)
-   */
-  async processUserMessageQueue() {
-    while (this.userMessageQueue.length > 0 && !this.abortController.signal.aborted) {
-      this.state = SESSION_STATE.PROCESSING_QUERY;
-      const userMessage = this.userMessageQueue.shift();
-      try {
-        await this.processUserMessage(userMessage);
-      } catch (error2) {
-        if (this.debugMode) {
-          console.error(
-            "[SessionManager] Error processing user message:",
-            error2
-          );
-        }
-        this.emitErrorResult(error2);
-      }
-    }
-    if (!this.abortController.signal.aborted && this.state === SESSION_STATE.PROCESSING_QUERY && this.controlSystemEnabled === false && this.userMessageQueue.length === 0) {
-      if (this.debugMode) {
-        console.error(
-          "[SessionManager] Single-query mode: queue processed, shutting down"
-        );
-      }
-      this.state = SESSION_STATE.SHUTTING_DOWN;
+  handleControlCancel(cancelRequest) {
+    const dispatcher = this.getDispatcher();
+    if (!dispatcher) {
       return;
     }
-    if (!this.abortController.signal.aborted && this.state === SESSION_STATE.PROCESSING_QUERY) {
-      this.state = SESSION_STATE.IDLE;
-      if (this.debugMode) {
-        console.error("[SessionManager] Queue processed, returning to idle");
-      }
-    }
+    dispatcher.handleCancel(cancelRequest.request_id);
   }
-  /**
-   * Process a single user message
-   */
   async processUserMessage(userMessage) {
     const input = extractUserMessageText(userMessage);
     if (!input) {
       if (this.debugMode) {
-        console.error("[SessionManager] No text content in user message");
+        console.error("[Session] No text content in user message");
       }
       return;
     }
+    await this.ensureConfigInitialized();
     const promptId = this.getNextPromptId();
     try {
       await runNonInteractive(
@@ -362969,13 +363266,41 @@ var SessionManager = class {
       );
     } catch (error2) {
       if (this.debugMode) {
-        console.error("[SessionManager] Query execution error:", error2);
+        console.error("[Session] Query execution error:", error2);
       }
     }
   }
-  /**
-   * Send tool results as user message
-   */
+  async processUserMessageQueue() {
+    if (this.isShuttingDown || this.abortController.signal.aborted) {
+      return;
+    }
+    while (this.userMessageQueue.length > 0 && !this.isShuttingDown && !this.abortController.signal.aborted) {
+      const userMessage = this.userMessageQueue.shift();
+      try {
+        await this.processUserMessage(userMessage);
+      } catch (error2) {
+        if (this.debugMode) {
+          console.error("[Session] Error processing user message:", error2);
+        }
+        this.emitErrorResult(error2);
+      }
+    }
+  }
+  enqueueUserMessage(userMessage) {
+    this.userMessageQueue.push(userMessage);
+    this.ensureProcessingStarted();
+  }
+  ensureProcessingStarted() {
+    if (this.processingPromise) {
+      return;
+    }
+    this.processingPromise = this.processUserMessageQueue().finally(() => {
+      this.processingPromise = null;
+      if (this.userMessageQueue.length > 0 && !this.isShuttingDown && !this.abortController.signal.aborted) {
+        this.ensureProcessingStarted();
+      }
+    });
+  }
   emitErrorResult(error2, numTurns = 0, durationMs = 0, apiDurationMs = 0) {
     const message = error2 instanceof Error ? error2.message : String(error2);
     this.outputAdapter.emitResult({
@@ -362987,46 +363312,44 @@ var SessionManager = class {
       usage: void 0
     });
   }
-  /**
-   * Handle interrupt control request
-   */
   handleInterrupt() {
     if (this.debugMode) {
-      console.error("[SessionManager] Interrupt requested");
-    }
-    if (this.state === SESSION_STATE.PROCESSING_QUERY) {
-      this.abortController.abort();
-      this.abortController = new AbortController();
+      console.error("[Session] Interrupt requested");
     }
+    this.abortController.abort();
+    this.abortController = new AbortController();
   }
-  /**
-   * Setup signal handlers for graceful shutdown
-   */
   setupSignalHandlers() {
     this.shutdownHandler = () => {
       if (this.debugMode) {
-        console.error("[SessionManager] Shutdown signal received");
+        console.error("[Session] Shutdown signal received");
       }
+      this.isShuttingDown = true;
       this.abortController.abort();
-      this.state = SESSION_STATE.SHUTTING_DOWN;
     };
     process.on("SIGINT", this.shutdownHandler);
     process.on("SIGTERM", this.shutdownHandler);
   }
-  /**
-   * Shutdown session and cleanup resources
-   */
   async shutdown() {
     if (this.debugMode) {
-      console.error("[SessionManager] Shutting down");
+      console.error("[Session] Shutting down");
+    }
+    this.isShuttingDown = true;
+    if (this.processingPromise) {
+      try {
+        await this.processingPromise;
+      } catch (error2) {
+        if (this.debugMode) {
+          console.error(
+            "[Session] Error waiting for processing to complete:",
+            error2
+          );
+        }
+      }
     }
-    this.state = SESSION_STATE.SHUTTING_DOWN;
     this.dispatcher?.shutdown();
     this.cleanupSignalHandlers();
   }
-  /**
-   * Remove signal handlers to prevent memory leaks
-   */
   cleanupSignalHandlers() {
     if (this.shutdownHandler) {
       process.removeListener("SIGINT", this.shutdownHandler);
@@ -363034,6 +363357,81 @@ var SessionManager = class {
       this.shutdownHandler = null;
     }
   }
+  async run() {
+    try {
+      if (this.debugMode) {
+        console.error("[Session] Starting session", this.sessionId);
+      }
+      if (this.initialPrompt !== null) {
+        const handled = await this.handleFirstMessage(this.initialPrompt);
+        if (handled && this.isShuttingDown) {
+          await this.shutdown();
+          return;
+        }
+      }
+      try {
+        for await (const message of this.inputReader.read()) {
+          if (this.abortController.signal.aborted) {
+            break;
+          }
+          if (this.controlSystemEnabled === null) {
+            const handled = await this.handleFirstMessage(message);
+            if (handled) {
+              if (this.isShuttingDown) {
+                break;
+              }
+              continue;
+            }
+          }
+          if (isControlRequest(message)) {
+            await this.handleControlRequest(message);
+          } else if (isControlResponse(message)) {
+            this.handleControlResponse(message);
+          } else if (isControlCancel(message)) {
+            this.handleControlCancel(message);
+          } else if (isCLIUserMessage(message)) {
+            this.enqueueUserMessage(message);
+          } else if (this.debugMode) {
+            if (!isCLIAssistantMessage(message) && !isCLISystemMessage(message) && !isCLIResultMessage(message) && !isCLIPartialAssistantMessage(message)) {
+              console.error(
+                "[Session] Unknown message type:",
+                JSON.stringify(message, null, 2)
+              );
+            }
+          }
+          if (this.isShuttingDown) {
+            break;
+          }
+        }
+      } catch (streamError) {
+        if (this.debugMode) {
+          console.error("[Session] Stream reading error:", streamError);
+        }
+        throw streamError;
+      }
+      while (this.processingPromise) {
+        if (this.debugMode) {
+          console.error("[Session] Waiting for final processing to complete");
+        }
+        try {
+          await this.processingPromise;
+        } catch (error2) {
+          if (this.debugMode) {
+            console.error("[Session] Error in final processing:", error2);
+          }
+        }
+      }
+      await this.shutdown();
+    } catch (error2) {
+      if (this.debugMode) {
+        console.error("[Session] Error:", error2);
+      }
+      await this.shutdown();
+      throw error2;
+    } finally {
+      this.cleanupSignalHandlers();
+    }
+  }
 };
 function extractUserMessageText(message) {
   const content = message.message.content;
@@ -363074,7 +363472,7 @@ async function runNonInteractiveStreamJson(config2, input) {
         parent_tool_use_id: null
       };
     }
-    const manager = new SessionManager(config2, initialPrompt);
+    const manager = new Session2(config2, initialPrompt);
     await manager.run();
   } finally {
     consolePatcher.cleanup();
@@ -383548,7 +383946,7 @@ var AgentSelectionStep = /* @__PURE__ */ __name(({
   return /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(Box_default, { flexDirection: "column", children: [
     projectAgents.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(Box_default, { flexDirection: "column", marginBottom: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(Text3, { color: theme.text.primary, bold: true, children: t3("Project Level ({{path}})", {
-        path: projectAgents[0].filePath.replace(/\/[^/]+$/, "")
+        path: projectAgents[0].filePath?.replace(/\/[^/]+$/, "") || ""
       }) }),
       /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(Box_default, { marginTop: 1, flexDirection: "column", children: projectAgents.map((agent, index) => {
         const isSelected = navigation.currentBlock === "project" && navigation.projectIndex === index;
@@ -383562,7 +383960,7 @@ var AgentSelectionStep = /* @__PURE__ */ __name(({
         marginBottom: builtinAgents.length > 0 ? 1 : 0,
         children: [
           /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(Text3, { color: theme.text.primary, bold: true, children: t3("User Level ({{path}})", {
-            path: userAgents[0].filePath.replace(/\/[^/]+$/, "")
+            path: userAgents[0].filePath?.replace(/\/[^/]+$/, "") || ""
           }) }),
           /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(Box_default, { marginTop: 1, flexDirection: "column", children: userAgents.map((agent, index) => {
             const isSelected = navigation.currentBlock === "user" && navigation.userIndex === index;
@@ -383725,7 +384123,10 @@ function EditOptionsStep({
       setError(null);
       if (selectedValue === "editor") {
         try {
-          await launchEditor(selectedAgent?.filePath);
+          if (!selectedAgent.filePath) {
+            throw new Error("Agent has no file path");
+          }
+          await launchEditor(selectedAgent.filePath);
         } catch (err) {
           setError(
             t3("Failed to launch editor: {{error}}", {
@@ -402682,7 +403083,11 @@ function getRdmindSsoId3() {
   }
 }
 __name(getRdmindSsoId3, "getRdmindSsoId");
-function useWebSocket({ onReloadCommands, debug: debug2, sessionId }) {
+function useWebSocket({
+  onReloadCommands,
+  debug: debug2,
+  sessionId
+}) {
   const wsClientRef = (0, import_react133.useRef)(null);
   (0, import_react133.useEffect)(() => {
     const wsRuntimeConfig = loadWebSocketRuntimeConfig(debug2);
@@ -405012,7 +405417,7 @@ async function validateNonInteractiveAuth(configuredAuthType, useExternalAuth, n
         throw new Error(message);
       }
     }
-    const effectiveAuthType = enforcedType || getAuthTypeFromEnv() || configuredAuthType;
+    const effectiveAuthType = enforcedType || configuredAuthType || getAuthTypeFromEnv();
     if (!effectiveAuthType) {
       const message = `Please set an Auth method in your ${USER_SETTINGS_PATH} or specify one of the following environment variables before running: QWEN_OAUTH, OPENAI_API_KEY`;
       throw new Error(message);
@@ -406706,7 +407111,7 @@ var SubAgentTracker = class {
 
 // packages/cli/src/acp-integration/session/Session.ts
 var ALLOWED_BUILTIN_COMMANDS_FOR_ACP = ["init"];
-var Session2 = class {
+var Session3 = class {
   constructor(id, chat, config2, client, settings) {
     this.chat = chat;
     this.config = config2;
@@ -407447,7 +407852,7 @@ var GeminiAgent = class {
       name: APPROVAL_MODE_INFO[mode].name,
       description: APPROVAL_MODE_INFO[mode].description
     }));
-    const version3 = "0.1.3-alpha.2";
+    const version3 = "0.1.3-alpha.3";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -407615,7 +408020,7 @@ var GeminiAgent = class {
     const geminiClient = config2.getGeminiClient();
     const history = conversation ? buildApiHistoryFromConversation(conversation) : void 0;
     const chat = history ? await geminiClient.startChat(history) : await geminiClient.startChat();
-    const session = new Session2(
+    const session = new Session3(
       sessionId,
       chat,
       config2,
@@ -407883,7 +408288,11 @@ ${finalArgs[promptIndex + 1]}`;
       kittyProtocolDetectionComplete = detectAndEnableKittyProtocol();
     }
     setMaxSizedBoxDebugging(isDebugMode2);
-    const initializationResult = await initializeApp(config2, settings);
+    const inputFormat = typeof config2.getInputFormat === "function" ? config2.getInputFormat() : "text" /* TEXT */;
+    let initializationResult;
+    if (inputFormat !== "stream-json" /* STREAM_JSON */) {
+      initializationResult = await initializeApp(config2, settings);
+    }
     if (settings.merged.security?.auth?.selectedType === "oauth-personal" /* LOGIN_WITH_GOOGLE */ && config2.isBrowserLaunchSuppressed()) {
       await getOauthClient(settings.merged.security.auth.selectedType, config2);
     }
@@ -407937,8 +408346,9 @@ ${finalArgs[promptIndex + 1]}`;
       );
       return;
     }
-    await config2.initialize();
-    const inputFormat = typeof config2.getInputFormat === "function" ? config2.getInputFormat() : "text" /* TEXT */;
+    if (inputFormat !== "stream-json" /* STREAM_JSON */) {
+      await config2.initialize();
+    }
     if (inputFormat !== "stream-json" /* STREAM_JSON */ && !process.stdin.isTTY) {
       const stdinData = await readStdin();
       if (stdinData) {
@@ -407948,7 +408358,7 @@ ${input}`;
       }
     }
     const nonInteractiveConfig = await validateNonInteractiveAuth(
-      settings.merged.security?.auth?.selectedType,
+      settings.merged.security?.auth?.selectedType || argv.authType,
       settings.merged.security?.auth?.useExternal,
       config2,
       settings