@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260718.767a32484

package/chunks/{chunk-URU5UEK6.js → chunk-XA7OKDWM.js}

@@ -2,33 +2,37 @@
 "use strict";
 import {
   CHANNEL_DAEMON_WORKER_SENTINEL,
+  CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
   CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
+  ChannelWebhookEnqueueError,
+  MAX_CHANNEL_STARTUP_FAILURES,
+  MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
+  MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,
+  MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH,
   QWEN_DAEMON_TOKEN_ENV,
   QWEN_DAEMON_URL_ENV,
   QWEN_DAEMON_WORKSPACE_ENV,
-  QWEN_SERVER_TOKEN_ENV
-} from "./chunk-GYTKQYDB.js";
+  QWEN_SERVER_TOKEN_ENV,
+  createChannelWebhookTaskMessage,
+  createWorkerDiagnosticRedactor,
+  isChannelStartupReportMessage,
+  isChannelStartupReportType,
+  isChannelWebhookEnqueueErrorCode,
+  isChannelWebhookTaskResultMessage,
+  normalizeWorkerDiagnostic,
+  sanitizeWorkerDiagnostic
+} from "./chunk-JDIUK2Y3.js";
 import {
   channelSelectionNames
 } from "./chunk-TJTKSVIV.js";
-import {
-  redactLogCredentials
-} from "./chunk-M5GB774H.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
   CHANNEL_WORKER_STOP_GRACE_MS
 } from "./chunk-5HBA2Z7V.js";
-import {
-  CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
-  ChannelWebhookEnqueueError,
-  createChannelWebhookTaskMessage,
-  isChannelWebhookEnqueueErrorCode,
-  isChannelWebhookTaskResultMessage
-} from "./chunk-OJAMDVF5.js";
 import {
   sanitizeLogText
-} from "./chunk-SXU3KKNI.js";
+} from "./chunk-ATJ7H5AS.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -44,12 +48,6 @@ var DEFAULT_CHANNEL_WORKER_HEARTBEAT_TIMEOUT_MS = 45e3;
 var MAX_WORKER_LOG_LINE_LENGTH = 4096;
 var MAX_WORKER_LOG_BUFFER_LENGTH = 64 * 1024;
 var MAX_WORKER_LOG_DISCARDED_REMAINDER_LENGTH = MAX_WORKER_LOG_BUFFER_LENGTH;
