@qwen-code/qwen-code 0.21.0-nightly.20260727.c003e1718 → 0.21.0-preview.0

package/chunks/{chunk-BJHP755Z.js → chunk-7I5GTCT4.js}

@@ -12,6 +12,163 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/channels/base/dist/ChannelLoopTools.js
+init_esbuild_shims();
+var CHANNEL_LOOP_MCP_SERVER_NAME = "channel_loop";
+var CLIENT_MCP_MESSAGE_METHOD = "qwen/control/client_mcp/message";
+var WORKSPACE_MCP_RUNTIME_ADD_METHOD = "qwen/control/workspace/mcp/runtime-add";
+var CLIENT_MCP_OVER_WS_CONFIG_FLAG = "__clientMcpOverWs";
+var createTool = {
+  name: "channel_loop_create",
+  description: "Create a recurring proactive reminder or scheduled prompt for the current channel chat. Use this in channel sessions instead of cron_create.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      cron: {
+        type: "string",
+        description: 'Standard 5-field cron expression in local time, for example "*/5 * * * *".'
+      },
+      prompt: {
+        type: "string",
+        description: "The message or instruction to run and proactively push to this channel chat."
+      },
+      recurring: {
+        type: "boolean",
+        description: "Whether the loop recurs. Defaults to true."
+      }
+    },
+    required: ["cron", "prompt"]
+  }
+};
+var listTool = {
+  name: "channel_loop_list",
+  description: "List proactive loops for the current channel chat.",
+  inputSchema: { type: "object", properties: {} }
+};
+var cancelTool = {
+  name: "channel_loop_cancel",
+  description: "Cancel a proactive loop for the current channel chat.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: "Loop id to cancel." }
+    },
+    required: ["id"]
+  }
+};
+var CHANNEL_LOOP_MCP_TOOLS = [createTool, listTool, cancelTool];
+var ChannelLoopMcpServer = class {
+  static {
+    __name(this, "ChannelLoopMcpServer");
+  }
+  handler;
+  constructor(handler) {
+    this.handler = handler;
+  }
+  async handleMessage(message, context) {
+    const id = message["id"];
+    if (id === void 0 || id === null) {
+      return void 0;
+    }
+    try {
+      const result = await this.dispatch(message, context);
+      return { jsonrpc: "2.0", id, result };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  async dispatch(message, context) {
+    switch (message["method"]) {
+      case "initialize":
+        return {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: CHANNEL_LOOP_MCP_SERVER_NAME, version: "0.0.1" }
+        };
+      case "tools/list":
+        return { tools: CHANNEL_LOOP_MCP_TOOLS };
+      case "tools/call":
+        return this.callTool(message["params"], context);
+      case "ping":
+        return {};
+      default:
+        throw new Error(`Method not found: ${String(message["method"])}`);
+    }
+  }
+  async callTool(rawParams, context) {
+    if (!context.sessionId) {
+      throw new Error("Missing channel session id.");
+    }
+    if (typeof rawParams !== "object" || rawParams === null) {
+      throw new Error("Invalid tools/call params.");
+    }
+    const params = rawParams;
+    const name = params["name"];
+    const args = typeof params["arguments"] === "object" && params["arguments"] !== null ? params["arguments"] : {};
+    let toolResult;
+    switch (name) {
+      case createTool.name:
+        toolResult = await this.handler.create(context.sessionId, readCreateInput(args));
+        break;
+      case listTool.name:
+        toolResult = await this.handler.list(context.sessionId);
+        break;
+      case cancelTool.name:
+        toolResult = await this.handler.cancel(context.sessionId, readId(args));
+        break;
+      default:
+        throw new Error(`Unknown channel loop tool: ${String(name)}`);
+    }
+    const result = typeof toolResult === "string" ? { text: toolResult } : toolResult;
+    return {
+      content: [{ type: "text", text: result.text }],
+      ...result.isError ? { isError: true } : {}
+    };
+  }
+};
+function readCreateInput(args) {
+  const cron = args["cron"];
+  const prompt = args["prompt"];
+  if (typeof cron !== "string" || cron.trim().length === 0) {
+    throw new Error("cron must be a non-empty string.");
+  }
+  if (typeof prompt !== "string" || prompt.trim().length === 0) {
+    throw new Error("prompt must be a non-empty string.");
+  }
+  const recurring = readRecurring(args["recurring"]);
+  return {
+    cron: cron.trim(),
+    prompt: prompt.trim(),
+    ...recurring !== void 0 ? { recurring } : {}
+  };
+}
+__name(readCreateInput, "readCreateInput");
+function readRecurring(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (value === "false" || value === 0)
+    return false;
+  if (value === "true" || value === 1)
+    return true;
+  return void 0;
+}
+__name(readRecurring, "readRecurring");
+function readId(args) {
+  const id = args["id"];
+  if (typeof id !== "string" || id.trim().length === 0) {
+    throw new Error("id must be a non-empty string.");
+  }
+  return id.trim();
+}
+__name(readId, "readId");
+
 // packages/channels/base/dist/sanitize.js
 init_esbuild_shims();
 var PROMPT_UNSAFE_INVISIBLES = new RegExp("[\\u0080-\\u009f\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
@@ -294,166 +451,8 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { Readable, Writable } from "node:stream";
 import { EventEmitter } from "node:events";
-
-// packages/channels/base/dist/ChannelLoopTools.js
-init_esbuild_shims();
-var CHANNEL_LOOP_MCP_SERVER_NAME = "channel_loop";
-var CLIENT_MCP_MESSAGE_METHOD = "qwen/control/client_mcp/message";
-var WORKSPACE_MCP_RUNTIME_ADD_METHOD = "qwen/control/workspace/mcp/runtime-add";
-var CLIENT_MCP_OVER_WS_CONFIG_FLAG = "__clientMcpOverWs";
-var createTool = {
-  name: "channel_loop_create",
-  description: "Create a recurring proactive reminder or scheduled prompt for the current channel chat. Use this in channel sessions instead of cron_create.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      cron: {
-        type: "string",
-        description: 'Standard 5-field cron expression in local time, for example "*/5 * * * *".'
-      },
-      prompt: {
-        type: "string",
-        description: "The message or instruction to run and proactively push to this channel chat."
-      },
-      recurring: {
-        type: "boolean",
-        description: "Whether the loop recurs. Defaults to true."
-      }
-    },
-    required: ["cron", "prompt"]
-  }
-};
-var listTool = {
-  name: "channel_loop_list",
-  description: "List proactive loops for the current channel chat.",
-  inputSchema: { type: "object", properties: {} }
-};
-var cancelTool = {
-  name: "channel_loop_cancel",
-  description: "Cancel a proactive loop for the current channel chat.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      id: { type: "string", description: "Loop id to cancel." }
-    },
-    required: ["id"]
-  }
-};
-var CHANNEL_LOOP_MCP_TOOLS = [createTool, listTool, cancelTool];
-var ChannelLoopMcpServer = class {
-  static {
-    __name(this, "ChannelLoopMcpServer");
-  }
-  handler;
-  constructor(handler) {
-    this.handler = handler;
-  }
-  async handleMessage(message, context) {
-    const id = message["id"];
-    if (id === void 0 || id === null) {
-      return void 0;
-    }
-    try {
-      const result = await this.dispatch(message, context);
-      return { jsonrpc: "2.0", id, result };
-    } catch (error) {
-      return {
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: -32603,
-          message: error instanceof Error ? error.message : String(error)
-        }
-      };
-    }
-  }
-  async dispatch(message, context) {
-    switch (message["method"]) {
-      case "initialize":
-        return {
-          protocolVersion: "2024-11-05",
-          capabilities: { tools: {} },
-          serverInfo: { name: CHANNEL_LOOP_MCP_SERVER_NAME, version: "0.0.1" }
-        };
-      case "tools/list":
-        return { tools: CHANNEL_LOOP_MCP_TOOLS };
-      case "tools/call":
-        return this.callTool(message["params"], context);
-      case "ping":
-        return {};
-      default:
-        throw new Error(`Method not found: ${String(message["method"])}`);
-    }
-  }
-  async callTool(rawParams, context) {
-    if (!context.sessionId) {
-      throw new Error("Missing channel session id.");
-    }
-    if (typeof rawParams !== "object" || rawParams === null) {
-      throw new Error("Invalid tools/call params.");
-    }
-    const params = rawParams;
-    const name = params["name"];
-    const args = typeof params["arguments"] === "object" && params["arguments"] !== null ? params["arguments"] : {};
-    let toolResult;
-    switch (name) {
-      case createTool.name:
-        toolResult = await this.handler.create(context.sessionId, readCreateInput(args));
-        break;
-      case listTool.name:
-        toolResult = await this.handler.list(context.sessionId);
-        break;
-      case cancelTool.name:
-        toolResult = await this.handler.cancel(context.sessionId, readId(args));
-        break;
-      default:
-        throw new Error(`Unknown channel loop tool: ${String(name)}`);
-    }
-    const result = typeof toolResult === "string" ? { text: toolResult } : toolResult;
-    return {
-      content: [{ type: "text", text: result.text }],
-      ...result.isError ? { isError: true } : {}
-    };
-  }
-};
-function readCreateInput(args) {
-  const cron = args["cron"];
-  const prompt = args["prompt"];
-  if (typeof cron !== "string" || cron.trim().length === 0) {
-    throw new Error("cron must be a non-empty string.");
-  }
-  if (typeof prompt !== "string" || prompt.trim().length === 0) {
-    throw new Error("prompt must be a non-empty string.");
-  }
-  const recurring = readRecurring(args["recurring"]);
-  return {
-    cron: cron.trim(),
-    prompt: prompt.trim(),
-    ...recurring !== void 0 ? { recurring } : {}
-  };
-}
-__name(readCreateInput, "readCreateInput");
-function readRecurring(value) {
-  if (typeof value === "boolean")
-    return value;
-  if (value === "false" || value === 0)
-    return false;
-  if (value === "true" || value === 1)
-    return true;
-  return void 0;
-}
-__name(readRecurring, "readRecurring");
-function readId(args) {
-  const id = args["id"];
-  if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error("id must be a non-empty string.");
-  }
-  return id.trim();
-}
-__name(readId, "readId");
-
-// packages/channels/base/dist/AcpBridge.js
 var MID_TURN_QUEUE_DRAIN_METHOD = "craft/drainMidTurnQueue";
