nolo-cli 0.33.0-alpha.9 → 0.34.0-alpha.3

package/{chunk-UEAUAXYS.js → chunk-ILZY5B4U.js}

@@ -1,3 +1,6 @@
+import {
+  generateRunReport
+} from "./chunk-IMHO5LC6.js";
 import {
   buildLocalRunEnv,
   isFullstackCodingAgentRef,
@@ -6,65 +9,92 @@ import {
   resolveRawAgentInput,
   resolveServerUrl,
   writeUsage
-} from "./chunk-ZHYK3N56.js";
-import {
-  getReadableCliDb
-} from "./chunk-NUO3QFWD.js";
-import {
-  normalizeAgentHandle,
-  readDbRecord,
-  resolveAgentRecordFromHybridStore
-} from "./chunk-YDTYDA5W.js";
+} from "./chunk-4AWH4LQA.js";
 import {
   agentRunCardLabels,
   createCliLocalRuntimeAdapter,
   getCliLocale,
   isBuiltinNoloAgentRef,
   isSubtaskRun,
+  isTransientFetchError,
   parseAgentRunEvent,
   t,
   toolLabel
-} from "./chunk-WNHST4IE.js";
+} from "./chunk-RKRXAL3V.js";
+import {
+  getReadableCliDb
+} from "./chunk-UNHKVD2N.js";
+import {
+  normalizeAgentHandle,
+  readDbRecord,
+  resolveAgentRecordFromHybridStore
+} from "./chunk-GZRMWK5R.js";
 import {
   NOLO_PROJECT_MANAGER_AGENT_KEY,
   isLocalCliAgentKey
 } from "./chunk-EKLRRZIN.js";
+import {
+  CliProviderQuotaError
+} from "./chunk-JDSUTNYY.js";
+import {
+  createRunActivityTracker,
+  finalizeRunRecord,
+  readRunRecord,
+  spawnLocalBackgroundRun
+} from "./chunk-E2OQ5N2F.js";
+import {
+  resolveMachineId
+} from "./chunk-ESHYE7WU.js";
 import {
   applyModelLayerOverride,
   buildModelLayerOverride
 } from "./chunk-LTRXGFMS.js";
-import {
-  resolveMachineId
-} from "./chunk-6HYVJV7B.js";
 import {
   formatAgentListCard
-} from "./chunk-BQ3OHLR5.js";
+} from "./chunk-5GQ6XCJY.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-7L5CQQIT.js";
+} from "./chunk-Y5W623XU.js";
 import {
   API_REPORTED_COST_MULTIPLIER,
   normalizeUsage,
   parseUiAskChoiceContent
-} from "./chunk-BXPBZVRE.js";
+} from "./chunk-PILJX4DH.js";
 import {
-  resolveAgentRuntimeConfigFromRecord
-} from "./chunk-OIQPORYI.js";
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-N4XRDM26.js";
+import {
+  buildSkillDiscoveryContextLayer
+} from "./chunk-2BWU4ORW.js";
+import {
+  parseExternalSkillMarkdown,
+  parseSkillDocProtocol
+} from "./chunk-EY7V7REW.js";
 import {
   LOCAL_AGENT_CONFIG_MISSING_CODE,
   LOCAL_TURN_ABORTED_CODE,
   readActionGate,
   readCommandActionGatePayload
-} from "./chunk-D5JI6VDM.js";
+} from "./chunk-I7VDDN45.js";
+import {
+  resolveAgentRuntimeConfigFromRecord
+} from "./chunk-64KIQZA2.js";
 import {
   createThinkParserState,
   flushThinkParser,
@@ -72,55 +102,33 @@ import {
 } from "./chunk-N7J63Q6C.js";
 import {
   resolvePlatformAuthToken
-} from "./chunk-7YYHKBJP.js";
+} from "./chunk-GKHV4UH5.js";
+import {
+  isQuotaExhaustedError
+} from "./chunk-X2K2JSO4.js";
 import {
   DEFAULT_CONTEXT_WINDOW,
   getModelContextWindow
-} from "./chunk-GJXRIOLS.js";
+} from "./chunk-WRP5TTM6.js";
 import {
   clipCompactText
-} from "./chunk-DKMOY3QI.js";
+} from "./chunk-FGLKRJDI.js";
 import {
   findModelConfig
-} from "./chunk-DFUPZE6V.js";
+} from "./chunk-C6ELZQ7H.js";
 import {
-  buildSkillDiscoveryContextLayer
-} from "./chunk-ZURFOV5J.js";
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
 import {
   buildAgentsMdLayer,
   buildMemoryOverlayLayer,
   buildMemoryUseGuidanceLayer,
   partitionScopedBlocks,
   renderTurnContextBlocksWithScope
-} from "./chunk-2UECQ7RE.js";
-import {
-  parseExternalSkillMarkdown,
-  parseSkillDocProtocol
-} from "./chunk-AETZ7AD6.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";
+} from "./chunk-3AOLVADY.js";
 import {
   readPipeText,
   spawnProcess
@@ -133,7 +141,7 @@ import {
 } from "./chunk-Y5GCAMGP.js";
 import {
   createMemoryKey
-} from "./chunk-KMSZPTM6.js";
+} from "./chunk-2WKUUY2E.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -141,13 +149,13 @@ import {
   BUILTIN_NOLO_AGENT_KEY,
   BUILTIN_NOLO_AGENT_NAME,
   builtinAgentCatalogEntryById
-} from "./chunk-IR6W62Q6.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
+} from "./chunk-XT73C4VH.js";
 import {
   parsePublicAgentId
 } from "./chunk-BJIRLHJR.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
 import {
   isLoopbackUrl
 } from "./chunk-4SN6J65J.js";
