nolo-cli 0.33.0-alpha.3 → 0.33.0-alpha.31

package/{chunk-AAGCMVFT.js → chunk-S6QP3AK4.js}

@@ -1,3 +1,6 @@
+import {
+  resolveMachineId
+} from "./chunk-ESHYE7WU.js";
 import {
   buildLocalRunEnv,
   isFullstackCodingAgentRef,
@@ -6,25 +9,26 @@ import {
   resolveRawAgentInput,
   resolveServerUrl,
   writeUsage
-} from "./chunk-ZHYK3N56.js";
-import {
-  getReadableCliDb
-} from "./chunk-NUO3QFWD.js";
-import {
-  normalizeAgentHandle,
-  readDbRecord,
-  resolveAgentRecordFromHybridStore
-} from "./chunk-YDTYDA5W.js";
+} from "./chunk-G7HTVVFL.js";
 import {
   agentRunCardLabels,
   createCliLocalRuntimeAdapter,
   getCliLocale,
   isBuiltinNoloAgentRef,
   isSubtaskRun,
+  isTransientFetchError,
   parseAgentRunEvent,
   t,
   toolLabel
-} from "./chunk-O6GEBMIY.js";
+} from "./chunk-JE4J3T7A.js";
+import {
+  getReadableCliDb
+} from "./chunk-UNHKVD2N.js";
+import {
+  normalizeAgentHandle,
+  readDbRecord,
+  resolveAgentRecordFromHybridStore
+} from "./chunk-NBIS3WYT.js";
 import {
   NOLO_PROJECT_MANAGER_AGENT_KEY,
   isLocalCliAgentKey
@@ -34,37 +38,59 @@ import {
   buildModelLayerOverride
 } from "./chunk-LTRXGFMS.js";
 import {
-  resolveMachineId
-} from "./chunk-6HYVJV7B.js";
+  CliProviderQuotaError
+} from "./chunk-JDSUTNYY.js";
+import {
+  createRunActivityTracker,
+  finalizeRunRecord,
+  spawnLocalBackgroundRun
+} from "./chunk-7KNERA53.js";
 import {
   formatAgentListCard
-} from "./chunk-HDKRSRYU.js";
+} from "./chunk-7CH6ONWB.js";
 import {
   isGatewayHttpStatus
 } from "./chunk-RQSOAMPJ.js";
 import {
-  getDefaultCliLocalRuntimeDb
-} from "./chunk-Q5ITEGIN.js";
+  formatFinishedRunCard,
+  formatListRunsCard,
+  formatNotFoundRunCard,
+  formatStartRunCard,
+  formatStatusRunCard,
+  formatStopRunCard,
+  isAgentRunTerminalStatus,
+  runShowsLogTail
+} from "./chunk-KXKQO4Q6.js";
 import {
   buildMemorySubjectsForAgent,
   chooseMemoryOwners,
   loadMemoryCandidatesFromDb,
   resolveAgentMemoryPolicy
-} from "./chunk-6SXC35F4.js";
+} from "./chunk-AXCXE35O.js";
 import {
   API_REPORTED_COST_MULTIPLIER,
   normalizeUsage,
   parseUiAskChoiceContent
-} from "./chunk-73GINUCW.js";
+} from "./chunk-SQPMYIR5.js";
 import {
-  resolveAgentRuntimeConfigFromRecord
-} from "./chunk-OIQPORYI.js";
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-N4XRDM26.js";
+import {
+  buildSkillDiscoveryContextLayer
+} from "./chunk-FS5VNMPF.js";
+import {
+  parseExternalSkillMarkdown,
+  parseSkillDocProtocol
+} from "./chunk-AETZ7AD6.js";
 import {
   LOCAL_AGENT_CONFIG_MISSING_CODE,
   LOCAL_TURN_ABORTED_CODE,
   readActionGate,
   readCommandActionGatePayload
-} from "./chunk-6PO2SYCS.js";
+} from "./chunk-6PI2635O.js";
+import {
+  resolveAgentRuntimeConfigFromRecord
+} from "./chunk-GN6ENM54.js";
 import {
   createThinkParserState,
   flushThinkParser,
@@ -72,62 +98,33 @@ import {
 } from "./chunk-N7J63Q6C.js";
 import {
   resolvePlatformAuthToken
-} from "./chunk-AFV4FOT2.js";
+} from "./chunk-3GDKZAPT.js";
+import {
+  isQuotaExhaustedError
+} from "./chunk-QUK7UZW7.js";
 import {
   DEFAULT_CONTEXT_WINDOW,
   getModelContextWindow
-} from "./chunk-2H3XIBY4.js";
+} from "./chunk-FSOCQPX7.js";
 import {
   clipCompactText
-} from "./chunk-AOXVOC6D.js";
+} from "./chunk-W2DNU6FK.js";
 import {
   findModelConfig
-} from "./chunk-DFUPZE6V.js";
-import {
-  buildSkillDiscoveryContextLayer
-} from "./chunk-ZURFOV5J.js";
-import {
-  buildAgentsMdLayer,
-  buildMemoryOverlayLayer,
-  buildMemoryUseGuidanceLayer,
-  partitionScopedBlocks,
-  renderTurnContextBlocksWithScope
-} from "./chunk-2UECQ7RE.js";
-import {
-  parseExternalSkillMarkdown,
-  parseSkillDocProtocol
-} from "./chunk-AETZ7AD6.js";
+} from "./chunk-P35OZHD4.js";
 import {
   compactWhitespace
 } from "./chunk-DWLEOOGR.js";
-import {
-  createRunActivityTracker,
-  finalizeRunRecord,
-  spawnLocalBackgroundRun
-} from "./chunk-7KNERA53.js";
-import {
-  formatFinishedRunCard,
-  formatListRunsCard,
-  formatNotFoundRunCard,
-  formatStartRunCard,
-  formatStatusRunCard,
-  formatStopRunCard,
-  isAgentRunTerminalStatus,
-  runShowsLogTail
-} from "./chunk-KXKQO4Q6.js";
-import {
-  CliProviderQuotaError
-} from "./chunk-SAQQLJZ5.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
 import {
-  readPipeText,
-  spawnProcess
-} from "./chunk-IDZTNRP2.js";
-import {
-  resolveAuthToken
-} from "./chunk-A7GB5UGH.js";
+  buildAgentsMdLayer,
+  buildMemoryOverlayLayer,
+  buildMemoryUseGuidanceLayer,
+  partitionScopedBlocks,
+  renderTurnContextBlocksWithScope
+} from "./chunk-3AOLVADY.js";
 import {
   parsePositiveFiniteNumberOrFallback
 } from "./chunk-Y5GCAMGP.js";