+var TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD = "craft/claimTodoStopGuardContinuation";
 var ACP_EVENT_LOOP_STALL_RESTART_MS = 5 * 60 * 1e3;
 var ACP_PERMISSION_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
 var ACP_EVENT_LOOP_STALL_RE = /^\[perf\] acp agent event loop stall: max=(\d+(?:\.\d+)?)ms/m;
@@ -480,6 +479,8 @@ var AcpBridge = class extends EventEmitter {
   _availableCommands = [];
   channelLoopMcpServer;
   channelLoopToolHandlers = [];
+  knownSessionIds = /* @__PURE__ */ new Set();
+  sessionBindingTokens = /* @__PURE__ */ new Map();
   channelLoopMcpRegistered = false;
   channelLoopMcpRegistration = null;
   pendingPermissions = /* @__PURE__ */ new Map();
@@ -518,6 +519,8 @@ var AcpBridge = class extends EventEmitter {
       process.stderr.write(`[AcpBridge] Process exited (code=${code}, signal=${signal})
 `);
       this.resolvePendingPermissions();
+      this.knownSessionIds.clear();
+      this.sessionBindingTokens.clear();
       this.connection = null;
       this.child = null;
       this.emit("disconnected", code, signal);
@@ -556,13 +559,15 @@ var AcpBridge = class extends EventEmitter {
     });
     void this.registerChannelLoopMcpServer();
   }
