@qwen-code/qwen-code 0.6.0-preview.1 → 0.6.0

package/cli.js

@@ -154418,7 +154418,7 @@ __export(geminiContentGenerator_exports, {
   createGeminiContentGenerator: () => createGeminiContentGenerator
 });
 function createGeminiContentGenerator(config2, gcConfig) {
-  const version2 = "0.6.0-preview.1";
+  const version2 = "0.6.0";
   const userAgent2 = config2.userAgent || `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -287291,6 +287291,7 @@ var init_en3 = __esm({
       "(Use Enter to select{{tabText}})": "(Use Enter to select{{tabText}})",
       ", Tab to change focus": ", Tab to change focus",
       "To see changes, Qwen Code must be restarted. Press r to exit and apply changes now.": "To see changes, Qwen Code must be restarted. Press r to exit and apply changes now.",
+      'The command "/{{command}}" is not supported in non-interactive mode.': 'The command "/{{command}}" is not supported in non-interactive mode.',
       // ============================================================================
       // Settings Labels
       // ============================================================================
@@ -287523,6 +287524,10 @@ var init_en3 = __esm({
       "Already generating summary, wait for previous request to complete": "Already generating summary, wait for previous request to complete",
       "No conversation found to summarize.": "No conversation found to summarize.",
       "Failed to generate project context summary: {{error}}": "Failed to generate project context summary: {{error}}",
+      "Saved project summary to {{filePathForDisplay}}.": "Saved project summary to {{filePathForDisplay}}.",
+      "Saving project summary...": "Saving project summary...",
+      "Generating project summary...": "Generating project summary...",
+      "Failed to generate summary - no text content received from LLM response": "Failed to generate summary - no text content received from LLM response",
       // ============================================================================
       // Commands - Model
       // ============================================================================
@@ -288118,6 +288123,7 @@ var init_ru = __esm({
       "(Use Enter to select{{tabText}})": "(Enter \u0434\u043B\u044F \u0432\u044B\u0431\u043E\u0440\u0430{{tabText}})",
       ", Tab to change focus": ", Tab \u0434\u043B\u044F \u0441\u043C\u0435\u043D\u044B \u0444\u043E\u043A\u0443\u0441\u0430",
       "To see changes, Qwen Code must be restarted. Press r to exit and apply changes now.": "\u0414\u043B\u044F \u043F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u0438\u044F \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439 \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C Qwen Code. \u041D\u0430\u0436\u043C\u0438\u0442\u0435 r \u0434\u043B\u044F \u0432\u044B\u0445\u043E\u0434\u0430 \u0438 \u043F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u0438\u044F \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u0439.",
+      'The command "/{{command}}" is not supported in non-interactive mode.': '\u041A\u043E\u043C\u0430\u043D\u0434\u0430 "/{{command}}" \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F \u0432 \u043D\u0435\u0438\u043D\u0442\u0435\u0440\u0430\u043A\u0442\u0438\u0432\u043D\u043E\u043C \u0440\u0435\u0436\u0438\u043C\u0435.',
       // ============================================================================
       // Метки настроек
       // ============================================================================
@@ -288350,6 +288356,10 @@ var init_ru = __esm({
       "Already generating summary, wait for previous request to complete": "\u0413\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u044F \u0441\u0432\u043E\u0434\u043A\u0438 \u0443\u0436\u0435 \u0432\u044B\u043F\u043E\u043B\u043D\u044F\u0435\u0442\u0441\u044F, \u0434\u043E\u0436\u0434\u0438\u0442\u0435\u0441\u044C \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u0438\u044F \u043F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0435\u0433\u043E \u0437\u0430\u043F\u0440\u043E\u0441\u0430",
       "No conversation found to summarize.": "\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u0434\u0438\u0430\u043B\u043E\u0433\u043E\u0432 \u0434\u043B\u044F \u0441\u043E\u0437\u0434\u0430\u043D\u0438\u044F \u0441\u0432\u043E\u0434\u043A\u0438.",
       "Failed to generate project context summary: {{error}}": "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0441\u0432\u043E\u0434\u043A\u0443 \u043A\u043E\u043D\u0442\u0435\u043A\u0441\u0442\u0430 \u043F\u0440\u043E\u0435\u043A\u0442\u0430: {{error}}",
+      "Saved project summary to {{filePathForDisplay}}.": "\u0421\u0432\u043E\u0434\u043A\u0430 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u0441\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u0430 \u0432 {{filePathForDisplay}}",
+      "Saving project summary...": "\u0421\u043E\u0445\u0440\u0430\u043D\u0435\u043D\u0438\u0435 \u0441\u0432\u043E\u0434\u043A\u0438 \u043F\u0440\u043E\u0435\u043A\u0442\u0430...",
+      "Generating project summary...": "\u0413\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u044F \u0441\u0432\u043E\u0434\u043A\u0438 \u043F\u0440\u043E\u0435\u043A\u0442\u0430...",
+      "Failed to generate summary - no text content received from LLM response": "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0441\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0441\u0432\u043E\u0434\u043A\u0443 - \u043D\u0435 \u043F\u043E\u043B\u0443\u0447\u0435\u043D \u0442\u0435\u043A\u0441\u0442\u043E\u0432\u044B\u0439 \u043A\u043E\u043D\u0442\u0435\u043D\u0442 \u0438\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 LLM",
       // ============================================================================
       // Команды - Модель
       // ============================================================================
@@ -288944,6 +288954,7 @@ var init_zh = __esm({
       "(Use Enter to select{{tabText}})": "\uFF08\u4F7F\u7528 Enter \u9009\u62E9{{tabText}}\uFF09",
       ", Tab to change focus": "\uFF0CTab \u5207\u6362\u7126\u70B9",
       "To see changes, Qwen Code must be restarted. Press r to exit and apply changes now.": "\u8981\u67E5\u770B\u66F4\u6539\uFF0C\u5FC5\u987B\u91CD\u542F Qwen Code\u3002\u6309 r \u9000\u51FA\u5E76\u7ACB\u5373\u5E94\u7528\u66F4\u6539\u3002",
+      'The command "/{{command}}" is not supported in non-interactive mode.': '\u4E0D\u652F\u6301\u5728\u975E\u4EA4\u4E92\u6A21\u5F0F\u4E0B\u4F7F\u7528\u547D\u4EE4 "/{{command}}"\u3002',
       // ============================================================================
       // Settings Labels
       // ============================================================================
@@ -289176,6 +289187,10 @@ var init_zh = __esm({
       "Already generating summary, wait for previous request to complete": "\u6B63\u5728\u751F\u6210\u6458\u8981\uFF0C\u8BF7\u7B49\u5F85\u4E0A\u4E00\u4E2A\u8BF7\u6C42\u5B8C\u6210",
       "No conversation found to summarize.": "\u672A\u627E\u5230\u8981\u603B\u7ED3\u7684\u5BF9\u8BDD",
       "Failed to generate project context summary: {{error}}": "\u751F\u6210\u9879\u76EE\u4E0A\u4E0B\u6587\u6458\u8981\u5931\u8D25\uFF1A{{error}}",
+      "Saved project summary to {{filePathForDisplay}}.": "\u9879\u76EE\u6458\u8981\u5DF2\u4FDD\u5B58\u5230 {{filePathForDisplay}}",
+      "Saving project summary...": "\u6B63\u5728\u4FDD\u5B58\u9879\u76EE\u6458\u8981...",
+      "Generating project summary...": "\u6B63\u5728\u751F\u6210\u9879\u76EE\u6458\u8981...",
+      "Failed to generate summary - no text content received from LLM response": "\u751F\u6210\u6458\u8981\u5931\u8D25 - \u672A\u4ECE LLM \u54CD\u5E94\u4E2D\u63A5\u6536\u5230\u6587\u672C\u5185\u5BB9",
       // ============================================================================
       // Commands - Model
       // ============================================================================
@@ -355471,7 +355486,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.6.0-preview.1";
+  return "0.6.0";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -362878,6 +362893,110 @@ import { randomUUID as randomUUID6 } from "node:crypto";
 // packages/cli/src/utils/nonInteractiveHelpers.ts
 init_esbuild_shims();
 
+// packages/cli/src/ui/utils/computeStats.ts
+init_esbuild_shims();
+function calculateErrorRate(metrics2) {
+  if (metrics2.api.totalRequests === 0) {
+    return 0;
+  }
+  return metrics2.api.totalErrors / metrics2.api.totalRequests * 100;
+}
+__name(calculateErrorRate, "calculateErrorRate");
+function calculateAverageLatency(metrics2) {
+  if (metrics2.api.totalRequests === 0) {
+    return 0;
+  }
+  return metrics2.api.totalLatencyMs / metrics2.api.totalRequests;
+}
+__name(calculateAverageLatency, "calculateAverageLatency");
+function calculateCacheHitRate(metrics2) {
+  if (metrics2.tokens.prompt === 0) {
+    return 0;
+  }
+  return metrics2.tokens.cached / metrics2.tokens.prompt * 100;
+}
+__name(calculateCacheHitRate, "calculateCacheHitRate");
+var computeSessionStats = /* @__PURE__ */ __name((metrics2) => {
+  const { models, tools, files } = metrics2;
+  const totalApiTime = Object.values(models).reduce(
+    (acc, model) => acc + model.api.totalLatencyMs,
+    0
+  );
+  const totalToolTime = tools.totalDurationMs;
+  const agentActiveTime = totalApiTime + totalToolTime;
+  const apiTimePercent = agentActiveTime > 0 ? totalApiTime / agentActiveTime * 100 : 0;
+  const toolTimePercent = agentActiveTime > 0 ? totalToolTime / agentActiveTime * 100 : 0;
+  const totalCachedTokens = Object.values(models).reduce(
+    (acc, model) => acc + model.tokens.cached,
+    0
+  );
+  const totalPromptTokens = Object.values(models).reduce(
+    (acc, model) => acc + model.tokens.prompt,
+    0
+  );
+  const cacheEfficiency = totalPromptTokens > 0 ? totalCachedTokens / totalPromptTokens * 100 : 0;
+  const totalDecisions = tools.totalDecisions.accept + tools.totalDecisions.reject + tools.totalDecisions.modify;
+  const successRate = tools.totalCalls > 0 ? tools.totalSuccess / tools.totalCalls * 100 : 0;
+  const agreementRate = totalDecisions > 0 ? tools.totalDecisions.accept / totalDecisions * 100 : 0;
+  return {
+    totalApiTime,
+    totalToolTime,
+    agentActiveTime,
+    apiTimePercent,
+    toolTimePercent,
+    cacheEfficiency,
+    totalDecisions,
+    successRate,
+    agreementRate,
+    totalCachedTokens,
+    totalPromptTokens,
+    totalLinesAdded: files.totalLinesAdded,
+    totalLinesRemoved: files.totalLinesRemoved
+  };
+}, "computeSessionStats");
+
+// packages/cli/src/nonInteractiveCliCommands.ts
+init_esbuild_shims();
+
+// packages/cli/src/utils/commands.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/commands/types.ts
+init_esbuild_shims();
+
+// packages/cli/src/utils/commands.ts
+var parseSlashCommand = /* @__PURE__ */ __name((query, commands) => {
+  const trimmed2 = query.trim();
+  const parts = trimmed2.substring(1).trim().split(/\s+/);
+  const commandPath = parts.filter((p2) => p2);
+  let currentCommands = commands;
+  let commandToExecute;
+  let pathIndex = 0;
+  const canonicalPath = [];
+  for (const part of commandPath) {
+    let foundCommand = currentCommands.find((cmd) => cmd.name === part);
+    if (!foundCommand) {
+      foundCommand = currentCommands.find(
+        (cmd) => cmd.altNames?.includes(part)
+      );
+    }
+    if (foundCommand) {
+      commandToExecute = foundCommand;
+      canonicalPath.push(foundCommand.name);
+      pathIndex++;
+      if (foundCommand.subCommands) {
+        currentCommands = foundCommand.subCommands;
+      } else {
+        break;
+      }
+    } else {
+      break;
+    }
+  }
+  const args = parts.slice(pathIndex).join(" ");
+  return { commandToExecute, args, canonicalPath };
+}, "parseSlashCommand");
+
 // packages/cli/src/services/CommandService.ts
 init_esbuild_shims();
 var CommandService = class _CommandService {
@@ -362961,9 +363080,6 @@ init_esbuild_shims();
 // packages/cli/src/ui/commands/aboutCommand.ts
 init_esbuild_shims();
 
-// packages/cli/src/ui/commands/types.ts
-init_esbuild_shims();
-
 // packages/cli/src/ui/types.ts
 init_esbuild_shims();
 var import_react26 = __toESM(require_react(), 1);
@@ -363046,7 +363162,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "89ad11df";
+var GIT_COMMIT_INFO2 = "17eb20c1";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -363381,7 +363497,8 @@ var compressCommand = {
   kind: "built-in" /* BUILT_IN */,
   action: /* @__PURE__ */ __name(async (context2) => {
     const { ui: ui2 } = context2;
-    if (ui2.pendingItem) {
+    const executionMode = context2.executionMode ?? "interactive";
+    if (executionMode === "interactive" && ui2.pendingItem) {
       ui2.addItem(
         {
           type: "error" /* ERROR */,
@@ -363400,11 +363517,72 @@ var compressCommand = {
         compressionStatus: null
       }
     };
-    try {
-      ui2.setPendingItem(pendingMessage);
+    const config2 = context2.services.config;
+    const geminiClient = config2?.getGeminiClient();
+    if (!config2 || !geminiClient) {
+      return {
+        type: "message",
+        messageType: "error",
+        content: t4("Config not loaded.")
+      };
+    }
+    const doCompress = /* @__PURE__ */ __name(async () => {
       const promptId = `compress-${Date.now()}`;
-      const compressed = await context2.services.config?.getGeminiClient()?.tryCompressChat(promptId, true);
-      if (compressed) {
+      return await geminiClient.tryCompressChat(promptId, true);
+    }, "doCompress");
+    if (executionMode === "acp") {
+      const messages = /* @__PURE__ */ __name(async function* () {
+        try {
+          yield {
+            messageType: "info",
+            content: "Compressing context..."
+          };
+          const compressed = await doCompress();
+          if (!compressed) {
+            yield {
+              messageType: "error",
+              content: t4("Failed to compress chat history.")
+            };
+            return;
+          }
+          yield {
+            messageType: "info",
+            content: `Context compressed (${compressed.originalTokenCount} -> ${compressed.newTokenCount}).`
+          };
+        } catch (e4) {
+          yield {
+            messageType: "error",
+            content: t4("Failed to compress chat history: {{error}}", {
+              error: e4 instanceof Error ? e4.message : String(e4)
+            })
+          };
+        }
+      }, "messages");
+      return { type: "stream_messages", messages: messages() };
+    }
+    try {
+      if (executionMode === "interactive") {
+        ui2.setPendingItem(pendingMessage);
+      }
+      const compressed = await doCompress();
+      if (!compressed) {
+        if (executionMode === "interactive") {
+          ui2.addItem(
+            {
+              type: "error" /* ERROR */,
+              text: t4("Failed to compress chat history.")
+            },
+            Date.now()
+          );
+          return;
+        }
+        return {
+          type: "message",
+          messageType: "error",
+          content: t4("Failed to compress chat history.")
+        };
+      }
+      if (executionMode === "interactive") {
         ui2.addItem(
           {
             type: "compression" /* COMPRESSION */,
@@ -363417,27 +363595,37 @@ var compressCommand = {
           },
           Date.now()
         );
-      } else {
+        return;
+      }
+      return {
+        type: "message",
+        messageType: "info",
+        content: `Context compressed (${compressed.originalTokenCount} -> ${compressed.newTokenCount}).`
+      };
+    } catch (e4) {
+      if (executionMode === "interactive") {
         ui2.addItem(
           {
             type: "error" /* ERROR */,
-            text: t4("Failed to compress chat history.")
+            text: t4("Failed to compress chat history: {{error}}", {
+              error: e4 instanceof Error ? e4.message : String(e4)
+            })
           },
           Date.now()
         );
+        return;
       }
-    } catch (e4) {
-      ui2.addItem(
-        {
-          type: "error" /* ERROR */,
-          text: t4("Failed to compress chat history: {{error}}", {
-            error: e4 instanceof Error ? e4.message : String(e4)
-          })
-        },
-        Date.now()
-      );
+      return {
+        type: "message",
+        messageType: "error",
+        content: t4("Failed to compress chat history: {{error}}", {
+          error: e4 instanceof Error ? e4.message : String(e4)
+        })
+      };
     } finally {
-      ui2.setPendingItem(null);
+      if (executionMode === "interactive") {
+        ui2.setPendingItem(null);
+      }
     }
   }, "action")
 };
@@ -365618,6 +365806,7 @@ var summaryCommand = {
   action: /* @__PURE__ */ __name(async (context2) => {
     const { config: config2 } = context2.services;
     const { ui: ui2 } = context2;
+    const executionMode = context2.executionMode ?? "interactive";
     if (!config2) {
       return {
         type: "message",
@@ -365633,7 +365822,7 @@ var summaryCommand = {
         content: t4("No chat client available to generate summary.")
       };
     }
-    if (ui2.pendingItem) {
+    if (executionMode === "interactive" && ui2.pendingItem) {
       ui2.addItem(
         {
           type: "error",
@@ -365651,25 +365840,17 @@ var summaryCommand = {
         )
       };
     }
-    try {
+    const getChatHistory = /* @__PURE__ */ __name(() => {
       const chat = geminiClient.getChat();
-      const history = chat.getHistory();
-      if (history.length <= 2) {
-        return {
-          type: "message",
-          messageType: "info",
-          content: t4("No conversation found to summarize.")
-        };
-      }
-      const pendingMessage = {
-        type: "summary",
-        summary: {
-          isPending: true,
-          stage: "generating"
-        }
-      };
-      ui2.setPendingItem(pendingMessage);
-      const conversationContext = history.map((message) => ({
+      return chat.getHistory();
+    }, "getChatHistory");
+    const validateChatHistory = /* @__PURE__ */ __name((history2) => {
+      if (history2.length <= 2) {
+        throw new Error(t4("No conversation found to summarize."));
+      }
+    }, "validateChatHistory");
+    const generateSummaryMarkdown = /* @__PURE__ */ __name(async (history2) => {
+      const conversationContext = history2.map((message) => ({
         role: message.role,
         parts: message.parts
       }));
@@ -365693,16 +365874,14 @@ var summaryCommand = {
       const markdownSummary = parts?.map((part) => part.text).filter((text) => typeof text === "string").join("") || "";
       if (!markdownSummary) {
         throw new Error(
-          "Failed to generate summary - no text content received from LLM response"
+          t4(
+            "Failed to generate summary - no text content received from LLM response"
+          )
         );
       }
-      ui2.setPendingItem({
-        type: "summary",
-        summary: {
-          isPending: true,
-          stage: "saving"
-        }
-      });
+      return markdownSummary;
+    }, "generateSummaryMarkdown");
+    const saveSummaryToDisk = /* @__PURE__ */ __name(async (markdownSummary) => {
       const projectRoot = config2.getProjectRoot();
       const qwenDir = path87.join(projectRoot, ".qwen");
       try {
@@ -365718,42 +365897,137 @@ var summaryCommand = {
 **Update time**: ${(/* @__PURE__ */ new Date()).toISOString()} 
 `;
       await fsPromises5.writeFile(summaryPath, summaryContent, "utf8");
+      return {
+        filePathForDisplay: ".qwen/PROJECT_SUMMARY.md",
+        fullPath: summaryPath
+      };
+    }, "saveSummaryToDisk");
+    const emitInteractivePending = /* @__PURE__ */ __name((stage) => {
+      if (executionMode !== "interactive") {
+        return;
+      }
+      const pendingMessage = {
+        type: "summary",
+        summary: {
+          isPending: true,
+          stage
+        }
+      };
+      ui2.setPendingItem(pendingMessage);
+    }, "emitInteractivePending");
+    const completeInteractive = /* @__PURE__ */ __name((filePathForDisplay) => {
+      if (executionMode !== "interactive") {
+        return;
+      }
       ui2.setPendingItem(null);
       const completedSummaryItem = {
         type: "summary",
         summary: {
           isPending: false,
           stage: "completed",
-          filePath: ".qwen/PROJECT_SUMMARY.md"
+          filePath: filePathForDisplay
         }
       };
       ui2.addItem(completedSummaryItem, Date.now());
-      return {
-        type: "message",
-        messageType: "info",
-        content: ""
-        // Empty content since we show the message in UI component
-      };
-    } catch (error2) {
+    }, "completeInteractive");
+    const formatErrorMessage = /* @__PURE__ */ __name((error2) => t4("Failed to generate project context summary: {{error}}", {
+      error: error2 instanceof Error ? error2.message : String(error2)
+    }), "formatErrorMessage");
+    const failInteractive = /* @__PURE__ */ __name((error2) => {
+      if (executionMode !== "interactive") {
+        return;
+      }
       ui2.setPendingItem(null);
       ui2.addItem(
         {
           type: "error",
-          text: `\u274C ${t4(
-            "Failed to generate project context summary: {{error}}",
-            {
-              error: error2 instanceof Error ? error2.message : String(error2)
-            }
-          )}`
+          text: `\u274C ${formatErrorMessage(error2)}`
         },
         Date.now()
       );
+    }, "failInteractive");
+    const formatSuccessMessage = /* @__PURE__ */ __name((filePathForDisplay) => t4("Saved project summary to {{filePathForDisplay}}.", {
+      filePathForDisplay
+    }), "formatSuccessMessage");
+    const returnNoConversationMessage = /* @__PURE__ */ __name(() => {
+      const msg = t4("No conversation found to summarize.");
+      if (executionMode === "acp") {
+        const messages = /* @__PURE__ */ __name(async function* () {
+          yield {
+            messageType: "info",
+            content: msg
+          };
+        }, "messages");
+        return {
+          type: "stream_messages",
+          messages: messages()
+        };
+      }
+      return {
+        type: "message",
+        messageType: "info",
+        content: msg
+      };
+    }, "returnNoConversationMessage");
+    const executeSummaryGeneration = /* @__PURE__ */ __name(async (history2) => {
+      emitInteractivePending("generating");
+      const markdownSummary = await generateSummaryMarkdown(history2);
+      emitInteractivePending("saving");
+      const { filePathForDisplay } = await saveSummaryToDisk(markdownSummary);
+      completeInteractive(filePathForDisplay);
+      return { markdownSummary, filePathForDisplay };
+    }, "executeSummaryGeneration");
+    const history = getChatHistory();
+    try {
+      validateChatHistory(history);
+    } catch (_error) {
+      return returnNoConversationMessage();
+    }
+    if (executionMode === "acp") {
+      const messages = /* @__PURE__ */ __name(async function* () {
+        try {
+          yield {
+            messageType: "info",
+            content: t4("Generating project summary...")
+          };
+          const { filePathForDisplay } = await executeSummaryGeneration(history);
+          yield {
+            messageType: "info",
+            content: formatSuccessMessage(filePathForDisplay)
+          };
+        } catch (error2) {
+          failInteractive(error2);
+          yield {
+            messageType: "error",
+            content: formatErrorMessage(error2)
+          };
+        }
+      }, "messages");
+      return {
+        type: "stream_messages",
+        messages: messages()
+      };
+    }
+    try {
+      const { filePathForDisplay } = await executeSummaryGeneration(history);
+      if (executionMode === "non_interactive") {
+        return {
+          type: "message",
+          messageType: "info",
+          content: formatSuccessMessage(filePathForDisplay)
+        };
+      }
+      return {
+        type: "message",
+        messageType: "info",
+        content: ""
+      };
+    } catch (error2) {
+      failInteractive(error2);
       return {
         type: "message",
         messageType: "error",
-        content: t4("Failed to generate project context summary: {{error}}", {
-          error: error2 instanceof Error ? error2.message : String(error2)
-        })
+        content: formatErrorMessage(error2)
       };
     }
   }, "action")