@@ -227,7 +235,8 @@ function buildTurnTokenUsage(usage, model) {
   const contextWindow = resolveContextWindow(model);
   const remaining = contextWindow && parsed.input > 0 ? Math.max(0, contextWindow - parsed.input) : void 0;
   const rawCost = typeof usage?.cost === "number" ? usage.cost : void 0;
-  const credits = rawCost !== void 0 && rawCost > 0 ? rawCost * API_REPORTED_COST_MULTIPLIER : void 0;
+  const isPlatformBilled = usage?.billing_unit === "credits";
+  const credits = rawCost !== void 0 && rawCost > 0 ? isPlatformBilled ? rawCost : rawCost * API_REPORTED_COST_MULTIPLIER : void 0;
   return {
     ...parsed,
     ...contextWindow ? { contextWindow } : {},
@@ -317,11 +326,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)+$/;
@@ -382,30 +623,78 @@ 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;
+function isAmbiguousWideSymbolCode(code) {
+  return code >= 8592 && code <= 8597 || // ←↑→↓↔↕
+  code === 8656 || code === 8658 || code === 8660 || // ⇐⇒⇔
+  code === 215 || code === 247 || code === 177 || // ×÷±
+  code === 8226 || code === 183;
+}
+function isForceWideSymbolCode(code) {
+  return code >= 9728 && code <= 10175 && !(code >= 10088 && code <= 10101) || code >= 11008 && code <= 11263 || code >= 127744 && code <= 129791 || isAmbiguousWideSymbolCode(code);
+}
+function isCjkQuoteCode(code) {
+  return code === 8220 || code === 8221 || code === 8216 || code === 8217;
+}
+function scanWidthNeeds(plain, locale) {
+  let hasNonAscii = false;
+  for (let i = 0; i < plain.length; i++) {
+    const cc = plain.charCodeAt(i);
+    if (isAmbiguousWideSymbolCode(cc)) {
+      return { hasNonAscii: true, hasCandidate: true };
+    }
+    if (cc < 8192) continue;
+    hasNonAscii = true;
+    let code = cc;
+    if (cc >= 55296 && cc <= 56319 && i + 1 < plain.length) {
+      const lo = plain.charCodeAt(i + 1);
+      if (lo >= 56320 && lo <= 57343) {
+        code = (cc - 55296) * 1024 + (lo - 56320) + 65536;
+        i += 1;
+      }
+    }
+    if (isForceWideSymbolCode(code) || locale === "zh" && isCjkQuoteCode(code)) {
+      return { hasNonAscii: true, hasCandidate: true };
     }
   }
+  return { hasNonAscii, hasCandidate: false };
+}
+var displayWidthCache = /* @__PURE__ */ new Map();
+var DISPLAY_WIDTH_CACHE_MAX = 4096;
+function displayWidth(str) {
+  const plain = stripAnsi2(str);
+  const locale = getCliLocale();
+  const needs = scanWidthNeeds(plain, locale);
+  if (!needs.hasNonAscii) {
+    return stringWidth(plain);
+  }
+  const key = locale + "\0" + plain;
+  const cached = displayWidthCache.get(key);
+  if (cached !== void 0) return cached;
+  const base = stringWidth(plain);
+  if (!needs.hasCandidate) {
+    if (displayWidthCache.size >= DISPLAY_WIDTH_CACHE_MAX) {
+      const eldest = displayWidthCache.keys().next().value;
+      if (eldest !== void 0) displayWidthCache.delete(eldest);
+    }
+    displayWidthCache.set(key, base);
+    return base;
+  }
+  let width = base;
+  for (const { segment } of graphemeSegmenter.segment(plain)) {
+    const code = segment.codePointAt(0) ?? 0;
+    if (isForceWideSymbolCode(code) || locale === "zh" && isCjkQuoteCode(code)) {
+      if (stringWidth(segment) === 1) width += 1;
+    }
+  }
+  if (displayWidthCache.size >= DISPLAY_WIDTH_CACHE_MAX) {
+    const eldest = displayWidthCache.keys().next().value;
+    if (eldest !== void 0) displayWidthCache.delete(eldest);
+  }
+  displayWidthCache.set(key, width);
   return width;
 }
 function visibleWidth(str) {
-  return displayWidth(stripAnsi(str));
+  return displayWidth(stripAnsi2(str));
 }
 function truncateAnsi(text, maxWidth) {
   if (maxWidth <= 0) return "";
@@ -473,6 +762,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 +770,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 +900,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 +919,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 +944,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;
@@ -749,12 +1194,17 @@ function setActiveThemeName(name) {
   }
   return false;
 }
-var activeBrightness = null;
-function getActiveBrightness() {
-  return activeBrightness;
+var activeThemeMode = "terminal";
+var resolvedBrightness = null;
+function getActiveThemeMode() {
+  return activeThemeMode;
+}
+function setActiveThemeMode(mode) {
+  activeThemeMode = mode;
+  if (mode === "terminal") resolvedBrightness = null;
 }
 function setActiveBrightness(brightness) {
-  activeBrightness = brightness;
+  setActiveThemeMode(brightness ?? "terminal");
 }
 var activeDensity = "spacious";
 function getActiveDensity() {
@@ -797,7 +1247,8 @@ function resolveTuiBrightness(env = process.env) {
   const explicit = (env.NOLO_TUI_THEME ?? "").trim().toLowerCase();
   if (explicit === "light") return "light";
   if (explicit === "dark") return "dark";
-  if (activeBrightness) return activeBrightness;
+  if (activeThemeMode !== "terminal") return activeThemeMode;
+  if (resolvedBrightness) return resolvedBrightness;
   const colorfgbg = env.COLORFGBG ?? "";
   if (colorfgbg) {
     const parts = colorfgbg.split(";");
@@ -809,6 +1260,12 @@ function resolveTuiBrightness(env = process.env) {
   if (sys) return sys;
   return "dark";
 }
+function resolveTuiThemeMode(env = process.env, fallback = activeThemeMode) {
+  const explicit = (env.NOLO_TUI_THEME ?? "").trim().toLowerCase();
+  if (explicit === "light" || explicit === "dark") return explicit;
+  if (explicit === "terminal" || explicit === "auto") return "terminal";
+  return fallback;
+}
 function hexToSgr(hex) {
   const r = Number.parseInt(hex.slice(0, 2), 16);
   const g = Number.parseInt(hex.slice(2, 4), 16);
@@ -835,11 +1292,15 @@ function setActiveTerminalBaseHex(hex) {
   }
   activeTerminalBaseHex = readHexChannels(hex.replace(/^#/, "").toUpperCase()) ? hex.replace(/^#/, "").toUpperCase() : null;
 }
+function resetWorkspaceThemeState() {
+  setActiveThemeMode("terminal");
+  setActiveTerminalBaseHex(null);
+}
 function applyDetectedBackground(detected) {
   const normalizedHex = detected.hex.replace(/^#/, "").toUpperCase();
   const hexChanged = normalizedHex !== "" && normalizedHex !== activeTerminalBaseHex;
-  const changed = detected.brightness !== activeBrightness || hexChanged;
-  setActiveBrightness(detected.brightness);
+  const changed = detected.brightness !== resolvedBrightness || hexChanged;
+  resolvedBrightness = detected.brightness;
   setActiveTerminalBaseHex(detected.hex);
   return changed;
 }
@@ -879,6 +1340,7 @@ function blendHex(fg, base, weight) {
   return `${r}${g}${b}`;
 }
 function diffLineSequences(env = process.env, brightness = resolveTuiBrightness(env)) {
+  if (resolveTuiThemeMode(env) === "terminal") return null;
   if (!supportsTruecolor(env)) return null;
   const palette = THEME_PALETTES[activeThemeName] ?? THEME_PALETTES.trail;
   const successHex = palette[brightness].success.hex;
@@ -937,10 +1399,12 @@ function renderDiffLine(args) {
   });
 }
 function surfaceBackgroundSequence(env = process.env, brightness = resolveTuiBrightness(env)) {
+  if (resolveTuiThemeMode(env) === "terminal") return "";
   if (!supportsTruecolor(env)) return "";
   return hexToBgSgr((SURFACE_HEX[activeThemeName] ?? SURFACE_HEX.trail)[brightness]);
 }
 function userSurfaceBackgroundSequence(env = process.env, brightness = resolveTuiBrightness(env)) {
+  if (resolveTuiThemeMode(env) === "terminal") return "";
   if (!supportsTruecolor(env)) return "";
   const palette = THEME_PALETTES[activeThemeName] ?? THEME_PALETTES.trail;
   const accentHex = palette[brightness].accent.hex;
@@ -950,12 +1414,18 @@ function userSurfaceBackgroundSequence(env = process.env, brightness = resolveTu
 function themeColorSequence(token, env = process.env, brightness = resolveTuiBrightness(env)) {
   const palette = THEME_PALETTES[activeThemeName] ?? THEME_PALETTES.trail;
   const entry = palette[brightness][token];
-  return supportsTruecolor(env) ? hexToSgr(entry.hex) : entry.ansiFallback;
+  return resolveTuiThemeMode(env) !== "terminal" && supportsTruecolor(env) ? hexToSgr(entry.hex) : entry.ansiFallback;
 }
 function themeText(text, token, colorEnabled = resolveCliColorEnabled(), env = process.env) {
   if (!colorEnabled) return text;
   return `${themeColorSequence(token, env)}${text}\x1B[39m`;
 }
+function tuiRenderThemeFingerprint(colorEnabled, env = process.env) {
+  const mode = resolveTuiThemeMode(env);
+  const colorKind = !colorEnabled ? "plain" : mode !== "terminal" && supportsTruecolor(env) ? "truecolor" : "ansi";
+  const surface = colorEnabled ? userSurfaceBackgroundSequence(env) : "";
+  return `${activeThemeName}|${mode}|${colorKind}|${surface}`;
+}
 function classifyDiffLine(line) {
   if (line.startsWith("@@")) return "hunk";
   if (line.startsWith("+") && !line.startsWith("+++")) return "added";
@@ -963,8 +1433,850 @@ 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/mathText.ts
+var mathRenderingEnabled = true;
+function setMathRenderingEnabled(enabled) {
+  mathRenderingEnabled = enabled;
+}
+var GREEK_LETTERS = {
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  varepsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  vartheta: "\u03B8",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  omicron: "\u03BF",
+  pi: "\u03C0",
+  varpi: "\u03C0",
+  rho: "\u03C1",
+  varrho: "\u03C1",
+  sigma: "\u03C3",
+  varsigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  varphi: "\u03C6",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Theta: "\u0398",
+  Lambda: "\u039B",
+  Xi: "\u039E",
+  Pi: "\u03A0",
+  Sigma: "\u03A3",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Psi: "\u03A8",
+  Omega: "\u03A9"
+};
+var OPERATORS_AND_SYMBOLS = {
+  // Operators
+  times: "\xD7",
+  div: "\xF7",
+  pm: "\xB1",
+  mp: "\u2213",
+  cdot: "\xB7",
+  bullet: "\xB7",
+  circ: "\u2218",
+  ast: "*",
+  star: "\u2605",
+  // Relations
+  leq: "\u2264",
+  le: "\u2264",
+  geq: "\u2265",
+  ge: "\u2265",
+  neq: "\u2260",
+  ne: "\u2260",
+  approx: "\u2248",
+  equiv: "\u2261",
+  sim: "\u223C",
+  simeq: "\u2243",
+  cong: "\u2245",
+  propto: "\u221D",
+  ll: "\u226A",
+  gg: "\u226B",
+  // Arrows
+  to: "\u2192",
+  rightarrow: "\u2192",
+  longrightarrow: "\u2192",
+  gets: "\u2190",
+  leftarrow: "\u2190",
+  longleftarrow: "\u2190",
+  Rightarrow: "\u21D2",
+  implies: "\u21D2",
+  Longrightarrow: "\u21D2",
+  Leftarrow: "\u21D0",
+  Longleftarrow: "\u21D0",
+  Leftrightarrow: "\u21D4",
+  iff: "\u21D4",
+  Longleftrightarrow: "\u21D4",
+  leftrightarrow: "\u2194",
+  uparrow: "\u2191",
+  downarrow: "\u2193",
+  mapsto: "\u21A6",
+  // Sets & Logic
+  in: "\u2208",
+  notin: "\u2209",
+  ni: "\u220B",
+  owns: "\u220B",
+  subset: "\u2282",
+  supset: "\u2283",
+  subseteq: "\u2286",
+  supseteq: "\u2287",
+  cap: "\u2229",
+  cup: "\u222A",
+  setminus: "\\",
+  emptyset: "\u2205",
+  varnothing: "\u2205",
+  forall: "\u2200",
+  exists: "\u2203",
+  nexists: "\u2204",
+  land: "\u2227",
+  wedge: "\u2227",
+  lor: "\u2228",
+  vee: "\u2228",
+  neg: "\xAC",
+  lnot: "\xAC",
+  top: "\u22A4",
+  bot: "\u22A5",
+  // Calculus & Special
+  infty: "\u221E",
+  inf: "\u221E",
+  partial: "\u2202",
+  nabla: "\u2207",
+  angle: "\u2220",
+  perp: "\u22A5",
+  degree: "\xB0",
+  prime: "\u2032",
+  hbar: "\u0127",
+  ell: "\u2113",
+  Re: "\u211C",
+  Im: "\u2111",
+  aleph: "\u2135",
+  // Punctuation dots
+  dots: "\u2026",
+  ldots: "\u2026",
+  cdots: "\u2026",
+  vdots: "\u22EE",
+  ddots: "\u22F1",
+  // Large operators
+  sum: "\u2211",
+  prod: "\u220F",
+  coprod: "\u2210",
+  int: "\u222B",
+  iint: "\u222C",
+  iiint: "\u222D",
+  oint: "\u222E"
+};
+var SUPERSCRIPTS = {
+  "0": "\u2070",
+  "1": "\xB9",
+  "2": "\xB2",
+  "3": "\xB3",
+  "4": "\u2074",
+  "5": "\u2075",
+  "6": "\u2076",
+  "7": "\u2077",
+  "8": "\u2078",
+  "9": "\u2079",
+  "+": "\u207A",
+  "-": "\u207B",
+  "=": "\u207C",
+  "(": "\u207D",
+  ")": "\u207E",
+  a: "\u1D43",
+  b: "\u1D47",
+  c: "\u1D9C",
+  d: "\u1D48",
+  e: "\u1D49",
+  f: "\u1DA0",
+  g: "\u1D4D",
+  h: "\u02B0",
+  i: "\u2071",
+  j: "\u02B2",
+  k: "\u1D4F",
+  l: "\u02E1",
+  m: "\u1D50",
+  n: "\u207F",
+  o: "\u1D52",
+  p: "\u1D56",
+  r: "\u02B3",
+  s: "\u02E2",
+  t: "\u1D57",
+  u: "\u1D58",
+  v: "\u1D5B",
+  w: "\u02B7",
+  x: "\u02E3",
+  y: "\u02B8",
+  z: "\u1DBB",
+  A: "\u1D2C",
+  B: "\u1D2E",
+  D: "\u1D30",
+  E: "\u1D31",
+  G: "\u1D33",
+  H: "\u1D34",
+  I: "\u1D35",
+  J: "\u1D36",
+  K: "\u1D37",
+  L: "\u1D38",
+  M: "\u1D39",
+  N: "\u1D3A",
+  O: "\u1D3C",
+  P: "\u1D3E",
+  R: "\u1D3F",
+  T: "\u1D40",
+  U: "\u1D41",
+  V: "\u2C7D",
+  W: "\u1D42"
+};
+var SUBSCRIPTS = {
+  "0": "\u2080",
+  "1": "\u2081",
+  "2": "\u2082",
+  "3": "\u2083",
+  "4": "\u2084",
+  "5": "\u2085",
+  "6": "\u2086",
+  "7": "\u2087",
+  "8": "\u2088",
+  "9": "\u2089",
+  "+": "\u208A",
+  "-": "\u208B",
+  "=": "\u208C",
+  "(": "\u208D",
+  ")": "\u208E",
+  a: "\u2090",
+  e: "\u2091",
+  h: "\u2095",
+  i: "\u1D62",
+  j: "\u2C7C",
+  k: "\u2096",
+  l: "\u2097",
+  m: "\u2098",
+  n: "\u2099",
+  o: "\u2092",
+  p: "\u209A",
+  r: "\u1D63",
+  s: "\u209B",
+  t: "\u209C",
+  u: "\u1D64",
+  v: "\u1D65",
+  x: "\u2093"
+};
+function hasUnsupportedLatex(latex) {
+  if (/\\(newcommand|renewcommand|def|let)\b/.test(latex)) {
+    return true;
+  }
+  if (/\\begin\s*\{/.test(latex)) {
+    return true;
+  }
+  return false;
+}
+function extractBalancedBraces(text, startIndex) {
+  if (text[startIndex] !== "{") return null;
+  let depth = 0;
+  for (let i = startIndex; i < text.length; i++) {
+    if (text[i] === "{") {
+      depth++;
+    } else if (text[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        return { content: text.slice(startIndex + 1, i), endIndex: i };
+      }
+    }
+  }
+  return null;
+}
+function extractBalancedBrackets(text, startIndex) {
+  if (text[startIndex] !== "[") return null;
+  let depth = 0;
+  for (let i = startIndex; i < text.length; i++) {
+    if (text[i] === "[") {
+      depth++;
+    } else if (text[i] === "]") {
+      depth--;
+      if (depth === 0) {
+        return { content: text.slice(startIndex + 1, i), endIndex: i };
+      }
+    }
+  }
+  return null;
+}
+function toSuperscriptString(raw) {
+  let res = "";
+  for (const char of raw) {
+    const s = SUPERSCRIPTS[char];
+    if (!s) return null;
+    res += s;
+  }
+  return res;
+}
+function toSubscriptString(raw) {
+  let res = "";
+  for (const char of raw) {
+    const s = SUBSCRIPTS[char];
+    if (!s) return null;
+    res += s;
+  }
+  return res;
+}
+function transpileLatexToUnicode(latex) {
+  if (!mathRenderingEnabled) return latex;
+  const trimmed = latex.trim();
+  if (!trimmed) return "";
+  if (hasUnsupportedLatex(trimmed)) {
+    return trimmed;
+  }
+  let s = trimmed;
+  s = s.replace(/\\left\s*\\\{/g, "{").replace(/\\right\s*\\\}/g, "}").replace(/\\left\s*([(\[|.])?/g, (_, p) => p === "." ? "" : p ?? "").replace(/\\right\s*([)\]|.])?/g, (_, p) => p === "." ? "" : p ?? "");
+  s = s.replace(/\\(?:text|mathrm|mathbf|mathit|operatorname|mathtt|mathsf)\s*\{([^}]*)\}/g, "$1");
+  s = s.replace(/\\qquad/g, "    ").replace(/\\quad/g, "  ").replace(/\\[,;:!]/g, " ").replace(/\\ /g, " ");
+  while (s.includes("\\frac")) {
+    const idx = s.indexOf("\\frac");
+    let afterFrac = idx + 5;
+    while (afterFrac < s.length && /\s/.test(s[afterFrac] ?? "")) afterFrac++;
+    const numMatch = extractBalancedBraces(s, afterFrac);
+    if (!numMatch) break;
+    let afterNum = numMatch.endIndex + 1;
+    while (afterNum < s.length && /\s/.test(s[afterNum] ?? "")) afterNum++;
+    const denMatch = extractBalancedBraces(s, afterNum);
+    if (!denMatch) break;
+    const numTranspiled = transpileLatexToUnicode(numMatch.content);
+    const denTranspiled = transpileLatexToUnicode(denMatch.content);
+    const isAtomic = (t2) => /^[a-zA-Z0-9α-ωΑ-Ω∞π\\]+$/.test(t2.trim());
+    const numOut = isAtomic(numTranspiled) ? numTranspiled.trim() : `(${numTranspiled.trim()})`;
+    const denOut = isAtomic(denTranspiled) ? denTranspiled.trim() : `(${denTranspiled.trim()})`;
+    const fracReplacement = `${numOut}/${denOut}`;
+    s = s.slice(0, idx) + fracReplacement + s.slice(denMatch.endIndex + 1);
+  }
+  while (s.includes("\\sqrt")) {
+    const idx = s.indexOf("\\sqrt");
+    let afterSqrt = idx + 5;
+    while (afterSqrt < s.length && /\s/.test(s[afterSqrt] ?? "")) afterSqrt++;
+    let rootDegree = null;
+    if (s[afterSqrt] === "[") {
+      const bracketMatch = extractBalancedBrackets(s, afterSqrt);
+      if (bracketMatch) {
+        rootDegree = transpileLatexToUnicode(bracketMatch.content);
+        afterSqrt = bracketMatch.endIndex + 1;
+        while (afterSqrt < s.length && /\s/.test(s[afterSqrt] ?? "")) afterSqrt++;
+      }
+    }
+    const radMatch = extractBalancedBraces(s, afterSqrt);
+    if (!radMatch) break;
+    const radContent = transpileLatexToUnicode(radMatch.content).trim();
+    let rootSym = "\u221A";
+    if (rootDegree === "3") {
+      rootSym = "\u221B";
+    } else if (rootDegree === "4") {
+      rootSym = "\u221C";
+    } else if (rootDegree) {
+      const supDeg = toSuperscriptString(rootDegree);
+      rootSym = supDeg ? `${supDeg}\u221A` : `^(${rootDegree})\u221A`;
+    }
+    const sqrtReplacement = `${rootSym}(${radContent})`;
+    s = s.slice(0, idx) + sqrtReplacement + s.slice(radMatch.endIndex + 1);
+  }
+  s = s.replace(/\\([a-zA-Z]+)/g, (fullMatch, name) => {
+    if (GREEK_LETTERS[name]) return GREEK_LETTERS[name];
+    if (OPERATORS_AND_SYMBOLS[name]) return OPERATORS_AND_SYMBOLS[name];
+    return fullMatch;
+  });
+  s = processSubSuperscripts(s);
+  s = s.replace(/\\([{}%$_&])/g, "$1");
+  s = s.replace(/\s{2,}/g, " ").trim();
+  return s;
+}
+function processSubSuperscripts(text) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "^" || text[i] === "_") {
+      const isSuper = text[i] === "^";
+      i++;
+      let rawInner = "";
+      if (i < text.length && text[i] === "{") {
+        const braceMatch = extractBalancedBraces(text, i);
+        if (braceMatch) {
+          rawInner = braceMatch.content;
+          i = braceMatch.endIndex + 1;
+        } else {
+          result += `${isSuper ? "^" : "_"}{`;
+          i++;
+          continue;
+        }
+      } else if (i < text.length) {
+        rawInner = text[i] ?? "";
+        i++;
+      }
+      const transpiledInner = transpileLatexToUnicode(rawInner);
+      const converted = isSuper ? toSuperscriptString(transpiledInner) : toSubscriptString(transpiledInner);
+      if (converted !== null && converted.length > 0) {
+        result += converted;
+      } else {
+        const marker = isSuper ? "^" : "_";
+        result += `${marker}(${transpiledInner})`;
+      }
+    } else {
+      result += text[i];
+      i++;
+    }
+  }
+  return result;
+}
+function renderMathBlock(latex, options = {}) {
+  const trimmed = latex.trim();
+  if (!mathRenderingEnabled) {
+    return `\x1B[2m${trimmed}\x1B[0m`;
+  }
+  if (hasUnsupportedLatex(trimmed)) {
+    return `\x1B[2m${trimmed}\x1B[0m`;
+  }
+  const columns = options.columns && options.columns > 10 ? options.columns : 80;
+  const fracMatch = trimmed.match(/^\\frac\s*\{([\s\S]+)\}\s*\{([\s\S]+)\}$/);
+  if (fracMatch) {
+    const num = transpileLatexToUnicode(fracMatch[1] ?? "");
+    const den = transpileLatexToUnicode(fracMatch[2] ?? "");
+    if (num.length > 8 || den.length > 8 || num.includes("+") || den.includes("+") || num.includes("-") || den.includes("-")) {
+      const width = Math.max(visibleWidth(num), visibleWidth(den)) + 2;
+      const bar = "\u2500".repeat(width);
+      const padNum = " ".repeat(Math.max(0, Math.floor((width - visibleWidth(num)) / 2)));
+      const padDen = " ".repeat(Math.max(0, Math.floor((width - visibleWidth(den)) / 2)));
+      const l1 = padNum + num;
+      const l2 = bar;
+      const l3 = padDen + den;
+      const centerIndent2 = Math.max(0, Math.floor((columns - width) / 2));
+      const indent2 = " ".repeat(centerIndent2);
+      return `\x1B[2m${indent2}${l1}
+${indent2}${l2}
+${indent2}${l3}\x1B[0m`;
+    }
+  }
+  const transpiled = transpileLatexToUnicode(trimmed);
+  const lines = transpiled.split("\n");
+  const maxLineW = Math.max(...lines.map((l) => visibleWidth(l)));
+  const centerIndent = Math.max(0, Math.floor((columns - maxLineW) / 2));
+  const indent = " ".repeat(centerIndent);
+  const centeredLines = lines.map((line) => `${indent}${line}`);
+  return `\x1B[2m${centeredLines.join("\n")}\x1B[0m`;
+}
+function isCurrencyOrNonMath(leadingChar, inner, trailingChar) {
+  if (!inner || /^\s/.test(inner) || /\s$/.test(inner)) return true;
+  if (/[a-zA-Z0-9]/.test(leadingChar)) return true;
+  if (/^(?:\d[\d,]*(?:\.\d+)?|\.\d+)$/.test(inner)) return true;
+  if (/^\d/.test(inner)) {
+    if (/\d/.test(trailingChar)) return true;
+    if (/[\u4e00-\u9fa5]/.test(inner)) return true;
+    if (/\b(to|and|or|for|is|between|with|at|from|dollars?|cents?|usd|cny|rmb|eur|gbp)\b/i.test(inner)) return true;
+    if (/,\s*\d/.test(inner)) return true;
+    if (/\s+/.test(inner) && !/[=+\-*/\\^_<>]/.test(inner)) return true;
+  }
+  return false;
+}
+function maskMathInLine(line, brightness) {
+  const replacements = [];
+  let out = "";
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === "\\") {
+      if (line.startsWith("\\(", i)) {
+        const closeIdx = line.indexOf("\\)", i + 2);
+        if (closeIdx !== -1) {
+          const inner = line.slice(i + 2, closeIdx);
+          const id = replacements.length;
+          const transpiled = transpileLatexToUnicode(inner);
+          replacements.push(transpiled);
+          out += `\0M${id}\0`;
+          i = closeIdx + 2;
+          continue;
+        }
+      }
+      if (line.startsWith("\\[", i)) {
+        const closeIdx = line.indexOf("\\]", i + 2);
+        if (closeIdx !== -1) {
+          const inner = line.slice(i + 2, closeIdx);
+          const id = replacements.length;
+          const transpiled = transpileLatexToUnicode(inner);
+          replacements.push(transpiled);
+          out += `\0M${id}\0`;
+          i = closeIdx + 2;
+          continue;
+        }
+      }
+      out += line[i];
+      if (i + 1 < line.length) {
+        out += line[i + 1];
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (line[i] === "`") {
+      let runLen = 1;
+      while (i + runLen < line.length && line[i + runLen] === "`") {
+        runLen++;
+      }
+      const fence = "`".repeat(runLen);
+      const closeIdx = line.indexOf(fence, i + runLen);
+      if (closeIdx !== -1) {
+        const span = line.slice(i, closeIdx + runLen);
+        out += span;
+        i = closeIdx + runLen;
+        continue;
+      }
+    }
+    if (line[i] === "$") {
+      if (line.startsWith("$$", i)) {
+        const closeIdx = line.indexOf("$$", i + 2);
+        if (closeIdx !== -1) {
+          const inner = line.slice(i + 2, closeIdx);
+          const id = replacements.length;
+          const transpiled = transpileLatexToUnicode(inner);
+          replacements.push(transpiled);
+          out += `\0M${id}\0`;
+          i = closeIdx + 2;
+          continue;
+        }
+      }
+      const nextChar = line[i + 1] ?? "";
+      if (nextChar && !/\s/.test(nextChar) && nextChar !== "$") {
+        let closeIdx = -1;
+        for (let j = i + 1; j < line.length; j++) {
+          if (line[j] === "$" && line[j - 1] !== "\\") {
+            if (!/\s/.test(line[j - 1] ?? "")) {
+              closeIdx = j;
+              break;
+            }
+          }
+        }
+        if (closeIdx !== -1) {
+          const inner = line.slice(i + 1, closeIdx);
+          const leadingChar = i > 0 ? line[i - 1] ?? "" : "";
+          const trailingChar = closeIdx + 1 < line.length ? line[closeIdx + 1] ?? "" : "";
+          if (!isCurrencyOrNonMath(leadingChar, inner, trailingChar)) {
+            const id = replacements.length;
+            const transpiled = transpileLatexToUnicode(inner);
+            replacements.push(transpiled);
+            out += `\0M${id}\0`;
+            i = closeIdx + 1;
+            continue;
+          }
+        }
+      }
+    }
+    out += line[i];
+    i++;
+  }
+  return {
+    maskedText: out,
+    restore: (styled) => {
+      return styled.replace(/\x00M(\d+)\x00/g, (_, id) => replacements[Number(id)] ?? "");
+    }
+  };
+}
+
+// packages/cli/client/inlineMarkdown.ts
+var STYLE2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
   dim: "\x1B[2m"
@@ -972,20 +2284,359 @@ var STYLE = {
 function colorSeq(token, brightness) {
   return themeColorSequence(token, process.env, brightness);
 }
+function renderMarkdownLink(match, text, url) {
+  const visible = `${text} (${url})`;
+  return `\x1B]8;;${url}\x1B\\${visible}\x1B]8;;\x1B\\`;
+}
+var MARKDOWN_LINK_RE = /\[([^\]]+)\]\(([^)\s]+)\)/g;
+function styleInlineMarkdown(line, brightness) {
+  const inlineCode = colorSeq("muted", brightness);
+  const reset = STYLE2.reset;
+  const bold = STYLE2.bold;
+  const dim = STYLE2.dim;
+  const zwsCode = "\u200B";
+  const mathMask = maskMathInLine(line, brightness);
+  const styled = mathMask.maskedText.replace(MARKDOWN_LINK_RE, (m, t2, u) => renderMarkdownLink(m, t2, u)).replace(
+    /\u200b([^\u200b\n]+)\u200b/g,
+    (_m, inner) => `${zwsCode}${inlineCode}${inner}${reset}${zwsCode}`
+  ).replace(/`([^`]+)`/g, `${inlineCode}$1${reset}`).replace(/\*\*(.+?)\*\*/g, `${bold}$1${reset}`).replace(/(?<!\*)\*([^*]+?)\*(?!\*)/g, `${dim}$1${reset}`).replace(/~~([^~]+?)~~/g, `${dim}\x1B[9m$1\x1B[29m${reset}`);
+  return mathMask.restore(styled);
+}
+
+// packages/cli/client/markdownTable.ts
+var SENTINEL_OPEN = "
";
+var SENTINEL_CLOSE = "";
+function maskCellInternals(cell) {
+  let out = "";
+  let index = 0;
+  while (index < cell.length) {
+    const ch = cell[index];
+    if (ch === "\\" && cell[index + 1] === "|") {
+      out += `${SENTINEL_OPEN}0${SENTINEL_CLOSE}`;
+      index += 2;
+      continue;
+    }
+    if (ch === "`") {
+      const end = cell.indexOf("`", index + 1);
+      if (end > index) {
+        out += cell.slice(index, end + 1).replace(/\|/g, `${SENTINEL_OPEN}1${SENTINEL_CLOSE}`);
+        index = end + 1;
+        continue;
+      }
+    }
+    out += ch;
+    index += 1;
+  }
+  return out;
+}
+function unmaskCell(cell) {
+  return cell.replace(/\x010\x02/g, "|").replace(/\x011\x02/g, "|");
+}
 function splitTableCells(line) {
   const trimmed = line.trim();
   if (!trimmed.includes("|")) return [];
   const core = trimmed.replace(/^\|/, "").replace(/\|$/, "");
-  return core.split("|").map((cell) => cell.trim()).filter(Boolean);
+  const masked = maskCellInternals(core);
+  return masked.split("|").map((cell) => unmaskCell(cell.trim()));
+}
+function parseTableAligns(sepLine) {
+  return splitTableCells(sepLine).map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.length > 1 && cell.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    return "left";
+  });
 }
-function isTableSeparator(line) {
+function isTableSeparatorLine(line) {
   const cells = splitTableCells(line);
-  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+  return cells.length > 0 && cells.every((cell) => /^:?-+:?$/.test(cell));
 }
 function isTableRow(line) {
   const cells = splitTableCells(line);
   return cells.length >= 2 && cells.some((cell) => cell.length > 0);
 }
+function parseMarkdownTableBlock(rows) {
+  if (rows.length < 2) return null;
+  const headerLine = rows[0];
+  const sepLine = rows[1] ?? "";
+  if (!isTableSeparatorLine(sepLine)) return null;
+  const headers = splitTableCells(headerLine ?? "");
+  if (headers.length < 2) return null;
+  const aligns = parseTableAligns(sepLine);
+  while (aligns.length < headers.length) aligns.push("left");
+  const tableRows = [];
+  for (let i = 2; i < rows.length; i++) {
+    const cells = splitTableCells(rows[i] ?? "");
+    if (cells.length === 0) continue;
+    const padded = [];
+    for (let c = 0; c < headers.length; c += 1) padded.push(cells[c] ?? "");
+    tableRows.push(padded);
+  }
+  return { headers, aligns, rows: tableRows };
+}
+function resolveTableWidth(explicit, env = process.env) {
+  if (typeof explicit === "number" && explicit > 0) return explicit;
+  const override = parseInt(env.NOLO_TEST_TABLE_WIDTH, 10);
+  if (!Number.isNaN(override) && override > 0) return override;
+  const cols = typeof process !== "undefined" && typeof process.stdout?.columns === "number" ? process.stdout.columns : 0;
+  if (cols > 0) return cols;
+  return 80;
+}
+function wrapCellToWidth(text, max) {
+  if (max <= 0 || displayWidth(text) <= max) return [text];
+  const tokens = tokenizeAnsiLine(text);
+  const charTokenIdx = [];
+  tokens.forEach((t2, i) => {
+    if (t2.kind === "char") charTokenIdx.push(i);
+  });
+  const n = charTokenIdx.length;
+  if (n === 0) return [text];
+  const widths = charTokenIdx.map((i) => tokens[i].width);
+  const prefix = [0];
+  for (let i = 0; i < widths.length; i += 1) prefix.push(prefix[i] + widths[i]);
+  const segWidth = (a, b) => prefix[b] - prefix[a];
+  const sliceTokens = (a, b) => {
+    const startTok = a === 0 ? 0 : charTokenIdx[a - 1] + 1;
+    const endTok = b < n ? charTokenIdx[b] - 1 : tokens.length - 1;
+    return tokens.slice(startTok, endTok + 1);
+  };
+  const applyStyles = (slice, state) => {
+    const next = [...state];
+    for (const t2 of slice) {
+      if (t2.kind !== "sgr") continue;
+      if (OSC8_CLOSER_REGEX.test(t2.value)) {
+        for (let i = next.length - 1; i >= 0; i -= 1) {
+          if (OSC8_OPENER_REGEX.test(next[i])) {
+            next.splice(i, 1);
+            break;
+          }
+        }
+      } else if (OSC8_OPENER_REGEX.test(t2.value)) {
+        next.push(t2.value);
+      } else if (SGR_RESET_REGEX2.test(t2.value)) {
+        for (let i = next.length - 1; i >= 0; i -= 1) {
+          if (!OSC8_OPENER_REGEX.test(next[i]) && !OSC8_CLOSER_REGEX.test(next[i])) {
+            next.splice(i, 1);
+          }
+        }
+      } else {
+        next.push(t2.value);
+      }
+    }
+    return next;
+  };
+  const renderSegment = (slice, opening) => {
+    const raw = slice.map((t2) => t2.value).join("");
+    const endState = applyStyles(slice, opening);
+    const hasOpenOsc = endState.some((v) => OSC8_OPENER_REGEX.test(v));
+    const hasOpenSgr = endState.some(
+      (v) => !OSC8_OPENER_REGEX.test(v) && !OSC8_CLOSER_REGEX.test(v)
+    );
+    const prefix2 = opening.length > 0 ? opening.join("") : "";
+    let suffix = "";
+    if (hasOpenOsc) suffix += "\x1B]8;;\x1B\\";
+    if (hasOpenSgr && !raw.endsWith("\x1B[0m")) suffix += "\x1B[0m";
+    return `${prefix2}${raw}${suffix}`;
+  };
+  const segments = [];
+  let active = [];
+  let start = 0;
+  for (let i = 1; i < n; i += 1) {
+    if (segWidth(start, i + 1) <= max) continue;
+    let cut = -1;
+    for (let j = i - 1; j > start; j -= 1) {
+      if (tokens[charTokenIdx[j]].value !== " ") continue;
+      if (segWidth(start, j) <= max && segWidth(j + 1, i + 1) <= max) {
+        cut = j;
+        break;
+      }
+    }
+    if (cut >= 0) {
+      const slice = sliceTokens(start, cut);
+      segments.push(renderSegment(slice, active));
+      active = applyStyles(slice, active);
+      start = cut + 1;
+    } else {
+      let hard = start;
+      let w = 0;
+      while (hard < i && widths[hard] > 0 && w + widths[hard] <= max) {
+        w += widths[hard];
+        hard += 1;
+      }
+      if (hard <= start) hard = start + 1;
+      const slice = sliceTokens(start, hard);
+      segments.push(renderSegment(slice, active));
+      active = applyStyles(slice, active);
+      start = hard;
+    }
+  }
+  if (start < n) {
+    const slice = sliceTokens(start, n);
+    segments.push(renderSegment(slice, active));
+  }
+  return segments.length > 0 ? segments : [text];
+}
+var SGR_RESET_REGEX2 = /^\x1b\[0?m$/;
+var OSC8_OPENER_REGEX = /^\x1b\]8;;[^\x07\x1b]+(?:\x07|\x1b\\)$/;
+var OSC8_CLOSER_REGEX = /^\x1b\]8;;\x1b\\$/;
+function padCell(text, width, align) {
+  const pad = width - displayWidth(text);
+  if (pad <= 0) return text;
+  switch (align) {
+    case "right":
+      return " ".repeat(pad) + text;
+    case "center": {
+      const left = Math.floor(pad / 2);
+      return " ".repeat(left) + text + " ".repeat(pad - left);
+    }
+    case "left":
+    default:
+      return text + " ".repeat(pad);
+  }
+}
+function computeColumnWidths(headers, rows, available) {
+  const colCount = headers.length;
+  const natural = headers.map((h, i) => {
+    let max = displayWidth(h ?? "");
+    for (const row of rows) {
+      const w = displayWidth(row[i] ?? "");
+      if (w > max) max = w;
+    }
+    return max;
+  });
+  const border = 2 * colCount + 1;
+  const total = () => border + natural.reduce((a, b) => a + b, 0);
+  if (total() <= available) return natural;
+  const minPerCol = Math.max(2, Math.floor((available - border) / colCount));
+  let guard = colCount * 64;
+  while (total() > available && guard-- > 0) {
+    let widest = 0;
+    for (let i = 1; i < colCount; i += 1) {
+      if (natural[i] > natural[widest]) widest = i;
+    }
+    if (natural[widest] <= minPerCol) break;
+    const overflow = total() - available;
+    const delta = Math.min(
+      natural[widest] - minPerCol,
+      Math.max(1, Math.ceil(overflow / 2))
+    );
+    natural[widest] -= delta;
+  }
+  return natural;
+}
+function makeStyle(brightness, headerToken) {
+  const color = themeColorSequence(headerToken, process.env, brightness);
+  const boldOn = "\x1B[1m";
+  const reset = "\x1B[0m";
+  const paint = (t2) => `${color}${boldOn}${t2}${reset}`;
+  return { header: paint, label: paint };
+}
+function boxLine(left, mid, right, widths) {
+  const seg = widths.map((w) => "\u2500".repeat(w + 2));
+  return `${left}${seg.join(mid)}${right}`;
+}
+function dataRow(cells, aligns, widths, style, header) {
+  const parts = cells.map((cell, i) => {
+    const width = widths[i] ?? 0;
+    const align = aligns[i] ?? "left";
+    const padded = padCell(cell, width, align);
+    const styled = header ? style.header(padded) : padded;
+    return ` ${styled} \u2502`;
+  });
+  return `\u2502${parts.join("")}`;
+}
+function renderBoxTable(table, width, style) {
+  const colCount = table.headers.length;
+  const widths = computeColumnWidths(table.headers, table.rows, width);
+  const headerGrid = table.headers.map(
+    (h, i) => wrapCellToWidth(h, widths[i] ?? 0)
+  );
+  const bodyGrids = table.rows.map(
+    (row) => row.map((cell, i) => wrapCellToWidth(cell, widths[i] ?? 0))
+  );
+  const headerDisplayRows = Math.max(1, ...headerGrid.map((g) => g.length));
+  const bodyDisplayRows = bodyGrids.map(
+    (r) => Math.max(1, ...r.map((g) => g.length))
+  );
+  const lines = [];
+  lines.push(boxLine("\u250C", "\u252C", "\u2510", widths));
+  for (let r = 0; r < headerDisplayRows; r += 1) {
+    lines.push(
+      dataRow(
+        Array.from({ length: colCount }, (_, c) => headerGrid[c]?.[r] ?? ""),
+        table.aligns,
+        widths,
+        style,
+        true
+      )
+    );
+  }
+  lines.push(boxLine("\u251C", "\u253C", "\u2524", widths));
+  bodyGrids.forEach((_, rec) => {
+    for (let r = 0; r < bodyDisplayRows[rec]; r += 1) {
+      lines.push(
+        dataRow(
+          Array.from(
+            { length: colCount },
+            (_2, c) => bodyGrids[rec][c]?.[r] ?? ""
+          ),
+          table.aligns,
+          widths,
+          style,
+          false
+        )
+      );
+    }
+  });
+  lines.push(boxLine("\u2514", "\u2534", "\u2518", widths));
+  return lines.join("\n");
+}
+function renderRecordCards(table, width, style) {
+  const lines = [];
+  table.rows.forEach((row, idx) => {
+    if (idx > 0) lines.push("");
+    const first = row[0] ?? "";
+    for (const seg of wrapCellToWidth(first, Math.max(4, width))) {
+      lines.push(style.label(seg));
+    }
+    for (let i = 1; i < table.headers.length; i += 1) {
+      const label = table.headers[i] ?? `col${i}`;
+      const value = row[i] ?? "";
+      const labelLine = `${style.label(label)}: `;
+      const indent = " ".repeat(displayWidth(label) + 2);
+      const valueSegs = wrapCellToWidth(
+        value,
+        Math.max(4, width - displayWidth(label) - 2)
+      );
+      if (valueSegs.length === 0 || valueSegs[0] === "") {
+        lines.push(labelLine);
+      } else {
+        lines.push(labelLine + valueSegs[0]);
+        for (let k = 1; k < valueSegs.length; k += 1) {
+          lines.push(indent + valueSegs[k]);
+        }
+      }
+    }
+  });
+  return lines.join("\n");
+}
+function renderMarkdownTable(table, options = {}) {
+  const brightness = options.brightness ?? resolveTuiBrightness();
+  const width = resolveTableWidth(options.width);
+  const style = makeStyle(brightness, options.headerToken ?? "chrome");
+  const styledTable = {
+    headers: table.headers.map((h) => styleInlineMarkdown(h, brightness)),
+    aligns: table.aligns,
+    rows: table.rows.map((r) => r.map((c) => styleInlineMarkdown(c, brightness)))
+  };
+  if (width < 40 || table.headers.length > 6) {
+    return renderRecordCards(styledTable, width, style);
+  }
+  return renderBoxTable(styledTable, width, style);
+}
+
+// packages/cli/client/assistantOutput.ts
 function isPipeWrappedTableRow(line) {
   const trimmed = line.trim();
   return trimmed.startsWith("|") && trimmed.endsWith("|") && isTableRow(line);
@@ -1143,7 +2794,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 +2805,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) {
@@ -1207,12 +2858,6 @@ function emitPlainGap(text, keywords, info, accent, warning, reset) {
   }
   return parts.join("");
 }
-function tableRowToBullet(line) {
-  const row = splitTableCells(line);
-  const label = row[0] ?? "";
-  const detail = row.slice(1).join(" \u2014 ").trim();
-  return detail ? `  \u2022 ${label} \u2014 ${detail}` : `  \u2022 ${label}`;
-}
 var UNORDERED_LIST_RE = /^(\s*)([-*+])\s+(.+)$/;
 var ORDERED_LIST_RE = /^(\s*)(\d+)\.\s+(.+)$/;
 var TASK_LIST_RE = /^(\s*)([-*+])\s+\[([ xX])\]\s+(.+)$/;
@@ -1248,17 +2893,36 @@ function convertMarkdownTablesForTerminal(text) {
       continue;
     }
     const next = lines[index + 1] ?? "";
-    if (isTableRow(line) && isTableSeparator(next)) {
-      index += 1;
-      while (index + 1 < lines.length && isTableRow(lines[index + 1] ?? "") && !isTableSeparator(lines[index + 1] ?? "")) {
-        index += 1;
-        out.push(tableRowToBullet(lines[index] ?? ""));
+    if (isTableRow(line) && isTableSeparatorLine(next)) {
+      const block = [line, next];
+      let cursor = index + 2;
+      while (cursor < lines.length && isTableRow(lines[cursor] ?? "") && !isTableSeparatorLine(lines[cursor] ?? "")) {
+        block.push(lines[cursor] ?? "");
+        cursor += 1;
+      }
+      index = cursor - 1;
+      const table = parseMarkdownTableBlock(block);
+      const hasBody = table !== null && table.rows.length > 0;
+      if (table && hasBody) {
+        out.push(renderMarkdownTable(table));
+        if (out[out.length - 1] !== "") out.push("");
+      } else {
+        for (const l of block) out.push(l);
       }
-      if (out.length > 0 && out[out.length - 1] !== "") out.push("");
       continue;
     }
     if (isPipeWrappedTableRow(line)) {
-      if (!isTableSeparator(line)) out.push(tableRowToBullet(line));
+      if (!isTableSeparatorLine(line)) {
+        const cells = splitTableCells(line);
+        out.push(
+          renderMarkdownTable({
+            headers: ["record", ...cells.slice(1).map((_, i) => `col${i + 1}`)],
+            aligns: ["left", ...cells.slice(1).map(() => "left")],
+            rows: [cells]
+          })
+        );
+        if (out[out.length - 1] !== "") out.push("");
+      }
       continue;
     }
     out.push(normalizeListLine(line));
@@ -1298,80 +2962,150 @@ function polishAssistantStructure(text, options = {}) {
   );
   return options.trimEdges === false ? polished : polished.trim();
 }
-function renderMarkdownLink(match, text, url) {
-  const visible = `${text} (${url})`;
-  return `\x1B]8;;${url}\x1B\\${visible}\x1B]8;;\x1B\\`;
-}
-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;
-  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) {
   const heading = line.match(/^(#{1,3})\s+(.+)$/);
   if (heading) {
     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");
+    const trimmed = line.trim();
+    if (trimmed.startsWith("$$") || trimmed.startsWith("\\[")) {
+      const isBracket = trimmed.startsWith("\\[");
+      const closeMarker = isBracket ? "\\]" : "$$";
+      if (trimmed.length > 2 && trimmed.endsWith(closeMarker)) {
+        const inner = trimmed.slice(2, trimmed.length - 2);
+        out.push(renderMathBlock(inner));
+        i++;
+        continue;
+      }
+      const blockLines = [];
+      const firstInner = trimmed.slice(2).trim();
+      if (firstInner) blockLines.push(firstInner);
+      let j = i + 1;
+      let closed = false;
+      while (j < lines.length) {
+        const curLine = lines[j] ?? "";
+        const curTrim = curLine.trim();
+        if (curTrim.endsWith(closeMarker) || curTrim === closeMarker) {
+          const lastInner = curTrim.slice(0, curTrim.length - 2).trim();
+          if (lastInner) blockLines.push(lastInner);
+          closed = true;
+          j++;
+          break;
+        }
+        blockLines.push(curLine);
+        j++;
+      }
+      if (closed) {
+        out.push(renderMathBlock(blockLines.join("\n")));
+        i = j;
+        continue;
+      }
+    }
+    out.push(styleRichMarkdownLine(line, brightness));
+    i++;
+  }
+  flushMermaid();
+  return out.join("\n");
 }
 function emitFormattedAssistantBlock(write, text, trailingNewline = false) {
   if (!text) return;
@@ -1396,6 +3130,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) => {
@@ -1412,7 +3148,7 @@ function createRenderAwareStreamWriter(args) {
     const whitespaceIndex = graphemes.slice(0, cut).findLastIndex((part) => /\s/.test(part));
     if (whitespaceIndex > 0) cut = whitespaceIndex + 1;
     const prefix = graphemes.slice(0, cut).join("");
-    const hasUnsafeMarkdownPrefix = /[`*_~\[]/.test(prefix) || /^\s*[#>]/.test(prefix) || /!\[/.test(prefix);
+    const hasUnsafeMarkdownPrefix = /[`*_~\[$]/.test(prefix) || /^\s*[#>]/.test(prefix) || /!\[/.test(prefix);
     if (hasUnsafeMarkdownPrefix) return;
     emitBreathIfNeeded("prose");
     emitFormattedAssistantBlock(args.write, prefix, false);
@@ -1425,19 +3161,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)}
 `);
@@ -1445,12 +3206,50 @@ function createRenderAwareStreamWriter(args) {
         buffer = lines.slice(1).join("\n");
         continue;
       }
+      const trimmedFirst = firstLine.trim();
+      if ((trimmedFirst.startsWith("$$") || trimmedFirst.startsWith("\\[")) && !inFence) {
+        const isBracket = trimmedFirst.startsWith("\\[");
+        const closeMarker = isBracket ? "\\]" : "$$";
+        if (trimmedFirst.length > 2 && trimmedFirst.endsWith(closeMarker)) {
+          emitBreathIfNeeded("other");
+          const inner = trimmedFirst.slice(2, trimmedFirst.length - 2);
+          args.write(renderMathBlock(inner) + "\n");
+          lastKind = "other";
+          buffer = lines.slice(1).join("\n");
+          continue;
+        }
+        let closeIndex = -1;
+        for (let j = 1; j < lines.length; j++) {
+          const curTrim = lines[j]?.trim() ?? "";
+          if (curTrim.endsWith(closeMarker) || curTrim === closeMarker) {
+            closeIndex = j;
+            break;
+          }
+        }
+        if (closeIndex === -1) {
+          break;
+        }
+        emitBreathIfNeeded("other");
+        const blockLines = lines.slice(0, closeIndex + 1);
+        const firstInner = blockLines[0].trim().slice(2).trim();
+        const middleLines = blockLines.slice(1, -1);
+        const lastTrim = blockLines[blockLines.length - 1].trim();
+        const lastInner = lastTrim.slice(0, lastTrim.length - 2).trim();
+        const innerParts = [];
+        if (firstInner) innerParts.push(firstInner);
+        innerParts.push(...middleLines);
+        if (lastInner) innerParts.push(lastInner);
+        args.write(renderMathBlock(innerParts.join("\n")) + "\n");
+        lastKind = "other";
+        buffer = lines.slice(closeIndex + 1).join("\n");
+        continue;
+      }
       if (isTableRow(firstLine)) {
         const nextLineComplete = lines.length > 2;
         if (!nextLineComplete) break;
-        if (isTableSeparator(lines[1] ?? "")) {
+        if (isTableSeparatorLine(lines[1] ?? "")) {
           let end = 2;
-          while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparator(lines[end] ?? "")) {
+          while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparatorLine(lines[end] ?? "")) {
             end += 1;
           }
           const tableComplete = end < lines.length - 1;
@@ -1481,6 +3280,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);
@@ -2321,7 +4128,7 @@ function isReadToolName(name) {
 }
 function isSearchToolName(name) {
   if (!name) return false;
-  return name === "grep" || name === "searchFiles" || name === "search_files" || name === "globFiles" || name === "glob_files" || name === "glob" || name === "searchWorkspace" || name === "search_workspace" || name === "search_all_spaces" || name === "search";
+  return name === "grep" || name === "codeSearch" || name === "code_search" || name === "globFiles" || name === "glob_files" || name === "glob" || name === "searchWorkspace" || name === "search_workspace" || name === "search_all_spaces" || name === "search";
 }
 function isRunToolName(name) {
   if (!name) return false;
@@ -2341,7 +4148,7 @@ function isRunResultFoldable(event) {
 function formatSearchTreeBlockForCli(items, colorEnabled) {
   if (items.length === 0) return "";
   const { count, lines } = formatSearchTreeLines(items);
-  const titleText = toolLabel("searchFiles");
+  const titleText = toolLabel("codeSearch");
   if (!colorEnabled) {
     const headerLine2 = `\u2022 ${titleText} (${count})
 `;
@@ -2992,6 +4799,28 @@ ${this.text}
 };
 
 // packages/cli/client/agentRunOutput.ts
+function formatCompactionSummaryLine(event) {
+  if (!event) return "";
+  const action = event.reason === "tool_stub" ? "stub \u5DE5\u5177\u8F93\u51FA" : "\u751F\u6210\u5386\u53F2\u6458\u8981";
+  let detail = action;
+  if (typeof event.stubbedCount === "number") {
+    detail = `stub ${event.stubbedCount} \u6761\u5DE5\u5177\u8F93\u51FA`;
+  }
+  const saved = typeof event.savedTokens === "number" ? event.savedTokens : void 0;
+  let line = `\u5DF2\u538B\u7F29\u4E0A\u4E0B\u6587\uFF1A${detail}`;
+  if (saved !== void 0) {
+    let k;
+    if (saved >= 1e3) {
+      const v = (saved / 1e3).toFixed(1);
+      k = v.replace(/\.0$/, "") + "k";
+    } else {
+      k = String(saved);
+    }
+    line += `\uFF0C\u7701\u7EA6 ${k} tokens`;
+  }
+  line += "\n";
+  return `${STYLE2.dim}${line}${STYLE2.reset}`;
+}
 function formatAssistantResponseForCli(text) {
   return formatAssistantDisplay(
     formatAssistantTextForCli(text)
@@ -3030,6 +4859,7 @@ function createCliTurnOutput(params) {
   let everStreamedAnyText = false;
   let printedAssistantLabel = false;
   let thinkState = createThinkParserState();
+  let compactionEvent = null;
   const renderWriter = createRenderAwareStreamWriter({
     write: (chunk) => options.output.write(chunk)
   });
@@ -3102,6 +4932,10 @@ ${options.agentName} > `);
       spinner.setThinkingHint(chunk);
     },
     handleToolEvent,
+    /** 记录一条 compaction 观测事件（TUI 在 turn 结束时渲染一行 dim 摘要）。 */
+    recordCompaction(event) {
+      compactionEvent = event;
+    },
     showWorking(label) {
       const activeLabel = label ?? workingLabel;
       spinner.show(activeLabel);
@@ -3136,6 +4970,10 @@ ${options.agentName} > (no text response)
 `);
         }
       }
+      const compactionLine = formatCompactionSummaryLine(compactionEvent);
+      if (compactionLine) {
+        options.output.write(compactionLine);
+      }
     }
   };
 }
@@ -3304,7 +5142,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 +5359,7 @@ function findCollapsedPasteSpanAt(buffer, pos, opts = {}) {
 // packages/cli/client/agentRun.ts
 import { ulid } from "ulid";
 async function loadRunLocalAgentTurn() {
-  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-PRAR3NCW.js");
+  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-XXBMDMBU.js");
   return runLocalAgentTurn;
 }
 async function resolveCurrentMachineId(options) {
@@ -3753,6 +5591,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,11 +5896,8 @@ 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
-`
-          );
+        if (event.kind === "compaction") {
+          turnOutput.recordCompaction(event);
         }
         options.onLoopEvent?.(event);
       },
@@ -4071,6 +5910,9 @@ async function runLocalAgentTurnForCli(options, settings) {
       ...!options.noStream ? {
         onTextDelta: (chunk) => {
           turnOutput.pushText(chunk);
+        },
+        onReasoningDelta: (chunk) => {
+          turnOutput.pushThinking(chunk);
         }
       } : {}
     });
@@ -4080,6 +5922,7 @@ async function runLocalAgentTurnForCli(options, settings) {
       dialogId: result.dialogId,
       title: result.title,
       ...result.titlePatchPromise ? { titlePatchPromise: result.titlePatchPromise } : {},
+      ...result.emptyAssistantFallbackReason ? { emptyAssistantFallbackReason: result.emptyAssistantFallbackReason } : {},
       turnTokens: buildTurnTokenUsage(result.usage, result.model)
     };
   } catch (error) {
@@ -4317,6 +6160,20 @@ ${patch}${skill.content}`);
   }
   return blocks;
 }
+var OUTPUT_FORMAT_GUIDANCE = [
+  "Output format guidance:",
+  "- Use semantic Markdown by default.",
+  "- Use tables for genuinely multi-column structured data.",
+  "- Use $...$ or $$...$$ for mathematical expressions.",
+  "- Use ```mermaid fenced blocks only when diagrams materially clarify a process, dependency, architecture, or state transition.",
+  "- Use language-tagged fenced blocks for code.",
+  "- Do not add tables or Mermaid for decoration; when complex syntax is uncertain, prefer plain Markdown or text.",
+  ""
+].join("\n");
+function prependOutputFormatGuidance(message) {
+  if (message.startsWith(OUTPUT_FORMAT_GUIDANCE)) return message;
+  return `${OUTPUT_FORMAT_GUIDANCE}${message}`;
+}
 function prependWorkflowReferencePrompt(message, workflow) {
   if (!workflow) return message;
   const config = workflow.config;
@@ -4868,40 +6725,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);
@@ -5131,6 +6954,7 @@ async function runAgentRunCommand(args, deps) {
         msgFile: readFlagValue(args, "--msg-file"),
         message: parsed.message,
         timeoutMs: parsed.timeoutMs,
+        ...parsed.dodCommands?.length ? { dodCommands: parsed.dodCommands } : {},
         output
       },
       {
@@ -5217,7 +7041,7 @@ async function runAgentRunCommand(args, deps) {
     message: prependWorkflowReferencePrompt(
       prependSubjectDialogMarker(
         prependFeatureWorktreeInstruction(
-          effectiveMessage,
+          prependOutputFormatGuidance(effectiveMessage),
           parsed.injectFeatureWorktreeInstruction
         ),
         parsed.subjectDialogKey
@@ -5325,13 +7149,16 @@ async function runAgentRunCommand(args, deps) {
     }
   }
   if (typeof childRunId === "string" && childRunId.length > 0) {
-    const finalStatus = result.exitCode === 0 ? "done" : "failed";
+    const isTruncated = result.emptyAssistantFallbackReason === "length_truncated" || result.emptyAssistantFallbackReason === "stream_truncated";
+    const truncationNote = isTruncated ? { note: `empty assistant output: ${result.emptyAssistantFallbackReason}` } : {};
+    const finalStatus = isTruncated || result.exitCode !== 0 ? "failed" : "done";
     await (deps.finalizeRunRecord ?? finalizeRunRecord)(
       childRunId,
       {
         status: finalStatus,
         exitCode: result.exitCode,
-        dialogId: result.dialogId
+        dialogId: result.dialogId,
+        ...truncationNote
       },
       {
         env,
@@ -5340,6 +7167,23 @@ async function runAgentRunCommand(args, deps) {
         now: deps.now
       }
     );
+    try {
+      const record = (deps.readRunRecord ?? readRunRecord)(childRunId, {
+        env,
+        homedir: deps.homedir,
+        fs: deps.fs
+      });
+      if (record) {
+        await (deps.generateRunReport ?? generateRunReport)(record, {
+          env,
+          homedir: deps.homedir,
+          fs: deps.fs,
+          now: deps.now
+        });
+      }
+    } catch (reportError) {
+      console.warn(`[nolo] failed to generate run report for ${childRunId}:`, reportError);
+    }
   }
   return result.exitCode;
 }
@@ -5363,7 +7207,7 @@ export {
   resolveCliColorEnabled,
   dimCliText,
   ANSI_ESCAPE_REGEX,
-  stripAnsi,
+  stripAnsi2 as stripAnsi,
   applyTerminalOutputToText,
   displayWidth,
   visibleWidth,
@@ -5372,25 +7216,32 @@ export {
   countPhysicalLines,
   takeDisplayWidth,
   padOrTruncateToWidth,
+  tokenizeAnsiLine,
+  buildSourceMapping,
+  wrapTranscriptLineWithLayout,
   wrapTranscriptLine,
   buildWindowTitle,
   wrapTextToLines,
   THEME_PALETTES,
   getActiveThemeName,
   setActiveThemeName,
-  getActiveBrightness,
+  getActiveThemeMode,
+  setActiveThemeMode,
   setActiveBrightness,
   getActiveDensity,
   setActiveDensity,
   detectSystemBrightnessFromEnv,
   resolveTuiBrightness,
-  setActiveTerminalBaseHex,
+  resolveTuiThemeMode,
+  resetWorkspaceThemeState,
   applyDetectedBackground,
   renderSurfaceLine,
   surfaceBackgroundSequence,
   userSurfaceBackgroundSequence,
   themeColorSequence,
   themeText,
+  tuiRenderThemeFingerprint,
+  setMathRenderingEnabled,
   formatAssistantDisplay,
   normalizeToolDisplayMode,
   COLLAPSED_PASTE_PLACEHOLDER_RE,
@@ -5411,8 +7262,6 @@ export {
   normalizeCliImageInput,
   inspectLocalRunWorkspace,
   resolveCliMemory,
-  QUOTA_ERROR_PATTERNS,
-  isQuotaExhaustedError,
   runAgentRunCommand,
   isBalanceExhaustedError
 };