-var ANSI_CSI_SEQUENCE_RE = new RegExp(
-  `${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`,
-  "g"
-);
-var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
-var WORKER_LOG_CONTROL_RE = /[\x00-\x08\x0a-\x1f\x7f]/g;
 var ChannelWorkerStopError = class extends Error {
   static {
     __name(this, "ChannelWorkerStopError");
@@ -59,6 +57,22 @@ var ChannelWorkerStopError = class extends Error {
     this.name = "ChannelWorkerStopError";
   }
 };
+var ChannelWorkerStartupError = class extends Error {
+  static {
+    __name(this, "ChannelWorkerStartupError");
+  }
+  startupFailures;
+  startupFailuresTruncated;
+  constructor(message, details) {
+    super(message);
+    this.name = "ChannelWorkerStartupError";
+    this.startupFailures = details.startupFailures.map((failure) => ({
+      ...failure,
+      workspaceCwd: details.workspaceCwd
+    }));
+    this.startupFailuresTruncated = details.startupFailuresTruncated === true;
+  }
+};
 var DEFAULT_RESTART_POLICY = {
   maxRestarts: 3,
   windowMs: 5 * 6e4,
@@ -101,9 +115,7 @@ function workerLogRedactionOptions(daemonToken, workerEnv) {
 }
 __name(workerLogRedactionOptions, "workerLogRedactionOptions");
 function sanitizeWorkerError(error, redaction) {
-  const normalized = normalizeWorkerLogLineForRedaction(error);
-  const redacted = redaction ? redactWorkerLogLine(normalized, redaction) : normalized;
-  return Array.from(sanitizeLogText(redacted, 512)).slice(0, 512).join("");
+  return redaction ? sanitizeWorkerDiagnostic(error, 512, redaction) : sanitizeLogText(normalizeWorkerDiagnostic(error), 512);
 }
 __name(sanitizeWorkerError, "sanitizeWorkerError");
 function notifyExit(onExit, snapshot) {
@@ -162,58 +174,20 @@ function createWorkerEnv(opts) {
   return env;
 }
 __name(createWorkerEnv, "createWorkerEnv");
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-__name(escapeRegExp, "escapeRegExp");
-function sensitiveEnvValues(env) {
-  const sensitiveKey = /(^|_)(TOKEN|SECRET|API_KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL|PASSWORD|PASSWD|PASSPHRASE|BASIC_AUTH|AUTH_TOKEN|AUTHORIZATION|SESSION_SECRET|SESSION_TOKEN|SESSION_KEY|SESSION_COOKIE|DSN|CONNECTION_STRING)($|_)/i;
-  return Object.entries(env).filter(([key, value]) => sensitiveKey.test(key) && value !== void 0).flatMap(([, value]) => {
-    const lines = value.split("\n").filter((l) => l.length >= 4);
-    return lines.length > 0 ? [value, ...lines] : [value];
-  }).filter((value) => value.length >= 4);
-}
-__name(sensitiveEnvValues, "sensitiveEnvValues");
-function redactWorkerLogLine(line, opts) {
-  return createWorkerLogRedactor(opts)(line);
-}
-__name(redactWorkerLogLine, "redactWorkerLogLine");
-function createWorkerLogRedactor(opts) {
-  const secretPatterns = [
-    .../* @__PURE__ */ new Set([
-      ...opts.daemonToken && opts.daemonToken.length >= 4 ? [opts.daemonToken] : [],
-      ...sensitiveEnvValues(opts.workerEnv)
-    ])
-  ].sort((a, b) => b.length - a.length).map((secret) => new RegExp(escapeRegExp(secret), "g"));
-  return (line) => {
-    let redacted = line.replace(
-      /\b([a-z][a-z0-9+.-]{0,31}:\/\/)([^\s/]*@)([^\s/]+)([^\s]*)/gi,
-      "$1<redacted>@$3$4"
-    );
-    for (const secretPattern of secretPatterns) {
-      redacted = redacted.replace(secretPattern, "<redacted>");
-    }
-    return redactLogCredentials(redacted);
-  };
-}
-__name(createWorkerLogRedactor, "createWorkerLogRedactor");
-function normalizeWorkerLogLineForRedaction(line) {
-  return line.replace(ANSI_CSI_SEQUENCE_RE, "").replace(WORKER_LOG_INVISIBLE_RE, "").replace(WORKER_LOG_CONTROL_RE, "");
-}
-__name(normalizeWorkerLogLineForRedaction, "normalizeWorkerLogLineForRedaction");
 function attachWorkerLogStream(stream, streamName, opts) {
   if (!stream) return () => {
   };
   let buffer = "";
   let discardingOversizedLineRemainder = false;
   let discardedOversizedLineRemainderLength = 0;
-  const redactWorkerLogLineForStream = createWorkerLogRedactor({
+  const redactWorkerLogLineForStream = createWorkerDiagnosticRedactor({
     ...opts.daemonToken ? { daemonToken: opts.daemonToken } : {},
     workerEnv: opts.workerEnv
   });
   const flushLine = /* @__PURE__ */ __name((line) => {
+    const displayLine = line.replace(/\t/gu, " ");
     const redacted = redactWorkerLogLineForStream(
-      normalizeWorkerLogLineForRedaction(line)
+      normalizeWorkerDiagnostic(displayLine)
     );
     notifyLog(opts.onLog, {
       stream: streamName,
@@ -294,7 +268,12 @@ function createChannelWorkerSupervisor(opts) {
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
     ...snapshot,
     channels: [...snapshot.channels],
-    ...snapshot.requestedChannels ? { requestedChannels: [...snapshot.requestedChannels] } : {}
+    ...snapshot.requestedChannels ? { requestedChannels: [...snapshot.requestedChannels] } : {},
+    ...snapshot.startupFailures ? {
+      startupFailures: snapshot.startupFailures.map((failure) => ({
+        ...failure
+      }))
+    } : {}
   }), "snapshotCopy");
   const clearRestartTimer = /* @__PURE__ */ __name(() => {
     if (restartTimer) {
@@ -557,6 +536,89 @@ function createChannelWorkerSupervisor(opts) {
           resolve();
         }
       }, "failBeforeReady");
+      const startupError = /* @__PURE__ */ __name((message) => {
+        const failures = snapshot.startupFailures;
+        return failures && failures.length > 0 ? new ChannelWorkerStartupError(message, {
+          workspaceCwd: opts.workspace,
+          startupFailures: failures,
+          ...snapshot.startupFailuresTruncated ? { startupFailuresTruncated: true } : {}
+        }) : new Error(message);
+      }, "startupError");
+      const failStartupProtocol = /* @__PURE__ */ __name((detail) => {
+        if (settled || ready || child !== startedChild) return;
+        const error = sanitizeWorkerError(
+          `Channel worker startup IPC protocol error: ${detail}`,
+          redaction
+        );
+        snapshot = { ...snapshot, state: "failed", error };
+        failBeforeReady(startupError(error));
+        terminateBeforeReady();
+      }, "failStartupProtocol");
+      const acknowledgeStartupReport = /* @__PURE__ */ __name(() => {
+        const send = startedChild.send;
+        if (!send) {
+          failStartupProtocol("acknowledgement is unavailable.");
+          return;
+        }
+        try {
+          send.call(
+            startedChild,
+            { type: "channel_startup_report_ack" },
+            (err) => {
+              if (err) {
+                failStartupProtocol("acknowledgement failed.");
+              }
+            }
+          );
+        } catch {
+          failStartupProtocol("acknowledgement failed.");
+        }
+      }, "acknowledgeStartupReport");
+      const handleStartupReport = /* @__PURE__ */ __name((message) => {
+        if (!isChannelStartupReportMessage(message)) {
+          failStartupProtocol("invalid startup report.");
+          return;
+        }
+        if (message.type === "channel_startup_failures_truncated") {
+          if (snapshot.startupFailuresTruncated || snapshot.startupFailures?.length !== MAX_CHANNEL_STARTUP_FAILURES) {
+            failStartupProtocol("invalid truncation marker.");
+            return;
+          }
+          snapshot = { ...snapshot, startupFailuresTruncated: true };
+          acknowledgeStartupReport();
+          return;
+        }
+        if (snapshot.startupFailuresTruncated || (snapshot.startupFailures?.length ?? 0) >= MAX_CHANNEL_STARTUP_FAILURES) {
+          failStartupProtocol("too many startup failures.");
+          return;
+        }
+        const safeChannel = sanitizeWorkerDiagnostic(
+          message.failure.channel,
+          MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
+          redaction
+        ) || "<unnamed>";
+        const safeMessage = sanitizeWorkerDiagnostic(
+          message.failure.message,
+          MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH,
+          redaction
+        ) || "Channel connection failed.";
+        const safeCode = message.failure.code ? sanitizeWorkerDiagnostic(
+          message.failure.code,
+          MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,
+          redaction
+        ) : void 0;
+        const failure = {
+          channel: safeChannel,
+          phase: "connect",
+          ...safeCode ? { code: safeCode } : {},
+          message: safeMessage
+        };
+        snapshot = {
+          ...snapshot,
+          startupFailures: [...snapshot.startupFailures ?? [], failure]
+        };
+        acknowledgeStartupReport();
+      }, "handleStartupReport");
       const completeReady = /* @__PURE__ */ __name((message) => {
         if (settled || child !== startedChild) return;
         settled = true;
@@ -597,7 +659,9 @@ function createChannelWorkerSupervisor(opts) {
         if (settleWebhookTask(message)) {
           return;
         }
-        if (!ready && isReadyMessage(message)) {
+        if (!ready && isChannelStartupReportType(message)) {
+          handleStartupReport(message);
+        } else if (!ready && isReadyMessage(message)) {
           completeReady(message);
         } else if (isHeartbeatMessage(message)) {
           handleHeartbeat(message);
@@ -626,7 +690,7 @@ function createChannelWorkerSupervisor(opts) {
           notifyExit(opts.onExit, snapshotCopy());
         }
         if (!settled) {
-          failBeforeReady(new Error(snapshot.error ?? message));
+          failBeforeReady(startupError(snapshot.error ?? message));
         }
       }
       __name(settleExit, "settleExit");
@@ -647,7 +711,9 @@ function createChannelWorkerSupervisor(opts) {
         };
         terminateBeforeReady();
         if (!settled) {
-          failBeforeReady(new Error(snapshot.error));
+          failBeforeReady(
+            startupError(snapshot.error ?? "Channel worker failed to start.")
+          );
         }
       }
       __name(settleError, "settleError");
@@ -659,7 +725,7 @@ function createChannelWorkerSupervisor(opts) {
           state: "failed",
           error: sanitizeWorkerError(error, redaction)
         };
-        failBeforeReady(new Error(error));
+        failBeforeReady(startupError(error));
         if (child === startedChild) {
           terminateBeforeReady();
         }
@@ -817,5 +883,6 @@ __name(createChannelWorkerSupervisor, "createChannelWorkerSupervisor");
 
 export {
   ChannelWorkerStopError,
+  ChannelWorkerStartupError,
   createChannelWorkerSupervisor
 };

package/chunks/{chunk-Q6TUALBE.js → chunk-XAAEDML2.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-RKUWKYED.js";
 import {
   createDebugLogger
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-KKRTYONM.js → chunk-XSPFQQRE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getTasksDir
-} from "./chunk-TV6K2FB4.js";
+} from "./chunk-4RPARQ5D.js";
 import {
   require_proper_lockfile
 } from "./chunk-E2UVIFI2.js";
@@ -11,11 +11,11 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   atomicWriteJSON
-} from "./chunk-WIEO4CWB.js";
+} from "./chunk-VAJS2E2D.js";
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-OATTJGPJ.js → chunk-Y72B36CP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-ZRKBI3DP.js";
+} from "./chunk-FZRES4GK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,12 +21,12 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-JZE7F6YR.js") },
-        { name: "weixin", promise: import("./dist-PHEPJLXD.js") },
-        { name: "dingtalk", promise: import("./dist-HNN7DR2L.js") },
-        { name: "wecom", promise: import("./dist-ERCPDVA6.js") },
-        { name: "feishu", promise: import("./dist-MOEC47TR.js") },
-        { name: "qqbot", promise: import("./dist-3V3ZV6ML.js") }
+        { name: "telegram", promise: import("./dist-LQHDHBPP.js") },
+        { name: "weixin", promise: import("./dist-KEZ5JWH4.js") },
+        { name: "dingtalk", promise: import("./dist-G6QCGO2K.js") },
+        { name: "wecom", promise: import("./dist-ILVRL322.js") },
+        { name: "feishu", promise: import("./dist-SVHAGOLN.js") },
+        { name: "qqbot", promise: import("./dist-4W3UGU2A.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {

package/chunks/{chunk-ZPAHLFZU.js → chunk-Z2LBNX3R.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   isTlsVerificationDisabled
-} from "./chunk-LQIDP6K5.js";
+} from "./chunk-4CHDYDG3.js";
 import {
   getErrorMessage,
   isNodeError
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XXJKGHZV.js → chunk-ZTSDZQZO.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   getEffectiveSupportedModes
-} from "./chunk-DK33QJ3V.js";
+} from "./chunk-CZSAIBUB.js";
 import {
   require_jsx_runtime
-} from "./chunk-K4PZ5F5T.js";
+} from "./chunk-TVYM3Q3J.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
 import {
   getCachedStringWidth
-} from "./chunk-WTSXKLG5.js";
+} from "./chunk-SUARMD4Q.js";
 import {
   uiTelemetryService
-} from "./chunk-P6LART6G.js";
+} from "./chunk-66IT3EY2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -555,6 +555,129 @@ function fitPendingSlice(allLines, contentWidth, budget, tableClampRows) {
 }
 __name(fitPendingSlice, "fitPendingSlice");
 
+// packages/cli/src/ui/utils/markdownUtilities.ts
+init_esbuild_shims();
+var findNextFence = /* @__PURE__ */ __name((content, from) => {
+  const backtick = content.indexOf("```", from);
+  const tilde = content.indexOf("~~~", from);
+  if (backtick === -1 && tilde === -1) return null;
+  let index;
+  let char;
+  if (tilde === -1 || backtick !== -1 && backtick < tilde) {
+    index = backtick;
+    char = "`";
+  } else {
+    index = tilde;
+    char = "~";
+  }
+  let length = 0;
+  while (content[index + length] === char) length++;
+  return { index, char, length };
+}, "findNextFence");
+var getEnclosingFence = /* @__PURE__ */ __name((content, indexToTest) => {
+  let open = null;
+  let searchPos = 0;
+  while (searchPos < content.length) {
+    const fence = findNextFence(content, searchPos);
+    if (!fence || fence.index >= indexToTest) break;
+    if (!open) {
+      open = { char: fence.char, len: fence.length, index: fence.index };
+    } else if (fence.char === open.char && fence.length >= open.len) {
+      open = null;
+    }
+    searchPos = fence.index + fence.length;
+  }
+  if (!open) return null;
+  const newlineIndex = content.indexOf("\n", open.index);
+  const fenceLineEnd = newlineIndex === -1 ? content.length : newlineIndex;
+  return {
+    startIndex: open.index,
+    delimiter: content.slice(open.index, open.index + open.len),
+    infoString: content.slice(open.index + open.len, fenceLineEnd)
+  };
+}, "getEnclosingFence");
+var isIndexInsideCodeBlock = /* @__PURE__ */ __name((content, index) => getEnclosingFence(content, index) !== null, "isIndexInsideCodeBlock");
+var findEnclosingCodeBlockStart = /* @__PURE__ */ __name((content, index) => getEnclosingFence(content, index)?.startIndex ?? -1, "findEnclosingCodeBlockStart");
+var getEnclosingFenceInfo = /* @__PURE__ */ __name((content, index) => {
+  const fence = getEnclosingFence(content, index);
+  return fence ? parseCodeFenceInfo(fence.infoString) : null;
+}, "getEnclosingFenceInfo");
+var findLastSafeSplitPoint = /* @__PURE__ */ __name((content, idealMaxLength) => {
+  const hasLengthCap = idealMaxLength !== void 0;
+  const searchEnd = hasLengthCap ? Math.min(Math.max(idealMaxLength, 0), content.length) : content.length;
+  if (hasLengthCap && content.length <= searchEnd) {
+    return content.length;
+  }
+  const enclosingBlockStart = findEnclosingCodeBlockStart(content, searchEnd);
+  if (enclosingBlockStart !== -1) {
+    return hasLengthCap && enclosingBlockStart === 0 ? searchEnd : enclosingBlockStart;
+  }
+  let searchStartIndex = searchEnd;
+  while (searchStartIndex >= 0) {
+    const dnlIndex = content.lastIndexOf("\n\n", searchStartIndex);
+    if (dnlIndex === -1) {
+      break;
+    }
+    const potentialSplitPoint = dnlIndex + 2;
+    if (potentialSplitPoint <= searchEnd && !isIndexInsideCodeBlock(content, potentialSplitPoint)) {
+      return potentialSplitPoint;
+    }
+    searchStartIndex = dnlIndex - 1;
+  }
+  if (hasLengthCap) {
+    searchStartIndex = searchEnd;
+    while (searchStartIndex >= 0) {
+      const nlIndex = content.lastIndexOf("\n", searchStartIndex);
+      if (nlIndex === -1) {
+        break;
+      }
+      const potentialSplitPoint = nlIndex + 1;
+      if (potentialSplitPoint <= searchEnd && !isIndexInsideCodeBlock(content, potentialSplitPoint)) {
+        return potentialSplitPoint;
+      }
+      searchStartIndex = nlIndex - 1;
+    }
+  }
+  return hasLengthCap ? searchEnd : content.length;
+}, "findLastSafeSplitPoint");
+var START_LINE_DIRECTIVE_RE = /\s*\bqwen-code:start-line=(\d+)\b/;
+var parseCodeFenceInfo = /* @__PURE__ */ __name((info) => {
+  const raw = info ?? "";
+  const directive = raw.match(START_LINE_DIRECTIVE_RE);
+  const startLine = directive ? Math.max(1, Number(directive[1])) : 1;
+  const lang = raw.replace(START_LINE_DIRECTIVE_RE, "").trim().split(/\s+/)[0];
+  return { lang: lang || null, startLine };
+}, "parseCodeFenceInfo");
+var countHeadContentLines = /* @__PURE__ */ __name((content, fenceStartIndex, splitPoint) => {
+  const headFromFence = content.slice(fenceStartIndex, splitPoint);
+  const newlineCount = (headFromFence.match(/\n/g) || []).length;
+  return headFromFence.endsWith("\n") ? newlineCount - 1 : newlineCount;
+}, "countHeadContentLines");
+var splitFencedMarkdown = /* @__PURE__ */ __name((content, splitPoint) => {
+  const before = content.slice(0, splitPoint);
+  const after = content.slice(splitPoint);
+  if (splitPoint <= 0 || splitPoint >= content.length) {
+    return { before, after };
+  }
+  const fence = getEnclosingFence(content, splitPoint);
+  if (!fence) {
+    return { before, after };
+  }
+  const closingFence = fence.delimiter;
+  const { startLine: headStart } = parseCodeFenceInfo(fence.infoString);
+  const tailStart = headStart + countHeadContentLines(content, fence.startIndex, splitPoint);
+  const baseInfo = fence.infoString.replace(START_LINE_DIRECTIVE_RE, "").replace(/\s+$/, "");
+  const directive = `qwen-code:start-line=${tailStart}`;
+  const reopeningFence = `${fence.delimiter}${baseInfo ? `${baseInfo} ${directive}` : directive}`;
+  const beforeWithClose = before.endsWith("\n") ? `${before}${closingFence}
+` : `${before}
+${closingFence}
+`;
+  const afterWithReopen = `${reopeningFence}
+${after}`;
+  return { before: beforeWithClose, after: afterWithReopen };
+}, "splitFencedMarkdown");
+
 export {
   TABLE_MAX_ROW_LINES,
   TABLE_ROW_RE,
@@ -562,6 +685,10 @@ export {
   CODE_FENCE_RE,
   splitMarkdownTableRow,
   fitPendingSlice,
+  getEnclosingFenceInfo,
+  findLastSafeSplitPoint,
+  parseCodeFenceInfo,
+  splitFencedMarkdown,
   SessionStatsProvider,
   useSessionStats,
   getCommandSourceBadge,

package/chunks/{computer-use-IYTX45WA.js → computer-use-UIFBH25Y.js}

@@ -4,56 +4,56 @@ import {
   Client,
   So,
   StdioClientTransport
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-3YJZ6WNY.js";
+import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5M6IDOMF.js";
-import "./chunk-E67NFMF4.js";
-import "./chunk-RCEEXIOO.js";
-import "./chunk-KKRTYONM.js";
-import "./chunk-TV6K2FB4.js";
+import "./chunk-LKR7QQ63.js";
+import "./chunk-4XCVGEEX.js";
+import "./chunk-XSPFQQRE.js";
+import "./chunk-4RPARQ5D.js";
 import "./chunk-E2UVIFI2.js";
-import "./chunk-6OATMEYN.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-SPJQO2CE.js";
+import "./chunk-J2MKYJKZ.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-TXY2C3D2.js";
+import "./chunk-VNN3JNYT.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-2Z5UX4KI.js";
-import "./chunk-ARKANCNX.js";
-import "./chunk-L5U3ELZX.js";
-import "./chunk-TYLOFD2U.js";
+import "./chunk-OSSDHJDU.js";
+import "./chunk-SGPFJMRP.js";
+import "./chunk-335ECZTA.js";
+import "./chunk-JCJPZMJV.js";
 import {
   safeJsonStringify
-} from "./chunk-P6LART6G.js";
+} from "./chunk-66IT3EY2.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
-import "./chunk-CARU2RR2.js";
+import "./chunk-U2LNTX56.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-FBU7WRZI.js";
-import "./chunk-Y66VOBRP.js";
-import "./chunk-WX6SD4IQ.js";
+import "./chunk-FUTHTZVV.js";
+import "./chunk-4CA4WUMS.js";
+import "./chunk-WEPXQKGP.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation
-} from "./chunk-2UUAIFQO.js";
-import "./chunk-OKAIGAYW.js";
-import "./chunk-ZPAHLFZU.js";
+} from "./chunk-ANRANWVE.js";
+import "./chunk-G274ETR6.js";
+import "./chunk-Z2LBNX3R.js";
 import "./chunk-JESCGQM3.js";
-import "./chunk-WIEO4CWB.js";
+import "./chunk-VAJS2E2D.js";
 import "./chunk-XVNQMZ2I.js";
-import "./chunk-B7NUUEXC.js";
-import "./chunk-TQBODCFD.js";
+import "./chunk-FEOZBUMT.js";
+import "./chunk-CMVFTMRD.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
-import "./chunk-4LD5APFL.js";
+import "./chunk-TYQMGACW.js";
 import "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-LQIDP6K5.js";
-import "./chunk-7NFB7LBQ.js";
+import "./chunk-4CHDYDG3.js";
+import "./chunk-UE5TZ55T.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";

package/chunks/{config-utils-CFT33LTP.js → config-utils-2LHI7JXU.js}

@@ -5,12 +5,12 @@ import {
   parseChannelWebhookConfig,
   parseChannelWebhookConfigLenient,
   resolveEnvVars
-} from "./chunk-OATTJGPJ.js";
-import "./chunk-ZRKBI3DP.js";
+} from "./chunk-Y72B36CP.js";
+import "./chunk-FZRES4GK.js";
 import {
   findCliEntryPath
 } from "./chunk-V6WHFGST.js";
-import "./chunk-SXU3KKNI.js";
+import "./chunk-ATJ7H5AS.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";