@@ -366517,67 +366791,720 @@ var BuiltinCommandLoader = class {
   }
 };
 
-// packages/cli/src/ui/utils/computeStats.ts
+// packages/cli/src/services/FileCommandLoader.ts
 init_esbuild_shims();
-function calculateErrorRate(metrics2) {
-  if (metrics2.api.totalRequests === 0) {
-    return 0;
+var import_toml = __toESM(require_toml(), 1);
+init_esm11();
+init_zod();
+import { promises as fs81 } from "node:fs";
+import path90 from "node:path";
+
+// packages/cli/src/services/prompt-processors/argumentProcessor.ts
+init_esbuild_shims();
+var DefaultArgumentProcessor = class {
+  static {
+    __name(this, "DefaultArgumentProcessor");
   }
-  return metrics2.api.totalErrors / metrics2.api.totalRequests * 100;
+  async process(prompt, context2) {
+    if (context2.invocation?.args) {
+      return appendToLastTextPart(prompt, context2.invocation.raw);
+    }
+    return prompt;
+  }
+};
+
+// packages/cli/src/services/prompt-processors/types.ts
+init_esbuild_shims();
+var SHORTHAND_ARGS_PLACEHOLDER = "{{args}}";
+var SHELL_INJECTION_TRIGGER = "!{";
+var AT_FILE_INJECTION_TRIGGER = "@{";
+
+// packages/cli/src/services/prompt-processors/shellProcessor.ts
+init_esbuild_shims();
+
+// packages/cli/src/services/prompt-processors/injectionParser.ts
+init_esbuild_shims();
+function extractInjections(prompt, trigger, contextName) {
+  const injections = [];
+  let index = 0;
+  while (index < prompt.length) {
+    const startIndex = prompt.indexOf(trigger, index);
+    if (startIndex === -1) {
+      break;
+    }
+    let currentIndex = startIndex + trigger.length;
+    let braceCount = 1;
+    let foundEnd = false;
+    while (currentIndex < prompt.length) {
+      const char = prompt[currentIndex];
+      if (char === "{") {
+        braceCount++;
+      } else if (char === "}") {
+        braceCount--;
+        if (braceCount === 0) {
+          const injectionContent = prompt.substring(
+            startIndex + trigger.length,
+            currentIndex
+          );
+          const endIndex = currentIndex + 1;
+          injections.push({
+            content: injectionContent.trim(),
+            startIndex,
+            endIndex
+          });
+          index = endIndex;
+          foundEnd = true;
+          break;
+        }
+      }
+      currentIndex++;
+    }
+    if (!foundEnd) {
+      const contextInfo = contextName ? ` in command '${contextName}'` : "";
+      throw new Error(
+        `Invalid syntax${contextInfo}: Unclosed injection starting at index ${startIndex} ('${trigger}'). Ensure braces are balanced. Paths or commands with unbalanced braces are not supported directly.`
+      );
+    }
+  }
+  return injections;
 }
-__name(calculateErrorRate, "calculateErrorRate");
-function calculateAverageLatency(metrics2) {
-  if (metrics2.api.totalRequests === 0) {
-    return 0;
+__name(extractInjections, "extractInjections");
+
+// packages/cli/src/services/prompt-processors/shellProcessor.ts
+var ConfirmationRequiredError = class extends Error {
+  constructor(message, commandsToConfirm) {
+    super(message);
+    this.commandsToConfirm = commandsToConfirm;
+    this.name = "ConfirmationRequiredError";
   }
-  return metrics2.api.totalLatencyMs / metrics2.api.totalRequests;
+  static {
+    __name(this, "ConfirmationRequiredError");
+  }
+};
+var ShellProcessor = class {
+  constructor(commandName) {
+    this.commandName = commandName;
+  }
+  static {
+    __name(this, "ShellProcessor");
+  }
+  async process(prompt, context2) {
+    return flatMapTextParts(
+      prompt,
+      (text) => this.processString(text, context2)
+    );
+  }
+  async processString(prompt, context2) {
+    const userArgsRaw = context2.invocation?.args || "";
+    if (!prompt.includes(SHELL_INJECTION_TRIGGER)) {
+      return [
+        { text: prompt.replaceAll(SHORTHAND_ARGS_PLACEHOLDER, userArgsRaw) }
+      ];
+    }
+    const config2 = context2.services.config;
+    if (!config2) {
+      throw new Error(
+        `Security configuration not loaded. Cannot verify shell command permissions for '${this.commandName}'. Aborting.`
+      );
+    }
+    const { sessionShellAllowlist } = context2.session;
+    const injections = extractInjections(
+      prompt,
+      SHELL_INJECTION_TRIGGER,
+      this.commandName
+    );
+    if (injections.length === 0) {
+      return [
+        { text: prompt.replaceAll(SHORTHAND_ARGS_PLACEHOLDER, userArgsRaw) }
+      ];
+    }
+    const { shell: shell2 } = getShellConfiguration();
+    const userArgsEscaped = escapeShellArg(userArgsRaw, shell2);
+    const resolvedInjections = injections.map(
+      (injection) => {
+        const command2 = injection.content;
+        if (command2 === "") {
+          return { ...injection, resolvedCommand: void 0 };
+        }
+        const resolvedCommand = command2.replaceAll(
+          SHORTHAND_ARGS_PLACEHOLDER,
+          userArgsEscaped
+        );
+        return { ...injection, resolvedCommand };
+      }
+    );
+    const commandsToConfirm = /* @__PURE__ */ new Set();
+    for (const injection of resolvedInjections) {
+      const command2 = injection.resolvedCommand;
+      if (!command2) continue;
+      const { allAllowed, disallowedCommands, blockReason, isHardDenial } = checkCommandPermissions(command2, config2, sessionShellAllowlist);
+      if (!allAllowed) {
+        if (isHardDenial) {
+          throw new Error(
+            `${this.commandName} cannot be run. Blocked command: "${command2}". Reason: ${blockReason || "Blocked by configuration."}`
+          );
+        }
+        if (config2.getApprovalMode() !== ApprovalMode.YOLO) {
+          disallowedCommands.forEach((uc) => commandsToConfirm.add(uc));
+        }
+      }
+    }
+    if (commandsToConfirm.size > 0) {
+      throw new ConfirmationRequiredError(
+        "Shell command confirmation required",
+        Array.from(commandsToConfirm)
+      );
+    }
+    let processedPrompt = "";
+    let lastIndex = 0;
+    for (const injection of resolvedInjections) {
+      const segment = prompt.substring(lastIndex, injection.startIndex);
+      processedPrompt += segment.replaceAll(
+        SHORTHAND_ARGS_PLACEHOLDER,
+        userArgsRaw
+      );
+      if (injection.resolvedCommand) {
+        const activeTheme = themeManager.getActiveTheme();
+        const shellExecutionConfig = {
+          ...config2.getShellExecutionConfig(),
+          defaultFg: activeTheme.colors.Foreground,
+          defaultBg: activeTheme.colors.Background
+        };
+        const { result } = await ShellExecutionService.execute(
+          injection.resolvedCommand,
+          config2.getTargetDir(),
+          () => {
+          },
+          new AbortController().signal,
+          config2.getShouldUseNodePtyShell(),
+          shellExecutionConfig
+        );
+        const executionResult = await result;
+        if (executionResult.error && !executionResult.aborted) {
+          throw new Error(
+            `Failed to start shell command in '${this.commandName}': ${executionResult.error.message}. Command: ${injection.resolvedCommand}`
+          );
+        }
+        processedPrompt += executionResult.output;
+        if (executionResult.aborted) {
+          processedPrompt += `
+[Shell command '${injection.resolvedCommand}' aborted]`;
+        } else if (executionResult.exitCode !== 0 && executionResult.exitCode !== null) {
+          processedPrompt += `
+[Shell command '${injection.resolvedCommand}' exited with code ${executionResult.exitCode}]`;
+        } else if (executionResult.signal !== null) {
+          processedPrompt += `
+[Shell command '${injection.resolvedCommand}' terminated by signal ${executionResult.signal}]`;
+        }
+      }
+      lastIndex = injection.endIndex;
+    }
+    const finalSegment = prompt.substring(lastIndex);
+    processedPrompt += finalSegment.replaceAll(
+      SHORTHAND_ARGS_PLACEHOLDER,
+      userArgsRaw
+    );
+    return [{ text: processedPrompt }];
+  }
+};
+
+// packages/cli/src/services/prompt-processors/atFileProcessor.ts
+init_esbuild_shims();
+var AtFileProcessor = class {
+  constructor(commandName) {
+    this.commandName = commandName;
+  }
+  static {
+    __name(this, "AtFileProcessor");
+  }
+  async process(input, context2) {
+    const config2 = context2.services.config;
+    if (!config2) {
+      return input;
+    }
+    return flatMapTextParts(input, async (text) => {
+      if (!text.includes(AT_FILE_INJECTION_TRIGGER)) {
+        return [{ text }];
+      }
+      const injections = extractInjections(
+        text,
+        AT_FILE_INJECTION_TRIGGER,
+        this.commandName
+      );
+      if (injections.length === 0) {
+        return [{ text }];
+      }
+      const output = [];
+      let lastIndex = 0;
+      for (const injection of injections) {
+        const prefix = text.substring(lastIndex, injection.startIndex);
+        if (prefix) {
+          output.push({ text: prefix });
+        }
+        const pathStr = injection.content;
+        try {
+          const fileContentParts = await readPathFromWorkspace(pathStr, config2);
+          if (fileContentParts.length === 0) {
+            const uiMessage = `File '@{${pathStr}}' was ignored by .gitignore or .qwenignore and was not included in the prompt.`;
+            context2.ui.addItem(
+              { type: "info" /* INFO */, text: uiMessage },
+              Date.now()
+            );
+          }
+          output.push(...fileContentParts);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          const uiMessage = `Failed to inject content for '@{${pathStr}}': ${message}`;
+          console.error(
+            `[AtFileProcessor] ${uiMessage}. Leaving placeholder in prompt.`
+          );
+          context2.ui.addItem(
+            { type: "error" /* ERROR */, text: uiMessage },
+            Date.now()
+          );
+          const placeholder = text.substring(
+            injection.startIndex,
+            injection.endIndex
+          );
+          output.push({ text: placeholder });
+        }
+        lastIndex = injection.endIndex;
+      }
+      const suffix = text.substring(lastIndex);
+      if (suffix) {
+        output.push({ text: suffix });
+      }
+      return output;
+    });
+  }
+};
+
+// packages/cli/src/services/FileCommandLoader.ts
+var TomlCommandDefSchema = external_exports.object({
+  prompt: external_exports.string({
+    required_error: "The 'prompt' field is required.",
+    invalid_type_error: "The 'prompt' field must be a string."
+  }),
+  description: external_exports.string().optional()
+});
+var FileCommandLoader = class {
+  constructor(config2) {
+    this.config = config2;
+    this.folderTrustEnabled = !!config2?.getFolderTrustFeature();
+    this.folderTrust = !!config2?.getFolderTrust();
+    this.projectRoot = config2?.getProjectRoot() || process.cwd();
+  }
+  static {
+    __name(this, "FileCommandLoader");
+  }
+  projectRoot;
+  folderTrustEnabled;
+  folderTrust;
+  /**
+   * Loads all commands from user, project, and extension directories.
+   * Returns commands in order: user → project → extensions (alphabetically).
+   *
+   * Order is important for conflict resolution in CommandService:
+   * - User/project commands (without extensionName) use "last wins" strategy
+   * - Extension commands (with extensionName) get renamed if conflicts exist
+   *
+   * @param signal An AbortSignal to cancel the loading process.
+   * @returns A promise that resolves to an array of all loaded SlashCommands.
+   */
+  async loadCommands(signal) {
+    const allCommands = [];
+    const globOptions = {
+      nodir: true,
+      dot: true,
+      signal,
+      follow: true
+    };
+    const commandDirs = this.getCommandDirectories();
+    for (const dirInfo of commandDirs) {
+      try {
+        const files = await glob("**/*.toml", {
+          ...globOptions,
+          cwd: dirInfo.path
+        });
+        if (this.folderTrustEnabled && !this.folderTrust) {
+          return [];
+        }
+        const commandPromises = files.map(
+          (file) => this.parseAndAdaptFile(
+            path90.join(dirInfo.path, file),
+            dirInfo.path,
+            dirInfo.extensionName
+          )
+        );
+        const commands = (await Promise.all(commandPromises)).filter(
+          (cmd) => cmd !== null
+        );
+        allCommands.push(...commands);
+      } catch (error2) {
+        const isEnoent = error2.code === "ENOENT";
+        const isAbortError2 = error2 instanceof Error && error2.name === "AbortError";
+        if (!isEnoent && !isAbortError2) {
+          console.error(
+            `[FileCommandLoader] Error loading commands from ${dirInfo.path}:`,
+            error2
+          );
+        }
+      }
+    }
+    return allCommands;
+  }
+  /**
+   * Get all command directories in order for loading.
+   * User commands → Project commands → Extension commands
+   * This order ensures extension commands can detect all conflicts.
+   */
+  getCommandDirectories() {
+    const dirs = [];
+    const storage = this.config?.storage ?? new Storage(this.projectRoot);
+    dirs.push({ path: Storage.getUserCommandsDir() });
+    dirs.push({ path: storage.getProjectCommandsDir() });
+    if (this.config) {
+      const activeExtensions = this.config.getExtensions().filter((ext2) => ext2.isActive).sort((a2, b2) => a2.name.localeCompare(b2.name));
+      const extensionCommandDirs = activeExtensions.map((ext2) => ({
+        path: path90.join(ext2.path, "commands"),
+        extensionName: ext2.name
+      }));
+      dirs.push(...extensionCommandDirs);
+    }
+    return dirs;
+  }
+  /**
+   * Parses a single .toml file and transforms it into a SlashCommand object.
+   * @param filePath The absolute path to the .toml file.
+   * @param baseDir The root command directory for name calculation.
+   * @param extensionName Optional extension name to prefix commands with.
+   * @returns A promise resolving to a SlashCommand, or null if the file is invalid.
+   */
+  async parseAndAdaptFile(filePath, baseDir, extensionName) {
+    let fileContent;
+    try {
+      fileContent = await fs81.readFile(filePath, "utf-8");
+    } catch (error2) {
+      console.error(
+        `[FileCommandLoader] Failed to read file ${filePath}:`,
+        error2 instanceof Error ? error2.message : String(error2)
+      );
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = import_toml.default.parse(fileContent);
+    } catch (error2) {
+      console.error(
+        `[FileCommandLoader] Failed to parse TOML file ${filePath}:`,
+        error2 instanceof Error ? error2.message : String(error2)
+      );
+      return null;
+    }
+    const validationResult = TomlCommandDefSchema.safeParse(parsed);
+    if (!validationResult.success) {
+      console.error(
+        `[FileCommandLoader] Skipping invalid command file: ${filePath}. Validation errors:`,
+        validationResult.error.flatten()
+      );
+      return null;
+    }
+    const validDef = validationResult.data;
+    const relativePathWithExt = path90.relative(baseDir, filePath);
+    const relativePath = relativePathWithExt.substring(
+      0,
+      relativePathWithExt.length - 5
+      // length of '.toml'
+    );
+    const baseCommandName = relativePath.split(path90.sep).map((segment) => segment.replaceAll(":", "_")).join(":");
+    const defaultDescription = `Custom command from ${path90.basename(filePath)}`;
+    let description = validDef.description || defaultDescription;
+    if (extensionName) {
+      description = `[${extensionName}] ${description}`;
+    }
+    const processors = [];
+    const usesArgs = validDef.prompt.includes(SHORTHAND_ARGS_PLACEHOLDER);
+    const usesShellInjection = validDef.prompt.includes(
+      SHELL_INJECTION_TRIGGER
+    );
+    const usesAtFileInjection = validDef.prompt.includes(
+      AT_FILE_INJECTION_TRIGGER
+    );
+    if (usesAtFileInjection) {
+      processors.push(new AtFileProcessor(baseCommandName));
+    }
+    if (usesShellInjection || usesArgs) {
+      processors.push(new ShellProcessor(baseCommandName));
+    }
+    if (!usesArgs) {
+      processors.push(new DefaultArgumentProcessor());
+    }
+    return {
+      name: baseCommandName,
+      description,
+      kind: "file" /* FILE */,
+      extensionName,
+      action: /* @__PURE__ */ __name(async (context2, _args) => {
+        if (!context2.invocation) {
+          console.error(
+            `[FileCommandLoader] Critical error: Command '${baseCommandName}' was executed without invocation context.`
+          );
+          return {
+            type: "submit_prompt",
+            content: [{ text: validDef.prompt }]
+            // Fallback to unprocessed prompt
+          };
+        }
+        try {
+          let processedContent = [
+            { text: validDef.prompt }
+          ];
+          for (const processor of processors) {
+            processedContent = await processor.process(
+              processedContent,
+              context2
+            );
+          }
+          return {
+            type: "submit_prompt",
+            content: processedContent
+          };
+        } catch (e4) {
+          if (e4 instanceof ConfirmationRequiredError) {
+            return {
+              type: "confirm_shell_commands",
+              commandsToConfirm: e4.commandsToConfirm,
+              originalInvocation: {
+                raw: context2.invocation.raw
+              }
+            };
+          }
+          throw e4;
+        }
+      }, "action")
+    };
+  }
+};
+
+// packages/cli/src/ui/noninteractive/nonInteractiveUi.ts
+init_esbuild_shims();
+function createNonInteractiveUI() {
+  return {
+    addItem: /* @__PURE__ */ __name((_item, _timestamp) => 0, "addItem"),
+    clear: /* @__PURE__ */ __name(() => {
+    }, "clear"),
+    setDebugMessage: /* @__PURE__ */ __name((_message) => {
+    }, "setDebugMessage"),
+    loadHistory: /* @__PURE__ */ __name((_newHistory) => {
+    }, "loadHistory"),
+    pendingItem: null,
+    setPendingItem: /* @__PURE__ */ __name((_item) => {
+    }, "setPendingItem"),
+    toggleVimEnabled: /* @__PURE__ */ __name(async () => false, "toggleVimEnabled"),
+    setGeminiMdFileCount: /* @__PURE__ */ __name((_count) => {
+    }, "setGeminiMdFileCount"),
+    reloadCommands: /* @__PURE__ */ __name(() => {
+    }, "reloadCommands"),
+    extensionsUpdateState: /* @__PURE__ */ new Map(),
+    dispatchExtensionStateUpdate: /* @__PURE__ */ __name((_action) => {
+    }, "dispatchExtensionStateUpdate"),
+    addConfirmUpdateExtensionRequest: /* @__PURE__ */ __name((_request) => {
+    }, "addConfirmUpdateExtensionRequest")
+  };
 }
-__name(calculateAverageLatency, "calculateAverageLatency");
-function calculateCacheHitRate(metrics2) {
-  if (metrics2.tokens.prompt === 0) {
-    return 0;
+__name(createNonInteractiveUI, "createNonInteractiveUI");
+
+// packages/cli/src/nonInteractiveCliCommands.ts
+var ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE = [
+  "init",
+  "summary",
+  "compress"
+];
+function handleCommandResult(result) {
+  switch (result.type) {
+    case "submit_prompt":
+      return {
+        type: "submit_prompt",
+        content: result.content
+      };
+    case "message":
+      return {
+        type: "message",
+        messageType: result.messageType,
+        content: result.content
+      };
+    case "stream_messages":
+      return {
+        type: "stream_messages",
+        messages: result.messages
+      };
+    /**
+     * Currently return types below are never generated due to the
+     * whitelist of allowed slash commands in ACP and non-interactive mode.
+     * We'll try to add more supported return types in the future.
+     */
+    case "tool":
+      return {
+        type: "unsupported",
+        reason: "Tool execution from slash commands is not supported in non-interactive mode.",
+        originalType: "tool"
+      };
+    case "quit":
+      return {
+        type: "unsupported",
+        reason: "Quit command is not supported in non-interactive mode. The process will exit naturally after completion.",
+        originalType: "quit"
+      };
+    case "dialog":
+      return {
+        type: "unsupported",
+        reason: `Dialog '${result.dialog}' cannot be opened in non-interactive mode.`,
+        originalType: "dialog"
+      };
+    case "load_history":
+      return {
+        type: "unsupported",
+        reason: "Loading history is not supported in non-interactive mode. Each invocation starts with a fresh context.",
+        originalType: "load_history"
+      };
+    case "confirm_shell_commands":
+      return {
+        type: "unsupported",
+        reason: "Shell command confirmation is not supported in non-interactive mode. Use YOLO mode or pre-approve commands.",
+        originalType: "confirm_shell_commands"
+      };
+    case "confirm_action":
+      return {
+        type: "unsupported",
+        reason: "Action confirmation is not supported in non-interactive mode. Commands requiring confirmation cannot be executed.",
+        originalType: "confirm_action"
+      };
+    default: {
+      const _exhaustive = result;
+      return {
+        type: "unsupported",
+        reason: `Unknown command result type: ${_exhaustive.type}`,
+        originalType: "unknown"
+      };
+    }
   }
-  return metrics2.tokens.cached / metrics2.tokens.prompt * 100;
 }
-__name(calculateCacheHitRate, "calculateCacheHitRate");
-var computeSessionStats = /* @__PURE__ */ __name((metrics2) => {
-  const { models, tools, files } = metrics2;
-  const totalApiTime = Object.values(models).reduce(
-    (acc, model) => acc + model.api.totalLatencyMs,
-    0
+__name(handleCommandResult, "handleCommandResult");
+function filterCommandsForNonInteractive(commands, allowedBuiltinCommandNames) {
+  return commands.filter((cmd) => {
+    if (cmd.kind === "file" /* FILE */) {
+      return true;
+    }
+    if (cmd.kind === "built-in" /* BUILT_IN */) {
+      return allowedBuiltinCommandNames.has(cmd.name);
+    }
+    return false;
+  });
+}
+__name(filterCommandsForNonInteractive, "filterCommandsForNonInteractive");
+var handleSlashCommand = /* @__PURE__ */ __name(async (rawQuery, abortController, config2, settings, allowedBuiltinCommandNames = [
+  ...ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE
+]) => {
+  const trimmed2 = rawQuery.trim();
+  if (!trimmed2.startsWith("/")) {
+    return { type: "no_command" };
+  }
+  const isAcpMode = config2.getExperimentalZedIntegration();
+  const isInteractive = config2.isInteractive();
+  const executionMode = isAcpMode ? "acp" : isInteractive ? "interactive" : "non_interactive";
+  const allowedBuiltinSet = new Set(allowedBuiltinCommandNames ?? []);
+  const allLoaders = [
+    new BuiltinCommandLoader(config2),
+    new FileCommandLoader(config2)
+  ];
+  const commandService = await CommandService.create(
+    allLoaders,
+    abortController.signal
   );
-  const totalToolTime = tools.totalDurationMs;
-  const agentActiveTime = totalApiTime + totalToolTime;
-  const apiTimePercent = agentActiveTime > 0 ? totalApiTime / agentActiveTime * 100 : 0;
-  const toolTimePercent = agentActiveTime > 0 ? totalToolTime / agentActiveTime * 100 : 0;
-  const totalCachedTokens = Object.values(models).reduce(
-    (acc, model) => acc + model.tokens.cached,
-    0
+  const allCommands = commandService.getCommands();
+  const filteredCommands = filterCommandsForNonInteractive(
+    allCommands,
+    allowedBuiltinSet
   );
-  const totalPromptTokens = Object.values(models).reduce(
-    (acc, model) => acc + model.tokens.prompt,
-    0
+  const { commandToExecute, args } = parseSlashCommand(
+    rawQuery,
+    filteredCommands
   );
-  const cacheEfficiency = totalPromptTokens > 0 ? totalCachedTokens / totalPromptTokens * 100 : 0;
-  const totalDecisions = tools.totalDecisions.accept + tools.totalDecisions.reject + tools.totalDecisions.modify;
-  const successRate = tools.totalCalls > 0 ? tools.totalSuccess / tools.totalCalls * 100 : 0;
-  const agreementRate = totalDecisions > 0 ? tools.totalDecisions.accept / totalDecisions * 100 : 0;
-  return {
-    totalApiTime,
-    totalToolTime,
-    agentActiveTime,
-    apiTimePercent,
-    toolTimePercent,
-    cacheEfficiency,
-    totalDecisions,
-    successRate,
-    agreementRate,
-    totalCachedTokens,
-    totalPromptTokens,
-    totalLinesAdded: files.totalLinesAdded,
-    totalLinesRemoved: files.totalLinesRemoved
+  if (!commandToExecute) {
+    const { commandToExecute: knownCommand } = parseSlashCommand(
+      rawQuery,
+      allCommands
+    );
+    if (knownCommand) {
+      return {
+        type: "unsupported",
+        reason: t4(
+          'The command "/{{command}}" is not supported in non-interactive mode.',
+          { command: knownCommand.name }
+        ),
+        originalType: "filtered_command"
+      };
+    }
+    return { type: "no_command" };
+  }
+  if (!commandToExecute.action) {
+    return { type: "no_command" };
+  }
+  const sessionStats = {
+    sessionId: config2?.getSessionId(),
+    sessionStartTime: /* @__PURE__ */ new Date(),
+    metrics: uiTelemetryService.getMetrics(),
+    lastPromptTokenCount: 0,
+    promptCount: 1
   };
-}, "computeSessionStats");
+  const logger6 = new Logger(config2?.getSessionId() || "", config2?.storage);
+  const context2 = {
+    executionMode,
+    services: {
+      config: config2,
+      settings,
+      git: void 0,
+      logger: logger6
+    },
+    ui: createNonInteractiveUI(),
+    session: {
+      stats: sessionStats,
+      sessionShellAllowlist: /* @__PURE__ */ new Set()
+    },
+    invocation: {
+      raw: trimmed2,
+      name: commandToExecute.name,
+      args
+    }
+  };
+  const result = await commandToExecute.action(context2, args);
+  if (!result) {
+    return {
+      type: "message",
+      messageType: "info",
+      content: "Command executed successfully."
+    };
+  }
+  return handleCommandResult(result);
+}, "handleSlashCommand");
+var getAvailableCommands = /* @__PURE__ */ __name(async (config2, abortSignal, allowedBuiltinCommandNames = [
+  ...ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE
+]) => {
+  try {
+    const allowedBuiltinSet = new Set(allowedBuiltinCommandNames ?? []);
+    const loaders = allowedBuiltinSet.size > 0 ? [new BuiltinCommandLoader(config2), new FileCommandLoader(config2)] : [new FileCommandLoader(config2)];
+    const commandService = await CommandService.create(loaders, abortSignal);
+    const commands = commandService.getCommands();
+    const filteredCommands = filterCommandsForNonInteractive(
+      commands,
+      allowedBuiltinSet
+    );
+    return filteredCommands.filter((cmd) => !cmd.hidden);
+  } catch (error2) {
+    console.error("Error loading available commands:", error2);
+    return [];
+  }
+}, "getAvailableCommands");
 
 // packages/cli/src/utils/nonInteractiveHelpers.ts
 function normalizePartList(parts) {
@@ -366642,19 +367569,15 @@ function computeUsageFromMetrics(metrics2) {
   return usage2;
 }
 __name(computeUsageFromMetrics, "computeUsageFromMetrics");
-async function loadSlashCommandNames(config2) {
+async function loadSlashCommandNames(config2, allowedBuiltinCommandNames) {
   const controller = new AbortController();
   try {
-    const service = await CommandService.create(
-      [new BuiltinCommandLoader(config2)],
-      controller.signal
+    const commands = await getAvailableCommands(
+      config2,
+      controller.signal,
+      allowedBuiltinCommandNames
     );
-    const names = /* @__PURE__ */ new Set();
-    const commands = service.getCommands();
-    for (const command2 of commands) {
-      names.add(command2.name);
-    }
-    return Array.from(names).sort();
+    return commands.map((cmd) => cmd.name).sort();
   } catch (error2) {
     if (config2.getDebugMode()) {
       console.error(
@@ -366668,7 +367591,7 @@ async function loadSlashCommandNames(config2) {
   }
 }
 __name(loadSlashCommandNames, "loadSlashCommandNames");
-async function buildSystemMessage(config2, sessionId, permissionMode) {
+async function buildSystemMessage(config2, sessionId, permissionMode, allowedBuiltinCommandNames) {
   const toolRegistry = config2.getToolRegistry();
   const tools = toolRegistry ? toolRegistry.getAllToolNames() : [];
   const mcpServers = config2.getMcpServers();
@@ -366676,7 +367599,10 @@ async function buildSystemMessage(config2, sessionId, permissionMode) {
     name: name3,
     status: getMCPServerStatus(name3)
   })) : [];
-  const slashCommands = await loadSlashCommandNames(config2);
+  const slashCommands = await loadSlashCommandNames(
+    config2,
+    allowedBuiltinCommandNames
+  );
   let agentNames = [];
   try {
     const subagentManager = config2.getSubagentManager();
@@ -367929,663 +368855,6 @@ var StreamJsonOutputAdapter = class extends BaseJsonOutputAdapter {
   }
 };
 
-// packages/cli/src/nonInteractiveCliCommands.ts
-init_esbuild_shims();
-
-// packages/cli/src/utils/commands.ts
-init_esbuild_shims();
-var parseSlashCommand = /* @__PURE__ */ __name((query, commands) => {
-  const trimmed2 = query.trim();
-  const parts = trimmed2.substring(1).trim().split(/\s+/);
-  const commandPath = parts.filter((p2) => p2);
-  let currentCommands = commands;
-  let commandToExecute;
-  let pathIndex = 0;
-  const canonicalPath = [];
-  for (const part of commandPath) {
-    let foundCommand = currentCommands.find((cmd) => cmd.name === part);
-    if (!foundCommand) {
-      foundCommand = currentCommands.find(
-        (cmd) => cmd.altNames?.includes(part)
-      );
-    }
-    if (foundCommand) {
-      commandToExecute = foundCommand;
-      canonicalPath.push(foundCommand.name);
-      pathIndex++;
-      if (foundCommand.subCommands) {
-        currentCommands = foundCommand.subCommands;
-      } else {
-        break;
-      }
-    } else {
-      break;
-    }
-  }
-  const args = parts.slice(pathIndex).join(" ");
-  return { commandToExecute, args, canonicalPath };
-}, "parseSlashCommand");
-
-// packages/cli/src/services/FileCommandLoader.ts
-init_esbuild_shims();
-var import_toml = __toESM(require_toml(), 1);
-init_esm11();
-init_zod();
-import { promises as fs81 } from "node:fs";
-import path90 from "node:path";
-
-// packages/cli/src/services/prompt-processors/argumentProcessor.ts
-init_esbuild_shims();
-var DefaultArgumentProcessor = class {
-  static {
-    __name(this, "DefaultArgumentProcessor");
-  }
-  async process(prompt, context2) {
-    if (context2.invocation?.args) {
-      return appendToLastTextPart(prompt, context2.invocation.raw);
-    }
-    return prompt;
-  }
-};
-
-// packages/cli/src/services/prompt-processors/types.ts
-init_esbuild_shims();
-var SHORTHAND_ARGS_PLACEHOLDER = "{{args}}";
-var SHELL_INJECTION_TRIGGER = "!{";
-var AT_FILE_INJECTION_TRIGGER = "@{";
-
-// packages/cli/src/services/prompt-processors/shellProcessor.ts
-init_esbuild_shims();
-
-// packages/cli/src/services/prompt-processors/injectionParser.ts
-init_esbuild_shims();
-function extractInjections(prompt, trigger, contextName) {
-  const injections = [];
-  let index = 0;
-  while (index < prompt.length) {
-    const startIndex = prompt.indexOf(trigger, index);
-    if (startIndex === -1) {
-      break;
-    }
-    let currentIndex = startIndex + trigger.length;
-    let braceCount = 1;
-    let foundEnd = false;
-    while (currentIndex < prompt.length) {
-      const char = prompt[currentIndex];
-      if (char === "{") {
-        braceCount++;
-      } else if (char === "}") {
-        braceCount--;
-        if (braceCount === 0) {
-          const injectionContent = prompt.substring(
-            startIndex + trigger.length,
-            currentIndex
-          );
-          const endIndex = currentIndex + 1;
-          injections.push({
-            content: injectionContent.trim(),
-            startIndex,
-            endIndex
-          });
-          index = endIndex;
-          foundEnd = true;
-          break;
-        }
-      }
-      currentIndex++;
-    }
-    if (!foundEnd) {
-      const contextInfo = contextName ? ` in command '${contextName}'` : "";
-      throw new Error(
-        `Invalid syntax${contextInfo}: Unclosed injection starting at index ${startIndex} ('${trigger}'). Ensure braces are balanced. Paths or commands with unbalanced braces are not supported directly.`
-      );
-    }
-  }
-  return injections;
-}
-__name(extractInjections, "extractInjections");
-
-// packages/cli/src/services/prompt-processors/shellProcessor.ts
-var ConfirmationRequiredError = class extends Error {
-  constructor(message, commandsToConfirm) {
-    super(message);
-    this.commandsToConfirm = commandsToConfirm;
-    this.name = "ConfirmationRequiredError";
-  }
-  static {
-    __name(this, "ConfirmationRequiredError");
-  }
-};
-var ShellProcessor = class {
-  constructor(commandName) {
-    this.commandName = commandName;
-  }
-  static {
-    __name(this, "ShellProcessor");
-  }
-  async process(prompt, context2) {
-    return flatMapTextParts(
-      prompt,
-      (text) => this.processString(text, context2)
-    );
-  }
-  async processString(prompt, context2) {
-    const userArgsRaw = context2.invocation?.args || "";
-    if (!prompt.includes(SHELL_INJECTION_TRIGGER)) {
-      return [
-        { text: prompt.replaceAll(SHORTHAND_ARGS_PLACEHOLDER, userArgsRaw) }
-      ];
-    }
-    const config2 = context2.services.config;
-    if (!config2) {
-      throw new Error(
-        `Security configuration not loaded. Cannot verify shell command permissions for '${this.commandName}'. Aborting.`
-      );
-    }
-    const { sessionShellAllowlist } = context2.session;
-    const injections = extractInjections(
-      prompt,
-      SHELL_INJECTION_TRIGGER,
-      this.commandName
-    );
-    if (injections.length === 0) {
-      return [
-        { text: prompt.replaceAll(SHORTHAND_ARGS_PLACEHOLDER, userArgsRaw) }
-      ];
-    }
-    const { shell: shell2 } = getShellConfiguration();
-    const userArgsEscaped = escapeShellArg(userArgsRaw, shell2);
-    const resolvedInjections = injections.map(
-      (injection) => {
-        const command2 = injection.content;
-        if (command2 === "") {
-          return { ...injection, resolvedCommand: void 0 };
-        }
-        const resolvedCommand = command2.replaceAll(
-          SHORTHAND_ARGS_PLACEHOLDER,
-          userArgsEscaped
-        );
-        return { ...injection, resolvedCommand };
-      }
-    );
-    const commandsToConfirm = /* @__PURE__ */ new Set();
-    for (const injection of resolvedInjections) {
-      const command2 = injection.resolvedCommand;
-      if (!command2) continue;
-      const { allAllowed, disallowedCommands, blockReason, isHardDenial } = checkCommandPermissions(command2, config2, sessionShellAllowlist);
-      if (!allAllowed) {
-        if (isHardDenial) {
-          throw new Error(
-            `${this.commandName} cannot be run. Blocked command: "${command2}". Reason: ${blockReason || "Blocked by configuration."}`
-          );
-        }
-        if (config2.getApprovalMode() !== ApprovalMode.YOLO) {
-          disallowedCommands.forEach((uc) => commandsToConfirm.add(uc));
-        }
-      }
-    }
-    if (commandsToConfirm.size > 0) {
-      throw new ConfirmationRequiredError(
-        "Shell command confirmation required",
-        Array.from(commandsToConfirm)
-      );
-    }
-    let processedPrompt = "";
-    let lastIndex = 0;
-    for (const injection of resolvedInjections) {
-      const segment = prompt.substring(lastIndex, injection.startIndex);
-      processedPrompt += segment.replaceAll(
-        SHORTHAND_ARGS_PLACEHOLDER,
-        userArgsRaw
-      );
-      if (injection.resolvedCommand) {
-        const activeTheme = themeManager.getActiveTheme();
-        const shellExecutionConfig = {
-          ...config2.getShellExecutionConfig(),
-          defaultFg: activeTheme.colors.Foreground,
-          defaultBg: activeTheme.colors.Background
-        };
-        const { result } = await ShellExecutionService.execute(
-          injection.resolvedCommand,
-          config2.getTargetDir(),
-          () => {
-          },
-          new AbortController().signal,
-          config2.getShouldUseNodePtyShell(),
-          shellExecutionConfig
-        );
-        const executionResult = await result;
-        if (executionResult.error && !executionResult.aborted) {
-          throw new Error(
-            `Failed to start shell command in '${this.commandName}': ${executionResult.error.message}. Command: ${injection.resolvedCommand}`
-          );
-        }
-        processedPrompt += executionResult.output;
-        if (executionResult.aborted) {
-          processedPrompt += `
-[Shell command '${injection.resolvedCommand}' aborted]`;
-        } else if (executionResult.exitCode !== 0 && executionResult.exitCode !== null) {
-          processedPrompt += `
-[Shell command '${injection.resolvedCommand}' exited with code ${executionResult.exitCode}]`;
-        } else if (executionResult.signal !== null) {
-          processedPrompt += `
-[Shell command '${injection.resolvedCommand}' terminated by signal ${executionResult.signal}]`;
-        }
-      }
-      lastIndex = injection.endIndex;
-    }
-    const finalSegment = prompt.substring(lastIndex);
-    processedPrompt += finalSegment.replaceAll(
-      SHORTHAND_ARGS_PLACEHOLDER,
-      userArgsRaw
-    );
-    return [{ text: processedPrompt }];
-  }
-};
-
-// packages/cli/src/services/prompt-processors/atFileProcessor.ts
-init_esbuild_shims();
-var AtFileProcessor = class {
-  constructor(commandName) {
-    this.commandName = commandName;
-  }
-  static {
-    __name(this, "AtFileProcessor");
-  }
-  async process(input, context2) {
-    const config2 = context2.services.config;
-    if (!config2) {
-      return input;
-    }
-    return flatMapTextParts(input, async (text) => {
-      if (!text.includes(AT_FILE_INJECTION_TRIGGER)) {
-        return [{ text }];
-      }
-      const injections = extractInjections(
-        text,
-        AT_FILE_INJECTION_TRIGGER,
-        this.commandName
-      );
-      if (injections.length === 0) {
-        return [{ text }];
-      }
-      const output = [];
-      let lastIndex = 0;
-      for (const injection of injections) {
-        const prefix = text.substring(lastIndex, injection.startIndex);
-        if (prefix) {
-          output.push({ text: prefix });
-        }
-        const pathStr = injection.content;
-        try {
-          const fileContentParts = await readPathFromWorkspace(pathStr, config2);
-          if (fileContentParts.length === 0) {
-            const uiMessage = `File '@{${pathStr}}' was ignored by .gitignore or .qwenignore and was not included in the prompt.`;
-            context2.ui.addItem(
-              { type: "info" /* INFO */, text: uiMessage },
-              Date.now()
-            );
-          }
-          output.push(...fileContentParts);
-        } catch (error2) {
-          const message = error2 instanceof Error ? error2.message : String(error2);
-          const uiMessage = `Failed to inject content for '@{${pathStr}}': ${message}`;
-          console.error(
-            `[AtFileProcessor] ${uiMessage}. Leaving placeholder in prompt.`
-          );
-          context2.ui.addItem(
-            { type: "error" /* ERROR */, text: uiMessage },
-            Date.now()
-          );
-          const placeholder = text.substring(
-            injection.startIndex,
-            injection.endIndex
-          );
-          output.push({ text: placeholder });
-        }
-        lastIndex = injection.endIndex;
-      }
-      const suffix = text.substring(lastIndex);
-      if (suffix) {
-        output.push({ text: suffix });
-      }
-      return output;
-    });
-  }
-};
-
-// packages/cli/src/services/FileCommandLoader.ts
-var TomlCommandDefSchema = external_exports.object({
-  prompt: external_exports.string({
-    required_error: "The 'prompt' field is required.",
-    invalid_type_error: "The 'prompt' field must be a string."
-  }),
-  description: external_exports.string().optional()
-});
-var FileCommandLoader = class {
-  constructor(config2) {
-    this.config = config2;
-    this.folderTrustEnabled = !!config2?.getFolderTrustFeature();
-    this.folderTrust = !!config2?.getFolderTrust();
-    this.projectRoot = config2?.getProjectRoot() || process.cwd();
-  }
-  static {
-    __name(this, "FileCommandLoader");
-  }
-  projectRoot;
-  folderTrustEnabled;
-  folderTrust;
-  /**
-   * Loads all commands from user, project, and extension directories.
-   * Returns commands in order: user → project → extensions (alphabetically).
-   *
-   * Order is important for conflict resolution in CommandService:
-   * - User/project commands (without extensionName) use "last wins" strategy
-   * - Extension commands (with extensionName) get renamed if conflicts exist
-   *
-   * @param signal An AbortSignal to cancel the loading process.
-   * @returns A promise that resolves to an array of all loaded SlashCommands.
-   */
-  async loadCommands(signal) {
-    const allCommands = [];
-    const globOptions = {
-      nodir: true,
-      dot: true,
-      signal,
-      follow: true
-    };
-    const commandDirs = this.getCommandDirectories();
-    for (const dirInfo of commandDirs) {
-      try {
-        const files = await glob("**/*.toml", {
-          ...globOptions,
-          cwd: dirInfo.path
-        });
-        if (this.folderTrustEnabled && !this.folderTrust) {
-          return [];
-        }
-        const commandPromises = files.map(
-          (file) => this.parseAndAdaptFile(
-            path90.join(dirInfo.path, file),
-            dirInfo.path,
-            dirInfo.extensionName
-          )
-        );
-        const commands = (await Promise.all(commandPromises)).filter(
-          (cmd) => cmd !== null
-        );
-        allCommands.push(...commands);
-      } catch (error2) {
-        const isEnoent = error2.code === "ENOENT";
-        const isAbortError2 = error2 instanceof Error && error2.name === "AbortError";
-        if (!isEnoent && !isAbortError2) {
-          console.error(
-            `[FileCommandLoader] Error loading commands from ${dirInfo.path}:`,
-            error2
-          );
-        }
-      }
-    }
-    return allCommands;
-  }
-  /**
-   * Get all command directories in order for loading.
-   * User commands → Project commands → Extension commands
-   * This order ensures extension commands can detect all conflicts.
-   */
-  getCommandDirectories() {
-    const dirs = [];
-    const storage = this.config?.storage ?? new Storage(this.projectRoot);
-    dirs.push({ path: Storage.getUserCommandsDir() });
-    dirs.push({ path: storage.getProjectCommandsDir() });
-    if (this.config) {
-      const activeExtensions = this.config.getExtensions().filter((ext2) => ext2.isActive).sort((a2, b2) => a2.name.localeCompare(b2.name));
-      const extensionCommandDirs = activeExtensions.map((ext2) => ({
-        path: path90.join(ext2.path, "commands"),
-        extensionName: ext2.name
-      }));
-      dirs.push(...extensionCommandDirs);
-    }
-    return dirs;
-  }
-  /**
-   * Parses a single .toml file and transforms it into a SlashCommand object.
-   * @param filePath The absolute path to the .toml file.
-   * @param baseDir The root command directory for name calculation.
-   * @param extensionName Optional extension name to prefix commands with.
-   * @returns A promise resolving to a SlashCommand, or null if the file is invalid.
-   */
-  async parseAndAdaptFile(filePath, baseDir, extensionName) {
-    let fileContent;
-    try {
-      fileContent = await fs81.readFile(filePath, "utf-8");
-    } catch (error2) {
-      console.error(
-        `[FileCommandLoader] Failed to read file ${filePath}:`,
-        error2 instanceof Error ? error2.message : String(error2)
-      );
-      return null;
-    }
-    let parsed;
-    try {
-      parsed = import_toml.default.parse(fileContent);
-    } catch (error2) {
-      console.error(
-        `[FileCommandLoader] Failed to parse TOML file ${filePath}:`,
-        error2 instanceof Error ? error2.message : String(error2)
-      );
-      return null;
-    }
-    const validationResult = TomlCommandDefSchema.safeParse(parsed);
-    if (!validationResult.success) {
-      console.error(
-        `[FileCommandLoader] Skipping invalid command file: ${filePath}. Validation errors:`,
-        validationResult.error.flatten()
-      );
-      return null;
-    }
-    const validDef = validationResult.data;
-    const relativePathWithExt = path90.relative(baseDir, filePath);
-    const relativePath = relativePathWithExt.substring(
-      0,
-      relativePathWithExt.length - 5
-      // length of '.toml'
-    );
-    const baseCommandName = relativePath.split(path90.sep).map((segment) => segment.replaceAll(":", "_")).join(":");
-    const defaultDescription = `Custom command from ${path90.basename(filePath)}`;
-    let description = validDef.description || defaultDescription;
-    if (extensionName) {
-      description = `[${extensionName}] ${description}`;
-    }
-    const processors = [];
-    const usesArgs = validDef.prompt.includes(SHORTHAND_ARGS_PLACEHOLDER);
-    const usesShellInjection = validDef.prompt.includes(
-      SHELL_INJECTION_TRIGGER
-    );
-    const usesAtFileInjection = validDef.prompt.includes(
-      AT_FILE_INJECTION_TRIGGER
-    );
-    if (usesAtFileInjection) {
-      processors.push(new AtFileProcessor(baseCommandName));
-    }
-    if (usesShellInjection || usesArgs) {
-      processors.push(new ShellProcessor(baseCommandName));
-    }
-    if (!usesArgs) {
-      processors.push(new DefaultArgumentProcessor());
-    }
-    return {
-      name: baseCommandName,
-      description,
-      kind: "file" /* FILE */,
-      extensionName,
-      action: /* @__PURE__ */ __name(async (context2, _args) => {
-        if (!context2.invocation) {
-          console.error(
-            `[FileCommandLoader] Critical error: Command '${baseCommandName}' was executed without invocation context.`
-          );
-          return {
-            type: "submit_prompt",
-            content: [{ text: validDef.prompt }]
-            // Fallback to unprocessed prompt
-          };
-        }
-        try {
-          let processedContent = [
-            { text: validDef.prompt }
-          ];
-          for (const processor of processors) {
-            processedContent = await processor.process(
-              processedContent,
-              context2
-            );
-          }
-          return {
-            type: "submit_prompt",
-            content: processedContent
-          };
-        } catch (e4) {
-          if (e4 instanceof ConfirmationRequiredError) {
-            return {
-              type: "confirm_shell_commands",
-              commandsToConfirm: e4.commandsToConfirm,
-              originalInvocation: {
-                raw: context2.invocation.raw
-              }
-            };
-          }
-          throw e4;
-        }
-      }, "action")
-    };
-  }
-};
-
-// packages/cli/src/ui/noninteractive/nonInteractiveUi.ts
-init_esbuild_shims();
-function createNonInteractiveUI() {
-  return {
-    addItem: /* @__PURE__ */ __name((_item, _timestamp) => 0, "addItem"),
-    clear: /* @__PURE__ */ __name(() => {
-    }, "clear"),
-    setDebugMessage: /* @__PURE__ */ __name((_message) => {
-    }, "setDebugMessage"),
-    loadHistory: /* @__PURE__ */ __name((_newHistory) => {
-    }, "loadHistory"),
-    pendingItem: null,
-    setPendingItem: /* @__PURE__ */ __name((_item) => {
-    }, "setPendingItem"),
-    toggleVimEnabled: /* @__PURE__ */ __name(async () => false, "toggleVimEnabled"),
-    setGeminiMdFileCount: /* @__PURE__ */ __name((_count) => {
-    }, "setGeminiMdFileCount"),
-    reloadCommands: /* @__PURE__ */ __name(() => {
-    }, "reloadCommands"),
-    extensionsUpdateState: /* @__PURE__ */ new Map(),
-    dispatchExtensionStateUpdate: /* @__PURE__ */ __name((_action) => {
-    }, "dispatchExtensionStateUpdate"),
-    addConfirmUpdateExtensionRequest: /* @__PURE__ */ __name((_request) => {
-    }, "addConfirmUpdateExtensionRequest")
-  };
-}
-__name(createNonInteractiveUI, "createNonInteractiveUI");
-
-// packages/cli/src/nonInteractiveCliCommands.ts
-function filterCommandsForNonInteractive(commands, allowedBuiltinCommandNames) {
-  return commands.filter((cmd) => {
-    if (cmd.kind === "file" /* FILE */) {
-      return true;
-    }
-    if (cmd.kind === "built-in" /* BUILT_IN */) {
-      return allowedBuiltinCommandNames.has(cmd.name);
-    }
-    return false;
-  });
-}
-__name(filterCommandsForNonInteractive, "filterCommandsForNonInteractive");
-var handleSlashCommand = /* @__PURE__ */ __name(async (rawQuery, abortController, config2, settings, allowedBuiltinCommandNames) => {
-  const trimmed2 = rawQuery.trim();
-  if (!trimmed2.startsWith("/")) {
-    return;
-  }
-  const allowedBuiltinSet = new Set(allowedBuiltinCommandNames ?? []);
-  const loaders = allowedBuiltinSet.size > 0 ? [new BuiltinCommandLoader(config2), new FileCommandLoader(config2)] : [new FileCommandLoader(config2)];
-  const commandService = await CommandService.create(
-    loaders,
-    abortController.signal
-  );
-  const commands = commandService.getCommands();
-  const filteredCommands = filterCommandsForNonInteractive(
-    commands,
-    allowedBuiltinSet
-  );
-  const { commandToExecute, args } = parseSlashCommand(
-    rawQuery,
-    filteredCommands
-  );
-  if (commandToExecute) {
-    if (commandToExecute.action) {
-      const sessionStats = {
-        sessionId: config2?.getSessionId(),
-        sessionStartTime: /* @__PURE__ */ new Date(),
-        metrics: uiTelemetryService.getMetrics(),
-        lastPromptTokenCount: 0,
-        promptCount: 1
-      };
-      const logger6 = new Logger(config2?.getSessionId() || "", config2?.storage);
-      const context2 = {
-        services: {
-          config: config2,
-          settings,
-          git: void 0,
-          logger: logger6
-        },
-        ui: createNonInteractiveUI(),
-        session: {
-          stats: sessionStats,
-          sessionShellAllowlist: /* @__PURE__ */ new Set()
-        },
-        invocation: {
-          raw: trimmed2,
-          name: commandToExecute.name,
-          args
-        }
-      };
-      const result = await commandToExecute.action(context2, args);
-      if (result) {
-        switch (result.type) {
-          case "submit_prompt":
-            return result.content;
-          case "confirm_shell_commands":
-            throw new FatalInputError(
-              "Exiting due to a confirmation prompt requested by the command."
-            );
-          default:
-            throw new FatalInputError(
-              "Exiting due to command result that is not supported in non-interactive mode."
-            );
-        }
-      }
-    }
-  }
-  return;
-}, "handleSlashCommand");
-var getAvailableCommands = /* @__PURE__ */ __name(async (config2, settings, abortSignal, allowedBuiltinCommandNames) => {
-  try {
-    const allowedBuiltinSet = new Set(allowedBuiltinCommandNames ?? []);
-    const loaders = allowedBuiltinSet.size > 0 ? [new BuiltinCommandLoader(config2), new FileCommandLoader(config2)] : [new FileCommandLoader(config2)];
-    const commandService = await CommandService.create(loaders, abortSignal);
-    const commands = commandService.getCommands();
-    const filteredCommands = filterCommandsForNonInteractive(
-      commands,
-      allowedBuiltinSet
-    );
-    return filteredCommands.filter((cmd) => !cmd.hidden);
-  } catch (error2) {
-    console.error("Error loading available commands:", error2);
-    return [];
-  }
-}, "getAvailableCommands");
-
 // packages/cli/src/ui/hooks/atCommandProcessor.ts
 init_esbuild_shims();
 import * as fs82 from "node:fs/promises";
@@ -368925,6 +369194,36 @@ Content from @${filePathSpecInContent}:
 __name(handleAtCommand, "handleAtCommand");
 
 // packages/cli/src/nonInteractiveCli.ts
+async function emitNonInteractiveFinalMessage(params) {
+  const { message, isError, adapter, config: config2 } = params;
+  if (!adapter) {
+    const target = isError ? process.stderr : process.stdout;
+    target.write(`${message}
+`);
+    return;
+  }
+  adapter.startAssistantMessage();
+  adapter.processEvent({
+    type: GeminiEventType.Content,
+    value: message
+  });
+  adapter.finalizeAssistantMessage();
+  const metrics2 = uiTelemetryService.getMetrics();
+  const usage2 = computeUsageFromMetrics(metrics2);
+  const outputFormat = config2.getOutputFormat();
+  const stats = outputFormat === OutputFormat.JSON ? uiTelemetryService.getMetrics() : void 0;
+  adapter.emitResult({
+    isError,
+    durationMs: Date.now() - params.startTimeMs,
+    apiDurationMs: 0,
+    numTurns: 0,
+    errorMessage: isError ? message : void 0,
+    usage: usage2,
+    stats,
+    summary: message
+  });
+}
+__name(emitNonInteractiveFinalMessage, "emitNonInteractiveFinalMessage");
 async function runNonInteractive(config2, settings, input, prompt_id, options2 = {}) {
   return promptIdContext.run(prompt_id, async () => {
     let adapter;
@@ -368962,6 +369261,14 @@ async function runNonInteractive(config2, settings, input, prompt_id, options2 =
       process.stdout.on("error", stdoutErrorHandler);
       process.on("SIGINT", shutdownHandler);
       process.on("SIGTERM", shutdownHandler);
+      if (adapter) {
+        const systemMessage = await buildSystemMessage(
+          config2,
+          sessionId,
+          permissionMode
+        );
+        adapter.emitMessage(systemMessage);
+      }
       let initialPartList = extractPartsFromUserMessage(
         options2.userMessage
       );
@@ -368974,9 +369281,43 @@ async function runNonInteractive(config2, settings, input, prompt_id, options2 =
             config2,
             settings
           );
-          if (slashCommandResult) {
-            initialPartList = slashCommandResult;
-            slashHandled = true;
+          switch (slashCommandResult.type) {
+            case "submit_prompt":
+              initialPartList = slashCommandResult.content;
+              slashHandled = true;
+              break;
+            case "message": {
+              await emitNonInteractiveFinalMessage({
+                message: slashCommandResult.content,
+                isError: slashCommandResult.messageType === "error",
+                adapter,
+                config: config2,
+                startTimeMs: startTime
+              });
+              return;
+            }
+            case "stream_messages":
+              throw new FatalInputError(
+                "Stream messages mode is not supported in non-interactive CLI"
+              );
+            case "unsupported": {
+              await emitNonInteractiveFinalMessage({
+                message: slashCommandResult.reason,
+                isError: true,
+                adapter,
+                config: config2,
+                startTimeMs: startTime
+              });
+              return;
+            }
+            case "no_command":
+              break;
+            default: {
+              const _exhaustive = slashCommandResult;
+              throw new FatalInputError(
+                `Unhandled slash command result type: ${_exhaustive.type}`
+              );
+            }
           }
         }
         if (!slashHandled) {
@@ -369002,14 +369343,6 @@ async function runNonInteractive(config2, settings, input, prompt_id, options2 =
       }
       const initialParts = normalizePartList(initialPartList);
       let currentMessages = [{ role: "user", parts: initialParts }];
-      if (adapter) {
-        const systemMessage = await buildSystemMessage(
-          config2,
-          sessionId,
-          permissionMode
-        );
-        adapter.emitMessage(systemMessage);
-      }
       let isFirstTurn = true;
       while (true) {
         turnCount++;
@@ -369689,7 +370022,7 @@ var SystemController = class extends BaseController {
     };
   }
   /**
-   * Load slash command names using CommandService
+   * Load slash command names using getAvailableCommands
    *
    * @param signal - AbortSignal to respect for cancellation
    * @returns Promise resolving to array of slash command names
@@ -369699,19 +370032,11 @@ var SystemController = class extends BaseController {
       return [];
     }
     try {
-      const service = await CommandService.create(
-        [new BuiltinCommandLoader(this.context.config)],
-        signal
-      );
+      const commands = await getAvailableCommands(this.context.config, signal);
       if (signal.aborted) {
         return [];
       }
-      const names = /* @__PURE__ */ new Set();
-      const commands = service.getCommands();
-      for (const command2 of commands) {
-        names.add(command2.name);
-      }
-      return Array.from(names).sort();
+      return commands.map((cmd) => cmd.name).sort();
     } catch (error2) {
       if (signal.aborted) {
         return [];
@@ -403285,6 +403610,11 @@ var useSlashCommandProcessor = /* @__PURE__ */ __name((config2, settings, addIte
                     true
                   );
                 }
+                case "stream_messages": {
+                  throw new Error(
+                    "stream_messages result type is not supported in interactive mode"
+                  );
+                }
                 default: {
                   const unhandled = result;
                   throw new Error(
@@ -412068,8 +412398,22 @@ var authenticateUpdateSchema = external_exports.object({
     authUri: external_exports.string()
   })
 });
+var acpMetaSchema = external_exports.record(external_exports.unknown()).nullable().optional();
+var modelIdSchema = external_exports.string();
+var modelInfoSchema = external_exports.object({
+  _meta: acpMetaSchema,
+  description: external_exports.string().nullable().optional(),
+  modelId: modelIdSchema,
+  name: external_exports.string()
+});
+var sessionModelStateSchema = external_exports.object({
+  _meta: acpMetaSchema,
+  availableModels: external_exports.array(modelInfoSchema),
+  currentModelId: modelIdSchema
+});
 var newSessionResponseSchema = external_exports.object({
-  sessionId: external_exports.string()
+  sessionId: external_exports.string(),
+  models: sessionModelStateSchema
 });
 var loadSessionResponseSchema = external_exports.null();
 var sessionListItemSchema = external_exports.object({
@@ -412283,6 +412627,10 @@ var currentModeUpdateSchema = external_exports.object({
   sessionUpdate: external_exports.literal("current_mode_update"),
   modeId: approvalModeValueSchema
 });
+var currentModelUpdateSchema = external_exports.object({
+  sessionUpdate: external_exports.literal("current_model_update"),
+  model: modelInfoSchema
+});
 var sessionUpdateSchema = external_exports.union([
   external_exports.object({
     content: contentBlockSchema,
@@ -412324,6 +412672,7 @@ var sessionUpdateSchema = external_exports.union([
     sessionUpdate: external_exports.literal("plan")
   }),
   currentModeUpdateSchema,
+  currentModelUpdateSchema,
   availableCommandsUpdateSchema
 ]);
 var agentResponseSchema = external_exports.union([
@@ -412437,6 +412786,13 @@ var AgentSideConnection = class {
       params
     );
   }
+  /**
+   * Sends a custom notification to the client.
+   * Used for extension-specific notifications that are not part of the core ACP protocol.
+   */
+  async sendCustomNotification(method, params) {
+    return await this.#connection.sendNotification(method, params);
+  }
   /**
    * Request permission before running a tool
    *
@@ -413426,7 +413782,6 @@ var SubAgentTracker = class {
 };
 
 // packages/cli/src/acp-integration/session/Session.ts
-var ALLOWED_BUILTIN_COMMANDS_FOR_ACP = ["init"];
 var Session3 = class {
   constructor(id, chat, config2, client, settings) {
     this.chat = chat;
@@ -413497,13 +413852,14 @@ var Session3 = class {
         inputText,
         pendingSend,
         this.config,
-        this.settings,
-        ALLOWED_BUILTIN_COMMANDS_FOR_ACP
+        this.settings
       );
-      if (slashCommandResult) {
-        parts = slashCommandResult;
-      } else {
-        parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
+      parts = await this.#processSlashCommandResult(
+        slashCommandResult,
+        params.prompt
+      );
+      if (parts === null) {
+        return { stopReason: "end_turn" };
       }
     } else {
       parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
@@ -413593,9 +413949,7 @@ var Session3 = class {
     try {
       const slashCommands = await getAvailableCommands(
         this.config,
-        this.settings,
-        abortController.signal,
-        ALLOWED_BUILTIN_COMMANDS_FOR_ACP
+        abortController.signal
       );
       const availableCommands = slashCommands.map(
         (cmd) => ({
@@ -413842,6 +414196,71 @@ var Session3 = class {
       return errorResponse(error2);
     }
   }
+  /**
+   * Processes the result of a slash command execution.
+   *
+   * Supported result types in ACP mode:
+   * - submit_prompt: Submits content to the model
+   * - stream_messages: Streams multiple messages to the client (ACP-specific)
+   * - unsupported: Command cannot be executed in ACP mode
+   * - no_command: No command was found, use original prompt
+   *
+   * Note: 'message' type is not supported in ACP mode - commands should use
+   * 'stream_messages' instead for consistent async handling.
+   *
+   * @param result The result from handleSlashCommand
+   * @param originalPrompt The original prompt blocks
+   * @returns Parts to use for the prompt, or null if command was handled without needing model interaction
+   */
+  async #processSlashCommandResult(result, originalPrompt) {
+    switch (result.type) {
+      case "submit_prompt":
+        return normalizePartList(result.content);
+      case "message": {
+        await this.client.sendCustomNotification("_qwencode/slash_command", {
+          sessionId: this.sessionId,
+          command: originalPrompt.filter((block2) => block2.type === "text").map((block2) => block2.type === "text" ? block2.text : "").join(" "),
+          messageType: result.messageType,
+          message: result.content || ""
+        });
+        if (result.messageType === "error") {
+          throw new Error(result.content || "Slash command failed.");
+        }
+        return null;
+      }
+      case "stream_messages": {
+        const command2 = originalPrompt.filter((block2) => block2.type === "text").map((block2) => block2.type === "text" ? block2.text : "").join(" ");
+        for await (const msg of result.messages) {
+          await this.client.sendCustomNotification("_qwencode/slash_command", {
+            sessionId: this.sessionId,
+            command: command2,
+            messageType: msg.messageType,
+            message: msg.content
+          });
+          if (msg.messageType === "error") {
+            throw new Error(msg.content || "Slash command failed.");
+          }
+        }
+        return null;
+      }
+      case "unsupported": {
+        const unsupportedError = `Slash command not supported in ACP integration: ${result.reason}`;
+        throw new Error(unsupportedError);
+      }
+      case "no_command":
+        return originalPrompt.map((block2) => {
+          if (block2.type === "text") {
+            return { text: block2.text };
+          }
+          throw new Error(`Unsupported block type: ${block2.type}`);
+        });
+      default: {
+        const _exhaustive = result;
+        const unknownError = `Unknown slash command result type: ${_exhaustive.type}`;
+        throw new Error(unknownError);
+      }
+    }
+  }
   async #resolvePrompt(message, abortSignal) {
     const FILE_URI_SCHEME = "file://";
     const embeddedContext = [];
@@ -414181,7 +414600,7 @@ var GeminiAgent = class {
       name: APPROVAL_MODE_INFO[mode].name,
       description: APPROVAL_MODE_INFO[mode].description
     }));
-    const version2 = "0.6.0-preview.1";
+    const version2 = "0.6.0";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -414237,8 +414656,25 @@ var GeminiAgent = class {
     await this.ensureAuthenticated(config2);
     this.setupFileSystem(config2);
     const session = await this.createAndStoreSession(config2);
+    const configuredModel = (config2.getModel() || this.config.getModel() || "").trim();
+    const modelId = configuredModel || "default";
+    const modelName = configuredModel || modelId;
     return {
-      sessionId: session.getId()
+      sessionId: session.getId(),
+      models: {
+        currentModelId: modelId,
+        availableModels: [
+          {
+            modelId,
+            name: modelName,
+            description: null,
+            _meta: {
+              contextLimit: tokenLimit(modelId)
+            }
+          }
+        ],
+        _meta: null
+      }
     };
   }
   async newSessionConfig(cwd7, mcpServers, sessionId) {
@@ -414364,8 +414800,10 @@ var GeminiAgent = class {
   async createAndStoreSession(config2, conversation) {
     const sessionId = config2.getSessionId();
     const geminiClient = config2.getGeminiClient();
-    const history = conversation ? buildApiHistoryFromConversation(conversation) : void 0;
-    const chat = history ? await geminiClient.startChat(history) : await geminiClient.startChat();
+    if (!geminiClient.isInitialized()) {
+      await geminiClient.initialize();
+    }
+    const chat = geminiClient.getChat();
     const session = new Session3(
       sessionId,
       chat,