-  async newSession(cwd) {
+  async newSession(cwd, _options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     const response = await conn.newSession({ cwd, mcpServers: [] });
+    this.knownSessionIds.add(response.sessionId);
+    this.sessionBindingTokens.set(response.sessionId, bindingToken);
     return response.sessionId;
   }
-  async loadSession(sessionId, cwd) {
+  async loadSession(sessionId, cwd, _options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     await conn.loadSession({
@@ -570,6 +575,8 @@ var AcpBridge = class extends EventEmitter {
       cwd,
       mcpServers: []
     });
+    this.knownSessionIds.add(sessionId);
+    this.sessionBindingTokens.set(sessionId, bindingToken);
     return sessionId;
   }
   async prompt(sessionId, text, options) {
@@ -622,6 +629,19 @@ var AcpBridge = class extends EventEmitter {
       this.resolvePendingPermissions(sessionId);
     }
   }
+  async discardSession(sessionId, expectedBindingToken) {
+    if (expectedBindingToken !== void 0 && this.sessionBindingTokens.get(sessionId) !== expectedBindingToken) {
+      return;
+    }
+    if (!this.knownSessionIds.delete(sessionId))
+      return;
+    this.sessionBindingTokens.delete(sessionId);
+    this.resolvePendingPermissions(sessionId);
+    const conn = this.connection;
+    if (!conn || !this.isConnected)
+      return;
+    await conn.extMethod("qwen/control/session/close", { sessionId });
+  }
   async respondToPermission(requestId, response) {
     const pending = this.pendingPermissions.get(requestId);
     if (!pending) {
@@ -638,6 +658,8 @@ var AcpBridge = class extends EventEmitter {
   }
   stop() {
     this.resolvePendingPermissions();
+    this.knownSessionIds.clear();
+    this.sessionBindingTokens.clear();
     if (this.child) {
       this.child.kill();
       this.child = null;
@@ -814,7 +836,14 @@ var AcpBridge = class extends EventEmitter {
       return this.handleClientMcpMessage(params);
     }
     if (method === MID_TURN_QUEUE_DRAIN_METHOD) {
-      return { messages: [] };
+      return { messages: [], hasQueuedPrompt: false };
+    }
+    if (method === TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD) {
+      const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : "";
+      return {
+        claimed: this.knownSessionIds.has(sessionId),
+        hasQueuedPrompt: false
+      };
     }
     throw new Error(`Method not found: ${method}`);
   }
@@ -948,6 +977,10 @@ var DaemonChannelBridge = class extends EventEmitter2 {
   activePromptControllers = /* @__PURE__ */ new Map();
   availableCommandsBySession = /* @__PURE__ */ new Map();
   turnBarriers = /* @__PURE__ */ new Map();
+  channelLoopToolHandlers = [];
+  registeredChannelLoopMcpSessions = /* @__PURE__ */ new Set();
+  channelLoopMcpRegistrations = /* @__PURE__ */ new Map();
+  channelLoopMcpServer;
   connected = false;
   lifecycleGeneration = 0;
   latestAvailableCommandsSessionId;
@@ -998,6 +1031,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       await this.rejectStaleSession(session);
     }
     this.attachSession(session, bindingToken);
+    await this.registerChannelLoopMcpForSession(session.sessionId);
     return session.sessionId;
   }
   async loadSession(sessionId, cwd, options, bindingToken) {
@@ -1019,8 +1053,22 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       throw new Error(`Daemon returned session ${session.sessionId} while loading ${sessionId}`);
     }
     this.attachSession(session, bindingToken);
+    await this.registerChannelLoopMcpForSession(session.sessionId);
     return session.sessionId;
   }
+  registerChannelLoopToolHandler(handler) {
+    if (!this.channelLoopToolHandlers.includes(handler)) {
+      this.channelLoopToolHandlers.push(handler);
+    }
+    this.channelLoopMcpServer ??= new ChannelLoopMcpServer({
+      create: /* @__PURE__ */ __name((sessionId, input) => this.resolveChannelLoopToolHandler(sessionId).create(sessionId, input), "create"),
+      list: /* @__PURE__ */ __name((sessionId) => this.resolveChannelLoopToolHandler(sessionId).list(sessionId), "list"),
+      cancel: /* @__PURE__ */ __name((sessionId, id) => this.resolveChannelLoopToolHandler(sessionId).cancel(sessionId, id), "cancel")
+    });
+    for (const sessionId of this.sessions.keys()) {
+      void this.registerChannelLoopMcpForSession(sessionId);
+    }
+  }
   async prompt(sessionId, text, options) {
     const session = this.ensureSession(sessionId);
     if (this.activePrompts.has(sessionId)) {
@@ -1177,7 +1225,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     return this.connected;
   }
   attachSession(session, bindingToken) {
-    const replacedSession = this.removeSessionBinding(session.sessionId);
+    const replacedSession = this.removeSessionBinding(session.sessionId, false);
     if (replacedSession) {
       void this.releaseSessionClient(replacedSession).catch((error) => {
         this.lastError = error;
@@ -1441,7 +1489,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
     }
     this.emit("sessionDied", { sessionId, reason });
   }
-  removeSessionBinding(sessionId) {
+  removeSessionBinding(sessionId, unregisterChannelLoopMcp = true) {
     const session = this.sessions.get(sessionId);
     if (!session)
       return void 0;
@@ -1466,8 +1514,51 @@ var DaemonChannelBridge = class extends EventEmitter2 {
         this.respondedRequestToSession.delete(requestId);
       }
     }
+    if (unregisterChannelLoopMcp) {
+      this.unregisterChannelLoopMcpForSession(sessionId);
+    }
     return session;
   }
+  async registerChannelLoopMcpForSession(sessionId) {
+    const host = this.options.channelLoopMcpHost;
+    const server = this.channelLoopMcpServer;
+    if (!host || !server || this.registeredChannelLoopMcpSessions.has(sessionId)) {
+      return;
+    }
+    const pending = this.channelLoopMcpRegistrations.get(sessionId);
+    if (pending) {
+      await pending;
+      return;
+    }
+    const registration = host.register(sessionId, (message) => server.handleMessage(message, { sessionId })).then(async () => {
+      if (this.sessions.has(sessionId)) {
+        this.registeredChannelLoopMcpSessions.add(sessionId);
+      } else {
+        await host.unregister(sessionId);
+      }
+    }).catch((error) => {
+      this.lastError = error;
+    }).finally(() => {
+      if (this.channelLoopMcpRegistrations.get(sessionId) === registration) {
+        this.channelLoopMcpRegistrations.delete(sessionId);
+      }
+    });
+    this.channelLoopMcpRegistrations.set(sessionId, registration);
+    await registration;
+  }
+  unregisterChannelLoopMcpForSession(sessionId) {
+    if (!this.registeredChannelLoopMcpSessions.delete(sessionId))
+      return;
+    void this.options.channelLoopMcpHost?.unregister(sessionId).catch((error) => {
+      this.lastError = error;
+    });
+  }
+  resolveChannelLoopToolHandler(sessionId) {
+    const handler = this.channelLoopToolHandlers.find((candidate) => candidate.canHandle?.(sessionId) === true || this.channelLoopToolHandlers.length === 1 && !candidate.canHandle);
+    if (handler)
+      return handler;
+    throw new Error(`No channel loop handler matched session ${sessionId}.`);
+  }
   getStringField(data, field, fallback) {
     return isRecord(data) && typeof data[field] === "string" ? data[field] : fallback;
   }
@@ -4288,6 +4379,7 @@ ${promptText}` : promptText;
         this.router.removeSessionId(sessionId);
         this.instructedSessions.delete(sessionId);
         this.unattendedMemorySessions.delete(sessionId);
+        this.discardRetiredSession(promptBridge, sessionId, `timed-out loop ${jobId}`);
         process.stderr.write(`[${this.name}] retired timed out loop ${jobId} session ${sessionId} after cancel did not settle
 `);
       }
@@ -4298,6 +4390,19 @@ ${promptText}` : promptText;
       clearTimeout(graceTimer);
     }
   }
+  discardRetiredSession(promptBridge, sessionId, reason) {
+    const safeSessionId = sanitizeLogText(sessionId, 64);
+    const safeReason = sanitizeLogText(reason, 128);
+    try {
+      void promptBridge.discardSession?.(sessionId).catch((err) => {
+        process.stderr.write(`[${this.name}] failed to discard ${safeReason} session ${safeSessionId}: ${this.lifecycleError(err)}
+`);
+      });
+    } catch (err) {
+      process.stderr.write(`[${this.name}] failed to discard ${safeReason} session ${safeSessionId}: ${this.lifecycleError(err)}
+`);
+    }
+  }
   requestActivePromptCancellation(sessionId, reason = "cancel_command") {
     const active = this.activePrompts.get(sessionId);
     if (!active) {
@@ -4702,6 +4807,7 @@ ${requestList}`);
           } else {
             this.sessionGenerations.delete(id);
           }
+          this.discardRetiredSession(this.bridge, id, "cleared");
         }
         await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Session cleared. The next message starts a fresh conversation.");
       } else {
@@ -6665,6 +6771,7 @@ var PollingChannelBase = class extends ChannelBase {
 export {
   resolvePath,
   getGlobalQwenDir,
+  CHANNEL_LOOP_MCP_SERVER_NAME,
   sanitizeSenderName,
   sanitizePromptText,
   sanitizeLogText,

package/chunks/{chunk-BOWYL27T.js → chunk-7XATOOE7.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-ATIV6G7N.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-HAZMIZP7.js → chunk-A2APC6HM.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-WZOPR2ZP.js";
+} from "./chunk-R7ZITH3J.js";
 import {
   detectRuntime,
   redactProxyCredentials
-} from "./chunk-XM5V2A2E.js";
+} from "./chunk-WZRWHXFE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-ZYD3KZPB.js → chunk-A3NDJ5SB.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-BOWYL27T.js";
+} from "./chunk-7XATOOE7.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-ATIV6G7N.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IIJCNWAY.js → chunk-AL62VKMS.js}

@@ -15,7 +15,7 @@ import {
   MODIFIER_CTRL_BIT,
   MODIFIER_SHIFT_BIT,
   clipboardHasImage
-} from "./chunk-SEWRIH7H.js";
+} from "./chunk-M7OONWYU.js";
 import {
   noteInteraction
 } from "./chunk-KW7NOTN6.js";
@@ -25,17 +25,17 @@ import {
 import {
   use_stdin_default,
   use_stdout_default
-} from "./chunk-TXI4LPWT.js";
+} from "./chunk-UWMLWVCA.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-6PQHZ4YW.js";
+} from "./chunk-BWKCTLEJ.js";
 import {
   createDebugLogger
-} from "./chunk-ATIV6G7N.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-NZYXKNSZ.js → chunk-AOAYOH3R.js}

@@ -14,7 +14,7 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.21.0-nightly.20260727.c003e1718";
+  return "0.21.0-preview.0";
 }
 __name(getCliVersion, "getCliVersion");
 

package/chunks/{chunk-C6U6ZR65.js → chunk-ATZOB5Y2.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-OWAK7LMW.js";
 import {
   resolveBundleDir
-} from "./chunk-G3RJEBAA.js";
+} from "./chunk-HUK2P4RS.js";
 import {
   Storage
-} from "./chunk-ATIV6G7N.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -272,15 +272,15 @@ var MUST_TRANSLATE_KEYS = [
 
 // import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
 var globImport_locales_js = __glob({
-  "./locales/ca.js": () => import("./ca-UBSN3YSM.js"),
-  "./locales/de.js": () => import("./de-LVJPZWUT.js"),
-  "./locales/en.js": () => import("./en-7JEDYSBE.js"),
-  "./locales/fr.js": () => import("./fr-JXF5ONTD.js"),
-  "./locales/ja.js": () => import("./ja-72VBFAM5.js"),
-  "./locales/pt.js": () => import("./pt-E4AMXNUG.js"),
-  "./locales/ru.js": () => import("./ru-OJOR34RM.js"),
-  "./locales/zh-TW.js": () => import("./zh-TW-JO4Z7CVC.js"),
-  "./locales/zh.js": () => import("./zh-2MA5UKNJ.js")
+  "./locales/ca.js": () => import("./ca-6W3SK7OQ.js"),
+  "./locales/de.js": () => import("./de-SY6O76BF.js"),
+  "./locales/en.js": () => import("./en-NBK3JKCE.js"),
+  "./locales/fr.js": () => import("./fr-4KG5V7UT.js"),
+  "./locales/ja.js": () => import("./ja-F3GSQXMF.js"),
+  "./locales/pt.js": () => import("./pt-EQ33KWEN.js"),
+  "./locales/ru.js": () => import("./ru-7OZAUKGG.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-JYCP7XUA.js"),
+  "./locales/zh.js": () => import("./zh-H3YDK5QW.js")
 });
 
 // packages/cli/src/i18n/index.ts