@@ -141,13 +138,20 @@ import {
   BUILTIN_NOLO_AGENT_KEY,
   BUILTIN_NOLO_AGENT_NAME,
   builtinAgentCatalogEntryById
-} from "./chunk-UK5JGQVU.js";
+} from "./chunk-52DHSNJC.js";
+import {
+  parsePublicAgentId
+} from "./chunk-BJIRLHJR.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
-  parsePublicAgentId
-} from "./chunk-BJIRLHJR.js";
+  readPipeText,
+  spawnProcess
+} from "./chunk-IDZTNRP2.js";
+import {
+  resolveAuthToken
+} from "./chunk-A7GB5UGH.js";
 import {
   isLoopbackUrl
 } from "./chunk-4SN6J65J.js";
@@ -317,11 +321,243 @@ function dimCliText(text, enabled = resolveCliColorEnabled()) {
   return styleCliText(text, "dim", enabled);
 }
 
+// node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][^\\u0007\\u001B\\u009C]*${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint = 161;
+var ambiguousMaximumCodePoint = 1114109;
+var ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+var fullwidthMinimalCodePoint = 12288;
+var fullwidthMaximumCodePoint = 65510;
+var fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+var wideMinimalCodePoint = 4352;
+var wideMaximumCodePoint = 262141;
+var wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+
+// node_modules/get-east-asian-width/utilities.js
+var isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+// node_modules/get-east-asian-width/lookup.js
+var commonCjkCodePoint = 19968;
+var [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+var isFullWidth = (codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+var isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+
+// node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// node_modules/string-width/index.js
+var segmenter = new Intl.Segmenter();
+var zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Format}|\\p{Nonspacing_Mark}|\\p{Enclosing_Mark}|\\p{Surrogate})+$", "v");
+var leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]+", "v");
+var spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
+var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (zeroWidthClusterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
+      }
+      for (let remaining = index; remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+function stringWidth(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("\x9B"))) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string)) {
+    return string.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const visibleSegment = baseVisible(segment);
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== void 0) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+
 // packages/cli/tui/tuiAnsi.ts
 var ANSI_ESCAPE_REGEX = /\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g;
