nolo-cli 0.8.0 → 0.9.0

package/chunk-KOCA5FCS.js

@@ -0,0 +1,4750 @@
+import {
+  createRunActivityTracker,
+  finalizeRunRecord,
+  spawnLocalBackgroundRun
+} from "./chunk-2FTTDCD4.js";
+import {
+  buildLocalRunEnv,
+  isFullstackCodingAgentRef,
+  parseAgentRunArgs,
+  readFlagValue,
+  resolveRawAgentInput,
+  resolveServerUrl,
+  writeUsage
+} from "./chunk-DZ3XJVET.js";
+import {
+  createCliCallAgentToolExecutor,
+  createCliLocalRuntimeAdapter,
+  isBuiltinNoloAgentRef
+} from "./chunk-LARL2V6G.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  readDbRecord,
+  resolveAgentRecordFromHybridStore
+} from "./chunk-7OOXPE3N.js";
+import {
+  normalizeAgentHandle
+} from "./chunk-2PUGVR6E.js";
+import {
+  NOLO_PROJECT_MANAGER_AGENT_KEY,
+  isLocalCliAgentKey
+} from "./chunk-VHBWHNVT.js";
+import {
+  applyModelLayerOverride,
+  buildMemoryOverlayLayer,
+  buildMemoryUseGuidanceLayer,
+  buildModelLayerOverride,
+  buildSkillDiscoveryLayer
+} from "./chunk-SL35K7AH.js";
+import {
+  CliProviderQuotaError
+} from "./chunk-X7W4TNB4.js";
+import {
+  resolveMachineId
+} from "./chunk-6HYVJV7B.js";
+import {
+  isGatewayHttpStatus
+} from "./chunk-GAKEBQD6.js";
+import {
+  buildMemorySubjectsForAgent,
+  resolveAgentMemoryPolicy
+} from "./chunk-PG5PNA7Y.js";
+import {
+  load,
+  parseExternalSkillMarkdown,
+  parseSkillDocProtocol
+} from "./chunk-ZQ2UM4KG.js";
+import {
+  touchMemoryItemsInDb
+} from "./chunk-3TZDXYSF.js";
+import {
+  chooseMemoryOwners,
+  loadMemoryCandidatesFromDb
+} from "./chunk-Q2YZULBH.js";
+import {
+  getModelContextWindow,
+  parseUiAskChoiceContent
+} from "./chunk-ZIG5LJ7X.js";
+import {
+  readPipeText,
+  spawnProcess
+} from "./chunk-IDZTNRP2.js";
+import {
+  resolveAuthToken
+} from "./chunk-ISNCLGUZ.js";
+import {
+  buildPlatformChatCompletionRequest,
+  parsePlatformChatCompletionData
+} from "./chunk-5KLGBAAR.js";
+import {
+  resolveAgentRuntimeConfigFromRecord
+} from "./chunk-TILFE6LV.js";
+import {
+  LOCAL_AGENT_CONFIG_MISSING_CODE,
+  LOCAL_TURN_ABORTED_CODE,
+  readActionGate,
+  readCommandActionGatePayload
+} from "./chunk-XS466O7S.js";
+import {
+  resolvePlatformChatCompletionsEndpoint
+} from "./chunk-JRKKFRAV.js";
+import {
+  clipCompactText
+} from "./chunk-5MMAK75Q.js";
+import {
+  findModelConfig
+} from "./chunk-BBYVOSU2.js";
+import {
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  getDefaultCliLocalRuntimeDb
+} from "./chunk-H33743XH.js";
+import {
+  parsePositiveFiniteNumberOrFallback
+} from "./chunk-Y5GCAMGP.js";
+import {
+  require_index_umd
+} from "./chunk-SH2CFQOH.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY,
+  PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
+  PUBLIC_GLM_52_AGENT_KEY,
+  PUBLIC_KIMI_K26_IMAGE_AGENT_KEY
+} from "./chunk-ELRRLDWI.js";
+import {
+  isLoopbackUrl
+} from "./chunk-4SN6J65J.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/cli/client/tokenUsage.ts
+var PROVIDER_LOOKUP_ORDER = [
+  "openrouter",
+  "fireworks",
+  "openai",
+  "mimo",
+  "gmi",
+  "google",
+  "deepseek",
+  "mistral",
+  "vultr",
+  "deepinfra",
+  "cloudflare"
+];
+function parseUsageRecord(usage) {
+  if (!usage || typeof usage !== "object") return void 0;
+  const input = Number(usage.input_tokens ?? usage.prompt_tokens ?? 0);
+  const output = Number(usage.output_tokens ?? usage.completion_tokens ?? 0);
+  if (!Number.isFinite(input) || !Number.isFinite(output)) return void 0;
+  if (!input && !output) return void 0;
+  return { input, output };
+}
+function resolveContextWindow(model) {
+  const raw = model?.trim();
+  if (!raw) return void 0;
+  for (const provider of PROVIDER_LOOKUP_ORDER) {
+    const config = findModelConfig(provider, raw);
+    if (config?.contextWindow) return config.contextWindow;
+  }
+  return getModelContextWindow(raw);
+}
+function buildTurnTokenUsage(usage, model) {
+  const parsed = parseUsageRecord(usage);
+  if (!parsed) return void 0;
+  const contextWindow = resolveContextWindow(model);
+  const remaining = contextWindow && parsed.input > 0 ? Math.max(0, contextWindow - parsed.input) : void 0;
+  return {
+    ...parsed,
+    ...contextWindow ? { contextWindow } : {},
+    ...remaining != null ? { remaining } : {}
+  };
+}
+function formatTokenCount(value) {
+  if (!Number.isFinite(value) || value < 0) return "\u2014";
+  if (value < 1e3) return String(Math.round(value));
+  if (value < 1e6) {
+    const compact2 = value / 1e3;
+    if (Number.isInteger(compact2)) return `${compact2}k`;
+    return `${compact2.toFixed(1).replace(/\.0$/, "")}k`;
+  }
+  const compact = value / 1e6;
+  return compact >= 100 ? `${Math.round(compact)}M` : `${compact.toFixed(1).replace(/\.0$/, "")}M`;
+}
+function renderTokenStatus(tokens) {
+  if (!tokens) return "in \u2014 out \u2014 left \u2014";
+  const left = tokens.remaining != null ? formatTokenCount(tokens.remaining) : tokens.contextWindow ? "\u2014" : "\u2014";
+  return `in ${formatTokenCount(tokens.input)} out ${formatTokenCount(tokens.output)} left ${left}`;
+}
+function shouldShowUsage(env) {
+  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
+}
+function formatUsage(usage, dialogId) {
+  const parts = [];
+  if (typeof dialogId === "string" && dialogId)
+    parts.push(`dialog=${dialogId}`);
+  const input = usage?.input_tokens ?? usage?.prompt_tokens ?? 0;
+  const output = usage?.output_tokens ?? usage?.completion_tokens ?? 0;
+  if (input || output) parts.push(`tokens=${input}+${output}`);
+  return parts.length ? `  (${parts.join("  ")})` : "";
+}
+
+// packages/cli/client/terminalStyles.ts
+var ANSI_FG = {
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  blue: "\x1B[34m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  white: "\x1B[37m",
+  black: "\x1B[30m"
+};
+var ANSI_BG = {
+  bgCyan: "\x1B[46m",
+  bgGray: "\x1B[100m",
+  bgMagenta: "\x1B[45m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgGreen: "\x1B[42m",
+  bgRed: "\x1B[41m",
+  bgWhite: "\x1B[47m"
+};
+var RESET = "\x1B[0m";
+function resolveCliColorEnabled(env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+  const setting = asTrimmedLowercaseString(env.NOLO_CLI_COLOR);
+  if (setting === "0" || setting === "false" || setting === "off") return false;
+  if (env.NO_COLOR) return false;
+  if (setting === "1" || setting === "true" || setting === "on") return true;
+  return isTTY;
+}
+function styleCliText(text, style, enabled = resolveCliColorEnabled()) {
+  if (!enabled || !text) return text;
+  const code = ANSI_FG[style] ?? ANSI_BG[style];
+  if (!code) return text;
+  return `${code}${text}${RESET}`;
+}
+function dimCliText(text, enabled = resolveCliColorEnabled()) {
+  return styleCliText(text, "dim", enabled);
+}
+
+// packages/cli/tui/theme.ts
+var THEME_PALETTES = {
+  trail: {
+    light: {
+      accent: { hex: "2E7DB5", ansiFallback: "\x1B[34m" },
+      // ocean blue
+      chrome: { hex: "768594", ansiFallback: "\x1B[90m" },
+      // slate — two steps below app placeholder A3B0BD (was 8A97A5); rules/tool markers on white need the extra notch
+      success: { hex: "3F8F5C", ansiFallback: "\x1B[32m" },
+      // moss green
+      warning: { hex: "9A6A1F", ansiFallback: "\x1B[33m" },
+      // deeper amber — B57F2E still read as yellow/washed on white (H2 headers like ## Plan floated); 9A6A1F raises contrast
+      info: { hex: "4A9FD4", ansiFallback: "\x1B[36m" },
+      // sky blue
+      danger: { hex: "C45C4A", ansiFallback: "\x1B[31m" },
+      // reddish
+      muted: { hex: "5E6A78", ansiFallback: "\x1B[90m" }
+      // denser slate — 687584 read too blue in dense prose (inline code/tool labels); 5E6A78 pulls blue down while staying darker than the old value
+    },
+    dark: {
+      accent: { hex: "89B4FA", ansiFallback: "\x1B[34m" },
+      // blue
+      chrome: { hex: "6C7086", ansiFallback: "\x1B[90m" },
+      success: { hex: "A6E3A1", ansiFallback: "\x1B[32m" },
+      warning: { hex: "F9E2AF", ansiFallback: "\x1B[33m" },
+      info: { hex: "94E2D5", ansiFallback: "\x1B[36m" },
+      danger: { hex: "F38BA8", ansiFallback: "\x1B[31m" },
+      muted: { hex: "9AA3B8", ansiFallback: "\x1B[90m" }
+      // dimmed from A6ADC8 so secondary text sits a step below body text
+    }
+  },
+  catppuccin: {
+    light: {
+      accent: { hex: "0969DA", ansiFallback: "\x1B[34m" },
+      chrome: { hex: "57606A", ansiFallback: "\x1B[90m" },
+      success: { hex: "116329", ansiFallback: "\x1B[32m" },
+      warning: { hex: "9A6700", ansiFallback: "\x1B[33m" },
+      info: { hex: "0969DA", ansiFallback: "\x1B[36m" },
+      danger: { hex: "CF222E", ansiFallback: "\x1B[31m" },
+      muted: { hex: "6E7781", ansiFallback: "\x1B[90m" }
+    },
+    dark: {
+      accent: { hex: "58A6FF", ansiFallback: "\x1B[34m" },
+      // GitHub sky blue
+      chrome: { hex: "6E7681", ansiFallback: "\x1B[90m" },
+      success: { hex: "3FB950", ansiFallback: "\x1B[32m" },
+      warning: { hex: "D29922", ansiFallback: "\x1B[33m" },
+      info: { hex: "58A6FF", ansiFallback: "\x1B[36m" },
+      danger: { hex: "FF7B72", ansiFallback: "\x1B[31m" },
+      muted: { hex: "B1BAC4", ansiFallback: "\x1B[90m" }
+    }
+  },
+  wave: {
+    light: {
+      accent: { hex: "4D699B", ansiFallback: "\x1B[34m" },
+      // ink blue
+      chrome: { hex: "9E9B8E", ansiFallback: "\x1B[90m" },
+      success: { hex: "6F894E", ansiFallback: "\x1B[32m" },
+      warning: { hex: "836F4A", ansiFallback: "\x1B[33m" },
+      info: { hex: "4D699B", ansiFallback: "\x1B[36m" },
+      danger: { hex: "C84053", ansiFallback: "\x1B[31m" },
+      muted: { hex: "716E61", ansiFallback: "\x1B[90m" }
+    },
+    dark: {
+      accent: { hex: "7E9CD8", ansiFallback: "\x1B[34m" },
+      // crystalBlue
+      chrome: { hex: "727169", ansiFallback: "\x1B[90m" },
+      success: { hex: "98BB6C", ansiFallback: "\x1B[32m" },
+      warning: { hex: "E6C384", ansiFallback: "\x1B[33m" },
+      info: { hex: "7FB4CA", ansiFallback: "\x1B[36m" },
+      danger: { hex: "E82424", ansiFallback: "\x1B[31m" },
+      muted: { hex: "938AA9", ansiFallback: "\x1B[90m" }
+    }
+  },
+  iris: {
+    light: {
+      accent: { hex: "5E6AD2", ansiFallback: "\x1B[34m" },
+      chrome: { hex: "9E9AB5", ansiFallback: "\x1B[90m" },
+      success: { hex: "16A34A", ansiFallback: "\x1B[32m" },
+      warning: { hex: "D97706", ansiFallback: "\x1B[33m" },
+      info: { hex: "5E6AD2", ansiFallback: "\x1B[36m" },
+      danger: { hex: "E5484D", ansiFallback: "\x1B[31m" },
+      muted: { hex: "6E6A8A", ansiFallback: "\x1B[90m" }
+    },
+    dark: {
+      accent: { hex: "8B9CF4", ansiFallback: "\x1B[34m" },
+      chrome: { hex: "5A5772", ansiFallback: "\x1B[90m" },
+      success: { hex: "26BD6C", ansiFallback: "\x1B[32m" },
+      warning: { hex: "F5A623", ansiFallback: "\x1B[33m" },
+      info: { hex: "8B9CF4", ansiFallback: "\x1B[36m" },
+      danger: { hex: "EC5B6E", ansiFallback: "\x1B[31m" },
+      muted: { hex: "938AA9", ansiFallback: "\x1B[90m" }
+    }
+  },
+  rose: {
+    light: {
+      accent: { hex: "D14D72", ansiFallback: "\x1B[35m" },
+      chrome: { hex: "9893A5", ansiFallback: "\x1B[90m" },
+      success: { hex: "56949F", ansiFallback: "\x1B[32m" },
+      warning: { hex: "EA9D34", ansiFallback: "\x1B[33m" },
+      info: { hex: "286983", ansiFallback: "\x1B[36m" },
+      danger: { hex: "B4637A", ansiFallback: "\x1B[31m" },
+      muted: { hex: "797593", ansiFallback: "\x1B[90m" }
+    },
+    dark: {
+      accent: { hex: "EB6F92", ansiFallback: "\x1B[35m" },
+      chrome: { hex: "6E6A86", ansiFallback: "\x1B[90m" },
+      success: { hex: "9CCFD8", ansiFallback: "\x1B[32m" },
+      warning: { hex: "F6C177", ansiFallback: "\x1B[33m" },
+      info: { hex: "C4A7E7", ansiFallback: "\x1B[36m" },
+      danger: { hex: "EB6F92", ansiFallback: "\x1B[31m" },
+      muted: { hex: "908CAA", ansiFallback: "\x1B[90m" }
+    }
+  },
+  mono: {
+    light: {
+      accent: { hex: "FF9500", ansiFallback: "\x1B[33m" },
+      chrome: { hex: "9DA6AF", ansiFallback: "\x1B[90m" },
+      success: { hex: "16A34A", ansiFallback: "\x1B[32m" },
+      warning: { hex: "D97706", ansiFallback: "\x1B[33m" },
+      info: { hex: "2563EB", ansiFallback: "\x1B[34m" },
+      danger: { hex: "DC2626", ansiFallback: "\x1B[31m" },
+      muted: { hex: "7B8793", ansiFallback: "\x1B[90m" }
+    },
+    dark: {
+      accent: { hex: "FFBF66", ansiFallback: "\x1B[33m" },
+      chrome: { hex: "7B8793", ansiFallback: "\x1B[90m" },
+      success: { hex: "4DE800", ansiFallback: "\x1B[32m" },
+      warning: { hex: "FCD34D", ansiFallback: "\x1B[33m" },
+      info: { hex: "60A5FA", ansiFallback: "\x1B[34m" },
+      danger: { hex: "F87171", ansiFallback: "\x1B[31m" },
+      muted: { hex: "C1C7CD", ansiFallback: "\x1B[90m" }
+    }
+  }
+};
+var activeThemeName = "catppuccin";
+function getActiveThemeName() {
+  return activeThemeName;
+}
+function setActiveThemeName(name) {
+  if (THEME_PALETTES[name]) {
+    activeThemeName = name;
+    return true;
+  }
+  return false;
+}
+var activeBrightness = null;
+function getActiveBrightness() {
+  return activeBrightness;
+}
+function setActiveBrightness(brightness) {
+  activeBrightness = brightness;
+}
+var activeDensity = "spacious";
+function getActiveDensity() {
+  return activeDensity;
+}
+function setActiveDensity(density) {
+  activeDensity = density;
+}
+function supportsTruecolor(env = process.env) {
+  return /truecolor|24bit/i.test(env.COLORTERM ?? "");
+}
+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;
+  const colorfgbg = env.COLORFGBG ?? "";
+  if (colorfgbg) {
+    const parts = colorfgbg.split(";");
+    const bg = parts.length > 1 ? Number.parseInt(parts[1] ?? "", 10) : NaN;
+    if (!Number.isNaN(bg) && bg >= 0 && bg <= 6) return "dark";
+    if (!Number.isNaN(bg) && bg >= 7 && bg <= 15) return "light";
+  }
+  return "dark";
+}
+function hexToSgr(hex) {
+  const r = Number.parseInt(hex.slice(0, 2), 16);
+  const g = Number.parseInt(hex.slice(2, 4), 16);
+  const b = Number.parseInt(hex.slice(4, 6), 16);
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+var SURFACE_HEX = {
+  trail: { light: "E4E8EC", dark: "313244" },
+  catppuccin: { light: "E8ECF0", dark: "161B22" },
+  wave: { light: "E5E1D6", dark: "2A2A37" },
+  iris: { light: "E9E8F2", dark: "2A2740" },
+  rose: { light: "F2EAE4", dark: "26233A" },
+  mono: { light: "E8EAED", dark: "2A2A2A" }
+};
+var TERMINAL_BASE = {
+  dark: "1E1E2E",
+  light: "FFFFFF"
+};
+function readHexChannels(hex) {
+  if (!/^[0-9A-F]{6}$/.test(hex)) return null;
+  return [
+    Number.parseInt(hex.slice(0, 2), 16),
+    Number.parseInt(hex.slice(2, 4), 16),
+    Number.parseInt(hex.slice(4, 6), 16)
+  ];
+}
+function hexToBgSgr(hex) {
+  const channels = readHexChannels(hex.replace(/^#/, "").toUpperCase());
+  if (!channels) return "";
+  const [r, g, b] = channels;
+  return `\x1B[48;2;${r};${g};${b}m`;
+}
+function blendHex(fg, base, weight) {
+  const w = Math.min(1, Math.max(0, weight));
+  const normFg = fg.replace(/^#/, "").toUpperCase();
+  const normBase = base.replace(/^#/, "").toUpperCase();
+  if (w === 0) return normBase;
+  if (w === 1) return normFg;
+  if (!readHexChannels(normFg) || !readHexChannels(normBase)) return normBase;
+  const fgR = Number.parseInt(normFg.slice(0, 2), 16);
+  const fgG = Number.parseInt(normFg.slice(2, 4), 16);
+  const fgB = Number.parseInt(normFg.slice(4, 6), 16);
+  const baseR = Number.parseInt(normBase.slice(0, 2), 16);
+  const baseG = Number.parseInt(normBase.slice(2, 4), 16);
+  const baseB = Number.parseInt(normBase.slice(4, 6), 16);
+  const r = Math.round(baseR + (fgR - baseR) * w).toString(16).padStart(2, "0").toUpperCase();
+  const g = Math.round(baseG + (fgG - baseG) * w).toString(16).padStart(2, "0").toUpperCase();
+  const b = Math.round(baseB + (fgB - baseB) * w).toString(16).padStart(2, "0").toUpperCase();
+  return `${r}${g}${b}`;
+}
+function diffLineSequences(env = process.env, brightness = resolveTuiBrightness(env)) {
+  if (!supportsTruecolor(env)) return null;
+  const palette = THEME_PALETTES[activeThemeName] ?? THEME_PALETTES.trail;
+  const successHex = palette[brightness].success.hex;
+  const dangerHex = palette[brightness].danger.hex;
+  const weight = brightness === "dark" ? 0.14 : 0.1;
+  const baseHex = TERMINAL_BASE[brightness];
+  const addedBgHex = blendHex(successHex, baseHex, weight);
+  const removedBgHex = blendHex(dangerHex, baseHex, weight);
+  return {
+    added: {
+      fg: hexToSgr(successHex),
+      bg: hexToBgSgr(addedBgHex)
+    },
+    removed: {
+      fg: hexToSgr(dangerHex),
+      bg: hexToBgSgr(removedBgHex)
+    }
+  };
+}
+function surfaceBackgroundSequence(env = process.env, brightness = resolveTuiBrightness(env)) {
+  if (!supportsTruecolor(env)) return "";
+  return hexToBgSgr((SURFACE_HEX[activeThemeName] ?? SURFACE_HEX.trail)[brightness]);
+}
+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;
+}
+function themeText(text, token, colorEnabled = resolveCliColorEnabled(), env = process.env) {
+  if (!colorEnabled) return text;
+  return `${themeColorSequence(token, env)}${text}\x1B[39m`;
+}
+function renderDiffCodeBlock(code, env = process.env) {
+  const border = themeText("\u2502", "chrome", true, env);
+  const addedColor = themeColorSequence("success", env);
+  const deletedColor = themeColorSequence("danger", env);
+  const hunkColor = themeColorSequence("info", env);
+  const contextColor = themeColorSequence("chrome", env);
+  const reset = "\x1B[0m";
+  const lines = code.split("\n").map((line) => {
+    let color = contextColor;
+    if (line.startsWith("@@")) {
+      color = hunkColor;
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      color = addedColor;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      color = deletedColor;
+    }
+    return ` ${border}  ${color}${line}${reset}`;
+  });
+  return ` ${themeText("\u250C\u2500\u2500\u2500", "chrome", true, env)}
+${lines.join("\n")}
+ ${themeText("\u2514\u2500\u2500\u2500", "chrome", true, env)}`;
+}
+function highlightMarkdown(text, colorEnabled = resolveCliColorEnabled(), env = process.env) {
+  if (!colorEnabled) return text;
+  let result = text;
+  result = result.replace(/```([a-zA-Z-]*)\n([\s\S]*?)\n```/g, (match, lang, code) => {
+    if (lang.toLowerCase() === "diff") {
+      return renderDiffCodeBlock(code, env);
+    }
+    const infoColor = themeColorSequence("info", env);
+    const reset2 = "\x1B[39m\x1B[22m";
+    const border = themeText("\u2502", "chrome", true, env);
+    const formattedCode = code.split("\n").map((line) => ` ${border}  ${infoColor}${line}${reset2}`).join("\n");
+    return ` ${themeText("\u250C\u2500\u2500\u2500", "chrome", true, env)}
+${formattedCode}
+ ${themeText("\u2514\u2500\u2500\u2500", "chrome", true, env)}`;
+  });
+  result = result.replace(/^(#{1,3})\s+(.+)$/gm, (match, hashes, title) => {
+    const level = hashes.length;
+    const reset2 = "\x1B[0m";
+    if (level === 1) {
+      return `\x1B[1m\x1B[4m${themeColorSequence("accent", env)}${title}${reset2}`;
+    }
+    if (level === 2) {
+      return `\x1B[1m${themeColorSequence("warning", env)}${title}${reset2}`;
+    }
+    return `\x1B[1m${themeColorSequence("info", env)}${title}${reset2}`;
+  });
+  result = result.replace(
+    /^(进入 nolo-plan[^\n]*)$/gm,
+    (match, content) => `${themeColorSequence("chrome", env)}\x1B[2m${content}\x1B[0m`
+  );
+  result = result.replace(/^>\s?(.*)$/gm, (match, content) => {
+    const border = themeColorSequence("chrome", env);
+    return `${border}\u2502\x1B[39m \x1B[2m${content}\x1B[22m`;
+  });
+  result = result.replace(/\*\*([\s\S]*?)\*\*/g, "\x1B[1m$1\x1B[22m");
+  const mutedColor = themeColorSequence("muted", env);
+  const reset = "\x1B[39m";
+  result = result.replace(/`([^`\n]+)`/g, `${mutedColor}$1${reset}`);
+  result = result.replace(/(?<!\*)\*([^*\n]+?)\*(?!\*)/g, `\x1B[2m$1\x1B[22m`);
+  result = result.replace(/~~([^~\n]+?)~~/g, `\x1B[2m\x1B[9m$1\x1B[29m\x1B[22m`);
+  return result;
+}
+
+// packages/cli/client/assistantOutput.ts
+var STYLE = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m"
+};
+function colorSeq(token, brightness) {
+  return themeColorSequence(token, process.env, brightness);
+}
+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);
+}
+function isTableSeparator(line) {
+  const cells = splitTableCells(line);
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function isTableRow(line) {
+  const cells = splitTableCells(line);
+  return cells.length >= 2 && cells.some((cell) => cell.length > 0);
+}
+function isPipeWrappedTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|") && isTableRow(line);
+}
+function isCodeFenceLine(line) {
+  return /^\s*```/.test(line);
+}
+function readFenceLanguage(line) {
+  const m = line.match(/^\s*```\s*([a-zA-Z0-9+#_-]*)/);
+  return m ? (m[1] ?? "").toLowerCase() : "";
+}
+function normalizeCodeLang(raw) {
+  switch (raw) {
+    case "js":
+    case "jsx":
+    case "ts":
+    case "tsx":
+    case "javascript":
+    case "typescript":
+      return "js";
+    case "py":
+    case "python":
+      return "py";
+    case "sh":
+    case "bash":
+    case "zsh":
+    case "shell":
+    case "console":
+      return "sh";
+    case "json":
+      return "json";
+    case "diff":
+      return "diff";
+    default:
+      return "unknown";
+  }
+}
+var KEYWORDS = {
+  js: /* @__PURE__ */ new Set([
+    "const",
+    "let",
+    "var",
+    "function",
+    "return",
+    "if",
+    "else",
+    "for",
+    "while",
+    "class",
+    "new",
+    "await",
+    "async",
+    "import",
+    "export",
+    "from",
+    "type",
+    "interface",
+    "extends",
+    "implements",
+    "null",
+    "undefined",
+    "true",
+    "false"
+  ]),
+  py: /* @__PURE__ */ new Set([
+    "def",
+    "class",
+    "return",
+    "if",
+    "elif",
+    "else",
+    "for",
+    "while",
+    "import",
+    "from",
+    "as",
+    "with",
+    "try",
+    "except",
+    "finally",
+    "lambda",
+    "None",
+    "True",
+    "False",
+    "self"
+  ]),
+  sh: /* @__PURE__ */ new Set([
+    "if",
+    "then",
+    "else",
+    "fi",
+    "for",
+    "do",
+    "done",
+    "while",
+    "case",
+    "esac",
+    "function",
+    "export",
+    "local",
+    "return",
+    "source",
+    "echo",
+    "cd"
+  ]),
+  json: /* @__PURE__ */ new Set(["true", "false", "null"]),
+  diff: /* @__PURE__ */ new Set([])
+};
+function scanStringCommentRegions(line, lang) {
+  const regions = [];
+  const n = line.length;
+  let i = 0;
+  const commentMarkers = lang === "py" || lang === "sh" ? ["#"] : ["//"];
+  while (i < n) {
+    const ch = line[i];
+    if (ch === "'" || ch === '"' || lang === "js" && ch === "`") {
+      const quote = ch;
+      const start = i;
+      i += 1;
+      while (i < n) {
+        if (line[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (line[i] === quote) {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      regions.push({ start, end: i, kind: "string" });
+      continue;
+    }
+    let matched = false;
+    for (const marker of commentMarkers) {
+      if (line.startsWith(marker, i)) {
+        regions.push({ start: i, end: n, kind: "comment" });
+        i = n;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) continue;
+    i += 1;
+  }
+  return regions;
+}
+function highlightCodeLine(line, lang, brightness) {
+  const info = colorSeq("info", brightness);
+  if (lang === "unknown") {
+    return `${info}${line}${STYLE.reset}`;
+  }
+  if (lang === "diff") {
+    const added = colorSeq("success", brightness);
+    const deleted = colorSeq("danger", brightness);
+    const hunk = colorSeq("info", brightness);
+    const context = colorSeq("chrome", brightness);
+    const reset2 = STYLE.reset;
+    let color = context;
+    if (line.startsWith("@@")) {
+      color = hunk;
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      color = added;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      color = deleted;
+    }
+    return `${color}${line}${reset2}`;
+  }
+  const regions = scanStringCommentRegions(line, lang);
+  const keywords = KEYWORDS[lang];
+  const accent = colorSeq("accent", 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 out = [];
+  let cursor = 0;
+  for (const region of regions) {
+    if (region.start > cursor) {
+      out.push(emitPlainGap(line.slice(cursor, region.start), keywords, info, accent, warning, reset));
+    }
+    const text = line.slice(region.start, region.end);
+    if (region.kind === "string") {
+      out.push(`${success}${text}${reset}`);
+    } else {
+      out.push(`${chrome}${dim}${text}${reset}`);
+    }
+    cursor = region.end;
+  }
+  if (cursor < line.length) {
+    out.push(emitPlainGap(line.slice(cursor), keywords, info, accent, warning, reset));
+  }
+  return out.join("");
+}
+function emitPlainGap(text, keywords, info, accent, warning, reset) {
+  const parts = [];
+  const re = /([A-Za-z_]\w*)|(\d+(?:\.\d+)?)|([\s\S])/g;
+  let last = 0;
+  let m;
+  let started = false;
+  while ((m = re.exec(text)) !== null) {
+    if (!started) {
+      started = true;
+    }
+    if (m.index > last) {
+      parts.push(`${info}${text.slice(last, m.index)}`);
+    }
+    if (m[1] !== void 0) {
+      const word = m[1];
+      if (keywords.has(word)) {
+        parts.push(`${accent}${word}${reset}`);
+      } else {
+        parts.push(`${info}${word}`);
+      }
+    } else if (m[2] !== void 0) {
+      parts.push(`${warning}${m[2]}${reset}`);
+    } else {
+      parts.push(`${info}${m[3]}`);
+    }
+    last = re.lastIndex;
+  }
+  if (last < text.length) {
+    parts.push(`${info}${text.slice(last)}`);
+  }
+  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+(.+)$/;
+function normalizeListLine(line) {
+  const task = line.match(TASK_LIST_RE);
+  if (task) {
+    const checked = task[3] === "x" || task[3] === "X";
+    return `${task[1]}${checked ? "\u2611" : "\u2610"} ${task[4]}`;
+  }
+  const unordered = line.match(UNORDERED_LIST_RE);
+  if (unordered) {
+    return `${unordered[1]}\u2022 ${unordered[3]}`;
+  }
+  const ordered = line.match(ORDERED_LIST_RE);
+  if (ordered) {
+    return `${ordered[1]}${ordered[2]}. ${ordered[3]}`;
+  }
+  return line;
+}
+function convertMarkdownTablesForTerminal(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let inFence = false;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (isCodeFenceLine(line)) {
+      inFence = !inFence;
+      out.push(line);
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      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 (out.length > 0 && out[out.length - 1] !== "") out.push("");
+      continue;
+    }
+    if (isPipeWrappedTableRow(line)) {
+      if (!isTableSeparator(line)) out.push(tableRowToBullet(line));
+      continue;
+    }
+    out.push(normalizeListLine(line));
+  }
+  return out.join("\n");
+}
+function polishAssistantStructure(text, options = {}) {
+  const converted = convertMarkdownTablesForTerminal(text).replace(/\r\n/g, "\n").replace(/\x00/g, "");
+  const lines = converted.split("\n");
+  let inFence = false;
+  const maskedLines = lines.map((line, index) => {
+    if (isCodeFenceLine(line)) {
+      inFence = !inFence;
+      return line;
+    }
+    if (inFence) {
+      return `\0F${index}\0`;
+    }
+    return line;
+  });
+  const afterHeading = maskedLines.join("\n").replace(/([^\n])\n(#{1,3} )/g, "$1\n\n$2").replace(/^(#{1,3} .+)\n(?!\n)/gm, "$1\n\n").replace(/\n{4,}/g, "\n\n\n");
+  const LIST_LIKE = /^\s*(?:•|☐|☑|\d+\.)\s|^\s*[\u2460-\u2473]/;
+  const headingLines = afterHeading.split("\n");
+  const breathed = [];
+  for (let i = 0; i < headingLines.length; i++) {
+    breathed.push(headingLines[i]);
+    const cur = headingLines[i];
+    const next = headingLines[i + 1];
+    if (cur === "" || next === void 0 || next === "") continue;
+    if (LIST_LIKE.test(cur) === LIST_LIKE.test(next)) continue;
+    breathed.push("");
+  }
+  const polishedMasked = breathed.join("\n");
+  const polished = polishedMasked.replace(
+    /\x00F(\d+)\x00/g,
+    (_, id) => lines[Number(id)] ?? ""
+  );
+  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}`;
+    }
+    if (level === 2) {
+      return `${STYLE.bold}${colorSeq("warning", brightness)}${title}${STYLE.reset}`;
+    }
+    return `${STYLE.bold}${colorSeq("info", brightness)}${title}${STYLE.reset}`;
+  }
+  if (line.startsWith("\u8FDB\u5165 nolo-plan")) {
+    return `${colorSeq("chrome", brightness)}${STYLE.dim}${line}${STYLE.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}`;
+  }
+  if (/^---+$/.test(line.trim())) {
+    return `${colorSeq("chrome", brightness)}${"\u2500".repeat(Math.min(line.trim().length, 40))}${STYLE.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}`;
+  }
+  const ordered = line.match(/^(\s*)(\d+\.)\s(.+)$/);
+  if (ordered) {
+    const styled = styleInlineMarkdown(ordered[3], brightness);
+    return `${ordered[1]}${colorSeq("accent", brightness)}${ordered[2]}${STYLE.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 styleInlineMarkdown(line, brightness);
+}
+function formatAssistantDisplay(text, options = {}) {
+  const brightness = resolveTuiBrightness();
+  const polished = polishAssistantStructure(text, options);
+  let inFence = false;
+  let fenceLang = "unknown";
+  return polished.split("\n").map((line) => {
+    if (isCodeFenceLine(line)) {
+      if (inFence) {
+        fenceLang = "unknown";
+      } else {
+        fenceLang = normalizeCodeLang(readFenceLanguage(line));
+      }
+      inFence = !inFence;
+      return `${STYLE.dim}${line}${STYLE.reset}`;
+    }
+    if (inFence) {
+      return highlightCodeLine(line, fenceLang, brightness);
+    }
+    return styleRichMarkdownLine(line, brightness);
+  }).join("\n");
+}
+function emitFormattedAssistantBlock(write, text, trailingNewline = false) {
+  if (!text) return;
+  write(formatAssistantDisplay(text, { trimEdges: false }));
+  if (trailingNewline) write("\n");
+}
+function classifyStreamLine(line) {
+  if (line === "") return "blank";
+  if (TASK_LIST_RE.test(line) || UNORDERED_LIST_RE.test(line) || ORDERED_LIST_RE.test(line) || /^\s*(?:•|☐|☑)\s/.test(line) || /^\s*[\u2460-\u2473]/.test(line)) {
+    return "list";
+  }
+  return "prose";
+}
+function needsListProseBreath(prev, next) {
+  if (prev === null || prev === "blank" || next === "blank") return false;
+  const prevList = prev === "list";
+  const nextList = next === "list";
+  return prevList !== nextList;
+}
+function createRenderAwareStreamWriter(args) {
+  const brightness = resolveTuiBrightness();
+  let buffer = "";
+  let inFence = false;
+  let fenceLang = "unknown";
+  let lastKind = null;
+  const emitBreathIfNeeded = (nextKind) => {
+    if (needsListProseBreath(lastKind, nextKind)) args.write("\n");
+  };
+  const flushCompleteBlocks = () => {
+    while (buffer.includes("\n")) {
+      const lines = buffer.split("\n");
+      if (lines.length < 2) break;
+      const firstLine = lines[0] ?? "";
+      if (isCodeFenceLine(firstLine)) {
+        if (inFence) {
+          fenceLang = "unknown";
+        } else {
+          fenceLang = normalizeCodeLang(readFenceLanguage(firstLine));
+        }
+        inFence = !inFence;
+        emitBreathIfNeeded("other");
+        args.write(`${STYLE.dim}${firstLine}${STYLE.reset}
+`);
+        lastKind = "other";
+        buffer = lines.slice(1).join("\n");
+        continue;
+      }
+      if (inFence) {
+        args.write(`${highlightCodeLine(firstLine, fenceLang, brightness)}
+`);
+        lastKind = "other";
+        buffer = lines.slice(1).join("\n");
+        continue;
+      }
+      if (isTableRow(firstLine)) {
+        const nextLineComplete = lines.length > 2;
+        if (!nextLineComplete) break;
+        if (isTableSeparator(lines[1] ?? "")) {
+          let end = 2;
+          while (end < lines.length && isTableRow(lines[end] ?? "") && !isTableSeparator(lines[end] ?? "")) {
+            end += 1;
+          }
+          const tableComplete = end < lines.length - 1;
+          if (!tableComplete) break;
+          emitBreathIfNeeded("list");
+          emitFormattedAssistantBlock(
+            args.write,
+            lines.slice(0, end).join("\n"),
+            true
+          );
+          lastKind = "list";
+          buffer = lines.slice(end).join("\n");
+          continue;
+        }
+      }
+      const kind = classifyStreamLine(firstLine);
+      emitBreathIfNeeded(kind);
+      emitFormattedAssistantBlock(args.write, firstLine, true);
+      lastKind = kind;
+      buffer = lines.slice(1).join("\n");
+    }
+  };
+  return {
+    push(chunk) {
+      if (!chunk) return;
+      buffer += chunk;
+      flushCompleteBlocks();
+    },
+    flush() {
+      if (!buffer) return;
+      if (inFence) {
+        args.write(buffer);
+      } else {
+        emitFormattedAssistantBlock(args.write, buffer);
+      }
+      buffer = "";
+    }
+  };
+}
+
+// packages/cli/client/thinkingOutput.ts
+var THINK_OPEN = /<think>/i;
+var THINK_CLOSE = /<\/think>/i;
+var COLLAPSED_MARKER = /^\s*▸ 思考已折叠\s*$/;
+function normalizeThinkingDisplayMode(raw, fallback = "hide") {
+  const normalized = asTrimmedLowercaseString(raw);
+  if (normalized === "hide" || normalized === "off" || normalized === "false" || normalized === "0") {
+    return "hide";
+  }
+  if (normalized === "marker" || normalized === "collapsed" || normalized === "fold") {
+    return "marker";
+  }
+  if (normalized === "show" || normalized === "on" || normalized === "true" || normalized === "1") {
+    return "show";
+  }
+  return fallback;
+}
+function resolveThinkingDisplayMode(env = process.env) {
+  return normalizeThinkingDisplayMode(env.NOLO_CLI_THINKING ?? env.NOLO_THINKING, "hide");
+}
+function collapseThinkingBlocks(text, mode = "hide") {
+  if (mode === "show") return text;
+  const replacement = mode === "marker" ? "\u25B8 \u601D\u8003\u5DF2\u6298\u53E0\n" : "";
+  return text.replace(/<think>[\s\S]*?<\/think>\s*/gi, replacement).replace(/\n{3,}/g, "\n\n").trim();
+}
+function stripCollapsedThinkingMarkers(text) {
+  return text.split("\n").filter((line) => !COLLAPSED_MARKER.test(line)).join("\n").replace(/\n{2,}/g, "\n").trim();
+}
+function formatAssistantTextForCli(text, mode = "hide") {
+  const collapsed = collapseThinkingBlocks(text, mode);
+  return mode === "hide" ? stripCollapsedThinkingMarkers(collapsed) : collapsed;
+}
+function createThinkingEventSink(arg1, arg2) {
+  let mode = "hide";
+  let write = () => {
+  };
+  if (typeof arg1 === "function") {
+    write = arg1;
+    if (typeof arg2 === "string") {
+      mode = arg2;
+    }
+  } else {
+    mode = arg1;
+    if (typeof arg2 === "function") {
+      write = arg2;
+    }
+  }
+  if (mode === "hide") {
+    return {
+      push(_chunk) {
+      }
+    };
+  }
+  if (mode === "show") {
+    return {
+      push(chunk) {
+        if (chunk) write(chunk);
+      }
+    };
+  }
+  let markerEmitted = false;
+  return {
+    push(chunk) {
+      if (!chunk || markerEmitted) return;
+      write("\n\u25B8 \u601D\u8003\u5DF2\u6298\u53E0\n");
+      markerEmitted = true;
+    }
+  };
+}
+function createThinkingAwareStreamFilter(write, mode = "hide") {
+  if (mode === "show") {
+    return {
+      push(chunk) {
+        write(chunk);
+      },
+      flush() {
+      }
+    };
+  }
+  let pending = "";
+  let insideThink = false;
+  let markerEmitted = false;
+  const emit = (chunk) => {
+    if (chunk) write(chunk);
+  };
+  const emitMarker = () => {
+    if (mode !== "marker" || markerEmitted) return;
+    emit("\n\u25B8 \u601D\u8003\u5DF2\u6298\u53E0\n");
+    markerEmitted = true;
+  };
+  const consume = (input) => {
+    pending += input;
+    while (pending.length > 0) {
+      if (insideThink) {
+        const closeMatch = pending.match(THINK_CLOSE);
+        if (!closeMatch || closeMatch.index == null) {
+          emitMarker();
+          pending = "";
+          return;
+        }
+        emitMarker();
+        pending = pending.slice(closeMatch.index + closeMatch[0].length);
+        insideThink = false;
+        markerEmitted = false;
+        continue;
+      }
+      const openMatch = pending.match(THINK_OPEN);
+      if (!openMatch || openMatch.index == null) {
+        const nextMarker = pending.indexOf("<");
+        if (nextMarker === -1) {
+          const cleaned = mode === "hide" ? pending.split("\n").filter((line) => !COLLAPSED_MARKER.test(line)).join("\n") : pending;
+          emit(cleaned);
+          pending = "";
+          return;
+        }
+        if (nextMarker > 0) {
+          const head = pending.slice(0, nextMarker);
+          const cleaned = mode === "hide" ? head.split("\n").filter((line) => !COLLAPSED_MARKER.test(line)).join("\n") : head;
+          emit(cleaned);
+          pending = pending.slice(nextMarker);
+          continue;
+        }
+        if (pending.length < 7) return;
+        emit(pending[0]);
+        pending = pending.slice(1);
+        continue;
+      }
+      if (openMatch.index > 0) {
+        const head = pending.slice(0, openMatch.index);
+        const cleaned = mode === "hide" ? head.split("\n").filter((line) => !COLLAPSED_MARKER.test(line)).join("\n") : head;
+        emit(cleaned);
+        pending = pending.slice(openMatch.index);
+        continue;
+      }
+      pending = pending.slice(openMatch[0].length);
+      insideThink = true;
+      markerEmitted = false;
+    }
+  };
+  return {
+    push(chunk) {
+      consume(chunk);
+    },
+    flush() {
+      if (insideThink) emitMarker();
+      if (pending) {
+        const cleaned = mode === "hide" ? pending.split("\n").filter((line) => !COLLAPSED_MARKER.test(line)).join("\n") : pending;
+        emit(cleaned);
+      }
+      pending = "";
+      insideThink = false;
+      markerEmitted = false;
+    }
+  };
+}
+
+// packages/cli/client/formatReadPathTree.ts
+import { homedir as osHomedir } from "node:os";
+function clipPathAware(value, max = 72) {
+  const compact = compactWhitespace(value);
+  if (compact.length <= max) return compact;
+  if (compact.includes(" ") || !compact.includes("/") && !compact.includes("\\")) {
+    return clipCompactText(value, max, "\u2026");
+  }
+  const segments = compact.split(/[/\\]/);
+  const filename = segments[segments.length - 1];
+  if (filename.length >= max) {
+    return clipCompactText(value, max, "\u2026");
+  }
+  const ELISION = "/\u2026/";
+  let prefix = "";
+  for (let i = 0; i < segments.length - 1; i += 1) {
+    const candidate = segments.slice(0, i + 1).join("/");
+    if (candidate.length + ELISION.length + filename.length > max) break;
+    prefix = candidate;
+  }
+  if (prefix) return `${prefix}${ELISION}${filename}`;
+  const filenameOnly = `\u2026/${filename}`;
+  if (filenameOnly.length <= max) return filenameOnly;
+  return clipCompactText(value, max, "\u2026");
+}
+function formatHomePath(path, customHomedir) {
+  if (!path) return "";
+  const home = customHomedir || (typeof process !== "undefined" ? process.env?.HOME : void 0) || (typeof osHomedir === "function" ? osHomedir() : "");
+  if (home && path.startsWith(home)) {
+    return `~${path.slice(home.length)}`;
+  }
+  return path.replace(/^(\/Users\/[^\/]+\/|\/home\/[^\/]+\/)/, "~/");
+}
+function formatReadItemPath(rawPath, metadata, customHomedir) {
+  const inputPath = rawPath || (typeof metadata?.path === "string" ? metadata.path : void 0) || (typeof metadata?.filePath === "string" ? metadata.filePath : void 0) || "file";
+  let formattedPath = formatHomePath(inputPath, customHomedir);
+  if (!formattedPath) return "file";
+  let rangePart = "";
+  const match = formattedPath.match(/(:[0-9]+(-[0-9]+)?(,[0-9]+(-[0-9]+)?)*)$/);
+  if (match) {
+    rangePart = match[1];
+    formattedPath = formattedPath.slice(0, -rangePart.length);
+  } else if (metadata && typeof metadata.startLine === "number" && typeof metadata.endLine === "number" && typeof metadata.totalLines === "number") {
+    const { startLine, endLine, totalLines, truncated } = metadata;
+    if (truncated || startLine !== 1 || endLine !== totalLines) {
+      rangePart = `:${startLine}-${endLine}`;
+    }
+  }
+  const clippedPath = clipPathAware(formattedPath, 72);
+  return `${clippedPath}${rangePart}`;
+}
+function formatReadTreeLines(items, customHomedir) {
+  const count = items.length;
+  const header = `Read (${count})`;
+  const lines = items.map((item, index) => {
+    const connector = index === items.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const pathWithRange = formatReadItemPath(item.path, item.metadata, customHomedir);
+    return { connector, pathWithRange };
+  });
+  return { header, count, lines };
+}
+function formatSearchItemQuery(query, path, customHomedir) {
+  let text = (query || "").trim();
+  if (path) {
+    const formattedPath = formatHomePath(path, customHomedir);
+    if (formattedPath) {
+      text = text ? `${text} in ${formattedPath}` : formattedPath;
+    }
+  }
+  if (!text) return "search";
+  return text.length > 80 ? `${text.slice(0, 79)}\u2026` : text;
+}
+function formatSearchTreeLines(items, customHomedir) {
+  const count = items.length;
+  const header = `Search (${count})`;
+  const lines = items.map((item, index) => {
+    const connector = index === items.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const queryText = formatSearchItemQuery(item.query, item.path, customHomedir);
+    return { connector, queryText };
+  });
+  return { header, count, lines };
+}
+function formatRunItemCommand(command, exitCode, timedOut) {
+  let text = compactWhitespace(command || "");
+  if (!text) text = "command";
+  text = text.length > 80 ? `${text.slice(0, 79)}\u2026` : text;
+  if (timedOut) return `${text} (timed out)`;
+  if (typeof exitCode === "number" && exitCode !== 0) return `${text} (exit ${exitCode})`;
+  return text;
+}
+function formatRunTreeLines(items) {
+  const count = items.length;
+  const header = `Run (${count})`;
+  const lines = items.map((item, index) => {
+    const connector = index === items.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const commandText = formatRunItemCommand(item.command, item.exitCode, item.timedOut);
+    return { connector, commandText };
+  });
+  return { header, count, lines };
+}
+function formatFetchItemUrl(url) {
+  const text = (url || "").trim();
+  if (!text) return "webpage";
+  return text.length > 80 ? `${text.slice(0, 79)}\u2026` : text;
+}
+function formatFetchTreeLines(items) {
+  const count = items.length;
+  const header = `Fetch (${count})`;
+  const lines = items.map((item, index) => {
+    const connector = index === items.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const urlText = formatFetchItemUrl(item.url);
+    return { connector, urlText };
+  });
+  return { header, count, lines };
+}
+
+// packages/cli/tui/i18n.ts
+var ZH_PATTERNS = /^zh/i;
+function parseCliLocale(raw) {
+  const normalized = raw?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (ZH_PATTERNS.test(normalized)) return "zh";
+  if (normalized === "en" || normalized.startsWith("en")) return "en";
+  return null;
+}
+function detectLocaleFromEnv(env) {
+  const explicit = parseCliLocale(env.NOLO_LANG);
+  if (explicit) return explicit;
+  const candidates = [env.LC_ALL, env.LC_CTYPE, env.LANG].filter(Boolean);
+  for (const candidate of candidates) {
+    if (ZH_PATTERNS.test(candidate)) return "zh";
+    if (candidate && !candidate.startsWith("C.") && !candidate.startsWith("POSIX")) {
+      return "en";
+    }
+  }
+  return null;
+}
+function detectLocale(env) {
+  return detectLocaleFromEnv(env) ?? "zh";
+}
+var currentLocale = detectLocale(process.env);
+function getCliLocale() {
+  return currentLocale;
+}
+function setCliLocale(locale) {
+  currentLocale = locale;
+}
+function initCliLocale(env = process.env) {
+  currentLocale = detectLocale(env);
+}
+var STRINGS = {
+  welcomeHint: {
+    en: "Tell nolo what you want. Use /help for commands. Shift+Enter for newline.",
+    zh: "\u544A\u8BC9 nolo \u4F60\u60F3\u8981\u4EC0\u4E48\u3002\u8F93\u5165 /help \u67E5\u770B\u547D\u4EE4\u3002Shift+Enter \u6362\u884C\u3002"
+  },
+  promptLabel: {
+    en: "\u276F ",
+    zh: "\u276F "
+  },
+  continueLabel: {
+    en: "\u2502 ",
+    zh: "\u2502 "
+  },
+  placeholder: {
+    en: "Type a message or / for commands...",
+    zh: "\u8F93\u5165\u6D88\u606F\uFF0C\u6216\u7528 / \u67E5\u770B\u547D\u4EE4\u2026"
+  },
+  newDialog: {
+    en: "new dialog",
+    zh: "\u65B0\u5BF9\u8BDD"
+  },
+  startedFreshDialog: {
+    en: "Started a fresh dialog.",
+    zh: "\u5DF2\u5F00\u59CB\u65B0\u5BF9\u8BDD\u3002"
+  },
+  bye: {
+    en: "Bye.",
+    zh: "\u518D\u89C1\u3002"
+  },
+  resumedDialogPrefix: {
+    en: "Resumed dialog",
+    zh: "\u5DF2\u6062\u590D\u5BF9\u8BDD"
+  },
+  resumeInvalidId: {
+    en: "does not look like a dialog id. Use /history to pick one.",
+    zh: "\u770B\u8D77\u6765\u4E0D\u662F dialog id\u3002\u7528 /history \u4ECE\u5217\u8868\u91CC\u9009\u4E00\u4E2A\u3002"
+  },
+  dialogResumeCancelled: {
+    en: "Dialog resume cancelled.",
+    zh: "\u5DF2\u53D6\u6D88\u6062\u590D\u5BF9\u8BDD\u3002"
+  },
+  agentSwitchCancelled: {
+    en: "Agent switch cancelled.",
+    zh: "\u5DF2\u53D6\u6D88\u5207\u6362 agent\u3002"
+  },
+  historyPickerTitle: {
+    en: "Resume dialog (\u2191\u2193 Enter Esc)",
+    zh: "\u6062\u590D\u5BF9\u8BDD\uFF08\u2191\u2193 \u79FB\u52A8 \xB7 Enter \u9009\u62E9 \xB7 Esc \u53D6\u6D88\uFF09"
+  },
+  noDialogsYet: {
+    en: "No dialogs yet.",
+    zh: "\u8FD8\u6CA1\u6709\u5386\u53F2\u5BF9\u8BDD\u3002"
+  },
+  langUsage: {
+    en: "Usage: /lang <zh|en>",
+    zh: "\u7528\u6CD5\uFF1A/lang <zh|en>"
+  },
+  stopHint: {
+    en: "Esc to stop",
+    zh: "Esc \u505C\u6B62\u56DE\u590D"
+  },
+  queuedHint: {
+    en: "queued",
+    zh: "\u6392\u961F"
+  },
+  turnStopped: {
+    en: "Stopped this reply.",
+    zh: "\u5DF2\u505C\u6B62\u672C\u6B21\u56DE\u590D\u3002"
+  },
+  turnFailed: {
+    en: "This reply failed. Queued messages are kept \u2014 press Enter to resend.",
+    zh: "\u672C\u6B21\u56DE\u590D\u51FA\u9519\u3002\u5DF2\u6392\u961F\u7684\u6D88\u606F\u4ECD\u4FDD\u7559\uFF0C\u6309 Enter \u53EF\u91CD\u65B0\u53D1\u9001\u3002"
+  },
+  quotaExhaustedHint: {
+    en: "[nolo] This agent seems to have hit a quota/rate limit (HTTP 429).\nUse /agent to switch to another agent and keep going \u2014 the dialog context is preserved.",
+    zh: "[nolo] \u5F53\u524D agent \u4F3C\u4E4E\u989D\u5EA6/\u901F\u7387\u53D7\u9650\uFF08429\uFF09\u3002\n\u53EF\u4EE5\u7528 /agent \u5207\u6362\u5230\u5176\u4ED6 agent \u540E\u7EE7\u7EED\uFF0C\u540C\u4E00\u5BF9\u8BDD\u4F1A\u4FDD\u7559\u4E0A\u4E0B\u6587\u3002"
+  },
+  copiedLastReply: {
+    en: "Copied the last reply to the clipboard.",
+    zh: "\u5DF2\u590D\u5236\u6700\u540E\u4E00\u6761\u56DE\u590D\u5230\u526A\u8D34\u677F\u3002"
+  },
+  copyNothing: {
+    en: "Nothing to copy yet.",
+    zh: "\u8FD8\u6CA1\u6709\u53EF\u590D\u5236\u7684\u5185\u5BB9\u3002"
+  },
+  copyFailed: {
+    en: "Copy failed",
+    zh: "\u590D\u5236\u5931\u8D25"
+  },
+  copyUnavailable: {
+    en: "Clipboard is unavailable in this environment. The last reply was printed above for manual copy.",
+    zh: "\u5F53\u524D\u73AF\u5883\u6CA1\u6709\u53EF\u7528\u7684\u526A\u8D34\u677F\u3002\u6700\u540E\u4E00\u6761\u56DE\u590D\u5DF2\u6253\u5370\u5728\u4E0A\u65B9\uFF0C\u53EF\u624B\u52A8\u590D\u5236\u3002"
+  },
+  copyUsage: {
+    en: "Usage: /copy or /copy view",
+    zh: "\u7528\u6CD5\uFF1A/copy \u6216 /copy view"
+  },
+  copyViewTitle: {
+    en: "Copy view \u2014 latest AI reply",
+    zh: "\u590D\u5236\u89C6\u56FE \u2014 \u6700\u65B0 AI \u56DE\u590D"
+  },
+  copyViewHint: {
+    en: "Drag to select; edge scrolling uses native terminal scrollback. Press Esc or Enter to return.",
+    zh: "\u76F4\u63A5\u62D6\u9009\uFF0C\u62D6\u5230\u8FB9\u7F18\u53EF\u7528\u7EC8\u7AEF\u539F\u751F\u56DE\u6EDA\u8DE8\u5C4F\u9009\u62E9\u3002\u6309 Esc \u6216 Enter \u8FD4\u56DE\u3002"
+  },
+  historyNoToken: {
+    en: "History requires an auth token. Run `nolo login` or set AUTH_TOKEN.",
+    zh: "\u67E5\u770B\u5386\u53F2\u5BF9\u8BDD\u9700\u8981\u767B\u5F55\u51ED\u8BC1\u3002\u8BF7\u8FD0\u884C `nolo login` \u6216\u8BBE\u7F6E AUTH_TOKEN\u3002"
+  },
+  historyBadToken: {
+    en: "Could not read a user id from AUTH_TOKEN. Run `nolo login` again.",
+    zh: "\u65E0\u6CD5\u4ECE AUTH_TOKEN \u89E3\u6790\u51FA\u7528\u6237 id\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C `nolo login`\u3002"
+  },
+  mouseOn: {
+    en: "Mouse mode on: wheel scrolls the transcript; hold Shift (or Option/Fn) to select text.",
+    zh: "\u9F20\u6807\u6A21\u5F0F\u5DF2\u5F00\u542F\uFF1A\u6EDA\u8F6E\u6EDA\u52A8\u5BF9\u8BDD\u8BB0\u5F55\uFF1B\u6309\u4F4F Shift\uFF08\u6216 Option/Fn\uFF09\u53EF\u62D6\u9009\u590D\u5236\u3002"
+  },
+  mouseOff: {
+    en: "Mouse mode off: drag to select/copy freely; scroll with PageUp/PageDown.",
+    zh: "\u9F20\u6807\u6A21\u5F0F\u5DF2\u5173\u95ED\uFF1A\u53EF\u76F4\u63A5\u62D6\u9009\u590D\u5236\uFF1B\u7528 PageUp/PageDown \u6EDA\u52A8\u5BF9\u8BDD\u8BB0\u5F55\u3002"
+  },
+  mouseUsage: {
+    en: "Usage: /mouse <on|off>",
+    zh: "\u7528\u6CD5\uFF1A/mouse <on|off>"
+  },
+  langSwitched: {
+    en: "Language switched to English.",
+    zh: "\u5DF2\u5207\u6362\u4E3A\u4E2D\u6587\u3002"
+  },
+  // --- Tool trace copy ------------------------------------------------------
+  // The compact trace shows only status, never timing or output size: a line
+  // count told the user nothing actionable and the ms figure read as noise.
+  toolNeedsAction: {
+    en: "needs action",
+    zh: "\u5F85\u786E\u8BA4"
+  },
+  toolTimedOut: {
+    en: "timed out",
+    zh: "\u5DF2\u8D85\u65F6"
+  },
+  toolExitCode: {
+    en: "exit",
+    zh: "\u9000\u51FA\u7801"
+  },
+  toolFailed: {
+    en: "failed",
+    zh: "\u5931\u8D25"
+  },
+  // --- Dialog (picker / confirm) copy --------------------------------------
+  // Key-hint wording is unified across select / multi-select / confirm so the
+  // three dialogs read as one family: "<Label>  <↑↓ move · Enter choose ·
+  // Esc cancel>  <count>". Connectors are "·" between keys, two spaces between
+  // the label, hint, and count. zh uses full-width parentheses to match the
+  // existing historyPickerTitle; en uses ASCII parentheses.
+  dialogSelectLabel: {
+    en: "Select",
+    zh: "\u9009\u62E9"
+  },
+  dialogSelectHint: {
+    en: "(\u2191\u2193 move \xB7 Enter choose \xB7 Esc cancel)",
+    zh: "\uFF08\u2191\u2193 \u79FB\u52A8 \xB7 Enter \u9009\u62E9 \xB7 Esc \u53D6\u6D88\uFF09"
+  },
+  dialogMultiSelectLabel: {
+    en: "Select",
+    zh: "\u9009\u62E9"
+  },
+  dialogMultiSelectHint: {
+    en: "(\u2191\u2193 move \xB7 Space toggle \xB7 Enter submit \xB7 Esc cancel)",
+    zh: "\uFF08\u2191\u2193 \u79FB\u52A8 \xB7 Space \u5207\u6362 \xB7 Enter \u63D0\u4EA4 \xB7 Esc \u53D6\u6D88\uFF09"
+  },
+  dialogMultiSelectSelected: {
+    en: "selected",
+    zh: "\u5DF2\u9009"
+  },
+  dialogConfirmHint: {
+    en: "(\u2191\u2193 move \xB7 Enter choose \xB7 Esc cancel)",
+    zh: "\uFF08\u2191\u2193 \u79FB\u52A8 \xB7 Enter \u9009\u62E9 \xB7 Esc \u53D6\u6D88\uFF09"
+  },
+  dialogConfirmTitle: {
+    en: "Confirm destructive shell command",
+    zh: "\u786E\u8BA4\u6267\u884C\u7834\u574F\u6027 shell \u547D\u4EE4"
+  },
+  dialogConfirmBody: {
+    en: "This command may delete or reset user content and needs explicit confirmation before it runs.",
+    zh: "\u8BE5\u547D\u4EE4\u53EF\u80FD\u5220\u9664\u6216\u91CD\u7F6E\u7528\u6237\u5185\u5BB9\uFF0C\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u624D\u80FD\u6267\u884C\u3002"
+  },
+  dialogConfirmCommandLabel: {
+    en: "Command",
+    zh: "\u547D\u4EE4"
+  },
+  dialogConfirmCommandTruncated: {
+    en: "(truncated)",
+    zh: "\uFF08\u5DF2\u622A\u65AD\uFF09"
+  },
+  dialogConfirmAllowLabel: {
+    en: "Allow",
+    zh: "\u5141\u8BB8"
+  },
+  dialogConfirmAllowDetail: {
+    en: "execute this time",
+    zh: "\u672C\u6B21\u6267\u884C"
+  },
+  dialogConfirmCancelLabel: {
+    en: "Cancel",
+    zh: "\u53D6\u6D88"
+  },
+  dialogConfirmCancelDetail: {
+    en: "abort the operation",
+    zh: "\u4E2D\u6B62\u64CD\u4F5C"
+  },
+  contextTitle: {
+    en: "Workspace context",
+    zh: "\u5DE5\u4F5C\u533A\u4E0A\u4E0B\u6587"
+  },
+  contextNext: {
+    en: "Next:",
+    zh: "\u4E0B\u4E00\u6B65\uFF1A"
+  },
+  contextFieldAgent: {
+    en: "agent",
+    zh: "\u667A\u80FD\u4F53"
+  },
+  contextFieldTokens: {
+    en: "tokens",
+    zh: "\u4EE4\u724C"
+  },
+  contextFieldDialog: {
+    en: "dialog",
+    zh: "\u5BF9\u8BDD"
+  },
+  contextFieldDocs: {
+    en: "docs",
+    zh: "\u6587\u6863"
+  },
+  contextFieldSkills: {
+    en: "skills",
+    zh: "\u6280\u80FD"
+  },
+  contextFieldProfile: {
+    en: "profile",
+    zh: "\u914D\u7F6E"
+  },
+  contextFieldRuntime: {
+    en: "runtime",
+    zh: "\u8FD0\u884C\u65F6"
+  },
+  contextFieldTools: {
+    en: "tools",
+    zh: "\u5DE5\u5177"
+  },
+  contextFieldThinking: {
+    en: "thinking",
+    zh: "\u601D\u8003"
+  },
+  contextFieldServer: {
+    en: "server",
+    zh: "\u670D\u52A1\u7AEF"
+  },
+  contextNextAgents: {
+    en: "see specialist shortcuts",
+    zh: "\u67E5\u770B\u4E13\u7528\u667A\u80FD\u4F53\u5FEB\u6377\u65B9\u5F0F"
+  },
+  contextNextDoc: {
+    en: "add working context",
+    zh: "\u6DFB\u52A0\u5DE5\u4F5C\u4E0A\u4E0B\u6587"
+  },
+  contextNextSkill: {
+    en: "attach a skill to this workspace",
+    zh: "\u4E3A\u8BE5\u5DE5\u4F5C\u533A\u6302\u8F7D\u6280\u80FD"
+  },
+  contextNextNew: {
+    en: "start a clean dialog",
+    zh: "\u5F00\u59CB\u4E00\u4E2A\u5E72\u51C0\u7684\u5BF9\u8BDD"
+  },
+  agentsTitle: {
+    en: "Agents:",
+    zh: "\u667A\u80FD\u4F53\uFF1A"
+  },
+  agentsTip: {
+    en: "Tip: run /switch for the full picker, or /switch list for your private agents too.",
+    zh: "\u63D0\u793A\uFF1A\u7528 /switch \u6253\u5F00\u5B8C\u6574\u9009\u62E9\u5668\uFF0C\u6216 /switch list \u8FDE\u4F60\u7684\u79C1\u6709\u667A\u80FD\u4F53\u4E00\u8D77\u5217\u51FA\u3002"
+  },
+  helpText: {
+    en: [
+      "Commands:",
+      "  /help                 Show this help",
+      "  /new                  Clear screen and start a fresh dialog",
+      "  /compact              Compact current dialog and fork a new one",
+      "  /context              Show workspace context and next actions",
+      "  /runtime <mode>       Use auto, local, or server runtime",
+      "  /tools <mode>         Control tool trace: hide, compact, verbose",
+      "  /thinking <mode>      Control thinking output: hide, marker, show",
+      "  /switch               Pick an agent interactively (\u2191\u2193, Enter)",
+      "  /switch list          List agents as text",
+      "  /switch <name>        Switch directly by name, alias, or key (alias: /agent)",
+      "  /agents               List platform agent shortcuts",
+      "  /history              Pick a recent dialog to resume (\u2191\u2193, Enter)",
+      "  /resume <dialogId>    Resume a dialog directly by id",
+      "  /lang <zh|en>         Switch interface language",
+      "  /copy                 Copy the last reply to the clipboard",
+      "  /copy view            Open native scrollback for partial selection (Ctrl+O)",
+      "  /mouse <on|off>       Toggle mouse mode (off = drag to select text)",
+      "  /doc                  List attached docs",
+      "  /doc attach <doc>     Attach a doc to this workspace",
+      "  /skill                List attached skills",
+      "  /skill attach <ref>   Attach a skill (dbKey, name, or SKILL.md path)",
+      "  /skill detach <ref>   Detach a skill",
+      "  /skill clear          Detach all skills",
+      "  /customize            Describe how you want to tune nolo",
+      "  /tasks                List background process tasks (aliases: /jobs, /procs)",
+      "  /stop <pid|all>       Stop background process tasks",
+      "  /login                Show login/profile hint",
+      "  /profile              Show active profile",
+      "  /update               Update the nolo CLI install",
+      "  /version              Show version/update hint",
+      "  /exit                 Leave the workspace",
+      "",
+      "You can also type normally. nolo routes simple read/status requests to CLI commands and sends the rest to the current agent."
+    ].join("\n"),
+    zh: [
+      "\u547D\u4EE4\uFF1A",
+      "  /help                 \u663E\u793A\u672C\u5E2E\u52A9",
+      "  /new                  \u6E05\u5C4F\u5E76\u5F00\u59CB\u65B0\u5BF9\u8BDD",
+      "  /compact              \u538B\u7F29\u5F53\u524D\u5BF9\u8BDD\u5E76\u5206\u53C9\u51FA\u65B0\u5BF9\u8BDD",
+      "  /context              \u67E5\u770B\u5DE5\u4F5C\u533A\u4E0A\u4E0B\u6587\u4E0E\u540E\u7EED\u64CD\u4F5C",
+      "  /runtime <mode>       \u5207\u6362 runtime\uFF1Aauto\u3001local\u3001server",
+      "  /tools <mode>         \u5DE5\u5177\u8F68\u8FF9\u663E\u793A\uFF1Ahide\u3001compact\u3001verbose",
+      "  /thinking <mode>      \u601D\u8003\u8FC7\u7A0B\u663E\u793A\uFF1Ahide\u3001marker\u3001show",
+      "  /switch               \u4EA4\u4E92\u5F0F\u9009\u62E9 agent\uFF08\u2191\u2193 \u79FB\u52A8\uFF0CEnter \u786E\u8BA4\uFF09",
+      "  /switch list          \u4EE5\u6587\u672C\u5217\u51FA\u5168\u90E8 agent",
+      "  /switch <name>        \u6309\u540D\u79F0\u3001\u522B\u540D\u6216 key \u76F4\u63A5\u5207\u6362\uFF08\u522B\u540D\uFF1A/agent\uFF09",
+      "  /agents               \u5217\u51FA\u5E73\u53F0 agent \u5FEB\u6377\u65B9\u5F0F",
+      "  /history              \u4ECE\u6700\u8FD1\u5BF9\u8BDD\u4E2D\u9009\u62E9\u5E76\u6062\u590D\uFF08\u2191\u2193\uFF0CEnter\uFF09",
+      "  /resume <dialogId>    \u6309 id \u76F4\u63A5\u6062\u590D\u5BF9\u8BDD",
+      "  /lang <zh|en>         \u5207\u6362\u754C\u9762\u8BED\u8A00",
+      "  /copy                 \u590D\u5236\u6700\u540E\u4E00\u6761\u56DE\u590D\u5230\u526A\u8D34\u677F",
+      "  /copy view            \u6253\u5F00\u539F\u751F\u56DE\u6EDA\u8FDB\u884C\u8DE8\u5C4F\u62D6\u9009\uFF08Ctrl+O\uFF09",
+      "  /mouse <on|off>       \u5207\u6362\u9F20\u6807\u6A21\u5F0F\uFF08off \u540E\u53EF\u76F4\u63A5\u62D6\u9009\u6587\u672C\uFF09",
+      "  /doc                  \u5217\u51FA\u5DF2\u6302\u8F7D\u7684\u6587\u6863",
+      "  /doc attach <doc>     \u6302\u8F7D\u6587\u6863\u5230\u5F53\u524D\u5DE5\u4F5C\u533A",
+      "  /skill                \u5217\u51FA\u5DF2\u6302\u8F7D\u7684\u6280\u80FD",
+      "  /skill attach <ref>   \u6302\u8F7D\u6280\u80FD\uFF08dbKey\u3001\u540D\u79F0\u6216 SKILL.md \u8DEF\u5F84\uFF09",
+      "  /skill detach <ref>   \u5378\u8F7D\u6307\u5B9A\u6280\u80FD",
+      "  /skill clear          \u5378\u8F7D\u5168\u90E8\u6280\u80FD",
+      "  /customize            \u63CF\u8FF0\u4F60\u60F3\u600E\u4E48\u8C03\u6559 nolo",
+      "  /tasks                \u5217\u51FA\u540E\u53F0\u5B50\u8FDB\u7A0B\u4EFB\u52A1\uFF08\u522B\u540D\uFF1A/jobs, /procs\uFF09",
+      "  /stop <pid|all>       \u505C\u6B62\u6307\u5B9A\u7684\u540E\u53F0\u4EFB\u52A1",
+      "  /login                \u67E5\u770B\u767B\u5F55 / \u914D\u7F6E\u63D0\u793A",
+      "  /profile              \u67E5\u770B\u5F53\u524D\u914D\u7F6E\u73AF\u5883",
+      "  /update               \u66F4\u65B0 nolo CLI",
+      "  /version              \u67E5\u770B\u7248\u672C\u4E0E\u66F4\u65B0\u63D0\u793A",
+      "  /exit                 \u9000\u51FA\u5DE5\u4F5C\u533A",
+      "",
+      "\u4E5F\u53EF\u4EE5\u76F4\u63A5\u8F93\u5165\u81EA\u7136\u8BED\u8A00\u3002\u7B80\u5355\u7684\u8BFB\u53D6/\u72B6\u6001\u8BF7\u6C42\u4F1A\u8D70 CLI \u547D\u4EE4\uFF0C\u5176\u4F59\u4EA4\u7ED9\u5F53\u524D agent\u3002"
+    ].join("\n")
+  }
+};
+function t(key) {
+  return STRINGS[key][currentLocale];
+}
+var TOOL_LABELS = {
+  // Local workspace tools (packages/agent-runtime/localWorkspaceTools.ts)
+  readFile: { en: "Read", zh: "\u8BFB\u53D6" },
+  writeFile: { en: "Write", zh: "\u5199\u5165" },
+  editFile: { en: "Edit", zh: "\u7F16\u8F91" },
+  listFiles: { en: "List", zh: "\u5217\u51FA" },
+  searchFiles: { en: "Search", zh: "\u641C\u7D22" },
+  globFiles: { en: "Glob", zh: "\u5339\u914D" },
+  execShell: { en: "Run", zh: "\u6267\u884C" },
+  runCommand: { en: "Run", zh: "\u6267\u884C" },
+  captureVisualState: { en: "Capture", zh: "\u622A\u5C4F" },
+  // Workspace / diagnostics
+  searchWorkspace: { en: "Search workspace", zh: "\u641C\u7D22\u5DE5\u4F5C\u533A" },
+  cliDoctor: { en: "Doctor", zh: "\u81EA\u68C0" },
+  cliWhoami: { en: "Whoami", zh: "\u67E5\u770B\u8EAB\u4EFD" },
+  checkEnv: { en: "Check env", zh: "\u68C0\u67E5\u73AF\u5883" },
+  configure: { en: "Configure", zh: "\u914D\u7F6E" },
+  notifyUser: { en: "Notify", zh: "\u901A\u77E5" },
+  // Docs / dialogs / spaces
+  readDoc: { en: "Read doc", zh: "\u8BFB\u53D6\u6587\u6863" },
+  createDoc: { en: "Create doc", zh: "\u65B0\u5EFA\u6587\u6863" },
+  updateDoc: { en: "Update doc", zh: "\u66F4\u65B0\u6587\u6863" },
+  readDialog: { en: "Read dialog", zh: "\u8BFB\u53D6\u5BF9\u8BDD" },
+  listDialogs: { en: "List dialogs", zh: "\u5217\u51FA\u5BF9\u8BDD" },
+  queryDialogsBySubjectRef: { en: "Query dialogs", zh: "\u67E5\u8BE2\u5BF9\u8BDD" },
+  searchDialogMessages: { en: "Search messages", zh: "\u641C\u7D22\u6D88\u606F" },
+  listSpaces: { en: "List spaces", zh: "\u5217\u51FA\u7A7A\u95F4" },
+  readSpace: { en: "Read space", zh: "\u8BFB\u53D6\u7A7A\u95F4" },
+  // Tables
+  createTable: { en: "Create table", zh: "\u521B\u5EFA\u8868" },
+  queryTableRows: { en: "Query rows", zh: "\u67E5\u8BE2\u8868\u884C" },
+  addTableRow: { en: "Add row", zh: "\u65B0\u589E\u8868\u884C" },
+  addTableRows: { en: "Add rows", zh: "\u65B0\u589E\u8868\u884C" },
+  updateTableRow: { en: "Update row", zh: "\u66F4\u65B0\u8868\u884C" },
+  deleteTableRow: { en: "Delete row", zh: "\u5220\u9664\u8868\u884C" },
+  // Web
+  fetchWebpage: { en: "Fetch page", zh: "\u6293\u53D6\u7F51\u9875" },
+  readPage: { en: "Read page", zh: "\u8BFB\u53D6\u7F51\u9875" },
+  exaSearch: { en: "Web search", zh: "\u8054\u7F51\u641C\u7D22" }
+};
+function toolLabel(name) {
+  return TOOL_LABELS[name]?.[currentLocale] ?? name;
+}
+
+// packages/cli/client/toolOutput.ts
+function normalizeToolDisplayMode(raw, fallback = "compact") {
+  const normalized = asTrimmedLowercaseString(raw);
+  if (normalized === "hide" || normalized === "off" || normalized === "false" || normalized === "0") {
+    return "hide";
+  }
+  if (normalized === "verbose" || normalized === "debug" || normalized === "trace" || normalized === "full") {
+    return "verbose";
+  }
+  if (normalized === "compact" || normalized === "minimal" || normalized === "short") {
+    return "compact";
+  }
+  return fallback;
+}
+function resolveToolDisplayMode(env = process.env) {
+  const legacyTrace = asTrimmedLowercaseString(env.NOLO_TRACE_TOOLS);
+  if (legacyTrace === "0" || legacyTrace === "false" || legacyTrace === "off") {
+    return "hide";
+  }
+  if (legacyTrace === "verbose" || legacyTrace === "full") {
+    return "verbose";
+  }
+  return normalizeToolDisplayMode(env.NOLO_CLI_TOOLS ?? env.NOLO_TOOLS, "compact");
+}
+function shouldEmitToolEvents(mode) {
+  return mode !== "hide";
+}
+function clip(value, max = 72) {
+  return clipCompactText(value, max, "\u2026");
+}
+function formatActiveToolLabel(event) {
+  const toolName = event.toolName || "tool";
+  const args = clipPathAware(event.argumentsPreview ?? "");
+  const label = toolLabel(toolName);
+  return args ? `${label} ${args}` : label;
+}
+function compactResultHint(event) {
+  const gate = readActionGate(event.metadata?.actionGate);
+  if (gate) {
+    const commandPayload = gate.kind === "handoff" ? readCommandActionGatePayload(gate.payload) : null;
+    const command = commandPayload?.displayCommand ?? commandPayload?.command.join(" ") ?? "";
+    const detail = command.trim() ? command : gate.title;
+    return { inline: `${t("toolNeedsAction")}: ${clip(detail, 120)}` };
+  }
+  if (event.metadata?.timedOut) return { inline: t("toolTimedOut") };
+  if (event.toolName === "readFile" && event.metadata) {
+    const range = readReadFileRange(event.metadata);
+    if (range) return { inline: range };
+  }
+  if (event.toolName === "editFile" && event.metadata) {
+    const detail = formatEditFileSnippet(event.metadata);
+    if (detail) return { inline: "", detail };
+  }
+  const summary = event.summary;
+  if (!summary) return { inline: "" };
+  const exitMatch = summary.match(/exit=(\d+)/);
+  if (exitMatch && exitMatch[1] !== "0") return { inline: `${t("toolExitCode")} ${exitMatch[1]}` };
+  return { inline: "" };
+}
+function readReadFileRange(metadata) {
+  const startLine = metadata.startLine;
+  const endLine = metadata.endLine;
+  const totalLines = metadata.totalLines;
+  const truncated = metadata.truncated;
+  if (typeof startLine !== "number" || typeof endLine !== "number" || typeof totalLines !== "number") {
+    return void 0;
+  }
+  if (!truncated && startLine === 1 && endLine === totalLines) return void 0;
+  return `${startLine}-${endLine}/${totalLines}`;
+}
+var EDIT_SNIPPET_MAX_LINES = 5;
+var EDIT_SNIPPET_MAX_WIDTH = 96;
+function formatEditFileSnippet(metadata) {
+  const oldSnippet = typeof metadata.oldSnippet === "string" ? metadata.oldSnippet : void 0;
+  const newSnippet = typeof metadata.newSnippet === "string" ? metadata.newSnippet : void 0;
+  if (!oldSnippet && !newSnippet) return void 0;
+  const lines = [];
+  if (oldSnippet) {
+    for (const line of snippetLines(oldSnippet)) lines.push(`- ${line}`);
+  }
+  if (newSnippet) {
+    for (const line of snippetLines(newSnippet)) lines.push(`+ ${line}`);
+  }
+  return lines.length ? lines.join("\n") : void 0;
+}
+function snippetLines(snippet) {
+  const lines = snippet.split(/\r?\n/).filter((line) => line.length > 0);
+  const shown = lines.slice(0, EDIT_SNIPPET_MAX_LINES);
+  return shown.map((line) => line.length > EDIT_SNIPPET_MAX_WIDTH ? `${line.slice(0, EDIT_SNIPPET_MAX_WIDTH)}\u2026` : line);
+}
+function isFailedToolResult(event) {
+  const exitCode = event.metadata?.exitCode;
+  if (event.metadata?.actionGate) return false;
+  if (typeof exitCode === "number" && exitCode !== 0) return true;
+  return Boolean(event.metadata?.timedOut);
+}
+function isNeedsActionToolResult(event) {
+  return Boolean(event.metadata?.actionGate);
+}
+function parseUiAskChoiceForCli(event) {
+  if (event.toolName !== "ui_ask_choice" && !event.metadata?.uiAskChoice) {
+    return null;
+  }
+  const parsed = parseUiAskChoiceContent(event.content);
+  if (!parsed) return null;
+  const question = typeof parsed.question === "string" ? parsed.question.trim() : "";
+  const choices = (Array.isArray(parsed.choices) ? parsed.choices : []).filter((c) => Boolean(c && typeof c === "object")).map((c) => ({
+    label: String(c.label ?? "").trim(),
+    userMessage: typeof c.userMessage === "string" ? c.userMessage : void 0
+  })).filter((c) => c.label.length > 0);
+  if (!question || choices.length === 0) return null;
+  return { question, choices };
+}
+function formatUiAskChoiceBlock(event, colorEnabled) {
+  const parsed = parseUiAskChoiceForCli(event);
+  if (!parsed) return null;
+  const lines = [];
+  lines.push("");
+  if (colorEnabled) {
+    lines.push(`${themeText("\u2753 ", "info", true)}${styleCliText(parsed.question, "cyan", true)}`);
+  } else {
+    lines.push(`\u2753 ${parsed.question}`);
+  }
+  parsed.choices.forEach((choice, i) => {
+    const num = String(i + 1);
+    const label = choice.label;
+    if (colorEnabled) {
+      lines.push(
+        `  ${themeText(num + ".", "chrome", true)} ${label}`
+      );
+    } else {
+      lines.push(`  ${num}. ${label}`);
+    }
+  });
+  const hint = "\u8BF7\u8F93\u5165\u5E8F\u53F7\u9009\u62E9\uFF0C\u6216\u76F4\u63A5\u56DE\u590D\uFF1A";
+  if (colorEnabled) {
+    lines.push(`  ${dimCliText(hint, true)}`);
+  } else {
+    lines.push(`  ${hint}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatToolTraceLine(text, colorEnabled, accent = "none") {
+  if (!colorEnabled) return `${text}
+`;
+  if (accent === "error") {
+    return `${themeText(text, "danger", true)}
+`;
+  }
+  return `${dimCliText(text, true)}
+`;
+}
+function formatVerboseToolEvent(event, colorEnabled) {
+  const round = event.round + 1;
+  const detail = event.argumentsPreview ? ` ${event.argumentsPreview}` : "";
+  if (event.type === "tool-call") {
+    return formatToolTraceLine(`[nolo:tool] #${round} -> ${event.toolName}${detail}`, colorEnabled);
+  }
+  if (event.type === "tool-error") {
+    const elapsed2 = typeof event.elapsedMs === "number" ? ` ${event.elapsedMs}ms` : "";
+    return formatToolTraceLine(
+      `[nolo:tool] #${round} !! ${event.toolName}${elapsed2}: ${event.message ?? "failed"}`,
+      colorEnabled,
+      "error"
+    );
+  }
+  const elapsed = typeof event.elapsedMs === "number" ? ` ${event.elapsedMs}ms` : "";
+  if (event.type === "tool-result" && (event.toolName === "ui_ask_choice" || event.metadata?.uiAskChoice)) {
+    const block = formatUiAskChoiceBlock(event, colorEnabled);
+    if (block) return `${formatToolTraceLine(`[nolo:tool] #${round} <- ${event.toolName}${elapsed}`, colorEnabled)}${block}`;
+  }
+  const summary = event.summary ? ` ${event.summary}` : "";
+  return formatToolTraceLine(
+    `[nolo:tool] #${round} <- ${event.toolName}${elapsed}${summary}`,
+    colorEnabled
+  );
+}
+function isReadToolName(name) {
+  if (!name) return false;
+  return name === "read" || name === "readFile" || name === "read_file" || name === "readWorkspaceFile";
+}
+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";
+}
+function isRunToolName(name) {
+  if (!name) return false;
+  return name === "execShell" || name === "runCommand" || name === "run_command" || name === "launchProcess";
+}
+function isFetchToolName(name) {
+  if (!name) return false;
+  return name === "fetchWebpage" || name === "fetch_webpage";
+}
+function isRunResultFoldable(event) {
+  return Boolean(event.metadata?.actionGate) === false;
+}
+function formatSearchTreeBlockForCli(items, colorEnabled) {
+  if (items.length === 0) return "";
+  const { count, lines } = formatSearchTreeLines(items);
+  if (!colorEnabled) {
+    const headerLine2 = `\u2022 Search (${count})
+`;
+    const treeLines2 = lines.map((l) => `  ${l.connector}${l.queryText}`).join("\n");
+    return `${headerLine2}${treeLines2}
+`;
+  }
+  const bullet = themeText("\u2022", "chrome", true);
+  const title = styleCliText("Search", "bold", true);
+  const countText = themeText(`(${count})`, "muted", true);
+  const headerLine = `${bullet} ${title} ${countText}
+`;
+  const treeLines = lines.map((l) => {
+    const connector = themeText(`  ${l.connector}`, "chrome", true);
+    const queryText = themeText(l.queryText, "muted", true);
+    return `${connector}${queryText}`;
+  }).join("\n");
+  return `${headerLine}${treeLines}
+`;
+}
+function formatReadTreeBlockForCli(items, colorEnabled) {
+  if (items.length === 0) return "";
+  const { count, lines } = formatReadTreeLines(items);
+  if (!colorEnabled) {
+    const headerLine2 = `\u2022 Read (${count})
+`;
+    const treeLines2 = lines.map((l) => `  ${l.connector}${l.pathWithRange}`).join("\n");
+    return `${headerLine2}${treeLines2}
+`;
+  }
+  const bullet = themeText("\u2022", "chrome", true);
+  const title = styleCliText("Read", "bold", true);
+  const countText = themeText(`(${count})`, "muted", true);
+  const headerLine = `${bullet} ${title} ${countText}
+`;
+  const treeLines = lines.map((l) => {
+    const connector = themeText(`  ${l.connector}`, "chrome", true);
+    const pathText = themeText(l.pathWithRange, "muted", true);
+    return `${connector}${pathText}`;
+  }).join("\n");
+  return `${headerLine}${treeLines}
+`;
+}
+function formatRunTreeBlockForCli(items, colorEnabled) {
+  if (items.length === 0) return "";
+  const { count, lines } = formatRunTreeLines(items);
+  if (!colorEnabled) {
+    const headerLine2 = `\u2022 Run (${count})
+`;
+    const treeLines2 = lines.map((l) => `  ${l.connector}${l.commandText}`).join("\n");
+    return `${headerLine2}${treeLines2}
+`;
+  }
+  const bullet = themeText("\u2022", "chrome", true);
+  const title = styleCliText("Run", "bold", true);
+  const countText = themeText(`(${count})`, "muted", true);
+  const headerLine = `${bullet} ${title} ${countText}
+`;
+  const treeLines = lines.map((l) => {
+    const connector = themeText(`  ${l.connector}`, "chrome", true);
+    const commandText = themeText(l.commandText, "muted", true);
+    return `${connector}${commandText}`;
+  }).join("\n");
+  return `${headerLine}${treeLines}
+`;
+}
+function formatFetchTreeBlockForCli(items, colorEnabled) {
+  if (items.length === 0) return "";
+  const { count, lines } = formatFetchTreeLines(items);
+  if (!colorEnabled) {
+    const headerLine2 = `\u2022 Fetch (${count})
+`;
+    const treeLines2 = lines.map((l) => `  ${l.connector}${l.urlText}`).join("\n");
+    return `${headerLine2}${treeLines2}
+`;
+  }
+  const bullet = themeText("\u2022", "chrome", true);
+  const title = styleCliText("Fetch", "bold", true);
+  const countText = themeText(`(${count})`, "muted", true);
+  const headerLine = `${bullet} ${title} ${countText}
+`;
+  const treeLines = lines.map((l) => {
+    const connector = themeText(`  ${l.connector}`, "chrome", true);
+    const urlText = themeText(l.urlText, "muted", true);
+    return `${connector}${urlText}`;
+  }).join("\n");
+  return `${headerLine}${treeLines}
+`;
+}
+function formatCompactToolLine(event, pending, colorEnabled) {
+  const toolName = event.toolName || pending?.toolName || "tool";
+  if (isReadToolName(toolName) && event.type === "tool-result") {
+    const rawPath = (typeof event.metadata?.path === "string" ? event.metadata.path : void 0) || (typeof event.metadata?.filePath === "string" ? event.metadata.filePath : void 0) || event.argumentsPreview || pending?.argumentsPreview || "";
+    return formatReadTreeBlockForCli([{ path: rawPath, metadata: event.metadata }], colorEnabled);
+  }
+  if (isSearchToolName(toolName) && event.type === "tool-result") {
+    const rawQuery = (typeof event.metadata?.query === "string" ? event.metadata.query : void 0) || (typeof event.metadata?.pattern === "string" ? event.metadata.pattern : void 0) || event.argumentsPreview || pending?.argumentsPreview || "";
+    const rawPath = typeof event.metadata?.path === "string" ? event.metadata.path : void 0;
+    return formatSearchTreeBlockForCli([{ query: rawQuery, path: rawPath }], colorEnabled);
+  }
+  if (isFetchToolName(toolName) && event.type === "tool-result") {
+    const rawUrl = (typeof event.metadata?.url === "string" ? event.metadata.url : void 0) || event.argumentsPreview || pending?.argumentsPreview || "";
+    return formatFetchTreeBlockForCli([{ url: rawUrl }], colorEnabled);
+  }
+  if (isRunToolName(toolName) && event.type === "tool-result" && isRunResultFoldable(event)) {
+    const rawCommand = (typeof event.metadata?.command === "string" ? event.metadata.command : void 0) || event.argumentsPreview || pending?.argumentsPreview || "";
+    const exitCode = typeof event.metadata?.exitCode === "number" ? event.metadata.exitCode : void 0;
+    const timedOut = Boolean(event.metadata?.timedOut);
+    return formatRunTreeBlockForCli([{ command: rawCommand, exitCode, timedOut }], colorEnabled);
+  }
+  const rawArgs = clipPathAware(event.argumentsPreview || pending?.argumentsPreview || "", 72);
+  const rawLabel = toolLabel(toolName);
+  const label = rawArgs ? `${rawLabel} ${rawArgs}` : rawLabel;
+  if (event.type === "tool-error") {
+    const message = clip(event.message ?? t("toolFailed"), 96);
+    return formatToolTraceLine(`\u25B8 ${label}  \u2717 ${message}`, colorEnabled, "error");
+  }
+  if (event.type === "tool-result" && (event.toolName === "ui_ask_choice" || event.metadata?.uiAskChoice)) {
+    const block = formatUiAskChoiceBlock(event, colorEnabled);
+    if (block) return block;
+  }
+  const hint = compactResultHint(event);
+  const suffix = hint.inline ? ` ${hint.inline}` : "";
+  const failed = isFailedToolResult(event);
+  const marker = failed ? "\u2717" : isNeedsActionToolResult(event) ? "!" : "\u2713";
+  let mainLine;
+  if (!colorEnabled) {
+    mainLine = `\u25B8 ${label}  ${marker}${suffix}
+`;
+  } else {
+    const chromePointer = themeText("\u25B8", "chrome", true);
+    const mutedLabel = themeText(rawLabel, "muted", true);
+    const argsPart = rawArgs ? ` ${dimCliText(rawArgs, true)}` : "";
+    const statusToken = failed ? themeText("\u2717", "danger", true) : isNeedsActionToolResult(event) ? themeText("!", "warning", true) : themeText("\u2713", "success", true);
+    const suffixPart = hint.inline ? ` ${dimCliText(hint.inline, true)}` : "";
+    mainLine = `${chromePointer} ${mutedLabel}${argsPart}  ${statusToken}${suffixPart}
+`;
+  }
+  if (!hint.detail) return mainLine;
+  const detailLines = hint.detail.split("\n").map((line) => formatEditDetailLine(line, colorEnabled)).join("");
+  return `${mainLine}${detailLines}`;
+}
+function formatEditDetailLine(line, colorEnabled) {
+  const marker = line.slice(0, 2);
+  const rest = line.slice(2);
+  if (!colorEnabled) return `  ${line}
+`;
+  const diff = diffLineSequences();
+  if (!diff) {
+    const color = marker === "- " ? "red" : marker === "+ " ? "green" : void 0;
+    if (color) {
+      return `  ${styleCliText(marker, color, true)}${dimCliText(rest, true)}
+`;
+    }
+    return `  ${dimCliText(line, true)}
+`;
+  }
+  const RESET2 = "\x1B[0m";
+  if (marker === "- ") {
+    return `  ${diff.removed.bg}${diff.removed.fg}- ${rest}${RESET2}
+`;
+  }
+  if (marker === "+ ") {
+    return `  ${diff.added.bg}${diff.added.fg}+ ${rest}${RESET2}
+`;
+  }
+  return `  ${dimCliText(line, true)}
+`;
+}
+function createToolEventFormatter(mode, colorEnabled = resolveCliColorEnabled()) {
+  const pending = /* @__PURE__ */ new Map();
+  let readBuffer = [];
+  let searchBuffer = [];
+  let runBuffer = [];
+  let fetchBuffer = [];
+  const flushBuffers = () => {
+    let out = "";
+    if (readBuffer.length > 0) {
+      const items = readBuffer.map((evt) => {
+        const call = pending.get(evt.toolCallId);
+        const rawPath = (typeof evt.metadata?.path === "string" ? evt.metadata.path : void 0) || (typeof evt.metadata?.filePath === "string" ? evt.metadata.filePath : void 0) || evt.argumentsPreview || call?.argumentsPreview || "";
+        return { path: rawPath, metadata: evt.metadata };
+      });
+      for (const evt of readBuffer) pending.delete(evt.toolCallId);
+      readBuffer = [];
+      out += formatReadTreeBlockForCli(items, colorEnabled);
+    }
+    if (searchBuffer.length > 0) {
+      const items = searchBuffer.map((evt) => {
+        const call = pending.get(evt.toolCallId);
+        const rawQuery = (typeof evt.metadata?.query === "string" ? evt.metadata.query : void 0) || (typeof evt.metadata?.pattern === "string" ? evt.metadata.pattern : void 0) || evt.argumentsPreview || call?.argumentsPreview || "";
+        const rawPath = typeof evt.metadata?.path === "string" ? evt.metadata.path : void 0;
+        return { query: rawQuery, path: rawPath };
+      });
+      for (const evt of searchBuffer) pending.delete(evt.toolCallId);
+      searchBuffer = [];
+      out += formatSearchTreeBlockForCli(items, colorEnabled);
+    }
+    if (runBuffer.length > 0) {
+      const items = runBuffer.map((evt) => {
+        const call = pending.get(evt.toolCallId);
+        const rawCommand = (typeof evt.metadata?.command === "string" ? evt.metadata.command : void 0) || evt.argumentsPreview || call?.argumentsPreview || "";
+        const exitCode = typeof evt.metadata?.exitCode === "number" ? evt.metadata.exitCode : void 0;
+        const timedOut = Boolean(evt.metadata?.timedOut);
+        return { command: rawCommand, exitCode, timedOut };
+      });
+      for (const evt of runBuffer) pending.delete(evt.toolCallId);
+      runBuffer = [];
+      out += formatRunTreeBlockForCli(items, colorEnabled);
+    }
+    if (fetchBuffer.length > 0) {
+      const items = fetchBuffer.map((evt) => {
+        const call = pending.get(evt.toolCallId);
+        const rawUrl = (typeof evt.metadata?.url === "string" ? evt.metadata.url : void 0) || evt.argumentsPreview || call?.argumentsPreview || "";
+        return { url: rawUrl };
+      });
+      for (const evt of fetchBuffer) pending.delete(evt.toolCallId);
+      fetchBuffer = [];
+      out += formatFetchTreeBlockForCli(items, colorEnabled);
+    }
+    return out;
+  };
+  const formatter = (event) => {
+    if (mode === "hide") return "";
+    if (mode === "verbose") return formatVerboseToolEvent(event, colorEnabled);
+    if (isReadToolName(event.toolName)) {
+      if (event.type === "tool-call") {
+        pending.set(event.toolCallId, {
+          toolName: event.toolName,
+          argumentsPreview: event.argumentsPreview
+        });
+        return "";
+      }
+      if (event.type === "tool-result") {
+        readBuffer.push(event);
+        return "";
+      }
+    }
+    if (isSearchToolName(event.toolName)) {
+      if (event.type === "tool-call") {
+        pending.set(event.toolCallId, {
+          toolName: event.toolName,
+          argumentsPreview: event.argumentsPreview
+        });
+        return "";
+      }
+      if (event.type === "tool-result") {
+        searchBuffer.push(event);
+        return "";
+      }
+    }
+    if (isRunToolName(event.toolName)) {
+      if (event.type === "tool-result" && !isRunResultFoldable(event)) {
+        const flushed2 = flushBuffers();
+        const call2 = pending.get(event.toolCallId);
+        pending.delete(event.toolCallId);
+        return `${flushed2}${formatCompactToolLine(event, call2, colorEnabled)}`;
+      }
+      if (event.type === "tool-call") {
+        pending.set(event.toolCallId, {
+          toolName: event.toolName,
+          argumentsPreview: event.argumentsPreview
+        });
+        return "";
+      }
+      if (event.type === "tool-result") {
+        runBuffer.push(event);
+        return "";
+      }
+    }
+    if (isFetchToolName(event.toolName)) {
+      if (event.type === "tool-call") {
+        pending.set(event.toolCallId, {
+          toolName: event.toolName,
+          argumentsPreview: event.argumentsPreview
+        });
+        return "";
+      }
+      if (event.type === "tool-result") {
+        fetchBuffer.push(event);
+        return "";
+      }
+    }
+    const flushed = flushBuffers();
+    if (event.type === "tool-call") {
+      pending.set(event.toolCallId, {
+        toolName: event.toolName,
+        argumentsPreview: event.argumentsPreview
+      });
+      return flushed;
+    }
+    const call = pending.get(event.toolCallId);
+    pending.delete(event.toolCallId);
+    return `${flushed}${formatCompactToolLine(event, call, colorEnabled)}`;
+  };
+  formatter.flush = flushBuffers;
+  return formatter;
+}
+function createSseToolEventAdapter(onEvent) {
+  let round = 0;
+  let callIndex = 0;
+  let pendingCalls = [];
+  const emit = (event) => {
+    onEvent?.(event);
+    return event;
+  };
+  return {
+    onToolStart(payload) {
+      const calls = Array.isArray(payload) ? payload : payload?.calls ?? [];
+      pendingCalls = [];
+      const events = [];
+      for (const name of calls) {
+        callIndex++;
+        const toolCallId = `sse-call-${callIndex}`;
+        const toolName = name || "tool";
+        pendingCalls.push({ toolCallId, toolName });
+        const event = {
+          type: "tool-call",
+          toolCallId,
+          toolName,
+          round
+        };
+        events.push(emit(event));
+      }
+      return events;
+    },
+    onToolResult(payload) {
+      const pending = payload.toolCallId ? pendingCalls.find((p) => p.toolCallId === payload.toolCallId) : pendingCalls.shift();
+      if (pending && payload.toolCallId) {
+        pendingCalls = pendingCalls.filter((p) => p.toolCallId !== payload.toolCallId);
+      }
+      const toolCallId = payload.toolCallId || pending?.toolCallId || `sse-call-${callIndex}`;
+      const toolName = payload.toolName || pending?.toolName || "tool";
+      const rawContent = typeof payload.content === "string" ? payload.content : "";
+      const summary = rawContent ? clipCompactText(rawContent, 120, "\u2026") : void 0;
+      const event = {
+        type: "tool-result",
+        toolCallId,
+        toolName,
+        summary,
+        metadata: payload.metadata,
+        round
+      };
+      return emit(event);
+    },
+    onToolEnd() {
+      round++;
+      pendingCalls = [];
+    }
+  };
+}
+
+// packages/cli/client/agentRunSpinner.ts
+function formatElapsed(totalSeconds) {
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes < 60) return `${minutes}m ${seconds}s`;
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  return `${hours}h ${mins}m`;
+}
+var Spinner = class {
+  constructor(output, text, silent = false) {
+    this.output = output;
+    this.text = text;
+    this.silent = silent;
+    const explicit = output.isTTY;
+    this.isTTY = typeof explicit === "boolean" ? explicit : Boolean(process.stdout.isTTY);
+  }
+  timer = null;
+  startTime = 0;
+  frameIndex = 0;
+  frames = ["\xB7", "~", "\u2248", "\u223F", "\u2248", "~"];
+  isTTY;
+  start() {
+    if (this.silent) {
+      this.startTime = Date.now();
+      return;
+    }
+    if (!this.isTTY) {
+      this.output.write(`
+${this.text}
+`);
+      return;
+    }
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.frameIndex = 0;
+    this.startTime = Date.now();
+    this.output.write("\x1B[?25l");
+    this.output.write(this.renderLine(this.frames[0]));
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      this.output.write(`\r${this.renderLine(this.frames[this.frameIndex])}`);
+    }, 80);
+  }
+  stop() {
+    const wasActive = this.timer !== null;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.silent) return;
+    if (this.isTTY && wasActive) {
+      this.output.write("\r\x1B[K");
+      this.output.write("\x1B[?25h");
+    }
+  }
+  show(text) {
+    this.text = text;
+    if (this.silent) {
+      if (!this.startTime) {
+        this.startTime = Date.now();
+      }
+      return;
+    }
+    if (!this.isTTY) return;
+    if (!this.timer) {
+      this.start();
+      return;
+    }
+    this.frameIndex = 0;
+    this.startTime = Date.now();
+    this.output.write(`\r${this.renderLine(this.frames[0])}`);
+  }
+  renderLine(frame) {
+    const elapsedSeconds = Math.max(
+      0,
+      Math.floor((Date.now() - this.startTime) / 1e3)
+    );
+    return `${themeColorSequence("accent")}${frame}\x1B[39m ${this.text} (${formatElapsed(elapsedSeconds)})`;
+  }
+};
+
+// packages/cli/client/agentRunOutput.ts
+function formatAssistantResponseForCli(text, options) {
+  const thinkingMode = resolveThinkingDisplayMode(options.env);
+  return formatAssistantDisplay(
+    formatAssistantTextForCli(text, thinkingMode)
+  );
+}
+function resolveAgentEventMode(options) {
+  if (options.eventsMode === "jsonl") return "jsonl";
+  return options.env.NOLO_AGENT_EVENTS === "jsonl" ? "jsonl" : "text";
+}
+function formatToolJsonEvent(event) {
+  return `${JSON.stringify({
+    schemaVersion: 1,
+    type: event.type,
+    round: event.round + 1,
+    tool: event.toolName,
+    toolCallId: event.toolCallId,
+    ...event.argumentsPreview ? { argsPreview: event.argumentsPreview } : {},
+    ...typeof event.elapsedMs === "number" ? { elapsedMs: event.elapsedMs } : {},
+    ...event.summary ? { summary: event.summary } : {},
+    ...event.message ? { message: event.message } : {},
+    ...event.metadata ? { metadata: event.metadata } : {}
+  })}
+`;
+}
+function createCliTurnOutput(params) {
+  const { options } = params;
+  const workingLabel = params.workingLabel ?? `${options.agentName} -> working`;
+  const spinner = params.spinner ?? new Spinner(options.output, workingLabel, Boolean(options.activityReporter));
+  const toolDisplayMode = resolveToolDisplayMode(options.env);
+  const traceLocalTools = shouldEmitToolEvents(toolDisplayMode);
+  const formatToolEvent = createToolEventFormatter(toolDisplayMode);
+  const eventMode = resolveAgentEventMode(options);
+  let streamedAssistantText = false;
+  let everStreamedAnyText = false;
+  let printedAssistantLabel = false;
+  const thinkingMode = resolveThinkingDisplayMode(options.env);
+  const renderWriter = createRenderAwareStreamWriter({
+    write: (chunk) => options.output.write(chunk)
+  });
+  const writeVisibleAssistantChunk = (chunk) => {
+    if (!chunk) return;
+    spinner.stop();
+    options.activityReporter?.(null);
+    if (!printedAssistantLabel) {
+      options.output.write(`
+${options.agentName} > `);
+      printedAssistantLabel = true;
+    }
+    streamedAssistantText = true;
+    everStreamedAnyText = true;
+    renderWriter.push(chunk);
+  };
+  const thinkingFilter = createThinkingAwareStreamFilter(
+    writeVisibleAssistantChunk,
+    thinkingMode
+  );
+  const thinkingSink = createThinkingEventSink((chunk) => {
+    spinner.stop();
+    options.activityReporter?.(null);
+    options.output.write(chunk);
+  }, thinkingMode);
+  const handleToolEvent = (event) => {
+    if (!traceLocalTools) return;
+    const chunk = eventMode === "jsonl" ? formatToolJsonEvent(event) : formatToolEvent(event);
+    if (eventMode === "jsonl") {
+      options.output.write(chunk);
+      return;
+    }
+    if (event.type === "tool-call") {
+      thinkingFilter.flush();
+      renderWriter.flush();
+    }
+    spinner.stop();
+    options.activityReporter?.(null);
+    if (event.type === "tool-call" && streamedAssistantText) {
+      options.output.write("\n");
+      streamedAssistantText = false;
+    }
+    if (chunk) {
+      options.output.write(chunk);
+    }
+    if (toolDisplayMode === "compact" && event.type === "tool-call") {
+      const activeLabel = formatActiveToolLabel(event);
+      spinner.show(activeLabel);
+      options.activityReporter?.(activeLabel);
+    }
+  };
+  return {
+    spinner,
+    thinkingMode,
+    toolDisplayMode,
+    traceLocalTools,
+    eventMode,
+    pushText(chunk) {
+      thinkingFilter.push(chunk);
+    },
+    pushThinking(chunk) {
+      thinkingSink.push(chunk);
+    },
+    handleToolEvent,
+    showWorking(label) {
+      const activeLabel = label ?? workingLabel;
+      spinner.show(activeLabel);
+      options.activityReporter?.(activeLabel);
+    },
+    finish(fallbackContent) {
+      spinner.stop();
+      options.activityReporter?.(null);
+      const pendingToolOutput = formatToolEvent.flush ? formatToolEvent.flush() : "";
+      if (pendingToolOutput) {
+        options.output.write(pendingToolOutput);
+      }
+      if (streamedAssistantText) {
+        thinkingFilter.flush();
+        renderWriter.flush();
+        options.output.write("\n");
+      } else if (everStreamedAnyText) {
+        thinkingFilter.flush();
+        options.output.write("\n");
+      } else {
+        const content = fallbackContent ? formatAssistantResponseForCli(fallbackContent.trim(), options) : "";
+        if (content) {
+          options.output.write(`
+${options.agentName} > ${content}
+`);
+        } else {
+          options.output.write(`
+${options.agentName} > (no text response)
+`);
+        }
+      }
+    }
+  };
+}
+
+// packages/cli/client/agentRunStream.ts
+async function readStreamingAgentRun(options, res, existingSpinner) {
+  const reader = res.body?.getReader();
+  if (!reader) {
+    existingSpinner?.stop();
+    options.output.write(
+      "[nolo] Agent stream response did not include a readable body.\n"
+    );
+    return { exitCode: 1 };
+  }
+  options.abortSignal?.addEventListener(
+    "abort",
+    () => {
+      reader.cancel("user-stop").catch(() => {
+      });
+    },
+    { once: true }
+  );
+  const decoder = new TextDecoder();
+  const turnOutput = createCliTurnOutput({
+    options,
+    workingLabel: `${options.agentName} -> working`,
+    spinner: existingSpinner
+  });
+  const sseAdapter = createSseToolEventAdapter((evt) => {
+    turnOutput.handleToolEvent(evt);
+  });
+  let buffer = "";
+  let content = "";
+  let dialogId;
+  let usage;
+  const handlePayload = (payload) => {
+    if (typeof payload?.dialogId === "string" && payload.dialogId.trim()) {
+      dialogId = payload.dialogId;
+    }
+    if (payload?.error || payload?.type === "error") {
+      throw new Error(
+        String(payload.error || payload.message || "Agent stream failed")
+      );
+    }
+    if (payload?.type === "done") {
+      usage = payload.usage;
+      return;
+    }
+    if (payload?.type === "dialog" || payload?.type === "status") {
+      return;
+    }
+    if (payload?.type === "turn_warning") {
+      return;
+    }
+    if (payload?.type === "thinking") {
+      const thinkChunk = typeof payload.content === "string" ? payload.content : typeof payload.chunk === "string" ? payload.chunk : "";
+      if (thinkChunk) {
+        turnOutput.pushThinking(thinkChunk);
+      }
+      return;
+    }
+    if (payload?.type === "tool_start") {
+      sseAdapter.onToolStart(payload.calls ?? payload);
+      return;
+    }
+    if (payload?.type === "tool_result") {
+      sseAdapter.onToolResult(payload);
+      return;
+    }
+    if (payload?.type === "tool_end") {
+      sseAdapter.onToolEnd();
+      turnOutput.showWorking();
+      return;
+    }
+    const chunk = payload?.type === "text" ? payload.content : typeof payload?.chunk === "string" ? payload.chunk : "";
+    if (!chunk) return;
+    content += chunk;
+    turnOutput.pushText(chunk);
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const events = buffer.split("\n\n");
+      buffer = events.pop() ?? "";
+      for (const event of events) {
+        const dataLines = event.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).filter(Boolean);
+        for (const raw of dataLines) {
+          handlePayload(JSON.parse(raw));
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const raw = buffer.split("\n").find((line) => line.startsWith("data:"))?.slice(5).trim();
+      if (raw) handlePayload(JSON.parse(raw));
+    }
+  } catch (error) {
+    turnOutput.spinner.stop();
+    if (options.abortSignal?.aborted) {
+      return {
+        exitCode: 0,
+        ...dialogId ? { dialogId } : {},
+        streamInterrupted: true
+      };
+    }
+    const message = toErrorMessage(error);
+    if (dialogId) {
+      options.output.write(
+        `
+[nolo] Agent stream transport interrupted after dialog ${dialogId} was created: ${message}
+`
+      );
+      options.output.write(
+        "[nolo] The agent run may still finish on the server; read the dialog before retrying.\n"
+      );
+      return { exitCode: 0, dialogId, streamInterrupted: true };
+    }
+    options.output.write(`
+[nolo] Agent stream failed: ${message}
+`);
+    return { exitCode: 1 };
+  }
+  turnOutput.finish(content);
+  const usageText = formatUsage(usage, dialogId);
+  if (usageText && shouldShowUsage(options.env))
+    options.output.write(`${usageText}
+`);
+  return {
+    exitCode: 0,
+    ...dialogId ? { dialogId } : {},
+    turnTokens: buildTurnTokenUsage(usage, options.agentKey)
+  };
+}
+
+// packages/cli/client/agentRunTypes.ts
+function resolveAuthToken2(env) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
+function isMachineBoundLocalhostCustomProvider(agentConfig) {
+  const machineId = agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object" ? String(agentConfig.runtimeBinding.machineId ?? "").trim() : "";
+  const providerUrl = asTrimmedString(agentConfig?.customProviderUrl);
+  if (!machineId || !providerUrl) return false;
+  return isLoopbackUrl(providerUrl);
+}
+function resolveBoundMachineId(agentConfig) {
+  return agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object" ? String(agentConfig.runtimeBinding.machineId ?? "").trim() : "";
+}
+var CLI_PROVIDER_NAMES = /* @__PURE__ */ new Set([
+  "agy",
+  "claude",
+  "codex",
+  "copilot",
+  "gemini",
+  "grok",
+  "kimi",
+  "opencode",
+  "qoder"
+]);
+function isCliProviderAgentConfig(agentConfig) {
+  const cliProvider = asTrimmedLowercaseString(agentConfig?.cliProvider);
+  const provider = asTrimmedLowercaseString(agentConfig?.provider);
+  return Boolean(cliProvider) || CLI_PROVIDER_NAMES.has(provider);
+}
+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 machine = await detectMachineInfo({ probeLaunchable: true });
+    return asOptionalTrimmedString(machine?.machineId);
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/cli/client/agentRunPlatformTools.ts
+var SERVER_PLATFORM_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "addTableRow",
+  "addTableRows",
+  "deleteTableRow",
+  "deleteTableRows",
+  "updateTableRow",
+  "updateTableRows"
+]);
+var KNOWN_SERVER_PLATFORM_AGENT_KEYS = /* @__PURE__ */ new Set([NOLO_PROJECT_MANAGER_AGENT_KEY]);
+var KNOWN_SERVER_PLATFORM_AGENT_ALIASES = /* @__PURE__ */ new Set([
+  "code-review",
+  "frontend",
+  "frontend-agent",
+  "frontend-implementer",
+  "full-stack",
+  "fullstack",
+  "nolo code review",
+  "nolo fullstack",
+  "nolo project manager",
+  "nolo reviewer",
+  "nolo-code-review",
+  "nolo-fullstack",
+  "nolo-pm",
+  "nolo-project-manager",
+  "nolo-reviewer",
+  "pm",
+  "project-manager",
+  "review",
+  "reviewer"
+]);
+function findServerPlatformTools(toolNames) {
+  if (!Array.isArray(toolNames)) return [];
+  return toolNames.filter(
+    (toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName)
+  );
+}
+function resolveServerPlatformToolNames(agentConfig) {
+  return findServerPlatformTools([
+    ...Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : [],
+    ...Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools) ? agentConfig.runtimeToolPolicy.agentTools : []
+  ]);
+}
+function isKnownServerPlatformAgent(options) {
+  if (KNOWN_SERVER_PLATFORM_AGENT_KEYS.has(options.agentKey)) return true;
+  const normalizedKey = normalizeAgentHandle(options.agentKey);
+  return Boolean(
+    normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey)
+  );
+}
+
+// packages/cli/client/agentRun.ts
+var import_ulid = __toESM(require_index_umd(), 1);
+async function loadRunLocalAgentTurn() {
+  const { runLocalAgentTurn } = await import("./agentRuntimeLocal-SKHJUWSS.js");
+  return runLocalAgentTurn;
+}
+async function resolveCurrentMachineId(options) {
+  return options.currentMachineIdResolver ? options.currentMachineIdResolver(options.env) : detectCurrentMachineId(options.env);
+}
+function resolveRequestedRuntimeMode(options) {
+  const envMode = options.env.NOLO_RUNTIME_MODE;
+  if (options.runtimeMode) return options.runtimeMode;
+  if (envMode === "local" || envMode === "server" || envMode === "auto")
+    return envMode;
+  return "auto";
+}
+function buildDefaultLocalRuntimeAdapter(options) {
+  return createCliLocalRuntimeAdapter({
+    env: options.env,
+    fetchImpl: options.fetchImpl,
+    cwd: options.localRuntimeCwd,
+    output: options.output,
+    ...options.confirmDestructiveAction ? { confirmDestructiveAction: options.confirmDestructiveAction } : {},
+    ...options.requestUserChoice ? { requestUserChoice: options.requestUserChoice } : {}
+  });
+}
+function resolveLocalRuntimeAdapter(options) {
+  return options.localRuntimeAdapter || options.localRuntimeAdapterFactory?.(options.env, {
+    cwd: options.localRuntimeCwd
+  }) || buildDefaultLocalRuntimeAdapter(options);
+}
+function wrapAdapterEphemeral(adapter) {
+  return {
+    ...adapter,
+    loadDialogHistory: async () => [],
+    saveTurn: async (input) => ({
+      dialogId: input.continueDialogId ?? "ephemeral"
+    })
+  };
+}
+function applyEphemeralIfRequested(options, adapter) {
+  return options.ephemeral ? wrapAdapterEphemeral(adapter) : adapter;
+}
+function wrapLoadAgentConfigWithModelOverride(adapter, targetAgentKey, override) {
+  return {
+    ...adapter,
+    loadAgentConfig: async (agentRef) => {
+      const config = await adapter.loadAgentConfig(agentRef);
+      if (!config || agentRef !== targetAgentKey) return config;
+      const baseRecord = config.rawRecord ?? config;
+      return resolveAgentRuntimeConfigFromRecord(
+        agentRef,
+        applyModelLayerOverride(baseRecord, override)
+      );
+    }
+  };
+}
+async function shouldSkipAutoLocalForServerPlatformTools(options) {
+  if (isBuiltinNoloAgentRef(options.agentKey)) return false;
+  if (options.localRuntimeCwd) {
+    return false;
+  }
+  const knownServerPlatformAgent = isKnownServerPlatformAgent(options);
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) return knownServerPlatformAgent;
+  let agentConfig;
+  try {
+    agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  } catch {
+    if (knownServerPlatformAgent) {
+      options.output.write(
+        `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. Use --local explicitly to force local workspace tools.
+`
+      );
+      return true;
+    }
+    return false;
+  }
+  if (isCliProviderAgentConfig(agentConfig)) {
+    const boundMachineId = resolveBoundMachineId(agentConfig);
+    if (!boundMachineId) return false;
+    const currentMachineId = (await resolveCurrentMachineId(options))?.trim() || "";
+    if (currentMachineId && currentMachineId === boundMachineId) return false;
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is bound to ${boundMachineId}` + (currentMachineId ? ` and this machine is ${currentMachineId}.` : ".") + " Use --local explicitly to force the current machine.\n"
+    );
+    return true;
+  }
+  if (knownServerPlatformAgent) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. Use --local explicitly to force local workspace tools.
+`
+    );
+    return true;
+  }
+  if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. Use --local explicitly to force the current machine.
+`
+    );
+    return true;
+  }
+  const serverTools = resolveServerPlatformToolNames(agentConfig);
+  if (serverTools.length === 0) return false;
+  options.output.write(
+    `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools (${serverTools.join(", ")}). Use --local explicitly to force local workspace tools.
+`
+  );
+  return true;
+}
+function buildUserInputContent(message, imageUrls = []) {
+  if (imageUrls.length === 0) return message;
+  return [
+    ...message.trim() ? [{ type: "text", text: message }] : [],
+    ...imageUrls.map((url) => ({
+      type: "image_url",
+      image_url: { url }
+    }))
+  ];
+}
+function buildSubjectRefs(options) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushRef = (ref) => {
+    const kind = ref.kind.trim();
+    const id = ref.id.trim();
+    const role = ref.role?.trim();
+    if (!kind || !id) return;
+    const key = `${kind}\0${id}\0${role ?? ""}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    refs.push({ kind, id, ...role ? { role } : {} });
+  };
+  for (const ref of options.subjectRefs ?? []) pushRef(ref);
+  if (options.subjectDialogKey) {
+    pushRef({
+      kind: "dialog",
+      id: options.subjectDialogKey,
+      role: "subject"
+    });
+  }
+  if (options.taskEvidence?.rowDbKey) {
+    pushRef({
+      kind: "table-row",
+      id: options.taskEvidence.rowDbKey,
+      role: "task"
+    });
+  }
+  for (const artifactId of options.taskEvidence?.artifactIds ?? []) {
+    pushRef({
+      kind: "artifact",
+      id: artifactId,
+      role: "evidence"
+    });
+  }
+  return refs.length ? refs : void 0;
+}
+function isMissingLocalAgentConfigError(error, agentRef) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === LOCAL_AGENT_CONFIG_MISSING_CODE && error.agentRef === agentRef
+  );
+}
+function shouldAttemptAutoLocal(options) {
+  if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory)
+    return true;
+  if (options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" && isBuiltinNoloAgentRef(options.agentKey) && resolveAuthToken2(options.env)) {
+    return true;
+  }
+  if (options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" && resolveAuthToken2(options.env) && !isKnownServerPlatformAgent(options)) {
+    return true;
+  }
+  return Boolean(
+    options.env.NOLO_LOCAL_OPENAI_API_KEY || options.env.OPENAI_API_KEY || options.env.NOLO_LOCAL_OPENAI_BASE_URL || options.env.OPENAI_BASE_URL || options.env.NOLO_LOCAL_AGENT_KEY
+  );
+}
+function buildTransportErrorHint(serverUrl, error) {
+  const endpoint = `${serverUrl}/api/agent/run`;
+  const reason = toErrorMessage(error);
+  let detail = `[nolo] Could not reach ${endpoint}.
+Reason: ${reason}
+`;
+  try {
+    const parsed = new URL(serverUrl);
+    if (parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost") {
+      detail += "If you meant local dev, start the local API first.\nOtherwise set NOLO_SERVER to a reachable server, or re-run `nolo login --server https://nolo.chat`.\n";
+      return detail;
+    }
+  } catch {
+  }
+  detail += "Check NOLO_SERVER / BASE_URL and make sure the configured server is reachable.\n";
+  return detail;
+}
+async function readAgentRunFailureMetadata(res) {
+  const data = await res.clone().json().catch(() => ({}));
+  return {
+    ...asOptionalTrimmedString(data?.dialogId) ? { dialogId: asOptionalTrimmedString(data?.dialogId) } : {}
+  };
+}
+async function runHttpAgentTurn(options, authToken) {
+  const spinner = new Spinner(
+    options.output,
+    `${options.agentName} -> working`,
+    // 与 createCliTurnOutput 的兜底构造一致：传入 activityReporter 时
+    // Spinner 静默，避免 TUI docked 活动行与 spinner 帧重复 live 指示。
+    Boolean(options.activityReporter)
+  );
+  spinner.start();
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const subjectRefs = buildSubjectRefs(options);
+  const allowedChildAgentKeys = options.allowedChildAgentKeys?.filter(
+    (key) => key.trim()
+  );
+  const allowedToolNames = options.allowedToolNames?.filter(
+    (name) => name.trim()
+  );
+  const blockedToolNames = options.blockedToolNames?.filter(
+    (name) => name.trim()
+  );
+  const shouldStream = !options.noStream && !options.background;
+  const buildRequestBody = (stream) => JSON.stringify({
+    agentKey: options.agentKey,
+    userInput: buildUserInputContent(
+      options.extraContextBlocks?.length ? [...options.extraContextBlocks, "", options.message].join("\n") : options.message,
+      options.imageUrls
+    ),
+    runtimeContext: {
+      surface: "cli",
+      host: "terminal",
+      runtime: "bun",
+      entrypoint: "nolo-cli",
+      capabilities: ["text-io", "streaming", "slash-commands"],
+      ...subjectRefs ? { subjectRefs } : {},
+      ...allowedChildAgentKeys?.length ? { allowedChildAgentKeys } : {},
+      ...blockedToolNames?.length ? { blockedToolNames } : {},
+      ...allowedToolNames?.length ? { allowedToolNames } : {}
+    },
+    ...options.continueDialogId ? { continueDialogId: options.continueDialogId } : {},
+    ...options.spaceId ? { spaceId: options.spaceId } : {},
+    ...options.category ? { category: options.category } : {},
+    ...options.inheritedFromDialogKey ? { inheritedFromDialogKey: options.inheritedFromDialogKey } : {},
+    ...options.parentDialogId ? { parentDialogId: options.parentDialogId } : {},
+    ...options.background ? { background: true } : {},
+    ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {},
+    ...options.modelOverride ? { runtimeOptions: { quickChatModelOverride: options.modelOverride } } : {},
+    stream
+  });
+  const postAgentRun = (stream) => fetchImpl(`${options.serverUrl}/api/agent/run`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: buildRequestBody(stream),
+    ...options.abortSignal ? { signal: options.abortSignal } : {}
+  });
+  let res;
+  try {
+    res = await postAgentRun(shouldStream);
+  } catch (error) {
+    spinner.stop();
+    if (options.abortSignal?.aborted) {
+      return { exitCode: 0, streamInterrupted: true };
+    }
+    options.output.write(buildTransportErrorHint(options.serverUrl, error));
+    return { exitCode: 1 };
+  }
+  if (shouldStream && isGatewayHttpStatus(res.status)) {
+    const failureMeta = await readAgentRunFailureMetadata(res);
+    if (!failureMeta.dialogId) {
+      spinner.stop();
+      options.output.write(
+        `[nolo] streaming request returned HTTP ${res.status}; retrying once without streaming.
+`
+      );
+      spinner.start();
+      try {
+        res = await postAgentRun(false);
+      } catch (error) {
+        spinner.stop();
+        options.output.write(buildTransportErrorHint(options.serverUrl, error));
+        return { exitCode: 1 };
+      }
+    }
+  }
+  const contentType = res.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream") && res.body) {
+    const result = await readStreamingAgentRun(options, res, spinner);
+    return result;
+  }
+  spinner.stop();
+  let data = {};
+  try {
+    data = await res.json();
+  } catch {
+    data = {};
+  }
+  if (!res.ok) {
+    options.output.write(`[nolo] Agent request failed: HTTP ${res.status}
+`);
+    const errorText = asTrimmedString(data?.error);
+    const messageText = asTrimmedString(data?.message);
+    const reasonText = asTrimmedString(data?.reason);
+    const codeText = asTrimmedString(data?.code);
+    const dialogIdText = asTrimmedString(data?.dialogId);
+    if (errorText || messageText) {
+      options.output.write(`${errorText || messageText}
+`);
+      if (messageText && messageText !== errorText) {
+        options.output.write(`${messageText}
+`);
+      }
+      if (codeText && codeText !== errorText && codeText !== messageText) {
+        options.output.write(`code=${codeText}
+`);
+      }
+      if (reasonText && reasonText !== errorText && reasonText !== messageText) {
+        options.output.write(`reason=${reasonText}
+`);
+      }
+    }
+    if (dialogIdText) {
+      options.output.write(`[nolo] failed dialog: ${dialogIdText}
+`);
+      options.output.write(
+        `[nolo] continue with: nolo agent run ${options.agentKey} --continue ${dialogIdText} --msg "retry"
+`
+      );
+    }
+    return dialogIdText ? { exitCode: 1, dialogId: dialogIdText } : { exitCode: 1 };
+  }
+  const content = formatAssistantResponseForCli(
+    String(data?.content ?? data?.message ?? ""),
+    options
+  );
+  if (content) {
+    options.output.write(`
+${options.agentName} > ${content}
+`);
+  } else {
+    options.output.write(`
+${options.agentName} > (no text response)
+`);
+  }
+  const usage = formatUsage(data?.usage, data?.dialogId);
+  if (usage && shouldShowUsage(options.env)) options.output.write(`${usage}
+`);
+  return {
+    exitCode: 0,
+    ...typeof data?.dialogId === "string" && data.dialogId ? { dialogId: data.dialogId } : {},
+    turnTokens: buildTurnTokenUsage(
+      data?.usage,
+      typeof data?.model === "string" ? data.model : options.agentKey
+    )
+  };
+}
+async function runInjectedLocalAgentTurn(options) {
+  return runLocalAgentTurnForCli(options, { reportFailure: true });
+}
+async function refreshMissingLocalAgentConfig(options) {
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) return false;
+  const agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  return Boolean(agentConfig);
+}
+async function runLocalAgentTurnForCli(options, settings) {
+  const resolvedBaseAdapter = resolveLocalRuntimeAdapter(options);
+  const baseAdapter = (() => {
+    let adapter2 = resolvedBaseAdapter && options.modelOverride ? wrapLoadAgentConfigWithModelOverride(
+      resolvedBaseAdapter,
+      options.agentKey,
+      options.modelOverride
+    ) : resolvedBaseAdapter;
+    if (adapter2) adapter2 = applyEphemeralIfRequested(options, adapter2);
+    return adapter2;
+  })();
+  if (!baseAdapter) {
+    options.output.write(
+      "[nolo] Local runtime was requested but no local runtime adapter is available.\n"
+    );
+    return { exitCode: 1 };
+  }
+  const subjectRefs = buildSubjectRefs(options);
+  const allowedChildAgentKeys = options.allowedChildAgentKeys?.filter(
+    (key) => key.trim()
+  );
+  const allowedToolNames = options.allowedToolNames?.filter(
+    (name) => name.trim()
+  );
+  const blockedToolNames = options.blockedToolNames?.filter(
+    (name) => name.trim()
+  );
+  const runtimeContext = subjectRefs || allowedChildAgentKeys?.length || allowedToolNames?.length || blockedToolNames?.length || options.parentWakeOnTerminal ? {
+    ...subjectRefs ? { subjectRefs } : {},
+    ...allowedChildAgentKeys?.length ? { allowedChildAgentKeys } : {},
+    ...allowedToolNames?.length ? { allowedToolNames } : {},
+    ...blockedToolNames?.length ? { blockedToolNames } : {},
+    ...options.parentWakeOnTerminal ? { parentWakeOnTerminal: true } : {},
+    ...options.parentDialogId ? { parentThreadId: options.parentDialogId } : {}
+  } : void 0;
+  const currentDialogId = options.continueDialogId ?? (0, import_ulid.ulid)();
+  const runChildTurn = async (input) => {
+    const { runLocalAgentTurn } = await import("./agentRuntimeLocal-SKHJUWSS.js");
+    return runLocalAgentTurn(input);
+  };
+  const createFreshChildBaseAdapter = () => {
+    const fresh = options.localRuntimeAdapterFactory?.(options.env, {
+      cwd: options.localRuntimeCwd
+    }) ?? buildDefaultLocalRuntimeAdapter(options);
+    return applyEphemeralIfRequested(options, fresh);
+  };
+  const withLocalDelegation = (args) => {
+    let adapter2;
+    const callAgentExecutor = createCliCallAgentToolExecutor(
+      {
+        env: options.env,
+        fetchImpl: options.fetchImpl,
+        cwd: options.localRuntimeCwd,
+        output: options.output
+      },
+      {
+        createChildAdapter: (child) => withLocalDelegation({
+          base: createFreshChildBaseAdapter(),
+          dialogId: child.dialogId,
+          spaceId: child.spaceId,
+          runtimeContext: child.runtimeContext
+        }),
+        runChildTurn,
+        dialogId: args.dialogId,
+        spaceId: args.spaceId,
+        runtimeContext: args.runtimeContext
+      }
+    );
+    adapter2 = {
+      ...args.base,
+      executeTool: async (call) => {
+        if (call.name === "callAgent") {
+          return callAgentExecutor(call);
+        }
+        return args.base.executeTool(call);
+      }
+    };
+    return adapter2;
+  };
+  const adapter = withLocalDelegation({
+    base: baseAdapter,
+    dialogId: currentDialogId,
+    spaceId: options.spaceId,
+    runtimeContext
+  });
+  const workingLabel = `${options.agentName} -> working locally`;
+  const turnOutput = createCliTurnOutput({
+    options,
+    workingLabel
+  });
+  turnOutput.spinner.start();
+  try {
+    const runLocalAgentTurn = await loadRunLocalAgentTurn();
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: options.agentKey,
+      input: buildUserInputContent(options.message, options.imageUrls),
+      continueDialogId: currentDialogId,
+      spaceId: options.spaceId,
+      category: options.category,
+      inheritedFromDialogKey: options.inheritedFromDialogKey,
+      parentDialogId: options.parentDialogId,
+      background: options.background,
+      noStream: options.noStream,
+      ...runtimeContext ? { runtimeContext } : {},
+      ...options.extraContextBlocks?.length ? { contextBlocks: options.extraContextBlocks } : {},
+      ...options.contextBlockScopes?.length ? { contextBlockScopes: options.contextBlockScopes } : {},
+      ...typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {},
+      ...options.actionGateHandler ? { onActionGate: options.actionGateHandler } : {},
+      onLoopEvent: (event) => {
+        if (event.kind === "llm-start") {
+          turnOutput.showWorking();
+        }
+        if (event.kind === "image-downgraded") {
+          options.output.write(
+            "[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"
+          );
+        }
+        options.onLoopEvent?.(event);
+      },
+      ...options.abortSignal ? { abortSignal: options.abortSignal } : {},
+      ...turnOutput.traceLocalTools ? {
+        onToolEvent: (event) => {
+          turnOutput.handleToolEvent(event);
+        }
+      } : {},
+      ...!options.noStream ? {
+        onTextDelta: (chunk) => {
+          turnOutput.pushText(chunk);
+        }
+      } : {}
+    });
+    turnOutput.finish(result.content);
+    return {
+      exitCode: 0,
+      dialogId: result.dialogId,
+      turnTokens: buildTurnTokenUsage(result.usage, result.model)
+    };
+  } catch (error) {
+    turnOutput.spinner.stop();
+    if (error?.code === LOCAL_TURN_ABORTED_CODE || options.abortSignal?.aborted) {
+      const stoppedDialogId = error?.dialogId;
+      return {
+        exitCode: 0,
+        streamInterrupted: true,
+        ...stoppedDialogId ? { dialogId: stoppedDialogId } : {}
+      };
+    }
+    if (settings.reportFailure) {
+      options.output.write(
+        `[nolo] Local agent run failed: ${toErrorMessage(error)}
+`
+      );
+    }
+    return { exitCode: 1, localError: error };
+  }
+}
+async function runAgentTurn(options) {
+  const authToken = resolveAuthToken2(options.env);
+  const runtimeMode = resolveRequestedRuntimeMode(options);
+  if (runtimeMode === "local") {
+    return runInjectedLocalAgentTurn(options);
+  }
+  if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
+    const skipLocal = await shouldSkipAutoLocalForServerPlatformTools(options);
+    if (!skipLocal) {
+      const localResult = await runLocalAgentTurnForCli(options, {
+        reportFailure: false
+      });
+      if (localResult.exitCode === 0) {
+        return {
+          exitCode: localResult.exitCode,
+          ...localResult.dialogId ? { dialogId: localResult.dialogId } : {},
+          ...localResult.turnTokens ? { turnTokens: localResult.turnTokens } : {},
+          ...localResult.streamInterrupted ? { streamInterrupted: localResult.streamInterrupted } : {}
+        };
+      }
+      if (isMissingLocalAgentConfigError(localResult.localError, options.agentKey)) {
+        options.output.write(
+          `[nolo] Local agent config was missing; refreshing local config and retrying local once.
+`
+        );
+        try {
+          const refreshed = await refreshMissingLocalAgentConfig(options);
+          if (refreshed) {
+            const retriedLocalResult = await runLocalAgentTurnForCli(options, {
+              reportFailure: false
+            });
+            if (retriedLocalResult.exitCode === 0) {
+              return {
+                exitCode: retriedLocalResult.exitCode,
+                ...retriedLocalResult.dialogId ? { dialogId: retriedLocalResult.dialogId } : {},
+                ...retriedLocalResult.turnTokens ? { turnTokens: retriedLocalResult.turnTokens } : {}
+              };
+            }
+          }
+        } catch {
+        }
+      }
+      const localErrorMessage = localResult.localError ? toErrorMessage(localResult.localError) : "local runtime failed";
+      options.output.write(
+        `[nolo] auto runtime: local run unavailable (${localErrorMessage}). Not falling back to server. Fix the local credential/config and retry, or use --server to run on the server explicitly.
+`
+      );
+      return {
+        exitCode: 1,
+        ...localResult.dialogId ? { dialogId: localResult.dialogId } : {}
+      };
+    }
+  }
+  if (!authToken) {
+    options.output.write(
+      "[nolo] This install needs an auth token before it can talk to agents.\nRun `nolo login`, or set AUTH_TOKEN / NOLO_SERVER for non-interactive runs.\n"
+    );
+    return { exitCode: 1 };
+  }
+  if (options.ephemeral) {
+    options.output.write(
+      "[nolo] --ephemeral/--memory-only is only effective with the local runtime (--local); the server stores dialogs on its own and cannot run memory-only.\n"
+    );
+  }
+  return runHttpAgentTurn(options, authToken);
+}
+
+// packages/cli/agentRunCommand.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// packages/agent-runtime/quickChatIntentCore.ts
+var INTENT_MODEL = "deepseek-v4-flash";
+var INTENT_PROVIDER = "deepseek";
+var QUICK_CHAT_INTENT_TIMEOUT_MS = 4e3;
+var SHORT_GREETING_MAX_LENGTH = 20;
+var SHORT_GREETING_PATTERN = /^(?:hi|hello|hey|hiya|yo|sup|howdy|嗨|哈喽|哈囉|你好|您好|在吗|在嘛|喂|早上好|中午好|下午好|晚上好|拜拜|再见|谢谢|thanks|thx|ok|好的|收到|了解)[!.。，、~～]?$/iu;
+function isShortGreeting(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return false;
+  if (trimmed.length > SHORT_GREETING_MAX_LENGTH) return false;
+  return SHORT_GREETING_PATTERN.test(trimmed);
+}
+var COMPLEXITY_SIMPLE_MAX_LENGTH = 80;
+var COMPLEXITY_MEDIUM_MAX_LENGTH = 500;
+var COMPLEXITY_KEYWORDS = /为什么|如何|分析|对比|比较|设计|架构|实现|原理|推导|评价|区别|关系|影响|优化|重构/;
+var COMPLEXITY_CODE_BLOCK = /```[\s\S]*```/;
+function estimateComplexity(text) {
+  const trimmed = text.trim();
+  const len = trimmed.length;
+  if (len > COMPLEXITY_MEDIUM_MAX_LENGTH) return "complex";
+  if (COMPLEXITY_CODE_BLOCK.test(trimmed)) return "complex";
+  if (len > COMPLEXITY_SIMPLE_MAX_LENGTH) return "medium";
+  if (COMPLEXITY_KEYWORDS.test(trimmed)) return "medium";
+  return "simple";
+}
+var TIER_DESCRIPTIONS = {
+  flash: "\u5FEB\u901F\u7B80\u5355\uFF1A\u95EE\u5019\u3001\u95F2\u804A\u3001\u5FEB\u901F\u95EE\u7B54\u3001\u7FFB\u8BD1\u3001\u77ED\u6587",
+  balanced: "\u5E73\u8861\u63A8\u7406\uFF1A\u5206\u6790\u3001\u4E2D\u7B49\u957F\u5EA6\u5199\u4F5C\u3001\u4EE3\u7801\u3001\u63A8\u7406",
+  quality: "\u9AD8\u8D28\u91CF\u6DF1\u5EA6\uFF1A\u590D\u6742\u63A8\u7406\u3001\u957F\u6587\u3001\u67B6\u6784\u8BBE\u8BA1\u3001\u6DF1\u5EA6\u5206\u6790"
+};
+function buildQuickChatIntentSystemPrompt(tierAgents) {
+  const agentList = tierAgents.map((t2) => `  - "${t2.agentKey}"\uFF1A${t2.description}`).join("\n");
+  return `\u4F60\u662F\u4E00\u4E2A\u610F\u56FE\u8DEF\u7531\u5668\u3002\u6839\u636E\u7528\u6237\u6D88\u606F\uFF0C\u5224\u65AD\u5E94\u8BE5\u4EA4\u7ED9\u54EA\u4E2A agent \u5904\u7406\u3002
+
+\u53EF\u9009 agent \u5217\u8868\uFF08agentKey \u4E0E\u63CF\u8FF0\uFF09\uFF1A
+${agentList}
+
+\u5224\u65AD\u539F\u5219\uFF08\u9ED8\u8BA4\u504F\u5411\u901A\u7528\u6863\u4F4D\uFF1B\u4E13\u804C agent \u5728\u660E\u786E\u5339\u914D\u65F6\u4F7F\u7528\uFF1B**\u7F16\u7801/\u672C\u5730\u4ED3\u5E93\u4EFB\u52A1\u8D70\u901A\u7528\u6863 + needsWorkspace=true**\uFF09\uFF1A
+- \u9ED8\u8BA4\u60C5\u51B5\u4E0B\uFF0C**\u9664\u975E\u7528\u6237\u660E\u786E\u8868\u8FBE\u8981\u5EFA\u5E94\u7528/\u5EFA Agent/\u63D0\u4EA4\u53CD\u9988/\u591A Agent \u7F16\u6392**\uFF0C\u5426\u5219\u9009\u901A\u7528\u6863\u4F4D\uFF08flash/balanced/quality\uFF09\uFF1A
+  - \u7B80\u5355\u95EE\u5019\u3001\u95F2\u804A\u3001\u5FEB\u901F\u95EE\u7B54\u3001\u7FFB\u8BD1\u3001\u77ED\u6587 \u2192 \u9009 flash \u6863
+  - \u9700\u8981\u63A8\u7406\u3001\u5206\u6790\u3001\u4E2D\u7B49\u957F\u5EA6\u5199\u4F5C\u3001\u666E\u901A\u4EE3\u7801\u89E3\u91CA/\u67B6\u6784\u95EE\u7B54 \u2192 \u9009 balanced \u6863
+  - \u590D\u6742\u63A8\u7406\u3001\u957F\u6587\u3001\u67B6\u6784\u8BBE\u8BA1\u3001\u6DF1\u5EA6\u5206\u6790 \u2192 \u9009 quality \u6863
+  - **\u660E\u786E\u7F16\u7801\u4EFB\u52A1\uFF08\u5B9E\u73B0\u529F\u80FD\u3001\u4FEE bug\u3001refactor\u3001\u5199/\u8865\u6D4B\u8BD5\u3001\u8DD1 build/tests/ci\uFF09\u6216\u67E5\u770B\u672C\u673A\u4ED3\u5E93/\u4EE3\u7801\u72B6\u6001\uFF08git/\u5206\u652F/commit/\u672C\u5730\u4E0E\u8FDC\u7A0B\u5DEE\u8DDD/\u672A\u63D0\u4EA4\u6539\u52A8\u7B49\uFF09** \u2192 \u9009 balanced \u6216 quality \u6863\uFF08\u6309\u590D\u6742\u5EA6\uFF1B**\u4E0D\u8981\u9009 flash**\uFF09\uFF0C\u4E14 needsWorkspace=true
+- \u4E13\u804C agent \u8DEF\u7531\u89C4\u5219\uFF08\u6709\u660E\u786E\u5339\u914D\u65F6\u4F7F\u7528\uFF09\uFF1A
+  - \u8981\u63D0\u4EA4/\u8BB0\u5F55 bug\u3001\u4F53\u9A8C\u95EE\u9898\u3001\u6570\u636E\u5F02\u5E38\u3001\u4EA7\u54C1\u5EFA\u8BAE\uFF0C\u6216\u53E3\u8BED\u5982\u300C\u60F3\u53CD\u9988\u4E00\u4E9B\u95EE\u9898\u300D\u300C\u53CD\u9988\u4E00\u4E0B\u300D\u2192 \u9009\u610F\u89C1\u53CD\u9988\u4E13\u804C agent
+  - \u8981\u65B0\u5EFA\u6216\u5B9A\u5236 AI/Agent/\u667A\u80FD\u4F53\u52A9\u624B\uFF08\u542B\u914D\u7F6E\u5DE5\u5177\u3001\u77E5\u8BC6\u3001\u786E\u8BA4\u521B\u5EFA\uFF09\u2192 \u9009\u521B\u5EFA Agent \u4E13\u804C agent
+  - \u8981\u505A/\u6539/\u53D1\u5E03\u7F51\u7AD9\u3001\u7F51\u9875\u3001\u5C0F\u5E94\u7528\u3001\u9884\u7EA6\u9875\u3001\u535A\u5BA2\u3001\u770B\u677F \u2192 \u9009\u5E94\u7528\u6784\u5EFA\u4E13\u804C agent
+  - \u8981\u6D3E\u591A\u4E2A agent\u3001\u591A agent \u5E76\u884C\u3001\u62C6\u6210\u4EFB\u52A1\u540E\u53F0\u6267\u884C\u3001\u591A\u4E2A agent review\u3001\u8BA9\u4E0D\u540C agent \u8BA8\u8BBA/\u4F1A\u5546 \u2192 \u9009\u591A Agent \u7F16\u6392\u4E13\u804C agent\uFF08\u663E\u5F0F multi-agent \u4F18\u5148\uFF09
+- **\u62FF\u4E0D\u51C6\u65F6**\uFF1A\u7EAF\u95F2\u804A\u9009 flash\uFF1B**\u82E5\u6CBE\u8FB9\u672C\u5730\u4ED3\u5E93/\u5F53\u524D\u4EE3\u7801\u72B6\u6001\uFF0C\u9009 balanced/quality + needsWorkspace=true**\u3002
+
+\u540C\u65F6\u5224\u65AD\u672C\u8F6E\u662F\u5426\u9700\u8981\u6CE8\u5165\u300C\u5DE5\u4F5C\u533A\u53EA\u8BFB\u5DE5\u5177\u300D\uFF08listFiles/globFiles/searchFiles/readFile/execShell \u7B49\uFF09\uFF1A
+- needsWorkspace=true \u7684\u573A\u666F\uFF1A\u7528\u6237\u8981\u8BFB/\u6539/\u5206\u6790\u6587\u4EF6\u6216\u4EE3\u7801\u3001\u63D0\u5230\u4E86\u6587\u4EF6\u8DEF\u5F84/\u6269\u5C55\u540D\uFF08.md/.csv/.ts \u7B49\uFF09\u3001\u63D0\u5230\u5DE5\u4F5C\u533A/\u4EE3\u7801\u5E93/\u4ED3\u5E93/\u76EE\u5F55/git/\u5206\u652F\u3001\u8981\u770B\u5F53\u524D\u4EE3\u7801\u6216\u4ED3\u5E93\u72B6\u6001\u3001\u672C\u5730\u641C\u7D22/\u67E5\u770B\u4EE3\u7801\u3002
+- needsWorkspace=false \u7684\u573A\u666F\uFF1A\u901A\u7528\u77E5\u8BC6\u95EE\u7B54\uFF08\u5982\u300C\u5E7F\u4E1C\u7ECF\u6D4E\u6570\u636E\u300D\u300C\u5199\u4E00\u9996\u8BD7\u300D\uFF09\u3001\u7EAF\u95F2\u804A\u95EE\u5019\u3001\u7FFB\u8BD1\u3001\u4E0D\u6D89\u53CA\u672C\u5730\u6587\u4EF6/\u4ED3\u5E93\u3002
+- \u6F0F\u5224\uFF08\u7528\u6237\u8981\u6587\u4EF6\u800C\u6CA1\u5E26\u5DE5\u5177\uFF09\u6BD4\u8BEF\u5224\uFF08\u767D\u641C\u51E0\u8F6E\uFF09\u4EE3\u4EF7\u66F4\u9AD8\uFF0C\u5B81\u53EF\u504F\u5BBD\u5224 true\u3002
+
+\u5728\u7ED9\u51FA agentKey \u4E4B\u524D\uFF0C\u5148\u5728\u5FC3\u91CC\u533A\u5206\u5019\u9009\u6863\u4F4D\u7684\u8FB9\u754C\u518D\u7ED9\u7F6E\u4FE1\u5EA6\uFF1Abalanced \u4E0E quality \u7684\u8FB9\u754C\u5728\u4E8E\u590D\u6742\u5EA6/\u7BC7\u5E45/\u662F\u5426\u9700\u8981\u6DF1\u5EA6\u5206\u6790\uFF0C\u62FF\u4E0D\u51C6\u5C31\u7ED9\u4F4E confidence\u3002
+
+\u540C\u65F6\u5224\u65AD\u672C\u8F6E\u6D88\u606F\u662F\u5426\u9700\u8981\u6302\u8F7D\u5BF9\u8C61\u64CD\u4F5C\u6280\u80FD\uFF08skills \u6570\u7EC4\uFF0C\u672A\u547D\u4E2D\u7ED9 []\uFF09\uFF1A
+- \u7528\u6237\u8981\u65B0\u5EFA/\u6574\u7406/\u5F55\u5165/\u6279\u91CF\u5904\u7406\u8868\u683C\u6570\u636E\uFF08\u5EFA\u8868\u3001\u52A0\u884C\u3001\u6539\u5217\u3001\u6309\u6761\u4EF6\u6574\u7406\u6570\u636E\uFF09\u2192 skills \u542B "table"
+- \u7528\u6237\u8981\u5199/\u6DA6\u8272/\u6539\u5199/\u7EED\u5199/\u6392\u7248\u4E00\u7BC7\u6587\u6863\u6216\u6587\u7AE0 \u2192 skills \u542B "doc"
+- \u7528\u6237\u8981\u5199/\u6539/\u5B9E\u73B0/\u4FEE bug/refactor/\u8865\u6D4B\u8BD5/\u5BA1\u67E5\u5E76\u4FEE\u6539\u4EE3\u7801 \u2192 skills \u542B "code"\uFF08\u4EC5\u95EE\u901A\u7528\u77E5\u8BC6\u3001\u7EAF\u95F2\u804A\u3001\u53EA\u67E5\u770B git/\u4ED3\u5E93\u72B6\u6001\u800C\u4E0D\u4FEE\u6539\u4EE3\u7801\u65F6\u4E0D\u6302 "code"\uFF09
+- \u666E\u901A\u95EE\u7B54/\u7EAF\u95F2\u804A/\u5EFA\u5E94\u7528 \u2192 skills \u4E3A []
+
+\u53EA\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u8F93\u51FA\u5176\u4ED6\u5185\u5BB9\uFF1A
+{"confidence": <0\u52301\u4E4B\u95F4\u7684\u5C0F\u6570\uFF0C\u8868\u793A\u4F60\u5BF9\u8FD9\u4E2A\u5206\u7C7B\u5224\u65AD\u7684\u628A\u63E1\u7A0B\u5EA6>, "agentKey": "<\u4ECE\u5217\u8868\u4E2D\u9009\u62E9\u7684 agentKey>", "needsWorkspace": <true \u6216 false>, "skills": <\u5B57\u7B26\u4E32\u6570\u7EC4\uFF0C\u5143\u7D20\u53EA\u80FD\u662F "table" | "doc" | "code"\uFF0C\u672A\u547D\u4E2D\u7ED9 []>}`;
+}
+function parseQuickChatIntentResult(content, tierAgents) {
+  try {
+    const parsed = JSON.parse(content.trim());
+    if (typeof parsed !== "object" || parsed === null || !("agentKey" in parsed)) return null;
+    const key = parsed.agentKey;
+    if (typeof key !== "string") return null;
+    if (!tierAgents.some((t2) => t2.agentKey === key)) return null;
+    const rawNeedsWorkspace = parsed.needsWorkspace;
+    const needsWorkspace = rawNeedsWorkspace === true;
+    const rawConfidence = parsed.confidence;
+    const confidence = typeof rawConfidence === "number" && Number.isFinite(rawConfidence) && rawConfidence >= 0 && rawConfidence <= 1 ? rawConfidence : void 0;
+    const rawSkills = parsed.skills;
+    let skills;
+    if (Array.isArray(rawSkills)) {
+      const filtered = [...new Set(rawSkills)].filter(
+        (s) => s === "table" || s === "doc" || s === "code"
+      );
+      if (filtered.length > 0) skills = filtered;
+    }
+    return { agentKey: key, needsWorkspace, confidence, skills };
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli/client/autoModelRouter.ts
+var CLI_AUTO_TIER_AGENT_KEYS = {
+  flash: PUBLIC_DEEPSEEK_V4_FLASH_AGENT_KEY,
+  balanced: PUBLIC_DEEPSEEK_V4_PRO_AGENT_KEY,
+  quality: PUBLIC_GLM_52_AGENT_KEY
+};
+var CLI_IMAGE_AGENT_KEY = PUBLIC_KIMI_K26_IMAGE_AGENT_KEY;
+var CLI_AUTO_TIER_AGENT_KEY_TABLE = {
+  [CLI_AUTO_TIER_AGENT_KEYS.flash]: true,
+  [CLI_AUTO_TIER_AGENT_KEYS.balanced]: true,
+  [CLI_AUTO_TIER_AGENT_KEYS.quality]: true
+};
+var buildRouteOptions = () => ["flash", "balanced", "quality"].map((tier) => ({
+  tier,
+  agentKey: CLI_AUTO_TIER_AGENT_KEYS[tier],
+  description: TIER_DESCRIPTIONS[tier]
+}));
+var tierForAgentKey = (agentKey) => {
+  for (const tier of ["flash", "balanced", "quality"]) {
+    if (CLI_AUTO_TIER_AGENT_KEYS[tier] === agentKey) return tier;
+  }
+  return null;
+};
+function resolveCliAutoFallbackTier(text) {
+  switch (estimateComplexity(text)) {
+    case "complex":
+      return "quality";
+    case "medium":
+      return "balanced";
+    case "simple":
+    default:
+      return "flash";
+  }
+}
+async function classifyCliAutoRoute(text, options) {
+  const timeoutMs = options.timeoutMs ?? QUICK_CHAT_INTENT_TIMEOUT_MS;
+  const fallbackTier = resolveCliAutoFallbackTier(text);
+  const fallback = () => ({
+    agentKey: CLI_AUTO_TIER_AGENT_KEYS[fallbackTier],
+    tier: fallbackTier,
+    classified: false
+  });
+  if (!text.trim()) return fallback();
+  if (isShortGreeting(text)) {
+    return {
+      agentKey: CLI_AUTO_TIER_AGENT_KEYS.flash,
+      tier: "flash",
+      classified: true
+    };
+  }
+  if (!options.authToken) return fallback();
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const routeOptions = buildRouteOptions();
+    const messages = [
+      { role: "system", content: buildQuickChatIntentSystemPrompt(routeOptions) },
+      { role: "user", content: text }
+    ];
+    const { url, init } = buildPlatformChatCompletionRequest({
+      providerConfig: {
+        serverUrl: options.serverUrl,
+        authToken: options.authToken,
+        agentKey: CLI_AUTO_TIER_AGENT_KEYS.flash,
+        model: INTENT_MODEL,
+        provider: INTENT_PROVIDER,
+        endpoint: resolvePlatformChatCompletionsEndpoint(INTENT_PROVIDER) ?? "",
+        requestOptions: {}
+      },
+      messages,
+      stream: false
+    });
+    const response = await fetchImpl(url, {
+      ...init,
+      signal: controller.signal
+    });
+    if (!response.ok) return fallback();
+    const data = parsePlatformChatCompletionData(await response.text());
+    const content = data?.choices?.[0]?.message?.content;
+    if (typeof content !== "string" || !content.trim()) return fallback();
+    const parsed = parseQuickChatIntentResult(content, routeOptions);
+    if (!parsed) return fallback();
+    const tier = tierForAgentKey(parsed.agentKey) ?? fallbackTier;
+    return {
+      agentKey: parsed.agentKey,
+      tier,
+      classified: true,
+      confidence: parsed.confidence,
+      needsWorkspace: parsed.needsWorkspace,
+      skills: parsed.skills
+    };
+  } catch {
+    return fallback();
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+// packages/agent-runtime/skillDiscovery.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+var SKILL_SCAN_DIRS = [".agents/skills", "docs/skills"];
+var MAX_DISCOVERED_SKILLS = 50;
+function parseSkillFrontmatter(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf8").slice(0, 2048);
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return {};
+    const fm = load(fmMatch[1]);
+    if (!fm || typeof fm !== "object") return {};
+    const name = typeof fm.name === "string" ? fm.name : void 0;
+    const rawDesc = fm.description;
+    const description = typeof rawDesc === "string" ? rawDesc : rawDesc == null ? void 0 : String(rawDesc);
+    const sanitize = (s) => s?.trim().replace(/^["']|["']$/g, "").replace(/[\n\r]+/g, " ").slice(0, 200);
+    return { name: sanitize(name), description: sanitize(description) };
+  } catch {
+    return {};
+  }
+}
+function discoverSkills(cwd) {
+  const skills = [];
+  for (const dir of SKILL_SCAN_DIRS) {
+    if (skills.length >= MAX_DISCOVERED_SKILLS) break;
+    const absDir = join(cwd, dir);
+    if (!existsSync(absDir) || !statSync(absDir).isDirectory()) continue;
+    try {
+      for (const entry of readdirSync(absDir)) {
+        if (skills.length >= MAX_DISCOVERED_SKILLS) break;
+        const skillMdPath = join(absDir, entry, "SKILL.md");
+        if (existsSync(skillMdPath)) {
+          const { name, description } = parseSkillFrontmatter(skillMdPath);
+          skills.push({ name: name ?? entry, description: description ?? "", relativePath: join(dir, entry, "SKILL.md") });
+          continue;
+        }
+        if (dir === "docs/skills" && entry.endsWith(".md")) {
+          const flatPath = join(absDir, entry);
+          const { name, description } = parseSkillFrontmatter(flatPath);
+          skills.push({ name: name ?? entry.replace(/\.md$/, ""), description: description ?? "", relativePath: join(dir, entry) });
+        }
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+function buildSkillDiscoveryContextBlock(cwd) {
+  try {
+    const discovered = discoverSkills(cwd);
+    const layer = buildSkillDiscoveryLayer(discovered, cwd);
+    return layer?.content ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli/agentRunPrompts.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { dirname, extname, isAbsolute, join as join2, relative as relativePath, resolve, sep } from "node:path";
+function workflowRefToCandidatePath(cwd, ref) {
+  const normalized = ref.trim();
+  if (!normalized) return "";
+  if (normalized.endsWith(".md") || normalized.includes("/") || normalized.includes("\\")) {
+    const directPath = resolve(cwd, normalized);
+    if (existsSync2(directPath)) return directPath;
+  }
+  const fileName = normalized.replace(/[^a-zA-Z0-9一-鿿]+/g, "-").replace(/^-+|-+$/g, "");
+  return resolve(cwd, "docs", "workflows", `${fileName}.md`);
+}
+var SKILL_SEARCH_DIRS = [
+  ".agents/skills",
+  "docs/skills"
+];
+function skillRefToCandidatePath(cwd, ref) {
+  const normalized = ref.trim();
+  if (!normalized) return "";
+  if (normalized.endsWith(".md") || normalized.includes("/") || normalized.includes("\\")) {
+    const directPath = resolve(cwd, normalized);
+    if (existsSync2(directPath)) return directPath;
+  }
+  const fileName = normalized.replace(/[^a-zA-Z0-9一-鿿]+/g, "-").replace(/^-+|-+$/g, "");
+  for (const dir of SKILL_SEARCH_DIRS) {
+    if (dir === "docs/skills") {
+      const flatPath = resolve(cwd, dir, `${fileName}.md`);
+      if (existsSync2(flatPath)) return flatPath;
+    } else {
+      const skillMdPath = resolve(cwd, dir, fileName, "SKILL.md");
+      if (existsSync2(skillMdPath)) return skillMdPath;
+    }
+  }
+  return resolve(cwd, "docs", "skills", `${fileName}.md`);
+}
+async function resolveWorkflowReference(ref, cwd = process.cwd()) {
+  const path = workflowRefToCandidatePath(cwd, ref);
+  if (!path || !existsSync2(path)) {
+    throw new Error(`Workflow reference not found: ${ref}`);
+  }
+  const markdown = readFileSync2(path, "utf8");
+  const parsed = parseSkillDocProtocol(markdown);
+  return {
+    ref,
+    content: parsed.content,
+    ...parsed.meta?.workflowConfig ? { config: parsed.meta.workflowConfig } : {}
+  };
+}
+function inlineRelativeRefs(body, skillDir) {
+  const refPattern = /\[([^\]]+)\]\((\.\/[^)]+|[^)]+\/[^)]+)\)/g;
+  const normalizedSkillDir = resolve(skillDir) + sep;
+  return body.replace(refPattern, (match, label, relPath) => {
+    const cleaned = relPath.trim();
+    if (!cleaned.startsWith("./") && !cleaned.startsWith("../")) return match;
+    const absPath = resolve(skillDir, cleaned);
+    const relative = relativePath(normalizedSkillDir, absPath);
+    if (relative.startsWith("..") || isAbsolute(relative)) return match;
+    if (!existsSync2(absPath) || !absPath.endsWith(".md")) return match;
+    const refContent = readFileSync2(absPath, "utf8");
+    return `
+
+### ${label}
+
+${refContent}
+
+`;
+  });
+}
+function listSkillScripts(skillDir) {
+  const scriptsDir = join2(skillDir, "scripts");
+  if (!existsSync2(scriptsDir) || !statSync2(scriptsDir).isDirectory()) return null;
+  const entries = readdirSync2(scriptsDir).filter((e) => !e.startsWith("."));
+  if (entries.length === 0) return null;
+  return [
+    "",
+    "--- Available scripts (use execShell/readFile to access) ---",
+    ...entries.map((e) => `- scripts/${e}`)
+  ].join("\n");
+}
+async function resolveSkillReference(ref, options = {}) {
+  const isDbKey = /^(page|doc)-[0-9a-z]+-/i.test(ref);
+  let markdown = "";
+  let skillDir;
+  let filePath;
+  if (isDbKey) {
+    if (!options.readDbRecord) {
+      throw new Error("skill dbKey requires server access");
+    }
+    const record = await options.readDbRecord(ref);
+    const contentText = record?.content ?? record?.prompt ?? record?.text;
+    if (contentText === void 0 || contentText === null || contentText === "") {
+      throw new Error(`Skill reference has no content: ${ref}`);
+    }
+    markdown = String(contentText);
+  } else {
+    const cwd = options.cwd ?? process.cwd();
+    const path = skillRefToCandidatePath(cwd, ref);
+    if (!path || !existsSync2(path)) {
+      throw new Error(`Skill reference not found: ${ref}`);
+    }
+    markdown = readFileSync2(path, "utf8");
+    filePath = path;
+    skillDir = dirname(path);
+  }
+  const parsed = parseSkillDocProtocol(markdown);
+  const name = parsed.meta?.skillConfig?.name;
+  const promptPatch = parsed.meta?.skillConfig?.promptPatch;
+  const externalParsed = parseExternalSkillMarkdown(markdown);
+  const allowedTools = externalParsed.allowedTools;
+  const effectiveName = name ?? externalParsed.name;
+  let effectiveContent = parsed.content;
+  if (skillDir) {
+    effectiveContent = inlineRelativeRefs(effectiveContent, skillDir);
+    const scriptsHint = listSkillScripts(skillDir);
+    if (scriptsHint) effectiveContent += scriptsHint;
+  }
+  return {
+    ref,
+    content: effectiveContent,
+    ...effectiveName ? { name: effectiveName } : {},
+    ...promptPatch ? { promptPatch } : {},
+    ...allowedTools && allowedTools.length > 0 ? { allowedTools } : {},
+    ...skillDir ? { skillDir } : {}
+  };
+}
+function buildSkillContextBlocks(skills) {
+  if (!skills || !skills.length) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const blocks = [];
+  for (const skill of skills) {
+    const dedupKey = skill.name ?? skill.ref;
+    if (seen.has(dedupKey)) continue;
+    seen.add(dedupKey);
+    const header = `## ${dedupKey}`;
+    const patch = skill.promptPatch ? `${skill.promptPatch}
+` : "";
+    blocks.push(`${header}
+${patch}${skill.content}`);
+  }
+  return blocks;
+}
+function prependWorkflowReferencePrompt(message, workflow) {
+  if (!workflow) return message;
+  const config = workflow.config;
+  return [
+    "AI-native workflow reference:",
+    "- This reference is guidance for the agent, not a central workflow engine.",
+    `- ref: ${workflow.ref}`,
+    ...config?.id ? [`- id: ${config.id}`] : [],
+    ...config?.name ? [`- name: ${config.name}`] : [],
+    ...config?.defaultAgent ? [`- suggested defaultAgent: ${config.defaultAgent}`] : [],
+    ...config?.inputs?.length ? [`- inputs: ${config.inputs.join(", ")}`] : [],
+    ...config?.recommendedTools?.length ? [`- recommendedTools: ${config.recommendedTools.join(", ")}`] : [],
+    ...config?.requiredTools?.length ? [`- requiredTools: ${config.requiredTools.join(", ")}`] : [],
+    ...config?.requiredOutputs?.length ? [`- requiredOutputs: ${config.requiredOutputs.join(", ")}`] : [],
+    ...config?.gates?.length ? [`- gates: ${config.gates.join(", ")}`] : [],
+    ...config?.contextStrategy ? [`- contextStrategy: ${config.contextStrategy}`] : [],
+    ...config?.failureProtocol ? [`- failureProtocol: ${config.failureProtocol}`] : [],
+    "",
+    "Reference body:",
+    workflow.content,
+    "",
+    "User task:",
+    message
+  ].join("\n");
+}
+function prependFeatureWorktreeInstruction(message, enabled) {
+  if (!enabled) return message;
+  return [
+    "Local execution rule:",
+    "- You are running in the current git checkout with shell access.",
+    "- For read-only checks, smoke tests, or answering questions, stay in the current directory.",
+    "- Before developing a new feature or making non-trivial code changes, create a separate git worktree yourself with git worktree and do the edits there.",
+    "- Commit and push only when the user explicitly asks or the task requires it.",
+    "",
+    "User task:",
+    message
+  ].join("\n");
+}
+function prependSubjectDialogMarker(message, subjectDialogKey) {
+  if (!subjectDialogKey) return message;
+  return [
+    `Subject dialog for this run: ${subjectDialogKey}`,
+    "If the user asks to evaluate the referenced dialog, call readDialog with this id/key first.",
+    "",
+    message
+  ].join("\n");
+}
+function normalizeCliImageInput(input) {
+  if (/^(https?:|data:|file:)/i.test(input)) return input;
+  const absolutePath = resolve(input);
+  if (!existsSync2(absolutePath)) return input;
+  const base64 = readFileSync2(absolutePath).toString("base64");
+  return `data:${imageMimeTypeForPath(absolutePath)};base64,${base64}`;
+}
+function imageMimeTypeForPath(path) {
+  switch (extname(path).toLowerCase()) {
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    default:
+      return "image/png";
+  }
+}
+
+// packages/cli/agentRunLocalWorkspace.ts
+async function runGitForLocalSummary(args, deps = {}) {
+  const spawn = deps.spawnProcess ?? spawnProcess;
+  const read = deps.readPipeText ?? readPipeText;
+  const proc = spawn({
+    cmd: ["git", ...args.gitArgs],
+    cwd: args.cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    read(proc.stdout),
+    read(proc.stderr),
+    proc.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new Error((stderr || stdout || `git ${args.gitArgs.join(" ")} failed`).trim());
+  }
+  return stdout.trim();
+}
+async function inspectLocalRunWorkspace(cwd, deps = {}) {
+  const run = (gitArgs) => runGitForLocalSummary({ cwd, gitArgs }, deps);
+  const status = await run(["status", "--short"]);
+  const rawCommit = await run(["log", "-1", "--format=%h%x00%s"]).catch(() => "");
+  const [hash, subject] = rawCommit.split("\0");
+  return {
+    cwd,
+    clean: status.trim() === "",
+    status,
+    ...hash ? { commit: { hash, subject: subject ?? "" } } : {}
+  };
+}
+function shouldPrintLocalRunSummary(args) {
+  return Boolean(args.localRuntimeCwd && args.parsed.runtimeMode === "local");
+}
+function formatLocalRunSummary(args) {
+  return [
+    "",
+    "[nolo] local run summary",
+    `workspace: ${args.inspection.cwd}`,
+    ...args.dialogId ? [`dialog: ${args.dialogId}`] : [],
+    ...args.inspection.commit ? [`commit: ${args.inspection.commit.hash} ${args.inspection.commit.subject}`] : [],
+    `dirty: ${args.inspection.clean ? "clean" : "dirty"}`,
+    ...!args.inspection.clean && args.inspection.status.trim() ? [`status:
+${args.inspection.status.trim()}`] : [],
+    ""
+  ].join("\n");
+}
+
+// packages/ai/memory/overlay.ts
+var KIND_TITLES = {
+  episodic: "Episodic",
+  semantic: "Semantic",
+  procedural: "Procedural"
+};
+var normalizeDisplayContent = (item) => {
+  const normalized = item.content.trim().replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "").replace(/[。！？!?]+$/u, "").trim();
+  const stripPrefix = (prefix) => normalized.startsWith(prefix) ? normalized.slice(prefix.length).trim() : normalized;
+  if (item.kind === "semantic") {
+    if (item.tags?.includes("understanding-memory")) {
+      switch (item.facet) {
+        case "unfinished":
+          return `\u7528\u6237\u4ECD\u672A\u5B9A\u4E0B\uFF1A${stripPrefix("\u8FD8\u6CA1\u51B3\u5B9A")}`;
+        case "tension":
+          return `\u7528\u6237\u5F53\u524D\u5728\u6743\u8861\uFF1A${stripPrefix("\u5728\u6743\u8861")}`;
+        case "preference":
+          return `\u7528\u6237\u5F53\u524D\u66F4\u5728\u610F\uFF1A${stripPrefix("\u66F4\u5728\u610F")}`;
+        case "style":
+          return `\u7528\u6237\u4E92\u52A8\u504F\u597D\uFF1A${stripPrefix("\u66F4\u559C\u6B22")}`;
+        case "goal":
+          return `\u7528\u6237\u5F53\u524D\u76EE\u6807\uFF1A${stripPrefix("\u60F3\u63A8\u8FDB")}`;
+      }
+    }
+    return `\u7528\u6237\u957F\u671F\u504F\u597D/\u4E8B\u5B9E\uFF1A${normalized}`;
+  }
+  if (item.kind === "episodic" && (item.patternKey === "explicit-remember" || item.patternKey === "agent-remember")) {
+    return `\u7528\u6237\u660E\u786E\u8981\u6C42\u4F60\u8BB0\u4F4F\uFF1A${normalized}`;
+  }
+  if (item.kind === "episodic" && item.tags?.includes("understanding-memory")) {
+    switch (item.facet) {
+      case "unfinished":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u8FD8\u6CA1\u5B9A\u4E0B ${stripPrefix("\u8FD8\u6CA1\u51B3\u5B9A")}`;
+      case "tension":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u8FD8\u5728\u6743\u8861 ${stripPrefix("\u5728\u6743\u8861")}`;
+      case "preference":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u66F4\u5728\u610F ${stripPrefix("\u66F4\u5728\u610F")}`;
+      case "style":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u66F4\u504F\u597D ${stripPrefix("\u66F4\u559C\u6B22")}`;
+      case "goal":
+        return `\u6700\u8FD1\u4E00\u6B21\u5BF9\u8BDD\u663E\u793A\uFF1A\u7528\u6237\u60F3\u63A8\u8FDB ${stripPrefix("\u60F3\u63A8\u8FDB")}`;
+    }
+  }
+  return normalized;
+};
+var buildMemoryOverlay = (items) => {
+  if (items.length === 0) return null;
+  const byKind = {
+    episodic: [],
+    semantic: [],
+    procedural: []
+  };
+  for (const item of items) {
+    byKind[item.kind].push(item);
+  }
+  const sections = Object.entries(byKind).filter(([, list]) => list.length > 0).map(([kind, list]) => {
+    const lines = list.slice(0, 3).map((item) => `- ${normalizeDisplayContent(item)}`);
+    return [`[${KIND_TITLES[kind]}]`, ...lines].join("\n");
+  });
+  return [
+    "--- Memory Overlay ---",
+    "\u4EE5\u4E0B\u662F\u5F53\u524D\u8BF7\u6C42\u53EF\u7528\u7684\u8BB0\u5FC6\u4E8B\u5B9E\uFF1B\u76F8\u5173\u65F6\u76F4\u63A5\u57FA\u4E8E\u8FD9\u4E9B\u8BB0\u5FC6\u56DE\u7B54\u3002",
+    "\u7528\u6237\u5F53\u524D\u8F93\u5165\u4F18\u5148\u4E8E\u8BB0\u5FC6\uFF1B\u8BB0\u5FC6\u53EA\u8F85\u52A9\u7406\u89E3\uFF0C\u4E0D\u8981\u6C42\u8FCE\u5408\u3002",
+    "",
+    ...sections
+  ].join("\n");
+};
+
+// packages/ai/memory/rank.ts
+var CJK_SEQUENCE_REGEX = /[\u3400-\u4dbf\u4e00-\u9fff]+/g;
+var MEMORY_IDENTIFIER_REGEX = /\b(?:memory|noise)-[a-z0-9][a-z0-9-]*/gi;
+var buildCjkTokens = (text) => {
+  const sequences = text.match(CJK_SEQUENCE_REGEX) ?? [];
+  const tokens = [];
+  for (const sequence of sequences) {
+    if (sequence.length >= 2) {
+      tokens.push(sequence);
+    }
+    for (let index = 0; index < sequence.length - 1; index += 1) {
+      tokens.push(sequence.slice(index, index + 2));
+    }
+  }
+  return tokens;
+};
+var tokenize = (text) => {
+  const normalized = text.toLowerCase();
+  const wordTokens = normalized.split(/[\s,.;:!?()[\]{}"'`，。！？：；、]+/).map((token) => token.trim()).filter((token) => token.length >= 2);
+  return [...wordTokens, ...buildCjkTokens(normalized)];
+};
+var keywordScore = (query, item) => {
+  const queryTokens = new Set(tokenize(query));
+  if (queryTokens.size === 0) return 0;
+  const haystack = /* @__PURE__ */ new Set([
+    ...tokenize(item.content),
+    ...(item.tags ?? []).map((tag) => tag.toLowerCase()),
+    item.patternKey?.toLowerCase() ?? ""
+  ]);
+  let matches = 0;
+  for (const token of queryTokens) {
+    if (haystack.has(token)) matches += 1;
+  }
+  return Math.min(1, matches / Math.max(2, queryTokens.size));
+};
+var identifierScore = (query, item) => {
+  const identifiers = query.match(MEMORY_IDENTIFIER_REGEX) ?? [];
+  if (identifiers.length === 0) return 0;
+  const content = item.content.toLowerCase();
+  const matches = identifiers.filter(
+    (identifier) => content.includes(identifier.toLowerCase())
+  ).length;
+  return matches / identifiers.length;
+};
+var activationScore = (item, nowMs) => {
+  const lastActivatedMs = Date.parse(item.lastActivatedAt || item.createdAt);
+  const ageDays = Math.max(0, (nowMs - lastActivatedMs) / 864e5);
+  const recency = 1 / (1 + ageDays / 7);
+  const reinforcement = Math.min(1, Math.log1p(item.activationCount ?? 0) / 3);
+  return 0.7 * recency + 0.3 * reinforcement;
+};
+var creationRecencyScore = (item, nowMs) => {
+  const createdMs = Date.parse(item.createdAt);
+  const ageDays = Math.max(0, (nowMs - createdMs) / 864e5);
+  return 1 / (1 + ageDays / 7);
+};
+var typeFitScore = (item) => {
+  if (item.kind === "episodic") return 0.75;
+  if (item.kind === "semantic") return 0.9;
+  return 0.85;
+};
+var understandingScore = (item) => {
+  if (!item.tags?.includes("understanding-memory")) return 0;
+  if (item.facet === "unfinished") return 1;
+  if (item.facet === "tension") return 0.95;
+  if (item.facet === "preference") return 0.85;
+  if (item.facet === "style") return 0.75;
+  return 0.8;
+};
+var pathScore = (item, context) => {
+  let score = 0;
+  if (context?.currentOwner && item.ownerType === context.currentOwner.ownerType && item.ownerId === context.currentOwner.ownerId) {
+    score += 0.65;
+  }
+  if (context?.currentSubject && item.subjectType === context.currentSubject.subjectType && item.subjectId === context.currentSubject.subjectId) {
+    score += 0.85;
+  }
+  return Math.min(1, score);
+};
+var scoreMemoryItem = (item, query, nowMs = Date.now(), context) => {
+  const queryMatch = keywordScore(query, item);
+  const identifierMatch = identifierScore(query, item);
+  const activation = activationScore(item, nowMs);
+  const createdRecency = creationRecencyScore(item, nowMs);
+  const importance = item.importance ?? 0;
+  const confidence = item.confidence ?? 0;
+  const typeFit = typeFitScore(item);
+  const understanding = understandingScore(item);
+  const path = pathScore(item, context);
+  return 0.25 * queryMatch + 0.2 * identifierMatch + 0.2 * path + 0.09 * activation + 0.16 * createdRecency + 0.06 * importance + 0.03 * confidence + 0.02 * typeFit + 0.01 * understanding;
+};
+var rankMemoryCandidates = (items, query, context) => {
+  const nowMs = Date.now();
+  return [...items].sort((a, b) => {
+    const aExplicit = a.sourceKind === "explicit-user-directive";
+    const bExplicit = b.sourceKind === "explicit-user-directive";
+    if (aExplicit !== bExplicit) return bExplicit ? 1 : -1;
+    if (aExplicit) {
+      return Date.parse(b.createdAt) - Date.parse(a.createdAt);
+    }
+    return scoreMemoryItem(b, query, nowMs, context) - scoreMemoryItem(a, query, nowMs, context);
+  });
+};
+
+// packages/ai/memory/runtime.ts
+var COLD_STORAGE_CONFIDENCE = 0.3;
+var normalizeSelectedContent = (text) => text.trim().replace(/^(你要记住|请记住|以后记住|记住)[，,。.\s:：]*/u, "").replace(/[。！？!?]+$/u, "").trim();
+var STACK_TERMS = [
+  "typescript",
+  "javascript",
+  "python",
+  "rust",
+  "go",
+  "golang",
+  "java",
+  "kotlin",
+  "swift",
+  "ruby",
+  "php"
+];
+var stackAliases = {
+  golang: "go"
+};
+var normalizeStackTerm = (term) => stackAliases[term] ?? term;
+var stackTermsIn = (text) => {
+  const lower = text.toLowerCase();
+  const terms = /* @__PURE__ */ new Set();
+  for (const term of STACK_TERMS) {
+    const pattern = term.length <= 2 ? new RegExp(`\\b${term}\\b`, "i") : new RegExp(term, "i");
+    if (pattern.test(lower)) {
+      terms.add(normalizeStackTerm(term));
+    }
+  }
+  return terms;
+};
+var conflictsWithCurrentStack = (item, userInput) => {
+  const currentStacks = stackTermsIn(userInput);
+  if (currentStacks.size === 0) return false;
+  const memoryStacks = stackTermsIn(item.content);
+  if (memoryStacks.size === 0) return false;
+  for (const stack of memoryStacks) {
+    if (!currentStacks.has(stack)) return true;
+  }
+  return false;
+};
+var INTERACTION_PREFERENCE_TERMS = [
+  "\u56DE\u7B54\u504F\u597D",
+  "\u8F93\u51FA\u504F\u597D",
+  "\u56DE\u590D\u504F\u597D",
+  "\u56DE\u7B54\u7ED3\u6784",
+  "\u8F93\u51FA\u7ED3\u6784",
+  "\u56DE\u590D\u7ED3\u6784",
+  "\u5148\u7ED9\u7ED3\u8BBA",
+  "\u518D\u5217\u98CE\u9669",
+  "\u6700\u540E\u7ED9\u8BC1\u636E",
+  "\u8BED\u6C14",
+  "\u98CE\u683C",
+  "\u79F0\u547C",
+  "\u53EB\u6211"
+];
+var isInteractionPreferenceMemory = (item) => {
+  if (item.facet === "style") return true;
+  const content = normalizeSelectedContent(item.content);
+  return INTERACTION_PREFERENCE_TERMS.some((term) => content.includes(term));
+};
+var isOffCurrentPath = (item, context) => {
+  const currentOwner = context?.currentOwner;
+  const currentSubject = context?.currentSubject;
+  if (currentSubject && (item.subjectType === "project" || item.subjectType === "space") && item.subjectType === currentSubject.subjectType && item.subjectId !== currentSubject.subjectId) {
+    return true;
+  }
+  if (currentOwner?.ownerType === "space" && item.ownerType === "user" && (item.subjectType === "project" || item.subjectType === "space") && item.subjectId !== currentOwner.ownerId) {
+    return true;
+  }
+  return false;
+};
+var selectRuntimeMemoryItems = (items, context, userInput = "") => {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = items.filter((item) => {
+    if ((item.confidence ?? 0) < COLD_STORAGE_CONFIDENCE) return false;
+    if (isOffCurrentPath(item, context)) return false;
+    if (conflictsWithCurrentStack(item, userInput)) return false;
+    const key = `${item.kind}:${normalizeSelectedContent(item.content).toLowerCase()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const selected = [];
+  const selectedIds = /* @__PURE__ */ new Set();
+  const add = (item) => {
+    if (!item || selectedIds.has(item.id) || selected.length >= 4) return;
+    selected.push(item);
+    selectedIds.add(item.id);
+  };
+  add(
+    unique.find(
+      (item) => context?.currentSubject && item.subjectType === context.currentSubject.subjectType && item.subjectId === context.currentSubject.subjectId
+    )
+  );
+  add(unique.find(isInteractionPreferenceMemory));
+  add(
+    unique.find(
+      (item) => context?.currentOwner && item.ownerType === context.currentOwner.ownerType && item.ownerId === context.currentOwner.ownerId
+    )
+  );
+  add(unique.find((item) => item.ownerType === "user"));
+  add(unique.find((item) => item.ownerType === "space"));
+  add(unique.find((item) => item.kind === "procedural"));
+  for (const item of unique) {
+    add(item);
+  }
+  return selected;
+};
+var resolveMemoryRuntime = async (input) => {
+  const owners = chooseMemoryOwners({
+    userId: input.userId,
+    spaceId: input.spaceId
+  });
+  if (owners.length === 0) {
+    return { selectedItems: [], promptBlock: null };
+  }
+  const policy = resolveAgentMemoryPolicy({ agentKey: input.agentKey });
+  const candidates = await loadMemoryCandidatesFromDb(input.db, {
+    owners,
+    subjects: buildMemorySubjectsForAgent({
+      userId: input.userId,
+      spaceId: input.spaceId,
+      agentKey: input.agentKey,
+      policy
+    }),
+    kinds: ["episodic", "semantic", "procedural"],
+    ownerLimit: 20,
+    ownerFallback: policy.ownerFallback
+  });
+  const rankContext = {
+    currentOwner: input.spaceId ? { ownerType: "space", ownerId: input.spaceId } : input.userId ? { ownerType: "user", ownerId: input.userId } : null,
+    currentSubject: input.spaceId ? { subjectType: "space", subjectId: input.spaceId } : input.userId ? { subjectType: "user", subjectId: input.userId } : null
+  };
+  const ranked = selectRuntimeMemoryItems(
+    rankMemoryCandidates(candidates, input.userInput, rankContext),
+    rankContext,
+    input.userInput
+  );
+  if (ranked.length === 0) {
+    return { selectedItems: [], promptBlock: null };
+  }
+  await touchMemoryItemsInDb(input.db, ranked);
+  return {
+    selectedItems: ranked,
+    promptBlock: buildMemoryOverlay(ranked)
+  };
+};
+
+// packages/cli/agentRunCommand.ts
+function resolvePositiveMs(value, fallback) {
+  return parsePositiveFiniteNumberOrFallback(value, fallback);
+}
+async function resolveAgentRunAgentKey(args) {
+  if (!args.agentInput.trim() || args.agentInput.startsWith("agent-")) {
+    return void 0;
+  }
+  const db = await getReadableCliDb(args.output);
+  const resolved = await resolveAgentRecordFromHybridStore({
+    agentInput: args.agentInput,
+    cliArgs: args.cliArgs,
+    env: args.env,
+    db,
+    fetchImpl: fetch
+  });
+  return resolved?.agentKey;
+}
+async function runAgentRunCommand(args, deps) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (args.includes("--help") || args.includes("-h")) {
+    writeUsage(output, deps.commandPath);
+    return 0;
+  }
+  const parsed = parseAgentRunArgs(args, { commandPath: deps.commandPath });
+  if (!parsed) {
+    writeUsage(output, deps.commandPath);
+    return 1;
+  }
+  const runner = deps.runner ?? runAgentTurn;
+  const nowMs = () => deps.now ? deps.now().getTime() : Date.now();
+  const childRunId = env.NOLO_AGENT_RUN_ID;
+  const hasRegistry = typeof childRunId === "string" && childRunId.length > 0;
+  const processExit = deps.processExit ?? ((code) => process.exit(code));
+  const stallTimeoutMs = resolvePositiveMs(
+    deps.stallTimeoutMs ?? env.NOLO_LOCAL_RUN_STALL_TIMEOUT_MS,
+    5 * 6e4
+  );
+  let timedOut = false;
+  let stalled = false;
+  let timeoutTimer;
+  let stallTimer;
+  const activityTracker = hasRegistry ? createRunActivityTracker(childRunId, {
+    env,
+    homedir: deps.homedir,
+    fs: deps.fs,
+    now: deps.now
+  }) : void 0;
+  const clearWatchdogs = () => {
+    if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+    if (stallTimer !== void 0) clearInterval(stallTimer);
+    activityTracker?.flush();
+    activityTracker?.dispose();
+  };
+  let rejectOnWatchdogFailure;
+  const watchdogFailure = hasRegistry ? new Promise((_, reject) => {
+    rejectOnWatchdogFailure = reject;
+  }) : void 0;
+  const raceWithWatchdog = (work) => watchdogFailure ? Promise.race([work, watchdogFailure]) : work;
+  const exitFromWatchdog = (code) => {
+    try {
+      processExit(code);
+    } catch {
+    }
+  };
+  if (hasRegistry) {
+    stallTimer = setInterval(() => {
+      if (timedOut || stalled) return;
+      const activity = activityTracker?.getActivity();
+      const lastEventAtMs = activity ? new Date(activity.lastEventAt).getTime() : nowMs();
+      const elapsedSinceEvent = nowMs() - lastEventAtMs;
+      if (activity?.inFlight?.kind === "tool") {
+        return;
+      }
+      if (activity?.inFlight?.kind === "llm" && elapsedSinceEvent < stallTimeoutMs) {
+        return;
+      }
+      if (elapsedSinceEvent >= stallTimeoutMs) {
+        stalled = true;
+        clearWatchdogs();
+        const note = `stalled: no progress for ${stallTimeoutMs}ms`;
+        output.write(`[nolo] local run ${note}
+`);
+        (deps.finalizeRunRecord ?? finalizeRunRecord)(
+          childRunId,
+          { status: "failed", note },
+          { env, homedir: deps.homedir, fs: deps.fs, now: deps.now }
+        );
+        rejectOnWatchdogFailure?.(new Error(`[nolo] local run ${note}`));
+        exitFromWatchdog(1);
+      }
+    }, Math.min(stallTimeoutMs, 1e4));
+    if (typeof parsed.timeoutMs === "number" && parsed.timeoutMs > 0) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        clearWatchdogs();
+        const note = `timed out after ${parsed.timeoutMs}ms`;
+        output.write(`[nolo] local run ${note}
+`);
+        (deps.finalizeRunRecord ?? finalizeRunRecord)(
+          childRunId,
+          { status: "timeout", note },
+          { env, homedir: deps.homedir, fs: deps.fs, now: deps.now }
+        );
+        rejectOnWatchdogFailure?.(new Error(`[nolo] local run ${note}`));
+        exitFromWatchdog(124);
+      }, parsed.timeoutMs);
+    }
+  }
+  const wantsFallbackSuggestions = parsed.fallbackAgentKeys && parsed.fallbackAgentKeys.length > 0;
+  const rawAgentInput = resolveRawAgentInput(args, deps.commandPath) ?? parsed.agentKey;
+  const fullstackLocal = isFullstackCodingAgentRef(rawAgentInput, parsed.agentKey);
+  const explicitLocalCli = isLocalCliAgentKey(parsed.agentKey);
+  const isLocalRun = parsed.runtimeMode === "local" || !parsed.runtimeMode && (fullstackLocal || explicitLocalCli || args.includes("--dangerously-allow-shell"));
+  if (wantsFallbackSuggestions && !isLocalRun) {
+    output.write("[nolo] --fallback-agent (suggestions) is only supported for local CLI runs (use --local)\n");
+    return 1;
+  }
+  let effectiveMessage = parsed.message;
+  if (wantsFallbackSuggestions) {
+    effectiveMessage = `${parsed.message}
+
+[Quota fallback context for agent decision: If this execution for ${parsed.agentKey} hits subscription quota, YOU (the agent) must decide the next agent to use. Do not rely on automatic wrapper. Reason based on the specific task (complexity, length, domain), agent strengths, cost, previous attempt results. Suggested alternatives: ${parsed.fallbackAgentKeys.join(", ")}. Update the task row with attempt history and dispatch the chosen next (via new agent run or callAgent({ background: true })).]`;
+  }
+  const resolvedAgentKey = parsed.runtimeMode !== "local" ? await (deps.resolveAgentRunAgentKey ?? resolveAgentRunAgentKey)({
+    agentInput: resolveRawAgentInput(args, deps.commandPath) ?? parsed.agentKey,
+    cliArgs: args,
+    env,
+    output
+  }).catch(() => void 0) : void 0;
+  const agentKey = resolvedAgentKey ?? parsed.agentKey;
+  let effectiveAgentKey = agentKey;
+  let modelOverride = null;
+  const autoRouteRequested = deps.commandPath?.join(" ") === "chat" && !parsed.continueDialogId && (args.includes("--auto-route") || env.NOLO_AUTO_ROUTE === "1") && env.NOLO_AUTO_ROUTE !== "0";
+  if (autoRouteRequested) {
+    const authToken = resolveAuthToken(args, env);
+    const serverUrl = resolveServerUrl(env);
+    const hasExplicitAgent = Boolean(readFlagValue(args, "--agent"));
+    const route = await classifyCliAutoRoute(effectiveMessage, {
+      serverUrl,
+      authToken
+    });
+    if (hasExplicitAgent) {
+      modelOverride = buildModelLayerOverride(
+        await readDbRecord({
+          dbKey: agentKey,
+          authToken,
+          serverUrl,
+          fetchImpl: fetch
+        }).catch(() => null)
+      );
+    }
+    if (hasExplicitAgent && !modelOverride) {
+      output.write(
+        "[nolo] auto-route: \u8986\u76D6\u6E90 agent \u8BFB\u53D6\u5931\u8D25\uFF0C\u6309\u539F\u6837\u76F4\u8DD1\u6240\u9009 agent\u3002\n"
+      );
+    } else {
+      effectiveAgentKey = route.agentKey;
+      output.write(
+        `[nolo] auto \u2192 ${route.tier}${modelOverride ? ` (model: ${agentKey})` : ""}
+`
+      );
+    }
+  }
+  let workflowReference;
+  if (parsed.workflowRef) {
+    try {
+      workflowReference = await (deps.resolveWorkflowReference ?? resolveWorkflowReference)(
+        parsed.workflowRef
+      );
+    } catch (error) {
+      output.write(`[nolo] ${toErrorMessage(error)}
+`);
+      return 1;
+    }
+  }
+  let skillReferences;
+  let skillAllowedToolOverride;
+  if (parsed.skillRefs?.length) {
+    const skills = [];
+    const authToken = resolveAuthToken(args, env);
+    const serverUrl = resolveServerUrl(env);
+    for (const ref of parsed.skillRefs) {
+      try {
+        const resolved = await resolveSkillReference(ref, {
+          cwd: parsed.cwd,
+          readDbRecord: async (dbKey) => {
+            return readDbRecord({
+              dbKey,
+              authToken,
+              serverUrl,
+              fetchImpl: fetch
+            });
+          }
+        });
+        skills.push(resolved);
+      } catch (error) {
+        output.write(`[nolo] ${toErrorMessage(error)}
+`);
+        return 1;
+      }
+    }
+    skillReferences = skills;
+    const skillToolLists = skills.map((s) => s.allowedTools).filter((t2) => !!t2 && t2.length > 0);
+    if (skillToolLists.length > 0) {
+      const skillAllowed = skillToolLists.reduce(
+        (acc, tools) => acc.filter((t2) => tools.includes(t2))
+      );
+      if (skillAllowed.length === 0) {
+        output.write(`[nolo] warning: attached skills declare incompatible allowed-tools; no tool restriction enforced
+`);
+      }
+      skillAllowedToolOverride = parsed.allowedToolNames?.length ? parsed.allowedToolNames.filter((t2) => skillAllowed.includes(t2)) : skillAllowed;
+    }
+  }
+  let localRuntimeCwd = parsed.cwd;
+  if (!localRuntimeCwd && parsed.runtimeMode === "local") {
+    localRuntimeCwd = process.cwd();
+  }
+  const runEnv = buildLocalRunEnv({
+    env,
+    allowShell: parsed.allowShell
+  });
+  if (parsed.background && isLocalRun) {
+    const { runId, pid, logPath } = await (deps.spawnLocalBackgroundRun ?? spawnLocalBackgroundRun)(
+      {
+        rawArgs: args,
+        commandPath: deps.commandPath,
+        cliEntrypointPath: deps.cliEntrypointPath,
+        agentKey,
+        cwd: localRuntimeCwd,
+        msgFile: readFlagValue(args, "--msg-file"),
+        message: parsed.message,
+        timeoutMs: parsed.timeoutMs,
+        output
+      },
+      {
+        env,
+        homedir: deps.homedir,
+        spawn: deps.spawn,
+        fs: deps.fs,
+        now: deps.now,
+        generateRunId: deps.generateRunId
+      }
+    );
+    output.write(`[nolo] runId=${runId}
+`);
+    output.write(`[nolo] pid=${pid ?? "-"}
+`);
+    output.write(`[nolo] log=${logPath}
+`);
+    output.write(`[nolo] status: nolo agent status ${runId}
+`);
+    output.write(`[nolo] stop: nolo agent stop ${runId}
+`);
+    return 0;
+  }
+  const cliCwd = parsed.cwd ?? process.cwd();
+  const extraContextBlocks = [];
+  const AGENTS_MD_MAX = 8192;
+  for (const name of ["AGENTS.md", "CLAUDE.md"]) {
+    const agentsMdPath = join3(cliCwd, name);
+    if (existsSync3(agentsMdPath)) {
+      try {
+        let mdContent = readFileSync3(agentsMdPath, "utf8").trim();
+        if (!mdContent) continue;
+        if (Buffer.byteLength(mdContent, "utf8") > AGENTS_MD_MAX) {
+          mdContent = Buffer.from(mdContent, "utf8").subarray(0, AGENTS_MD_MAX).toString("utf8") + "\n\n<!-- AGENTS.md truncated -->";
+        }
+        extraContextBlocks.push(`--- \u9879\u76EE\u6307\u4EE4\uFF08${name}\uFF09---
+${mdContent}`);
+        break;
+      } catch {
+      }
+    }
+  }
+  extraContextBlocks.push(...buildSkillContextBlocks(skillReferences));
+  const skillDiscoveryBlock = buildSkillDiscoveryContextBlock(cliCwd);
+  if (skillDiscoveryBlock) {
+    extraContextBlocks.push(skillDiscoveryBlock);
+  }
+  let memoryPromptBlock = null;
+  if (!deps.memoryRecallDisabled) {
+    const memoryServerUrl = resolveServerUrl(env);
+    const memoryAuthToken = resolveAuthToken(args, env);
+    const memoryAgentKey = effectiveAgentKey;
+    const memorySpaceId = parsed.spaceId ?? void 0;
+    try {
+      if (memoryAuthToken && memoryServerUrl) {
+        const memoryResponse = await fetch(`${memoryServerUrl}/api/memory/query`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${memoryAuthToken}`
+          },
+          body: JSON.stringify({
+            agentKey: memoryAgentKey,
+            userInput: effectiveMessage,
+            ...memorySpaceId ? { spaceId: memorySpaceId } : {}
+          }),
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (memoryResponse.ok) {
+          const memoryPayload = await memoryResponse.json().catch(() => null);
+          const block = typeof memoryPayload?.promptBlock === "string" ? memoryPayload.promptBlock.trim() : "";
+          memoryPromptBlock = block || null;
+        } else {
+          console.warn("[cli-memory] memory query returned non-ok status:", memoryResponse.status);
+        }
+      } else {
+        const localDb = await getDefaultCliLocalRuntimeDb({ env });
+        const machineId = resolveMachineId();
+        const resolution = await resolveMemoryRuntime({
+          db: localDb,
+          userId: machineId,
+          agentKey: memoryAgentKey,
+          userInput: effectiveMessage,
+          ...memorySpaceId ? { spaceId: memorySpaceId } : {}
+        });
+        memoryPromptBlock = resolution.promptBlock;
+      }
+    } catch (memoryError) {
+      console.warn("[cli-memory] memory recall failed, omitting memory layer:", memoryError);
+    }
+  }
+  const memoryOverlayLayer = buildMemoryOverlayLayer({ promptBlock: memoryPromptBlock });
+  const memoryUseGuidanceLayer = buildMemoryUseGuidanceLayer({ promptBlock: memoryPromptBlock });
+  const contextBlockScopes = [];
+  const agentsMdMarker = "--- \u9879\u76EE\u6307\u4EE4\uFF08";
+  for (const block of extraContextBlocks) {
+    if (block.startsWith(agentsMdMarker)) {
+      contextBlockScopes.push({ content: block, cacheScope: "session" });
+    }
+  }
+  if (memoryUseGuidanceLayer?.content?.trim()) {
+    contextBlockScopes.push({ content: memoryUseGuidanceLayer.content, cacheScope: "session" });
+  }
+  for (const block of extraContextBlocks) {
+    if (!block.startsWith(agentsMdMarker)) {
+      contextBlockScopes.push({ content: block, cacheScope: "turn" });
+    }
+  }
+  if (memoryOverlayLayer?.content?.trim()) {
+    contextBlockScopes.push({ content: memoryOverlayLayer.content, cacheScope: "turn" });
+  }
+  const buildRunOptions = (targetAgentKey) => ({
+    agentName: targetAgentKey,
+    agentKey: targetAgentKey,
+    serverUrl: resolveServerUrl(env),
+    message: prependWorkflowReferencePrompt(
+      prependSubjectDialogMarker(
+        prependFeatureWorktreeInstruction(
+          effectiveMessage,
+          parsed.injectFeatureWorktreeInstruction
+        ),
+        parsed.subjectDialogKey
+      ),
+      workflowReference
+    ),
+    imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
+    scriptDir: deps.scriptDir,
+    env: runEnv,
+    output,
+    ...deps.localRuntimeAdapterFactory ? { localRuntimeAdapterFactory: deps.localRuntimeAdapterFactory } : {},
+    ...localRuntimeCwd ? { localRuntimeCwd } : {},
+    ...parsed.runtimeMode ? { runtimeMode: parsed.runtimeMode } : {},
+    ...parsed.continueDialogId ? { continueDialogId: parsed.continueDialogId } : {},
+    ...parsed.spaceId ? { spaceId: parsed.spaceId } : {},
+    ...parsed.category ? { category: parsed.category } : {},
+    ...parsed.inheritedFromDialogKey ? { inheritedFromDialogKey: parsed.inheritedFromDialogKey } : {},
+    ...parsed.parentDialogId ? { parentDialogId: parsed.parentDialogId } : {},
+    ...parsed.parentWakeOnTerminal ? { parentWakeOnTerminal: true } : {},
+    ...parsed.subjectDialogKey ? { subjectDialogKey: parsed.subjectDialogKey } : {},
+    ...parsed.subjectRefs?.length ? { subjectRefs: parsed.subjectRefs } : {},
+    ...parsed.allowedChildAgentKeys?.length ? { allowedChildAgentKeys: parsed.allowedChildAgentKeys } : {},
+    ...skillAllowedToolOverride !== void 0 ? { allowedToolNames: skillAllowedToolOverride } : parsed.allowedToolNames?.length ? { allowedToolNames: parsed.allowedToolNames } : {},
+    ...parsed.blockedToolNames?.length ? { blockedToolNames: parsed.blockedToolNames } : {},
+    ...activityTracker ? { onLoopEvent: activityTracker.onLoopEvent } : {},
+    background: parsed.background,
+    noStream: parsed.noStream,
+    ephemeral: parsed.ephemeral,
+    ...typeof parsed.timeoutMs === "number" ? { timeoutMs: parsed.timeoutMs } : {},
+    traceTools: parsed.traceTools,
+    ...parsed.eventsMode ? { eventsMode: parsed.eventsMode } : {},
+    ...parsed.taskEvidence ? { taskEvidence: parsed.taskEvidence } : {},
+    ...extraContextBlocks.length > 0 ? { extraContextBlocks } : {},
+    ...contextBlockScopes.length > 0 ? { contextBlockScopes } : {}
+  });
+  let result = await raceWithWatchdog(
+    runner({
+      ...buildRunOptions(effectiveAgentKey),
+      ...modelOverride ? { modelOverride } : {}
+    })
+  );
+  clearWatchdogs();
+  if (result.exitCode !== 0 && isQuotaExhaustedError(result.localError) && isLocalRun && parsed.fallbackAgentKeys && parsed.fallbackAgentKeys.length > 0) {
+    const fallbackAgentKey = parsed.fallbackAgentKeys[0];
+    output.write(
+      `[nolo] quota exhausted on ${agentKey}, falling back to ${fallbackAgentKey}
+`
+    );
+    const fallbackResult = await raceWithWatchdog(runner(buildRunOptions(fallbackAgentKey)));
+    clearWatchdogs();
+    if (fallbackResult.exitCode === 0) {
+      result = fallbackResult;
+    } else {
+      result = fallbackResult;
+      output.write(
+        `[nolo] fallback to ${fallbackAgentKey} also failed: ${fallbackResult.localError instanceof Error ? fallbackResult.localError.message : String(fallbackResult.localError ?? "unknown error")}
+`
+      );
+    }
+  } else if (result.localError instanceof CliProviderQuotaError) {
+    output.write(`
+[nolo] Quota limit hit for ${parsed.agentKey} (CliProviderQuotaError).
+`);
+    if (parsed.fallbackAgentKeys && parsed.fallbackAgentKeys.length > 0) {
+      output.write(`Suggested alternatives for your decision: ${parsed.fallbackAgentKeys.join(", ")}
+`);
+    }
+    output.write(`As the orchestrating agent, decide next based on task and re-dispatch (update task state with this attempt).
+`);
+  }
+  if (result.dialogId) {
+    if (parsed.background) {
+      output.write(`
+[nolo] background dialog ${result.dialogId}
+`);
+      output.write(`[nolo] read: nolo dialog read ${result.dialogId}
+`);
+    } else {
+      output.write(`
+[nolo] dialog ${result.dialogId}
+`);
+    }
+  }
+  if (shouldPrintLocalRunSummary({ parsed, localRuntimeCwd })) {
+    try {
+      const inspect = deps.inspectLocalRunWorkspace ?? inspectLocalRunWorkspace;
+      const inspection = await inspect(localRuntimeCwd);
+      output.write(formatLocalRunSummary({
+        dialogId: result.dialogId,
+        inspection
+      }));
+    } catch (error) {
+      output.write(
+        `
+[nolo] local run summary unavailable: ${toErrorMessage(error)}
+`
+      );
+    }
+  }
+  if (typeof childRunId === "string" && childRunId.length > 0) {
+    const finalStatus = result.exitCode === 0 ? "done" : "failed";
+    await (deps.finalizeRunRecord ?? finalizeRunRecord)(
+      childRunId,
+      {
+        status: finalStatus,
+        exitCode: result.exitCode,
+        dialogId: result.dialogId
+      },
+      {
+        env,
+        homedir: deps.homedir,
+        fs: deps.fs,
+        now: deps.now
+      }
+    );
+  }
+  return result.exitCode;
+}
+var QUOTA_ERROR_PATTERNS = [
+  /429/,
+  /quota/i,
+  /rate\s*limit/i,
+  /too\s*many\s*requests/i,
+  /额度/,
+  /上限/,
+  /用尽/,
+  /CliProviderQuotaError/i
+];
+function isQuotaExhaustedError(error) {
+  if (!error) return false;
+  if (error instanceof CliProviderQuotaError) 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;
+}
+
+export {
+  formatTokenCount,
+  renderTokenStatus,
+  resolveCliColorEnabled,
+  dimCliText,
+  THEME_PALETTES,
+  getActiveThemeName,
+  setActiveThemeName,
+  getActiveBrightness,
+  setActiveBrightness,
+  getActiveDensity,
+  setActiveDensity,
+  resolveTuiBrightness,
+  surfaceBackgroundSequence,
+  themeColorSequence,
+  themeText,
+  highlightMarkdown,
+  formatAssistantDisplay,
+  normalizeThinkingDisplayMode,
+  parseCliLocale,
+  getCliLocale,
+  setCliLocale,
+  initCliLocale,
+  t,
+  normalizeToolDisplayMode,
+  runAgentTurn,
+  CLI_IMAGE_AGENT_KEY,
+  CLI_AUTO_TIER_AGENT_KEY_TABLE,
+  classifyCliAutoRoute,
+  buildSkillDiscoveryContextBlock,
+  resolveWorkflowReference,
+  resolveSkillReference,
+  buildSkillContextBlocks,
+  prependSubjectDialogMarker,
+  normalizeCliImageInput,
+  inspectLocalRunWorkspace,
+  runAgentRunCommand,
+  isQuotaExhaustedError
+};