-var OSC_HYPERLINK_REGEX = /\x1b\]8;;[^\x07\x1b]*(?:\x07|\x1b\\)\x1b\]8;;(?:\x07|\x1b\\)|\x1b\]8;;[^\x07\x1b]*(?:\x07|\x1b\\)/g;
-function stripAnsi(text) {
-  return text.replace(OSC_HYPERLINK_REGEX, "").replace(ANSI_ESCAPE_REGEX, "");
+var ALL_ANSI_ESCAPE_REGEX = ansiRegex();
+var FIRST_ANSI_ESCAPE_REGEX = ansiRegex({ onlyFirst: true });
+function stripAnsi2(text) {
+  return text.replace(ANSI_ESCAPE_REGEX, "").replace(ALL_ANSI_ESCAPE_REGEX, "");
 }
 var SGR_SEQUENCE_REGEX = /^\x1b\[[0-9;]*m/;
 var TRAILING_SGR_REGEX = /(?:\x1b\[[0-9;]*m)+$/;
@@ -383,29 +619,19 @@ function applyTerminalOutputToText(existing, chunk) {
   return text;
 }
 function displayWidth(str) {
-  let width = 0;
-  for (const char of str) {
-    const code = char.codePointAt(0) ?? 0;
-    if (code < 32 || code === 127) continue;
-    if (code >= 4352 && code <= 4447 || // 0x2768-0x2775 (ornamental brackets, incl. the ❯ prompt at U+276F)
-    // render narrow in terminals; counting them wide drifts the cursor.
-    code >= 9728 && code <= 10175 && !(code >= 10088 && code <= 10101) || // 0x2B00-0x2BFF (Misc Symbols and Arrows, incl. ⬢ U+2B22 used as the
-    // status-line agent icon) render double-wide in common monospace fonts;
-    // counting ⬢ as width 1 drifts the whole status line right of the icon.
-    code >= 11008 && code <= 11263 || code >= 11904 && code <= 12350 || code >= 12352 && code <= 13247 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 127744 && code <= 129791 || code >= 131072 && code <= 196605 || code >= 196608 && code <= 262141 || // East Asian Ambiguous CJK quotation marks (U+201C/D “ ”, U+2018/9 ‘ ’).
-    // In CJK locale + CJK fonts these render double-wide like 全角 punctuation;
-    // in English fonts they stay width 1. Follow the active locale so Chinese
-    // replies align correctly without breaking English terminal output.
-    getCliLocale() === "zh" && (code === 8220 || code === 8221 || code === 8216 || code === 8217)) {
-      width += 2;
-    } else {
-      width += 1;
-    }
+  const plain = stripAnsi2(str);
+  let width = stringWidth(plain);
+  for (const { segment } of graphemeSegmenter.segment(plain)) {
+    if (stringWidth(segment) !== 1) continue;
+    const code = segment.codePointAt(0) ?? 0;
+    const forceWideSymbol = code >= 9728 && code <= 10175 && !(code >= 10088 && code <= 10101) || code >= 11008 && code <= 11263 || code >= 127744 && code <= 129791;
+    const cjkQuote = getCliLocale() === "zh" && (code === 8220 || code === 8221 || code === 8216 || code === 8217);
+    if (forceWideSymbol || cjkQuote) width += 1;
   }
   return width;
 }
 function visibleWidth(str) {
-  return displayWidth(stripAnsi(str));
+  return displayWidth(stripAnsi2(str));
 }
 function truncateAnsi(text, maxWidth) {
   if (maxWidth <= 0) return "";
@@ -473,6 +699,7 @@ function padOrTruncateToWidth(text, width) {
   return `${text}${" ".repeat(width - textWidth)}`;
 }
 var SGR_RESET_REGEX = /^\x1b\[0?m$/;
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 function tokenizeAnsiLine(line) {
   const tokens = [];
   let index = 0;
@@ -480,28 +707,125 @@ function tokenizeAnsiLine(line) {
     if (line[index] === "\x1B") {
       const osc = line.slice(index).match(/^\x1b\]8;;[^\x07\x1b]*(?:\x07|\x1b\\)/);
       if (osc) {
-        tokens.push({ kind: "sgr", value: osc[0], width: 0 });
+        tokens.push({ kind: "sgr", value: osc[0], width: 0, charIndex: index });
         index += osc[0].length;
         continue;
       }
       const sgr = SGR_SEQUENCE_REGEX.exec(line.slice(index));
       if (sgr) {
-        tokens.push({ kind: "sgr", value: sgr[0], width: 0 });
+        tokens.push({ kind: "sgr", value: sgr[0], width: 0, charIndex: index });
         index += sgr[0].length;
         continue;
       }
+      const csi = line.slice(index).match(/^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/);
+      if (csi) {
+        index += csi[0].length;
+        continue;
+      }
+      const escape = FIRST_ANSI_ESCAPE_REGEX.exec(line.slice(index));
+      if (escape?.index === 0) {
+        index += escape[0].length;
+        continue;
+      }
+      index += 1;
+      continue;
     }
-    const codePoint = line.codePointAt(index) ?? 0;
-    const value = String.fromCodePoint(codePoint);
-    tokens.push({ kind: "char", value, width: displayWidth(value) });
-    index += value.length;
+    let nextEsc = line.indexOf("\x1B", index);
+    if (nextEsc === -1) nextEsc = line.length;
+    const chunk = line.slice(index, nextEsc);
+    for (const item of graphemeSegmenter.segment(chunk)) {
+      tokens.push({
+        kind: "char",
+        value: item.segment,
+        width: displayWidth(item.segment),
+        charIndex: index + item.index
+      });
+    }
+    index = nextEsc;
   }
   return tokens;
 }
-function wrapTranscriptLine(line, columns, hangingIndent = "") {
-  if (line === "") return [""];
+function buildSourceMapping(rawLine, styledLine, prefixCharCount) {
+  let contentStart = 0;
+  const headingMatch = rawLine.match(/^(#{1,3})\s+(.+)$/);
+  let lineToParse = rawLine;
+  if (headingMatch) {
+    contentStart = headingMatch[1].length + 1;
+    while (contentStart < rawLine.length && rawLine[contentStart] === " ") contentStart++;
+    lineToParse = rawLine.slice(contentStart);
+  }
+  const INLINE_RE = /(\[([^\]]+)\]\(([^)\s]+)\)|`([^`]+)`|\*\*(.+?)\*\*|(?<!\*)\*([^*]+?)\*(?!\*)|~~([^~]+?)~~)/g;
+  const mapping = [];
+  let lastIdx = 0;
+  let match;
+  while ((match = INLINE_RE.exec(lineToParse)) !== null) {
+    const plainBefore = lineToParse.slice(lastIdx, match.index);
+    for (let c = 0; c < plainBefore.length; c++) {
+      mapping.push(contentStart + lastIdx + c);
+    }
+    const fullMatch = match[0];
+    if (match[2] !== void 0 && match[3] !== void 0) {
+      const linkText = match[2];
+      const linkUrl = match[3];
+      const textOffset = contentStart + match.index + 1;
+      for (let c = 0; c < linkText.length; c++) {
+        mapping.push(textOffset + c);
+      }
+      const parenOffset = textOffset + linkText.length;
+      mapping.push(parenOffset);
+      mapping.push(parenOffset + 1);
+      const urlOffset = parenOffset + 2;
+      for (let c = 0; c < linkUrl.length; c++) {
+        mapping.push(urlOffset + c);
+      }
+      mapping.push(urlOffset + linkUrl.length);
+    } else if (match[4] !== void 0) {
+      const codeText = match[4];
+      const codeOffset = contentStart + match.index + 1;
+      for (let c = 0; c < codeText.length; c++) {
+        mapping.push(codeOffset + c);
+      }
+    } else if (match[5] !== void 0) {
+      const boldText = match[5];
+      const boldOffset = contentStart + match.index + 2;
+      for (let c = 0; c < boldText.length; c++) {
+        mapping.push(boldOffset + c);
+      }
+    } else if (match[6] !== void 0) {
+      const italicText = match[6];
+      const italicOffset = contentStart + match.index + 1;
+      for (let c = 0; c < italicText.length; c++) {
+        mapping.push(italicOffset + c);
+      }
+    } else if (match[7] !== void 0) {
+      const strikeText = match[7];
+      const strikeOffset = contentStart + match.index + 2;
+      for (let c = 0; c < strikeText.length; c++) {
+        mapping.push(strikeOffset + c);
+      }
+    }
+    lastIdx = match.index + fullMatch.length;
+  }
+  const plainRest = lineToParse.slice(lastIdx);
+  for (let c = 0; c < plainRest.length; c++) {
+    mapping.push(contentStart + lastIdx + c);
+  }
+  return mapping;
+}
+function wrapTranscriptLineWithLayout(line, columns, hangingIndent = "", lineSourceStart = 0, prefixWidth = 0, prefixCharCount = 0, sourceMapping, rawLineLength) {
+  if (line === "") {
+    const rawLen = rawLineLength ?? 0;
+    return [
+      {
+        rendered: "",
+        sourceStart: lineSourceStart,
+        sourceEnd: lineSourceStart + rawLen,
+        prefixWidth
+      }
+    ];
+  }
   const tokens = tokenizeAnsiLine(line);
-  const result = [];
+  const rows = [];
   let activeStyles = [];
   const applyStyleToken = (value) => {
     if (SGR_RESET_REGEX.test(value)) {
@@ -513,10 +837,11 @@ function wrapTranscriptLine(line, columns, hangingIndent = "") {
   let start = 0;
   while (start < tokens.length) {
     if (tokens.slice(start).every((token) => token.kind === "sgr")) {
-      if (result.length > 0) break;
+      if (rows.length > 0) break;
     }
     const openingStyles = [...activeStyles];
-    const isContinuation = result.length > 0 && hangingIndent.length > 0;
+    const isContinuation = rows.length > 0;
+    const currentPrefixWidth = isContinuation ? visibleWidth(hangingIndent) : prefixWidth;
     const indentWidth = isContinuation ? visibleWidth(hangingIndent) : 0;
     const maxSegmentWidth = Math.max(1, columns - indentWidth);
     let width = 0;
@@ -531,7 +856,7 @@ function wrapTranscriptLine(line, columns, hangingIndent = "") {
       if (width + token.width > maxSegmentWidth && width > 0) break;
       width += token.width;
       end += 1;
-      if (token.value === " " || token.value === "	") {
+      if ((token.value === " " || token.value === "	") && token.charIndex >= prefixCharCount) {
         lastBreak = end;
       }
     }
@@ -556,21 +881,78 @@ function wrapTranscriptLine(line, columns, hangingIndent = "") {
     const prefix = openingStyles.join("");
     const needsReset = (sawStyle || activeStyles.length > 0) && !segment.endsWith("\x1B[0m");
     const lineContent = `${prefix}${segment}${needsReset ? "\x1B[0m" : ""}`;
-    result.push(isContinuation ? `${hangingIndent}${lineContent}` : lineContent);
+    const rowRendered = isContinuation && hangingIndent.length > 0 ? `${hangingIndent}${lineContent}` : lineContent;
+    let segSourceStart = lineSourceStart;
+    let segSourceEnd = lineSourceStart;
+    let foundFirst = false;
+    const rowMapping = [];
+    let plainCharIndex = 0;
+    for (let i = 0; i < start; i++) {
+      const tok = tokens[i];
+      if (tok.kind === "char" && tok.charIndex >= prefixCharCount) {
+        plainCharIndex += tok.value.length;
+      }
+    }
+    for (let i = start; i < segmentEnd; i++) {
+      const tok = tokens[i];
+      if (tok.kind === "char" && tok.charIndex >= prefixCharCount) {
+        const mappedOffset = sourceMapping && sourceMapping[plainCharIndex] !== void 0 ? sourceMapping[plainCharIndex] : plainCharIndex;
+        if (!foundFirst) {
+          segSourceStart = lineSourceStart + mappedOffset;
+          foundFirst = true;
+        }
+        for (let c = 0; c < tok.value.length; c++) {
+          const idx = plainCharIndex + c;
+          const mapped = sourceMapping && sourceMapping[idx] !== void 0 ? sourceMapping[idx] : idx;
+          rowMapping.push(lineSourceStart + mapped);
+        }
+        const lastCharIdx = plainCharIndex + tok.value.length - 1;
+        const mappedEndOffset = sourceMapping && sourceMapping[lastCharIdx] !== void 0 ? sourceMapping[lastCharIdx] + 1 : plainCharIndex + tok.value.length;
+        segSourceEnd = lineSourceStart + mappedEndOffset;
+        plainCharIndex += tok.value.length;
+      }
+    }
     start = segmentEnd;
+    let softWrapJoiner = "";
     while (start < tokens.length) {
       const token = tokens[start];
-      if (token.kind === "char" && token.value === " ") {
+      if (token.kind === "char" && token.value === " " && token.charIndex >= prefixCharCount) {
+        softWrapJoiner += token.value;
+        const mappedOffset = sourceMapping && sourceMapping[plainCharIndex] !== void 0 ? sourceMapping[plainCharIndex] + 1 : plainCharIndex + 1;
+        segSourceEnd = lineSourceStart + mappedOffset;
+        plainCharIndex += token.value.length;
         start += 1;
         continue;
       }
       break;
     }
+    if (start >= tokens.length && rawLineLength !== void 0) {
+      segSourceEnd = lineSourceStart + rawLineLength;
+    }
+    rows.push({
+      rendered: rowRendered,
+      sourceStart: segSourceStart,
+      sourceEnd: segSourceEnd,
+      prefixWidth: currentPrefixWidth,
+      sourceMapping: rowMapping.length > 0 ? rowMapping : void 0,
+      softWrapped: start < tokens.length,
+      softWrapJoiner
+    });
   }
-  return result.length > 0 ? result : [""];
+  return rows.length > 0 ? rows : [
+    {
+      rendered: "",
+      sourceStart: lineSourceStart,
+      sourceEnd: lineSourceStart + (rawLineLength ?? 0),
+      prefixWidth
+    }
+  ];
+}
+function wrapTranscriptLine(line, columns, hangingIndent = "") {
+  return wrapTranscriptLineWithLayout(line, columns, hangingIndent).map((r) => r.rendered);
 }
 function buildWindowTitle(title) {
-  const plain = stripAnsi(title).replace(/[\x00-\x1f\x7f]+/g, " ");
+  const plain = stripAnsi2(title).replace(/[\x00-\x1f\x7f]+/g, " ");
   let truncated = "";
   let width = 0;
   const maxCols = 80;
@@ -963,8 +1345,295 @@ function classifyDiffLine(line) {
   return "context";
 }
 
-// packages/cli/client/assistantOutput.ts
+// packages/cli/client/mermaid.ts
 var STYLE = {
+  reset: "\x1B[0m"
+};
+function maskLabelSpans(line, restores = []) {
+  const text = line.replace(
+    /("[^"\n]*"|\[[^\]\n]*\]|\{[^}\n]*\}|\([^()\n]*\)|\|[^|\n]*\|)/g,
+    (m) => {
+      const idx = restores.push(m) - 1;
+      return `\0M${idx}\0`;
+    }
+  );
+  return { text, restores };
+}
+function unmask(masked, restores) {
+  return masked.replace(/\x00M(\d+)\x00/g, (_, i) => restores[+i] ?? "");
+}
+function decodeShape(rest) {
+  let lm;
+  if (lm = rest.match(/^\[\s*"([^"]*)"\s*\]/)) return { shape: "rect", label: lm[1] };
+  if (lm = rest.match(/^\(\s*\(\s*"?([^"()]*)"?\s*\)\s*\)/)) return { shape: "stadium", label: lm[1] };
+  if (lm = rest.match(/^\(\s*\[\s*"?([^"()]*)"?\s*\]\s*\)/)) return { shape: "stadium", label: lm[1] };
+  if (lm = rest.match(/^\[\s*([^\[\]]+)\s*\]/)) return { shape: "rect", label: lm[1] };
+  if (lm = rest.match(/^\{\s*([^}]*)\s*\}/)) return { shape: "diamond", label: lm[1] };
+  if (lm = rest.match(/^\(\s*"?([^[\]()]*)"?\s*\)/)) return { shape: "rounded", label: lm[1] };
+  return null;
+}
+function parseNodeSeg(seg) {
+  const t2 = seg.trim();
+  if (!t2) return null;
+  const m = t2.match(/^([A-Za-z_][A-Za-z0-9_-]*)(.*)$/s);
+  if (!m) return null;
+  const id = m[1];
+  const rest = m[2].trim();
+  if (rest && decodeShape(rest) === null) return null;
+  const dec = decodeShape(rest);
+  return { id, shape: dec ? dec.shape : "rect", label: (dec ? dec.label : id).trim() || id };
+}
+function stripComment(line) {
+  const idx = line.indexOf("%%");
+  return (idx >= 0 ? line.slice(0, idx) : line).trim().replace(/[,;]\s*$/, "");
+}
+var DIAGRAM_HEADERS = /^\s*(graph|flowchart|subgraph|end)\b|^\s*(sequenceDiagram|sequence|gantt|classDiagram|stateDiagram|erDiagram|requirementDiagram|pie|journey|mindmap|sankey|timeline)\b/;
+function parseMermaid(source) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const skipped = [];
+  const parseStatement = (maskedStmt, restores) => {
+    const parts = maskedStmt.split(/-->/);
+    if (parts.length < 2) {
+      const parsed = parseNodeSeg(unmask(parts[0], restores).trim());
+      if (parsed) {
+        nodes.set(parsed.id, { id: parsed.id, label: parsed.label, shape: parsed.shape });
+        return true;
+      }
+      return false;
+    }
+    const lineNodes = /* @__PURE__ */ new Map();
+    const lineEdges = [];
+    let ok = true;
+    let fromPrev = null;
+    for (let i = 0; i < parts.length; i++) {
+      let seg = parts[i];
+      let label;
+      if (i > 0) {
+        const restored = unmask(seg, restores);
+        const pm = restored.match(/^\|\s*([^|]*)\s*\|([\s\S]*)$/);
+        if (pm) {
+          label = pm[1].trim() || void 0;
+          seg = pm[2];
+        }
+      }
+      const nodeText = unmask(seg, restores).trim();
+      const parsed = parseNodeSeg(nodeText);
+      if (!parsed) {
+        ok = false;
+        break;
+      }
+      const prev = lineNodes.get(parsed.id);
+      lineNodes.set(parsed.id, {
+        id: parsed.id,
+        label: parsed.label !== parsed.id && parsed.label ? parsed.label : prev?.label ?? parsed.label,
+        shape: parsed.shape !== "rect" ? parsed.shape : prev?.shape ?? parsed.shape
+      });
+      if (i > 0 && fromPrev !== null) lineEdges.push({ from: fromPrev, to: parsed.id, label });
+      fromPrev = parsed.id;
+    }
+    if (!ok) return false;
+    for (const [id, n] of lineNodes) {
+      const cur = nodes.get(id);
+      if (cur) {
+        if (n.label !== id) cur.label = n.label;
+        if (n.shape !== "rect") cur.shape = n.shape;
+      } else nodes.set(id, n);
+    }
+    for (const e of lineEdges) edges.push(e);
+    return true;
+  };
+  for (const raw of source.split("\n")) {
+    const line = stripComment(raw);
+    if (!line) continue;
+    if (DIAGRAM_HEADERS.test(line)) continue;
+    const restores = [];
+    const { text: masked1 } = maskLabelSpans(line, restores);
+    let norm = masked1.replace(/-{2,}>/g, "-->");
+    norm = norm.replace(/\.?-[.]?->/g, "-->");
+    norm = norm.replace(/={2,}>/g, "-->");
+    norm = norm.replace(/--\s*([^>]+?)\s*-->/g, "-->|$1|");
+    const { text: masked } = maskLabelSpans(norm, restores);
+    const stmts = masked.split(";").map((s) => s.trim()).filter(Boolean);
+    const results = stmts.map((s) => parseStatement(s, restores));
+    if (results.some((r) => !r)) {
+      skipped.push(raw.trim());
+    }
+  }
+  return { nodes, edges, skipped };
+}
+function assignLayers(flow) {
+  const layer = /* @__PURE__ */ new Map();
+  const adj = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  for (const id of flow.nodes.keys()) {
+    adj.set(id, []);
+    indeg.set(id, 0);
+  }
+  for (const e of flow.edges) {
+    adj.get(e.from)?.push(e.to);
+    indeg.set(e.to, (indeg.get(e.to) ?? 0) + 1);
+  }
+  const queue = [];
+  for (const [id, d] of indeg) {
+    if (d === 0) {
+      layer.set(id, 0);
+      queue.push(id);
+    }
+  }
+  let head = 0;
+  while (head < queue.length) {
+    const cur = queue[head++];
+    const l = layer.get(cur) ?? 0;
+    for (const next of adj.get(cur) ?? []) {
+      if ((layer.get(next) ?? 0) < l + 1) {
+        layer.set(next, l + 1);
+        queue.push(next);
+      }
+    }
+  }
+  if (queue.length === 0) {
+    for (const id of flow.nodes.keys()) if (!layer.has(id)) layer.set(id, 0);
+  }
+  return layer;
+}
+function wrapLabel(label, width) {
+  const clean = label.replace(/\s+/g, " ").trim();
+  if (!clean) return [""];
+  if (clean.length <= width) return [clean];
+  const words = clean.split(" ");
+  const lines = [];
+  let cur = "";
+  for (const w of words) {
+    if ((cur + " " + w).trim().length > width && cur) {
+      lines.push(cur);
+      cur = w;
+    } else {
+      cur = cur ? cur + " " + w : w;
+    }
+  }
+  if (cur) lines.push(cur);
+  return lines;
+}
+function boxCorners(shape) {
+  switch (shape) {
+    case "diamond":
+      return { l: "<", r: ">" };
+    case "rounded":
+    case "stadium":
+      return { l: "(", r: ")" };
+    case "parallelogram":
+      return { l: "/", r: "\\" };
+    default:
+      return { l: "[", r: "]" };
+  }
+}
+function drawBox(node, width, accent) {
+  const inner = wrapLabel(node.label, Math.max(1, width - 2));
+  const { l, r } = boxCorners(node.shape);
+  const rows = [];
+  rows.push(accent(l + "\u2500".repeat(width) + r));
+  for (const text of inner) {
+    const pad = " ".repeat(Math.max(0, width - 2 - text.length));
+    rows.push(accent(l + " " + text + pad + " " + r));
+  }
+  rows.push(accent(l + "\u2500".repeat(width) + r));
+  return rows;
+}
+function renderMermaid(flow, brightness, colorEnabled = true) {
+  const accentTok = themeColorSequence("accent", process.env, brightness);
+  const warningTok = themeColorSequence("warning", process.env, brightness);
+  const mutedTok = themeColorSequence("muted", process.env, brightness);
+  const wrap = (s, tok) => colorEnabled ? `${tok}${s}${STYLE.reset}` : s;
+  const cAccent = (s) => wrap(s, accentTok);
+  const cWarn = (s) => wrap(s, warningTok);
+  const cMuted = (s) => wrap(s, mutedTok);
+  if (flow.nodes.size === 0) {
+    const sk = flow.skipped.join("\n");
+    return cMuted("(empty mermaid diagram)") + (sk ? "\n" + cMuted(sk) : "");
+  }
+  const layers = assignLayers(flow);
+  const maxLayer = Math.max(...Array.from(layers.values(), (v) => v));
+  const byLayer = [];
+  for (let l = 0; l <= maxLayer; l++) byLayer.push([]);
+  for (const [id] of flow.nodes) byLayer[layers.get(id) ?? 0].push(id);
+  const width = Math.max(
+    8,
+    ...Array.from(flow.nodes.values(), (n) => n.label.length + 2)
+  );
+  const GAP = 3;
+  const edgeLabel = /* @__PURE__ */ new Map();
+  for (const e of flow.edges) {
+    if (e.label && !edgeLabel.has(`${e.from}:${e.to}`)) {
+      edgeLabel.set(`${e.from}:${e.to}`, e.label);
+    }
+  }
+  const out = [];
+  for (let l = 0; l <= maxLayer; l++) {
+    const layerIds = byLayer[l] ?? [];
+    if (layerIds.length === 0) continue;
+    const boxes = layerIds.map((id) => drawBox(flow.nodes.get(id), width, cAccent));
+    const boxHeight = Math.max(...boxes.map((b) => b.length));
+    const colStart = (bi) => bi * (width + GAP);
+    for (let r = 0; r < boxHeight; r++) {
+      let line = "";
+      boxes.forEach((b, bi) => {
+        const cell = b[r] ?? b[b.length - 1];
+        const col = colStart(bi);
+        if (line.length < col) line += " ".repeat(col - line.length);
+        line += cell;
+      });
+      out.push(line);
+    }
+    if (l < maxLayer) {
+      const down = layerIds.map(
+        (id) => flow.edges.some(
+          (e) => e.from === id && (layers.get(e.to) ?? -1) === l + 1
+        )
+      );
+      if (down.some(Boolean)) {
+        let stemRow = "";
+        layerIds.forEach((_, bi) => {
+          if (!down[bi]) return;
+          const mid = colStart(bi) + Math.floor(width / 2);
+          if (stemRow.length < mid) stemRow += " ".repeat(mid - stemRow.length);
+          stemRow += "\u2502";
+        });
+        out.push(stemRow);
+        let arrowRow = "";
+        layerIds.forEach((_, bi) => {
+          if (!down[bi]) return;
+          const mid = colStart(bi) + Math.floor(width / 2);
+          if (arrowRow.length < mid) arrowRow += " ".repeat(mid - arrowRow.length);
+          arrowRow += cWarn("\u25BC");
+        });
+        out.push(arrowRow);
+        const labels = layerIds.flatMap((id, bi) => {
+          if (!down[bi]) return [];
+          return flow.edges.filter((e) => e.from === id && (layers.get(e.to) ?? -1) === l + 1).map((e) => edgeLabel.get(`${e.from}:${e.to}`)).filter((t2) => !!t2);
+        });
+        if (labels.length > 0) {
+          out.push(cMuted("  \u2937 " + labels.join(" / ")));
+        }
+      }
+    }
+  }
+  if (flow.skipped.length > 0) {
+    out.push(cMuted("(skipped)"));
+    for (const s of flow.skipped) out.push(cMuted(s));
+  }
+  return out.join("\n");
+}
+function renderMermaidBlock(source, brightness, colorEnabled = true) {
+  const flow = parseMermaid(source);
+  if (flow.nodes.size === 0) {
+    return source;
+  }
+  return renderMermaid(flow, brightness, colorEnabled);
+}
+
+// packages/cli/client/assistantOutput.ts
+var STYLE2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m"
@@ -1143,7 +1812,7 @@ function detectCodeLangFromPath(filePath) {
 function highlightCodeLine(line, lang, brightness) {
   const info = colorSeq("info", brightness);
   if (lang === "unknown") {
-    return `${info}${line}${STYLE.reset}`;
+    return `${info}${line}${STYLE2.reset}`;
   }
   if (lang === "diff") {
     return renderDiffLine({ kind: classifyDiffLine(line), text: line, colorEnabled: true });
@@ -1154,8 +1823,8 @@ function highlightCodeLine(line, lang, brightness) {
   const success = colorSeq("success", brightness);
   const warning = colorSeq("warning", brightness);
   const chrome = colorSeq("chrome", brightness);
-  const dim = STYLE.dim;
-  const reset = STYLE.reset;
+  const dim = STYLE2.dim;
+  const reset = STYLE2.reset;
   const out = [];
   let cursor = 0;
   for (const region of regions) {
@@ -1305,9 +1974,9 @@ function renderMarkdownLink(match, text, url) {
 var MARKDOWN_LINK_RE = /\[([^\]]+)\]\(([^)\s]+)\)/g;
 function styleInlineMarkdown(line, brightness) {
   const inlineCode = colorSeq("muted", brightness);
-  const reset = STYLE.reset;
-  const bold = STYLE.bold;
-  const dim = STYLE.dim;
+  const reset = STYLE2.reset;
+  const bold = STYLE2.bold;
+  const dim = STYLE2.dim;
   return line.replace(MARKDOWN_LINK_RE, (m, t2, u) => renderMarkdownLink(m, t2, u)).replace(/`([^`]+)`/g, `${inlineCode}$1${reset}`).replace(/\*\*(.+?)\*\*/g, `${bold}$1${reset}`).replace(/(?<!\*)\*([^*]+?)\*(?!\*)/g, `${dim}$1${reset}`).replace(/~~([^~]+?)~~/g, `${dim}\x1B[9m$1\x1B[29m${reset}`);
 }
 function styleRichMarkdownLine(line, brightness) {
@@ -1316,62 +1985,110 @@ function styleRichMarkdownLine(line, brightness) {
     const level = heading[1].length;
     const title = heading[2];
     if (level === 1) {
-      return `${STYLE.bold}\x1B[4m${colorSeq("accent", brightness)}${title}${STYLE.reset}`;
+      return `${STYLE2.bold}\x1B[4m${colorSeq("accent", brightness)}${title}${STYLE2.reset}`;
     }
     if (level === 2) {
-      return `${STYLE.bold}${colorSeq("warning", brightness)}${title}${STYLE.reset}`;
+      return `${STYLE2.bold}${colorSeq("warning", brightness)}${title}${STYLE2.reset}`;
     }
-    return `${STYLE.bold}${colorSeq("info", brightness)}${title}${STYLE.reset}`;
+    return `${STYLE2.bold}${colorSeq("info", brightness)}${title}${STYLE2.reset}`;
   }
   if (line.startsWith("\u8FDB\u5165 nolo-plan")) {
-    return `${colorSeq("chrome", brightness)}${STYLE.dim}${line}${STYLE.reset}`;
+    return `${colorSeq("chrome", brightness)}${STYLE2.dim}${line}${STYLE2.reset}`;
   }
   const blockquote = line.match(/^>\s?(.*)$/);
   if (blockquote) {
     const border = colorSeq("chrome", brightness);
     const content = blockquote[1];
-    return `${border}\u2502${STYLE.reset} ${STYLE.dim}${content}${STYLE.reset}`;
+    return `${border}\u2502${STYLE2.reset} ${STYLE2.dim}${content}${STYLE2.reset}`;
   }
   if (/^---+$/.test(line.trim())) {
-    return `${colorSeq("chrome", brightness)}${"\u2500".repeat(Math.min(line.trim().length, 40))}${STYLE.reset}`;
+    return `${colorSeq("chrome", brightness)}${"\u2500".repeat(Math.min(line.trim().length, 40))}${STYLE2.reset}`;
   }
   const bullet = line.match(/^(\s*)(•)\s(.+)$/);
   if (bullet) {
     const styled = styleInlineMarkdown(bullet[3], brightness);
-    return `${bullet[1]}${colorSeq("accent", brightness)}\u2022${STYLE.reset} ${styled}`;
+    return `${bullet[1]}${colorSeq("accent", brightness)}\u2022${STYLE2.reset} ${styled}`;
   }
   const ordered = line.match(/^(\s*)(\d+\.)\s(.+)$/);
   if (ordered) {
     const styled = styleInlineMarkdown(ordered[3], brightness);
-    return `${ordered[1]}${colorSeq("chrome", brightness)}${ordered[2]}${STYLE.reset} ${styled}`;
+    return `${ordered[1]}${colorSeq("chrome", brightness)}${ordered[2]}${STYLE2.reset} ${styled}`;
   }
   const task = line.match(/^(\s*)(☐|☑)\s(.+)$/);
   if (task) {
     const styled = styleInlineMarkdown(task[3], brightness);
-    return `${task[1]}${colorSeq("accent", brightness)}${task[2]}${STYLE.reset} ${styled}`;
+    return `${task[1]}${colorSeq("accent", brightness)}${task[2]}${STYLE2.reset} ${styled}`;
   }
   return styleInlineMarkdown(line, brightness);
 }
+function renderMermaidBody(bodyLines, brightness) {
+  const body = bodyLines.join("\n");
+  const rendered = renderMermaidBlock(body, brightness, true);
+  if (rendered === body) {
+    return bodyLines.map((l) => highlightCodeLine(l, "unknown", brightness)).join("\n");
+  }
+  return rendered;
+}
 function formatAssistantDisplay(text, options = {}) {
   const brightness = resolveTuiBrightness();
   const polished = polishAssistantStructure(text, options);
+  const lines = polished.split("\n");
+  const out = [];
+  let i = 0;
   let inFence = false;
   let fenceLang = "unknown";
-  return polished.split("\n").map((line) => {
+  let inMermaid = false;
+  let mermaidBody = null;
+  const flushMermaid = () => {
+    if (mermaidBody !== null) {
+      out.push(renderMermaidBody(mermaidBody, brightness));
+      mermaidBody = null;
+    }
+  };
+  while (i < lines.length) {
+    const line = lines[i];
     if (isCodeFenceLine(line)) {
+      const lang = readFenceLanguage(line);
+      if (inMermaid) {
+        flushMermaid();
+        inMermaid = false;
+        inFence = false;
+        out.push(`${STYLE2.dim}${line}${STYLE2.reset}`);
+        i++;
+        continue;
+      }
       if (inFence) {
         fenceLang = "unknown";
-      } else {
-        fenceLang = normalizeCodeLang(readFenceLanguage(line));
+        inFence = false;
+        out.push(`${STYLE2.dim}${line}${STYLE2.reset}`);
+        i++;
+        continue;
       }
-      inFence = !inFence;
-      return `${STYLE.dim}${line}${STYLE.reset}`;
+      inFence = true;
+      fenceLang = normalizeCodeLang(lang);
+      if (/^mermaid$/i.test(lang)) {
+        inMermaid = true;
+        mermaidBody = [];
+      }
+      out.push(`${STYLE2.dim}${line}${STYLE2.reset}`);
+      i++;
+      continue;
+    }
+    if (inMermaid && mermaidBody !== null) {
+      mermaidBody.push(line);
+      i++;
+      continue;
     }
     if (inFence) {
-      return highlightCodeLine(line, fenceLang, brightness);
+      out.push(highlightCodeLine(line, fenceLang, brightness));
+      i++;
+      continue;
     }
-    return styleRichMarkdownLine(line, brightness);
-  }).join("\n");
+    out.push(styleRichMarkdownLine(line, brightness));
+    i++;
+  }
+  flushMermaid();
+  return out.join("\n");
 }
 function emitFormattedAssistantBlock(write, text, trailingNewline = false) {
   if (!text) return;
@@ -1396,6 +2113,8 @@ function createRenderAwareStreamWriter(args) {
   let buffer = "";
   let inFence = false;
   let fenceLang = "unknown";
+  let inMermaid = false;
+  let mermaidBody = [];
   let lastKind = null;
   const PARTIAL_FLUSH_THRESHOLD = 48;
   const emitBreathIfNeeded = (nextKind) => {
@@ -1425,19 +2144,44 @@ function createRenderAwareStreamWriter(args) {
       if (lines.length < 2) break;
       const firstLine = lines[0] ?? "";
       if (isCodeFenceLine(firstLine)) {
+        if (inMermaid) {
+          const diagram = renderMermaidBody(mermaidBody, brightness);
+          args.write(diagram + "\n");
+          mermaidBody = [];
+          inMermaid = false;
+          inFence = false;
+          fenceLang = "unknown";
+          emitBreathIfNeeded("other");
+          args.write(`${STYLE2.dim}${firstLine}${STYLE2.reset}
+`);
+          lastKind = "other";
+          buffer = lines.slice(1).join("\n");
+          continue;
+        }
         if (inFence) {
           fenceLang = "unknown";
+          inFence = false;
         } else {
-          fenceLang = normalizeCodeLang(readFenceLanguage(firstLine));
+          const lang = readFenceLanguage(firstLine);
+          fenceLang = normalizeCodeLang(lang);
+          if (/^mermaid$/i.test(lang)) {
+            inMermaid = true;
+            mermaidBody = [];
+          }
+          inFence = true;
         }
-        inFence = !inFence;
         emitBreathIfNeeded("other");
-        args.write(`${STYLE.dim}${firstLine}${STYLE.reset}
+        args.write(`${STYLE2.dim}${firstLine}${STYLE2.reset}
 `);
         lastKind = "other";
         buffer = lines.slice(1).join("\n");
         continue;
       }
+      if (inMermaid) {
+        mermaidBody.push(firstLine);
+        buffer = lines.slice(1).join("\n");
+        continue;
+      }
       if (inFence) {
         args.write(`${highlightCodeLine(firstLine, fenceLang, brightness)}
 `);
@@ -1481,6 +2225,14 @@ function createRenderAwareStreamWriter(args) {
       flushPartialProse();
     },
     flush() {
+      if (inMermaid) {
+        if (buffer) mermaidBody.push(...buffer.split("\n"));
+        args.write(renderMermaidBody(mermaidBody, brightness) + "\n");
+        mermaidBody = [];
+        inMermaid = false;
+        buffer = "";
+        return;
+      }
       if (!buffer) return;
       if (inFence) {
         args.write(buffer);
@@ -3304,7 +4056,7 @@ async function detectCurrentMachineId(env) {
   const fromEnv = (env.NOLO_CURRENT_MACHINE_ID || env.NOLO_MACHINE_ID || "").trim();
   if (fromEnv) return fromEnv;
   try {
-    const { detectMachineInfo } = await import("./machineInfo-M6KB6HZN.js");
+    const { detectMachineInfo } = await import("./machineInfo-66ZFUMLE.js");
     const machine = await detectMachineInfo({ probeLaunchable: true });
     return asOptionalTrimmedString(machine?.machineId);
   } catch {
@@ -3521,7 +4273,7 @@ function findCollapsedPasteSpanAt(buffer, pos, opts = {}) {
 // packages/cli/client/agentRun.ts
 import { ulid } from "ulid";
 async function loadRunLocalAgentTurn() {
-  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-JX34G47Z.js");
+  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-TEJECMTH.js");
   return runLocalAgentTurn;
 }
 async function resolveCurrentMachineId(options) {
@@ -3753,6 +4505,10 @@ function describeLocalRunFailure(message) {
   }
   const cls = classifyLocalRunError(message);
   if (cls.kind === "generic") {
+    if (isTransientFetchError(message)) {
+      return `${RUN_UNAVAILABLE_PREFIX} (${message}). ${NO_FALLBACK} The upstream connection dropped mid-request (transient network/gateway issue \u2014 not a local credential or config problem). Send again (or say "continue") to retry in the same conversation.
+`;
+    }
     return `${RUN_UNAVAILABLE_PREFIX} (${message}). ${NO_FALLBACK} Fix the local credential/config and retry, ${SERVER_FALLBACK_HINT}.
 `;
   }
@@ -4054,12 +4810,6 @@ async function runLocalAgentTurnForCli(options, settings) {
             "[nolo] \u5F53\u524D agent \u4E0D\u652F\u6301\u56FE\u7247\u8F93\u5165\uFF0C\u5DF2\u7528\u5360\u4F4D\u6587\u672C\u66FF\u4EE3\u3002\u8981\u5B8C\u6574\u56FE\u7247\u7406\u89E3\u53EF /switch \u5230 Kimi K2.6\u3002\n"
           );
         }
-        if (event.kind === "image-preprocessed") {
-          options.output.write(
-            `[nolo] \u5DF2\u7528\u89C6\u89C9\u6A21\u578B\u89E3\u6790 ${event.imageCount} \u5F20\u56FE\u7247\u4E3A\u6587\u5B57\u63CF\u8FF0\uFF0C\u4F9B\u5F53\u524D agent \u4F7F\u7528\u3002
-`
-          );
-        }
         options.onLoopEvent?.(event);
       },
       ...options.abortSignal ? { abortSignal: options.abortSignal } : {},
@@ -4071,6 +4821,9 @@ async function runLocalAgentTurnForCli(options, settings) {
       ...!options.noStream ? {
         onTextDelta: (chunk) => {
           turnOutput.pushText(chunk);
+        },
+        onReasoningDelta: (chunk) => {
+          turnOutput.pushThinking(chunk);
         }
       } : {}
     });
@@ -4868,40 +5621,6 @@ var resolveCliMemory = async (input) => {
   }
 };
 
-// packages/ai/tools/agent/quotaCircuitBreaker.ts
-var QUOTA_ERROR_PATTERNS = [
-  /429/,
-  /quota/i,
-  /rate\s*limit/i,
-  /too\s*many\s*requests/i,
-  /额度/,
-  /上限/,
-  /用尽/,
-  /CliProviderQuotaError/i
-];
-function isCliProviderQuotaErrorShape(error) {
-  if (!error || typeof error !== "object") return false;
-  const e = error;
-  return e.name === "CliProviderQuotaError" || typeof e.message === "string" && e.message.startsWith("[QUOTA_LIMITED:");
-}
-function isQuotaExhaustedError(error) {
-  if (!error) return false;
-  if (isCliProviderQuotaErrorShape(error)) return true;
-  if (error instanceof Error) {
-    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error.message));
-  }
-  if (typeof error === "string") {
-    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error));
-  }
-  const maybeStatus = error.status;
-  if (typeof maybeStatus === "number" && maybeStatus === 429) return true;
-  const maybeStatusCode = error.statusCode;
-  if (typeof maybeStatusCode === "number" && maybeStatusCode === 429) return true;
-  return false;
-}
-var DEFAULT_QUOTA_BREAKER_MS = 6 * 3600 * 1e3;
-var DEFAULT_AGENT_NOT_FOUND_BREAKER_MS = 15 * 60 * 1e3;
-
 // packages/cli/agentRunCommand.ts
 function resolvePositiveMs(value, fallback) {
   return parsePositiveFiniteNumberOrFallback(value, fallback);
@@ -5363,7 +6082,7 @@ export {
   resolveCliColorEnabled,
   dimCliText,
   ANSI_ESCAPE_REGEX,
-  stripAnsi,
+  stripAnsi2 as stripAnsi,
   applyTerminalOutputToText,
   displayWidth,
   visibleWidth,
@@ -5372,6 +6091,9 @@ export {
   countPhysicalLines,
   takeDisplayWidth,
   padOrTruncateToWidth,
+  tokenizeAnsiLine,
+  buildSourceMapping,
+  wrapTranscriptLineWithLayout,
   wrapTranscriptLine,
   buildWindowTitle,
   wrapTextToLines,
@@ -5411,8 +6133,6 @@ export {
   normalizeCliImageInput,
   inspectLocalRunWorkspace,
   resolveCliMemory,
-  QUOTA_ERROR_PATTERNS,
-  isQuotaExhaustedError,
   runAgentRunCommand,
   isBalanceExhaustedError
 };