flavor-code 1.3.11 → 1.3.13

package/dist/{chunk-IGFN2DM5.js → chunk-W2D2MLY2.js}

@@ -12,7 +12,7 @@ import {
   redactConfig,
   setProjectMcpServerDisabled,
   updateProtectedFile
-} from "./chunk-IG4Z23CL.js";
+} from "./chunk-JFKRX2KG.js";
 import {
   AuditLogger,
   appendUsageLog,
@@ -66,12 +66,12 @@ function normalizeProviderError(error) {
 
 // src/utils/async.ts
 function withTimeout(promise, ms) {
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve29, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      resolve28({ timedOut: true, value: void 0 });
+      resolve29({ timedOut: true, value: void 0 });
     }, ms);
     timer.unref?.();
     promise.then(
@@ -79,7 +79,7 @@ function withTimeout(promise, ms) {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve28({ timedOut: false, value });
+          resolve29({ timedOut: false, value });
         }
       },
       (error) => {
@@ -94,13 +94,13 @@ function withTimeout(promise, ms) {
 }
 function awaitWithSignal(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve29, reject) => {
     const onAbort = () => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve28(value);
+        resolve29(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -1082,6 +1082,231 @@ function packageVersion() {
   throw new Error("package.json with a version field was not found");
 }
 
+// src/ui/char-width.ts
+function charWidth(codePoint) {
+  if (codePoint === 8203 || // ZERO WIDTH SPACE
+  codePoint === 8204 || // ZERO WIDTH NON-JOINER
+  codePoint === 8205 || // ZERO WIDTH JOINER
+  codePoint === 65279 || // BOM / ZERO WIDTH NO-BREAK SPACE
+  codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks
+  codePoint >= 1155 && codePoint <= 1161 || // Cyrillic combining marks
+  codePoint >= 1425 && codePoint <= 1469 || // Hebrew combining marks
+  codePoint >= 1552 && codePoint <= 1562 || // Arabic combining marks
+  codePoint >= 1611 && codePoint <= 1631 || // Arabic combining marks
+  codePoint >= 1648 && codePoint <= 1648 || // Arabic combining marks
+  codePoint >= 1750 && codePoint <= 1756 || // Arabic combining marks
+  codePoint >= 1759 && codePoint <= 1764 || // Arabic combining marks
+  codePoint >= 1767 && codePoint <= 1768 || // Arabic combining marks
+  codePoint >= 1770 && codePoint <= 1773 || // Arabic combining marks
+  codePoint >= 1809 && codePoint <= 1809 || // Syriac combining marks
+  codePoint >= 1840 && codePoint <= 1866 || // Syriac combining marks
+  codePoint >= 1958 && codePoint <= 1968 || // Thaana combining marks
+  codePoint >= 2304 && codePoint <= 2306 || // Devanagari combining marks
+  codePoint >= 2362 && codePoint <= 2362 || // Devanagari combining marks
+  codePoint >= 2364 && codePoint <= 2364 || // Devanagari combining marks
+  codePoint >= 2369 && codePoint <= 2376 || // Devanagari combining marks
+  codePoint >= 2381 && codePoint <= 2381 || // Devanagari combining marks
+  codePoint >= 2385 && codePoint <= 2391 || // Devanagari combining marks
+  codePoint >= 2402 && codePoint <= 2403 || // Devanagari combining marks
+  codePoint >= 2433 && codePoint <= 2433 || // Bengali combining marks
+  codePoint >= 2492 && codePoint <= 2492 || // Bengali combining marks
+  codePoint >= 2497 && codePoint <= 2500 || // Bengali combining marks
+  codePoint >= 2509 && codePoint <= 2509 || // Bengali combining marks
+  codePoint >= 2530 && codePoint <= 2531 || // Bengali combining marks
+  codePoint >= 2561 && codePoint <= 2562 || // Gurmukhi combining marks
+  codePoint >= 2620 && codePoint <= 2620 || // Gurmukhi combining marks
+  codePoint >= 2625 && codePoint <= 2626 || // Gurmukhi combining marks
+  codePoint >= 2631 && codePoint <= 2632 || // Gurmukhi combining marks
+  codePoint >= 2635 && codePoint <= 2637 || // Gurmukhi combining marks
+  codePoint >= 2672 && codePoint <= 2673 || // Gurmukhi combining marks
+  codePoint >= 2689 && codePoint <= 2690 || // Gujarati combining marks
+  codePoint >= 2748 && codePoint <= 2748 || // Gujarati combining marks
+  codePoint >= 2753 && codePoint <= 2757 || // Gujarati combining marks
+  codePoint >= 2759 && codePoint <= 2760 || // Gujarati combining marks
+  codePoint >= 2765 && codePoint <= 2765 || // Gujarati combining marks
+  codePoint >= 2786 && codePoint <= 2787 || // Gujarati combining marks
+  codePoint >= 2817 && codePoint <= 2817 || // Oriya combining marks
+  codePoint >= 2876 && codePoint <= 2876 || // Oriya combining marks
+  codePoint >= 2879 && codePoint <= 2879 || // Oriya combining marks
+  codePoint >= 2881 && codePoint <= 2883 || // Oriya combining marks
+  codePoint >= 2893 && codePoint <= 2893 || // Oriya combining marks
+  codePoint >= 2902 && codePoint <= 2902 || // Oriya combining marks
+  codePoint >= 2946 && codePoint <= 2946 || // Tamil combining marks
+  codePoint >= 3008 && codePoint <= 3008 || // Tamil combining marks
+  codePoint >= 3021 && codePoint <= 3021 || // Tamil combining marks
+  codePoint >= 3134 && codePoint <= 3136 || // Telugu combining marks
+  codePoint >= 3142 && codePoint <= 3144 || // Telugu combining marks
+  codePoint >= 3146 && codePoint <= 3149 || // Telugu combining marks
+  codePoint >= 3157 && codePoint <= 3158 || // Telugu combining marks
+  codePoint >= 3260 && codePoint <= 3260 || // Kannada combining marks
+  codePoint >= 3263 && codePoint <= 3263 || // Kannada combining marks
+  codePoint >= 3270 && codePoint <= 3270 || // Kannada combining marks
+  codePoint >= 3276 && codePoint <= 3277 || // Kannada combining marks
+  codePoint >= 3298 && codePoint <= 3299 || // Kannada combining marks
+  codePoint >= 3393 && codePoint <= 3395 || // Malayalam combining marks
+  codePoint >= 3405 && codePoint <= 3405 || // Malayalam combining marks
+  codePoint >= 3530 && codePoint <= 3530 || // Sinhala combining marks
+  codePoint >= 3538 && codePoint <= 3540 || // Sinhala combining marks
+  codePoint >= 3542 && codePoint <= 3542 || // Sinhala combining marks
+  codePoint >= 3633 && codePoint <= 3633 || // Thai combining marks
+  codePoint >= 3636 && codePoint <= 3642 || // Thai combining marks
+  codePoint >= 3655 && codePoint <= 3662 || // Thai combining marks
+  codePoint >= 3761 && codePoint <= 3761 || // Lao combining marks
+  codePoint >= 3764 && codePoint <= 3769 || // Lao combining marks
+  codePoint >= 3771 && codePoint <= 3772 || // Lao combining marks
+  codePoint >= 3784 && codePoint <= 3789 || // Lao combining marks
+  codePoint >= 3864 && codePoint <= 3865 || // Tibetan combining marks
+  codePoint >= 3893 && codePoint <= 3893 || // Tibetan combining marks
+  codePoint >= 3895 && codePoint <= 3895 || // Tibetan combining marks
+  codePoint >= 3897 && codePoint <= 3897 || // Tibetan combining marks
+  codePoint >= 3953 && codePoint <= 3966 || // Tibetan combining marks
+  codePoint >= 3968 && codePoint <= 3972 || // Tibetan combining marks
+  codePoint >= 3974 && codePoint <= 3975 || // Tibetan combining marks
+  codePoint >= 3984 && codePoint <= 3991 || // Tibetan combining marks
+  codePoint >= 3993 && codePoint <= 4028 || // Tibetan combining marks
+  codePoint >= 4038 && codePoint <= 4038 || // Tibetan combining marks
+  codePoint >= 4146 && codePoint <= 4151 || // Myanmar combining marks
+  codePoint >= 4153 && codePoint <= 4154 || // Myanmar combining marks
+  codePoint >= 4157 && codePoint <= 4158 || // Myanmar combining marks
+  codePoint >= 4184 && codePoint <= 4185 || // Myanmar combining marks
+  codePoint >= 4190 && codePoint <= 4192 || // Myanmar combining marks
+  codePoint >= 4209 && codePoint <= 4212 || // Myanmar combining marks
+  codePoint >= 4226 && codePoint <= 4226 || // Myanmar combining marks
+  codePoint >= 4229 && codePoint <= 4230 || // Myanmar combining marks
+  codePoint >= 4237 && codePoint <= 4237 || // Myanmar combining marks
+  codePoint >= 4957 && codePoint <= 4959 || // Ethiopic combining marks
+  codePoint >= 5906 && codePoint <= 5908 || // Tagalog combining marks
+  codePoint >= 5938 && codePoint <= 5940 || // Hanunoo combining marks
+  codePoint >= 5970 && codePoint <= 5971 || // Buhid combining marks
+  codePoint >= 6002 && codePoint <= 6003 || // Tagbanwa combining marks
+  codePoint >= 6068 && codePoint <= 6069 || // Khmer combining marks
+  codePoint >= 6071 && codePoint <= 6077 || // Khmer combining marks
+  codePoint >= 6086 && codePoint <= 6086 || // Khmer combining marks
+  codePoint >= 6089 && codePoint <= 6099 || // Khmer combining marks
+  codePoint >= 6109 && codePoint <= 6109 || // Khmer combining marks
+  codePoint >= 6155 && codePoint <= 6157 || // Mongolian combining marks
+  codePoint >= 6313 && codePoint <= 6313 || // Mongolian combining marks
+  codePoint >= 6432 && codePoint <= 6434 || // Limbu combining marks
+  codePoint >= 6439 && codePoint <= 6440 || // Limbu combining marks
+  codePoint >= 6450 && codePoint <= 6450 || // Limbu combining marks
+  codePoint >= 6457 && codePoint <= 6459 || // Limbu combining marks
+  codePoint >= 6679 && codePoint <= 6680 || // Buginese combining marks
+  codePoint >= 6912 && codePoint <= 6915 || // Balinese combining marks
+  codePoint >= 6964 && codePoint <= 6964 || // Balinese combining marks
+  codePoint >= 6966 && codePoint <= 6970 || // Balinese combining marks
+  codePoint >= 6972 && codePoint <= 6972 || // Balinese combining marks
+  codePoint >= 6978 && codePoint <= 6978 || // Balinese combining marks
+  codePoint >= 7019 && codePoint <= 7027 || // Balinese combining marks
+  codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks Supplement
+  codePoint >= 8400 && codePoint <= 8432 || // Combining Diacritical Marks for Symbols
+  codePoint >= 11503 && codePoint <= 11505 || // Coptic combining marks
+  codePoint >= 11647 && codePoint <= 11647 || // Tifinagh combining marks
+  codePoint >= 11744 && codePoint <= 11775 || // Cyrillic Extended-A combining marks
+  codePoint >= 42607 && codePoint <= 42610 || // Cyrillic Extended-B combining marks
+  codePoint >= 42612 && codePoint <= 42621 || // Cyrillic Extended-B combining marks
+  codePoint >= 42654 && codePoint <= 42655 || // Cyrillic Extended-B combining marks
+  codePoint >= 42736 && codePoint <= 42737 || // Bamum combining marks
+  codePoint >= 43010 && codePoint <= 43010 || // Syloti Nagri combining marks
+  codePoint >= 43014 && codePoint <= 43014 || // Syloti Nagri combining marks
+  codePoint >= 43019 && codePoint <= 43019 || // Syloti Nagri combining marks
+  codePoint >= 43045 && codePoint <= 43046 || // Syloti Nagri combining marks
+  codePoint >= 43204 && codePoint <= 43204 || // Saurashtra combining marks
+  codePoint >= 43232 && codePoint <= 43249 || // Devanagari Extended combining marks
+  codePoint >= 43302 && codePoint <= 43309 || // Kayah Li combining marks
+  codePoint >= 43335 && codePoint <= 43345 || // Rejang combining marks
+  codePoint >= 43392 && codePoint <= 43394 || // Javanese combining marks
+  codePoint >= 43443 && codePoint <= 43443 || // Javanese combining marks
+  codePoint >= 43446 && codePoint <= 43449 || // Javanese combining marks
+  codePoint >= 43452 && codePoint <= 43452 || // Javanese combining marks
+  codePoint >= 43561 && codePoint <= 43566 || // Cham combining marks
+  codePoint >= 43569 && codePoint <= 43570 || // Cham combining marks
+  codePoint >= 43573 && codePoint <= 43574 || // Cham combining marks
+  codePoint >= 43587 && codePoint <= 43587 || // Cham combining marks
+  codePoint >= 43596 && codePoint <= 43596 || // Cham combining marks
+  codePoint >= 43696 && codePoint <= 43696 || // Tai Viet combining marks
+  codePoint >= 43698 && codePoint <= 43700 || // Tai Viet combining marks
+  codePoint >= 43703 && codePoint <= 43704 || // Tai Viet combining marks
+  codePoint >= 43710 && codePoint <= 43711 || // Tai Viet combining marks
+  codePoint >= 43713 && codePoint <= 43713 || // Tai Viet combining marks
+  codePoint >= 44005 && codePoint <= 44005 || // Meetei Mayek combining marks
+  codePoint >= 44008 && codePoint <= 44008 || // Meetei Mayek combining marks
+  codePoint >= 44013 && codePoint <= 44013 || // Meetei Mayek combining marks
+  codePoint >= 64286 && codePoint <= 64286 || // Hebrew combining marks
+  codePoint >= 65024 && codePoint <= 65039 || // Variation Selectors
+  codePoint >= 65056 && codePoint <= 65071 || // Combining Half Marks
+  codePoint >= 917760 && codePoint <= 917999) {
+    return 0;
+  }
+  if (codePoint >= 4352 && codePoint <= 4447 || // Hangul Jamo
+  codePoint >= 9001 && codePoint <= 9002 || // Left/Right-pointing angle bracket
+  codePoint >= 11904 && codePoint <= 12350 || // CJK Radicals Supplement, Kangxi Radicals, CJK Symbols
+  codePoint >= 12352 && codePoint <= 13247 || // Hiragana, Katakana, Bopomofo, Hangul Compatibility, Kanbun, CJK Strokes, Enclosed CJK
+  codePoint >= 13312 && codePoint <= 19903 || // CJK Unified Ideographs Extension A
+  codePoint >= 19968 && codePoint <= 42191 || // CJK Unified Ideographs, Yi Syllables, Yi Radicals
+  codePoint >= 43360 && codePoint <= 43388 || // Hangul Jamo Extended-A
+  codePoint >= 44032 && codePoint <= 55203 || // Hangul Syllables
+  codePoint >= 63744 && codePoint <= 64255 || // CJK Compatibility Ideographs
+  codePoint >= 65040 && codePoint <= 65049 || // Vertical forms
+  codePoint >= 65072 && codePoint <= 65135 || // CJK Compatibility Forms, Small Form Variants
+  codePoint >= 65281 && codePoint <= 65376 || // Fullwidth Forms
+  codePoint >= 65504 && codePoint <= 65510 || // Fullwidth Signs
+  codePoint >= 110592 && codePoint <= 111359 || // Kana Supplement, Kana Extended-A, Small Kana Extension
+  codePoint >= 126980 && codePoint <= 126980 || // Mahjong tile
+  codePoint >= 127183 && codePoint <= 127183 || // Playing card
+  codePoint >= 127232 && codePoint <= 129535 || // Enclosed Alphanumeric Supplement, Emoticons, Transport, etc.
+  codePoint >= 129536 && codePoint <= 129647 || // Chess Symbols
+  codePoint >= 129648 && codePoint <= 129791 || // Symbols and Pictographs Extended-A
+  codePoint >= 131072 && codePoint <= 196605 || // CJK Unified Ideographs Extension B–G, CJK Compatibility Supplement
+  codePoint >= 196608 && codePoint <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+
+// src/ui/thinking-line.ts
+var THINKING_SCROLL_CELLS_PER_SEC = 16;
+var THINKING_EASE = 0.18;
+var THINKING_MAX_STEP_MS = 250;
+var THINKING_MAX_STORED_CHARS = 4e3;
+function normalizeThinkingText(text) {
+  return text.replace(/\s+/gu, " ").trim();
+}
+function thinkingDisplayWidth(text) {
+  let width = 0;
+  for (const character of text) width += charWidth(character.codePointAt(0) ?? 32);
+  return width;
+}
+function sliceThinkingByWidth(text, startCell, cellCount) {
+  let out = "";
+  let cell = 0;
+  for (const character of text) {
+    const w = charWidth(character.codePointAt(0) ?? 32);
+    if (cell + w > startCell && cell < startCell + cellCount) out += character;
+    cell += w;
+    if (cell >= startCell + cellCount) break;
+  }
+  return out;
+}
+function thinkingWindow(text, previousStart, options) {
+  const normalized = normalizeThinkingText(text);
+  const width = Math.max(1, Math.floor(options.width));
+  const total = thinkingDisplayWidth(normalized);
+  if (total <= width) return { text: normalized, start: 0 };
+  const maxStart = total - width;
+  const from = Math.min(Math.max(0, previousStart), maxStart);
+  const cellsPerSecond = options.cellsPerSecond ?? THINKING_SCROLL_CELLS_PER_SEC;
+  const ease = options.ease ?? THINKING_EASE;
+  const dt = Math.max(0, Math.min(options.dtMs, THINKING_MAX_STEP_MS));
+  const lag = maxStart - from;
+  const step = Math.max(cellsPerSecond * dt / 1e3, lag * ease);
+  const start = Math.min(maxStart, Math.floor(from + step));
+  return { text: sliceThinkingByWidth(normalized, start, width), start };
+}
+function appendThinkingText(previous, delta) {
+  const next = (previous ?? "") + delta;
+  return next.length > THINKING_MAX_STORED_CHARS ? next.slice(-THINKING_MAX_STORED_CHARS) : next;
+}
+
 // src/ui/transcript.ts
 function createTranscriptState() {
   return { completed: [], nextId: 1 };
@@ -1178,6 +1403,9 @@ function transcriptReducer(state, action) {
   if (event.type === "text") {
     return { ...state, active: addText(withoutModelActivity(state.active), event.text) };
   }
+  if (event.type === "thinking") {
+    return { ...state, active: attachThinking(state.active, event.text) };
+  }
   if (event.type === "tool-start") return upsertStatus({ ...state, active: withoutModelActivity(state.active) }, {
     kind: "status",
     id: `tool:${event.id}`,
@@ -1478,6 +1706,18 @@ function finishActive(state) {
     ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
   };
 }
+function attachThinking(turn, text) {
+  const blocks = [...turn.blocks];
+  const index = blocks.findIndex((block2) => block2.kind === "status" && block2.activity === "model" && block2.state === "running");
+  if (index < 0) return turn;
+  const block = blocks[index];
+  if (block === void 0 || block.kind !== "status") return turn;
+  blocks[index] = {
+    ...block,
+    thinkingText: appendThinkingText(block.thinkingText, text)
+  };
+  return { ...turn, blocks };
+}
 function withoutModelActivity(turn, id) {
   const blocks = turn.blocks.filter((block) => block.kind !== "status" || block.activity !== "model" || id !== void 0 && block.id !== id);
   if (blocks.length === turn.blocks.length) return turn;
@@ -2984,6 +3224,7 @@ var MVP_COMMANDS = [
   "mcp",
   "commit",
   "review",
+  "explain",
   "ide",
   "memory",
   "remember",
@@ -3022,6 +3263,7 @@ var COMMAND_DESCRIPTIONS = {
   evolve: "Self-improvement loop: capture failures, suggest fixes, verify with tests",
   commit: "Generate a commit message for staged changes and commit after confirmation",
   review: "Review uncommitted changes for bugs and risks before committing",
+  explain: "Explain a symbol for newcomers (AST graph + source + git history)",
   mcp: "Manage MCP servers",
   ide: "Show the connected IDE and editor context",
   memory: "Show long-term project memory",
@@ -3098,6 +3340,12 @@ function parseSlashCommand(input, dynamicCommands = [], skillCommands = [], mana
     const focus = args.join(" ").trim();
     return focus.length === 0 ? { name } : { name, focus };
   }
+  if (name === "explain") {
+    const [query, ...focusParts] = args;
+    if (query === void 0) return { name };
+    const focus = focusParts.join(" ").trim();
+    return focus.length === 0 ? { name, query } : { name, query, focus };
+  }
   if (name === "loop") {
     const goal = args.join(" ").trim();
     if (!goal) return { name: "invalid", command: name, message: "Use /loop <goal>." };
@@ -3701,6 +3949,14 @@ var FlavorSession = class {
       this.#notice(await required(this.#services.gitCommit, "commit")(command.hint, signal));
     } else if (command.name === "review") {
       this.#notice(await required(this.#services.gitReview, "review")(command.focus, signal));
+    } else if (command.name === "explain") {
+      const result = await required(this.#services.explain, "explain")(
+        command.query,
+        command.focus,
+        signal,
+        (chunk) => this.#services.output({ type: "text", text: chunk })
+      );
+      if (result !== "") this.#notice(result);
     } else if (command.name === "mcp") {
       this.#notice(await this.#services.mcp(command, signal));
     } else if (command.name === "pals") {
@@ -3867,9 +4123,9 @@ var FlavorSession = class {
   }
   #waitForPlanningIdle(key) {
     if (!this.#activePlanning.has(key)) return Promise.resolve();
-    return new Promise((resolve28) => {
+    return new Promise((resolve29) => {
       const check = () => {
-        if (!this.#activePlanning.has(key)) resolve28();
+        if (!this.#activePlanning.has(key)) resolve29();
         else this.#planningIdleWaiters.add(check);
       };
       this.#planningIdleWaiters.add(check);
@@ -4217,12 +4473,12 @@ var BrokerStateError = class extends Error {
 };
 var WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
 function canConnect(address) {
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const socket = new Socket();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve28(connected);
+      resolve29(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -4271,7 +4527,7 @@ var PalBrokerServer = class {
     this.authToken ??= await loadOrCreatePalAuthToken(this.authHome === void 0 ? {} : { home: this.authHome });
     try {
       await this.prepareAddress();
-      await new Promise((resolve28, reject) => {
+      await new Promise((resolve29, reject) => {
         const onError = (error) => {
           this.server.off("listening", onListening);
           reject(error);
@@ -4280,7 +4536,7 @@ var PalBrokerServer = class {
           this.server.off("error", onError);
           this.started = true;
           this.ownsAddress = true;
-          resolve28();
+          resolve29();
         };
         this.server.once("error", onError);
         this.server.once("listening", onListening);
@@ -4308,7 +4564,7 @@ var PalBrokerServer = class {
     const ownsAddress = this.ownsAddress;
     for (const connection of this.connections) connection.socket.destroy();
     if (this.started) {
-      await new Promise((resolve28) => this.server.close(() => resolve28()));
+      await new Promise((resolve29) => this.server.close(() => resolve29()));
       this.started = false;
     }
     this.ownsAddress = false;
@@ -4327,8 +4583,8 @@ var PalBrokerServer = class {
     });
     if (this.endpointLock === void 0) throw new Error(`Pals endpoint '${this.address}' is active or owned`);
     try {
-      const stat9 = await lstat3(this.address);
-      if (!stat9.isSocket()) throw new Error(`Refusing to unlink '${this.address}' because it is not a socket`);
+      const stat10 = await lstat3(this.address);
+      if (!stat10.isSocket()) throw new Error(`Refusing to unlink '${this.address}' because it is not a socket`);
       await unlink3(this.address);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -4341,8 +4597,8 @@ var PalBrokerServer = class {
   }
   async unlinkKnownSocket() {
     try {
-      const stat9 = await lstat3(this.address);
-      if (stat9.isSocket()) await unlink3(this.address);
+      const stat10 = await lstat3(this.address);
+      if (stat10.isSocket()) await unlink3(this.address);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
@@ -4977,15 +5233,15 @@ var PalBrokerState = class {
 // src/pals/broker-cli.ts
 var startupAttempts = /* @__PURE__ */ new Map();
 function delay(milliseconds) {
-  return new Promise((resolve28) => setTimeout(resolve28, milliseconds));
+  return new Promise((resolve29) => setTimeout(resolve29, milliseconds));
 }
 function canConnect2(address) {
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const socket = new Socket2();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve28(connected);
+      resolve29(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -5028,8 +5284,8 @@ async function runPalBroker(options) {
   const sweepIntervalMs = options.sweepIntervalMs ?? 5e3;
   const idleShutdownMs = options.idleShutdownMs ?? 3e4;
   let resolveClosed;
-  const closed = new Promise((resolve28) => {
-    resolveClosed = resolve28;
+  const closed = new Promise((resolve29) => {
+    resolveClosed = resolve29;
   });
   let closing;
   const timer = setInterval(() => {
@@ -5072,7 +5328,7 @@ async function ensureOnce(options) {
 import { readFile as readFile22 } from "fs/promises";
 import { createHash as createHash18, randomUUID as randomUUID20 } from "crypto";
 import { homedir as homedir2, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename6, join as join25, relative as relative20, resolve as resolve27, sep as sep20 } from "path";
+import { basename as basename6, join as join26, relative as relative20, resolve as resolve28, sep as sep20 } from "path";
 
 // src/agent/subagents.ts
 import { z as z5 } from "zod";
@@ -6341,7 +6597,12 @@ function providerValidMessages(input) {
       const calls = original.toolCalls.filter((call) => call.id && call.name && availableResults.has(call.id));
       calls.forEach((call) => announced.add(call.id));
       if (!original.content && calls.length === 0) continue;
-      output.push({ role: "assistant", content: original.content, ...calls.length === 0 ? {} : { toolCalls: calls.map((call) => ({ ...call })) } });
+      output.push({
+        role: "assistant",
+        content: original.content,
+        ...calls.length === 0 ? {} : { toolCalls: calls.map((call) => ({ ...call })) },
+        ...original.thinkingBlocks === void 0 ? {} : { thinkingBlocks: original.thinkingBlocks.map((block) => ({ ...block })) }
+      });
       continue;
     }
     if (original.role === "tool") {
@@ -6919,10 +7180,10 @@ function sanitize(message2, secrets) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve29, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve28();
+      resolve29();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -7064,6 +7325,7 @@ var AgentLoop = class {
       }
       let assistantText = "";
       const collectedToolCalls = [];
+      const collectedThinking = [];
       let completed = false;
       let reactiveRetried = false;
       let attempt = 1;
@@ -7101,6 +7363,7 @@ var AgentLoop = class {
         }
         assistantText = "";
         collectedToolCalls.length = 0;
+        collectedThinking.length = 0;
         completed = false;
         let terminalError;
         let providerError = false;
@@ -7121,6 +7384,10 @@ var AgentLoop = class {
               assistantText += event.text;
               accumulatedText += event.text;
               yield event;
+            } else if (event.type === "thinking") {
+              yield event;
+            } else if (event.type === "thinking-block") {
+              collectedThinking.push({ text: event.text, ...event.signature === void 0 ? {} : { signature: event.signature } });
             } else if (event.type === "tool-call") {
               collectedToolCalls.push({ kind: "valid", id: event.id, name: event.name, input: event.input });
             } else if (event.type === "invalid-tool-call") {
@@ -7468,7 +7735,8 @@ var AgentLoop = class {
       const assistantMessage = {
         role: "assistant",
         content: assistantText,
-        toolCalls: toolCalls.map(({ id, name, input }) => ({ id, name, input }))
+        toolCalls: toolCalls.map(({ id, name, input }) => ({ id, name, input })),
+        ...collectedThinking.length === 0 ? {} : { thinkingBlocks: collectedThinking.map((block) => ({ ...block })) }
       };
       this.#options.context.appendMany([assistantMessage, ...stagedMessages]);
       for (const { call, result } of stagedResults) {
@@ -7526,10 +7794,10 @@ function serializeToolInput(input) {
 }
 function waitForRetry2(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve29, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve28();
+      resolve29();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -8735,7 +9003,7 @@ function decoratePayload(payload, envelope) {
   return envelope === void 0 ? payload : { ...payload, ...envelope };
 }
 function runShellHandler(descriptor, event, signal) {
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve29, reject) => {
     const child = spawn4(descriptor.command, [...descriptor.args ?? []], {
       env: { ...process.env, ...descriptor.env },
       shell: false,
@@ -8778,7 +9046,7 @@ function runShellHandler(descriptor, event, signal) {
         return;
       }
       try {
-        resolve28(HookDecisionSchema.parse(JSON.parse(stdout)));
+        resolve29(HookDecisionSchema.parse(JSON.parse(stdout)));
       } catch (error) {
         reject(error);
       }
@@ -8975,14 +9243,14 @@ async function createIslandControlServer(options) {
       void dispatch(line, socket, options, token);
     });
   });
-  await new Promise((resolve28, reject) => {
+  await new Promise((resolve29, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve28();
+      resolve29();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -9053,11 +9321,11 @@ function write(socket, payload) {
   }
 }
 function closeServer(server) {
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     try {
-      server.close(() => resolve28());
+      server.close(() => resolve29());
     } catch {
-      resolve28();
+      resolve29();
     }
   });
 }
@@ -10242,7 +10510,7 @@ var USAGE = [
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const isWindows = process.platform === "win32";
     const child = spawn5(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
       cwd,
@@ -10252,7 +10520,7 @@ function runCommand(command, cwd, timeoutMs) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve28({ ok: false, stdout, stderr: `${stderr}
+      resolve29({ ok: false, stdout, stderr: `${stderr}
 [killed: exceeded ${timeoutMs}ms]`, code: "timeout" });
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
@@ -10263,12 +10531,12 @@ function runCommand(command, cwd, timeoutMs) {
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve28({ ok: false, stdout, stderr: `${stderr}
+      resolve29({ ok: false, stdout, stderr: `${stderr}
 ${error.message}`, code: "spawn" });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve28({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
+      resolve29({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
     });
   });
 }
@@ -12725,6 +12993,7 @@ var CLAUDE_CLIENT_HEADERS = {
   "x-app": "cli"
 };
 var DEFAULT_MAX_OUTPUT_TOKENS = 32768;
+var DEFAULT_THINKING_BUDGET = 8192;
 var MAX_CACHE_MARKERS = 4;
 function collectCacheMarkers(system, messages) {
   const markers = [];
@@ -12783,9 +13052,26 @@ function formatCacheUsage(model, snapshot4, shape) {
     ...shape === void 0 ? {} : { requestMessages: shape.messages, requestMarkers: shape.markers }
   });
 }
+function stripThinkingBlocks(messages) {
+  for (const message2 of messages) {
+    if (message2.role !== "assistant" || !Array.isArray(message2.content)) continue;
+    const blocks = message2.content;
+    if (!blocks.some((block) => block?.type === "thinking")) continue;
+    message2.content = blocks.filter((block) => block?.type !== "thinking");
+  }
+}
+function isThinkingParamRejected(error) {
+  const status = error?.status;
+  if (status !== void 0 && status !== 400) return false;
+  const message2 = error instanceof Error ? error.message : String(error ?? "");
+  return /\bthinking\b/iu.test(message2) && /(budget_tokens|expected|not supported|unsupported|unknown|invalid|extra inputs|unrecognized)/iu.test(message2);
+}
 var AnthropicModelAdapter = class {
   client;
   maxOutputTokens;
+  thinkingBudget;
+  /** Set once an endpoint rejects the `thinking` parameter; later requests stop sending it. */
+  #thinkingRejected = false;
   debugUsage;
   constructor(options) {
     const maxOutputTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
@@ -12793,6 +13079,7 @@ var AnthropicModelAdapter = class {
       throw new Error("maxOutputTokens must be a positive integer");
     }
     this.maxOutputTokens = maxOutputTokens;
+    this.thinkingBudget = options.thinkingBudget ?? DEFAULT_THINKING_BUDGET;
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
     this.client = options.client ?? new Anthropic({
       ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
@@ -12800,6 +13087,16 @@ var AnthropicModelAdapter = class {
       ...options.headers === void 0 ? {} : { defaultHeaders: options.headers }
     });
   }
+  /**
+   * Extended-thinking request parameter when enabled, otherwise undefined.
+   * Anthropic requires the budget to fit inside max_tokens with a 1024 floor.
+   */
+  #thinkingParam() {
+    if (this.#thinkingRejected || this.thinkingBudget <= 0) return void 0;
+    const budget = Math.min(this.thinkingBudget, this.maxOutputTokens - 1);
+    if (budget < 1024) return void 0;
+    return { type: "enabled", budget_tokens: budget };
+  }
   #logUsage(request, snapshot4, shape) {
     const line = formatCacheUsage(request.model, snapshot4, shape);
     if (this.debugUsage) {
@@ -12855,7 +13152,13 @@ var AnthropicModelAdapter = class {
           }
           messages.push({ role: "user", content: results });
         } else if (message2.role === "assistant" && message2.toolCalls?.length) {
+          const echoThinking = this.#thinkingRejected ? [] : (message2.thinkingBlocks ?? []).filter((block) => block.signature !== void 0);
           const content = [
+            ...echoThinking.map((block) => ({
+              type: "thinking",
+              thinking: block.text,
+              signature: block.signature
+            })),
             ...modelContentText(message2.content) ? [{ type: "text", text: modelContentText(message2.content) }] : [],
             ...message2.toolCalls.map((call) => ({
               type: "tool_use",
@@ -12917,18 +13220,56 @@ var AnthropicModelAdapter = class {
         stream: true,
         messages,
         ...system ? { system } : {},
+        ...(() => {
+          const thinking = this.#thinkingParam();
+          return thinking === void 0 ? {} : { thinking };
+        })(),
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           name: tool.name,
           description: tool.description,
           input_schema: { ...tool.inputSchema, type: "object" }
         }))
       };
-      const stream = await this.client.messages.create(body, { signal: request.signal });
+      let stream;
+      try {
+        stream = await this.client.messages.create(body, { signal: request.signal });
+      } catch (error) {
+        if (this.thinkingBudget > 0 && !this.#thinkingRejected && isThinkingParamRejected(error)) {
+          this.#thinkingRejected = true;
+          delete body.thinking;
+          stripThinkingBlocks(body.messages);
+          stream = await this.client.messages.create(body, { signal: request.signal });
+        } else {
+          throw error;
+        }
+      }
+      const thinkingBuffers = /* @__PURE__ */ new Map();
       for await (const event of stream) {
         if (event.type === "message_start") {
           hasUsage = event.message?.usage !== void 0;
           inputTokens = updateInputUsage(inputUsage, event.message?.usage);
           outputTokens = event.message?.usage?.output_tokens ?? outputTokens;
+        } else if (event.type === "content_block_start" && event.content_block?.type === "thinking" && event.index !== void 0) {
+          thinkingBuffers.set(event.index, { text: "" });
+        } else if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta") {
+          if (event.index !== void 0 && event.delta.thinking) {
+            const pending = thinkingBuffers.get(event.index);
+            if (pending) pending.text += event.delta.thinking;
+          }
+          if (event.delta.thinking) yield { type: "thinking", text: event.delta.thinking };
+        } else if (event.type === "content_block_delta" && event.delta?.type === "signature_delta" && event.index !== void 0) {
+          const pending = thinkingBuffers.get(event.index);
+          if (pending) pending.signature = (pending.signature ?? "") + (event.delta.signature ?? "");
+        } else if (event.type === "content_block_stop" && event.index !== void 0 && thinkingBuffers.has(event.index)) {
+          const pending = thinkingBuffers.get(event.index);
+          if (pending.text.length > 0 || pending.signature !== void 0) {
+            yield {
+              type: "thinking-block",
+              text: pending.text,
+              ...pending.signature === void 0 ? {} : { signature: pending.signature }
+            };
+          }
+          thinkingBuffers.delete(event.index);
         } else if (event.type === "content_block_start" && event.content_block?.type === "tool_use" && event.index !== void 0 && event.content_block.id && event.content_block.name) {
           pendingTools.set(event.index, {
             id: event.content_block.id,
@@ -13131,12 +13472,14 @@ function formatOpenAIUsage(model, breakdown) {
 var OpenAIModelAdapter = class {
   client;
   debugUsage;
+  thinkingEffort;
   constructor(options) {
     this.client = options.client ?? new OpenAI({
       ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
       ...options.baseURL === void 0 ? {} : { baseURL: options.baseURL }
     });
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
+    this.thinkingEffort = options.thinkingEffort;
   }
   #logUsage(model, breakdown) {
     if (breakdown === void 0) return;
@@ -13158,6 +13501,7 @@ var OpenAIModelAdapter = class {
       const body = {
         model: request.model,
         input: (await Promise.all(request.messages.map(toInput))).flat(),
+        ...this.thinkingEffort === void 0 ? {} : { reasoning: { effort: this.thinkingEffort } },
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           type: "function",
           name: tool.name,
@@ -13190,6 +13534,8 @@ var OpenAIModelAdapter = class {
           }
         } else if (event.type === "response.output_text.delta" && event.delta) {
           yield { type: "text", text: event.delta };
+        } else if ((event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_text.delta") && event.delta) {
+          yield { type: "thinking", text: event.delta };
         } else if (event.type === "response.function_call_arguments.done" && event.output_index !== void 0 && event.name) {
           const callId = callIds.get(event.output_index);
           if (callId && !emittedCalls.has(event.output_index)) {
@@ -13706,8 +14052,8 @@ var OAuthCallbackAuthProvider = class {
   async #startCallbackServer(expectedState, signal) {
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve28, reject) => {
-      serverResolve = resolve28;
+    const codePromise = new Promise((resolve29, reject) => {
+      serverResolve = resolve29;
       serverReject = reject;
     });
     const server = createServer3((req, res) => {
@@ -13741,7 +14087,7 @@ var OAuthCallbackAuthProvider = class {
       );
       serverResolve(code);
     });
-    return new Promise((resolve28, reject) => {
+    return new Promise((resolve29, reject) => {
       server.once("error", (error) => {
         reject(new Error(`OAuth callback server failed: ${error.message}`));
       });
@@ -13758,7 +14104,7 @@ var OAuthCallbackAuthProvider = class {
         signal.addEventListener("abort", () => {
           serverReject(new Error("OAuth flow aborted"));
         }, { once: true });
-        resolve28({ redirectUri, promise: codePromise });
+        resolve29({ redirectUri, promise: codePromise });
       });
     });
   }
@@ -16897,8 +17243,8 @@ var LspConnection = class {
     const id = this.#nextId++;
     const request = { jsonrpc: "2.0", id, method, params };
     const timeout = AbortSignal.timeout(LSP_REQUEST_TIMEOUT_MS);
-    const promise = new Promise((resolve28, reject) => {
-      this.#pending.set(id, { resolve: resolve28, reject });
+    const promise = new Promise((resolve29, reject) => {
+      this.#pending.set(id, { resolve: resolve29, reject });
       timeout.addEventListener("abort", () => {
         if (this.#pending.has(id)) {
           this.#pending.delete(id);
@@ -17302,19 +17648,19 @@ async function changeSummary(workspace) {
   };
 }
 async function stagedDiff(workspace, maxChars = 96e3) {
-  const stat9 = await git2(workspace, ["diff", "--staged", "--stat"]);
+  const stat10 = await git2(workspace, ["diff", "--staged", "--stat"]);
   const diff = await git2(workspace, ["diff", "--staged", "--no-ext-diff", "--no-color"]);
   if (!diff.ok) throw gitFailure(diff, "diff --staged");
   const text = diff.stdout;
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat9.stdout.trim(),
+    stat: stat10.stdout.trim(),
     truncated: text.length > maxChars
   };
 }
 async function uncommittedDiff(workspace, maxChars = 96e3) {
-  const stat9 = await git2(workspace, ["diff", "HEAD", "--stat"]);
+  const stat10 = await git2(workspace, ["diff", "HEAD", "--stat"]);
   const diff = await git2(workspace, ["diff", "HEAD", "--no-ext-diff", "--no-color"]);
   if (!diff.ok && !diff.stderr.includes("unknown revision")) throw gitFailure(diff, "diff HEAD");
   const summary2 = await changeSummary(workspace);
@@ -17322,7 +17668,7 @@ async function uncommittedDiff(workspace, maxChars = 96e3) {
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat9.stdout.trim(),
+    stat: stat10.stdout.trim(),
     untracked: summary2.untrackedFiles
   };
 }
@@ -17463,6 +17809,232 @@ function formatReviewReport(report) {
   return lines.join("\n");
 }
 
+// src/explain/service.ts
+async function resolveExplainTarget(graph, query) {
+  const trimmed = query.trim();
+  if (trimmed.includes("#")) {
+    const hit = await graph.relations(trimmed).catch(() => void 0);
+    if (hit?.origin !== void 0) return { kind: "resolved", node: hit.origin };
+  }
+  const hits = await graph.search(trimmed, 10);
+  if (hits.length === 0) return { kind: "not-found", query: trimmed };
+  if (hits.length === 1) return { kind: "resolved", node: hits[0] };
+  return { kind: "ambiguous", candidates: hits };
+}
+function explainCandidateLabel(candidate) {
+  return candidate.id;
+}
+async function selectExplainCandidate(candidates, questions, signal) {
+  const shown = candidates.slice(0, 3);
+  const answers = await questions.ask([{
+    header: "Symbol",
+    question: "Multiple symbols match. Which one should /explain cover? (Pick one, or type a more exact name.)",
+    options: [
+      ...shown.map((candidate) => ({
+        label: explainCandidateLabel(candidate),
+        description: `${candidate.kind} \xB7 ${candidate.filePath}:${candidate.startLine}-${candidate.endLine}`
+      })),
+      { label: "Cancel", description: "Abort /explain without choosing." }
+    ]
+  }], signal);
+  const answer = (answers[0] ?? "").trim();
+  if (answer === "Cancel" || answer === "") return { kind: "cancelled" };
+  const picked = shown.find((candidate) => explainCandidateLabel(candidate) === answer);
+  if (picked !== void 0) return { kind: "picked", node: picked };
+  return { kind: "typed", query: answer };
+}
+var MAX_SOURCE_CHARS = 2e4;
+function buildExplainPrompt(input) {
+  const source = input.anchorSource.length > MAX_SOURCE_CHARS ? `${input.anchorSource.slice(0, MAX_SOURCE_CHARS)}
+\u2026 (truncated)` : input.anchorSource;
+  const line = (n) => `- ${n.name} \u2014 ${n.filePath}:${n.startLine}`;
+  return [
+    "You are a senior engineer onboarding a new team member. Explain the following code symbol clearly and concretely; never invent behavior that is not in the shown evidence.",
+    `Answer in ${input.language}.`,
+    "Structure the answer with short markdown sections:",
+    "1. \u5B83\u662F\u505A\u4EC0\u4E48\u7684 \u2014 one paragraph, plain language, beginner first.",
+    "2. \u5173\u952E\u5B9E\u73B0\u70B9 \u2014 2-5 bullets tied to concrete lines/branches in the source.",
+    "3. \u8C01\u8C03\u7528\u5B83 / \u5B83\u8C03\u7528\u8C01 \u2014 use the relation lists; explain the data flow in one or two sentences.",
+    "4. \u4E3A\u4EC0\u4E48\u8FD9\u6837\u5199 \u2014 infer from the recent commit subjects when possible; say '\u4E0D\u786E\u5B9A' instead of guessing.",
+    "5. \u65B0\u4EBA\u6CE8\u610F\u4E8B\u9879 \u2014 pitfalls, guards or invariants worth knowing.",
+    ...input.focus === void 0 || input.focus.trim() === "" ? [] : [`The user specifically asks about: ${input.focus.trim()}`],
+    "",
+    `Symbol: ${input.anchor.id} (${input.anchor.kind}${input.anchor.signature ? `, signature: ${input.anchor.signature}` : ""})`,
+    "",
+    `Source (${input.anchor.filePath}:${input.anchor.startLine}-${input.anchor.endLine}):`,
+    source,
+    "",
+    `Callers:
+${input.callers.map(line).join("\n") || "- (none)"}`,
+    `Callees:
+${input.callees.map(line).join("\n") || "- (none)"}`,
+    "",
+    `Recent commits touching the file:
+${input.history.map((h) => `- ${h.date} ${h.author}: ${h.subject}`).join("\n") || "- (no history)"}`
+  ].join("\n");
+}
+async function explainWithModel(options, prompt, signal, onText) {
+  const { adapter, model } = options.registry.get(options.modelId());
+  let text = "";
+  for await (const event of adapter.stream({
+    model,
+    messages: [{ role: "user", content: prompt }],
+    tools: [],
+    signal
+  })) {
+    if (event.type === "text") {
+      text += event.text;
+      onText?.(event.text);
+    } else if (event.type === "error") throw new Error(`explain generation failed: ${event.error.message}`);
+    else if (event.type === "done") break;
+  }
+  const cleaned = text.trim();
+  if (cleaned === "") throw new Error("explain generation returned no text");
+  return cleaned;
+}
+var HISTORY_LIMIT = 8;
+var MAX_RESOLVE_ROUNDS = 2;
+async function runExplain(deps, query, focus, signal) {
+  if (query === void 0) {
+    return "Usage: /explain <symbol | file.ts#symbol> [what to focus on]. Example: /explain src/order.ts#cancelOrder error handling";
+  }
+  if (!(await deps.graph.status()).available) {
+    return "The code graph is not built yet \u2014 run /ast init, then try /explain again.";
+  }
+  let target = await resolveExplainTarget(deps.graph, query);
+  for (let round = 1; round <= MAX_RESOLVE_ROUNDS; round += 1) {
+    if (target.kind !== "ambiguous") break;
+    if (deps.questions === void 0) {
+      return `"${query}" is ambiguous. Use the exact node id, e.g. /explain ${target.candidates[0]?.id ?? "path/file.ts#name"}.`;
+    }
+    const selection = await selectExplainCandidate(target.candidates, deps.questions, signal);
+    if (selection.kind === "cancelled") return "/explain cancelled \u2014 no symbol was selected.";
+    if (selection.kind === "picked") {
+      target = { kind: "resolved", node: selection.node };
+      break;
+    }
+    target = await resolveExplainTarget(deps.graph, selection.query);
+    if (round === MAX_RESOLVE_ROUNDS && target.kind === "ambiguous") {
+      return `"${selection.query}" is still ambiguous. Pick one node id explicitly: /explain ${target.candidates[0]?.id ?? "path/file.ts#name"}`;
+    }
+  }
+  if (target.kind === "not-found") {
+    return `No matching symbol for "${target.query}" \u2014 check the name, or refresh the graph with /ast sync.`;
+  }
+  if (target.kind !== "resolved") {
+    return `"${query}" is ambiguous. Pick one node id explicitly: /explain ${target.candidates[0]?.id ?? "path/file.ts#name"}`;
+  }
+  const anchor = target.node;
+  signal.throwIfAborted();
+  deps.notify?.(`Explaining ${anchor.id} \u2026`);
+  const { callers, callees } = await deps.graph.relations(anchor.id, 1);
+  const raw = await deps.readFile(anchor.filePath).catch(() => "");
+  const lines = raw.split("\n");
+  const anchorSource = lines.slice(Math.max(0, anchor.startLine - 1), anchor.endLine).join("\n") || raw;
+  const history = deps.history === void 0 ? [] : await deps.history(anchor.filePath, HISTORY_LIMIT).catch(() => []);
+  try {
+    if (deps.onText !== void 0) deps.onText(`Explain ${anchor.id}
+
+`);
+    const explanation = await explainWithModel(
+      { registry: deps.registry, modelId: deps.modelId },
+      buildExplainPrompt({
+        anchor,
+        anchorSource,
+        callers: callers.map((n) => ({ name: n.name, filePath: n.filePath, startLine: n.startLine })),
+        callees: callees.map((n) => ({ name: n.name, filePath: n.filePath, startLine: n.startLine })),
+        history,
+        ...focus === void 0 ? {} : { focus },
+        language: deps.language
+      }),
+      signal,
+      deps.onText
+    );
+    return deps.onText === void 0 ? `Explain ${anchor.id}
+
+${explanation}` : "";
+  } catch (error) {
+    if (signal.aborted) throw error;
+    return `/explain failed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+// src/desktop/astgraph-service.ts
+import { stat as stat8 } from "fs/promises";
+import { createRequire as nodeCreateRequire } from "module";
+import { join as join22, resolve as resolve22 } from "path";
+var FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature";
+var DesktopAstGraphService = class {
+  #path;
+  constructor(workspace) {
+    this.#path = join22(resolve22(workspace), ".flavor", "astgraph", "index.db");
+  }
+  async status() {
+    if ((await stat8(this.#path).catch(() => void 0))?.isFile() !== true) {
+      return { available: false, path: this.#path, files: 0, nodes: 0, edges: 0 };
+    }
+    return this.#read((db) => {
+      const count = (table) => Number(db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get().count);
+      const metadata = db.prepare("SELECT value FROM project_metadata WHERE key = 'last_index'").get();
+      let indexedAt;
+      try {
+        const at = Number(JSON.parse(metadata?.value ?? "{}").at);
+        if (Number.isFinite(at)) indexedAt = new Date(at).toISOString();
+      } catch {
+      }
+      return { available: true, path: this.#path, files: count("files"), nodes: count("nodes"), edges: count("edges"), ...indexedAt === void 0 ? {} : { indexedAt } };
+    });
+  }
+  async search(query, limit = 40) {
+    const value = query.trim().slice(0, 200);
+    if (value.length === 0 || !(await this.status()).available) return [];
+    return this.#read((db) => db.prepare(`SELECT ${FIELDS} FROM nodes WHERE lower(name) LIKE ? OR lower(qualified_name) LIKE ? ORDER BY CASE WHEN lower(name) = ? THEN 0 ELSE 1 END, name LIMIT ?`).all(`%${value.toLowerCase()}%`, `%${value.toLowerCase()}%`, value.toLowerCase(), Math.min(Math.max(limit, 1), 100)).map(mapNode));
+  }
+  async relations(id, hops = 2) {
+    if (!/^[A-Za-z0-9._:/#@+~-]{1,512}$/.test(id)) throw new Error("Invalid AST node id");
+    if (!(await this.status()).available) return { callers: [], callees: [], impact: [] };
+    return this.#read((db) => {
+      const originRow = db.prepare(`SELECT ${FIELDS} FROM nodes WHERE id = ?`).get(id);
+      const linked = (direction) => {
+        const source = direction === "callers" ? "e.source" : "e.target";
+        const predicate = direction === "callers" ? "e.target = ?" : "e.source = ?";
+        return db.prepare(`SELECT DISTINCT n.${FIELDS.split(", ").join(", n.")} FROM edges e JOIN nodes n ON n.id = ${source} WHERE ${predicate} AND e.kind IN ('calls','imports') LIMIT 100`).all(id).map(mapNode);
+      };
+      const seen = /* @__PURE__ */ new Map();
+      let frontier = [id];
+      for (let hop = 1; hop <= Math.min(Math.max(hops, 1), 4) && frontier.length > 0 && seen.size < 200; hop += 1) {
+        const next = [];
+        for (const current of frontier) {
+          const rows = db.prepare("SELECT source AS other FROM edges WHERE target = ? UNION SELECT target AS other FROM edges WHERE source = ? LIMIT 200").all(current, current);
+          for (const row of rows) if (row.other !== id && !seen.has(row.other)) {
+            seen.set(row.other, hop);
+            next.push(row.other);
+          }
+        }
+        frontier = next;
+      }
+      const impact = [...seen].flatMap(([nodeId, hop]) => {
+        const row = db.prepare(`SELECT ${FIELDS} FROM nodes WHERE id = ?`).get(nodeId);
+        return row === void 0 ? [] : [{ ...mapNode(row), hop }];
+      });
+      return { ...originRow === void 0 ? {} : { origin: mapNode(originRow) }, callers: linked("callers"), callees: linked("callees"), impact };
+    });
+  }
+  #read(run) {
+    const sqlite = nodeCreateRequire(import.meta.url)("node:sqlite");
+    const db = new sqlite.DatabaseSync(this.#path, { readOnly: true });
+    try {
+      return run(db);
+    } finally {
+      db.close();
+    }
+  }
+};
+function mapNode(value) {
+  const row = value;
+  return { id: String(row.id), kind: String(row.kind), name: String(row.name), qualifiedName: String(row.qualified_name), filePath: String(row.file_path), language: String(row.language), startLine: Number(row.start_line), endLine: Number(row.end_line), ...row.signature == null ? {} : { signature: String(row.signature) } };
+}
+
 // src/git/tools.ts
 import { z as z28 } from "zod";
 var GitHistoryInput = z28.object({
@@ -17557,7 +18129,7 @@ var QuestionBridge = class {
     }
   }
   #askLocally(questions, signal) {
-    return new Promise((resolve28, reject) => {
+    return new Promise((resolve29, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
         this.#active = false;
@@ -17571,7 +18143,7 @@ var QuestionBridge = class {
           this.#pending = void 0;
           this.#active = false;
           this.#onChange?.();
-          resolve28(answers);
+          resolve29(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
@@ -17664,7 +18236,7 @@ function createTodoWriteTool() {
 // src/tools/managed.ts
 import { randomUUID as randomUUID16 } from "crypto";
 import { link as link2, lstat as lstat11, mkdir as mkdir17, readFile as readFile19, readdir as readdir8, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname18, join as join22, resolve as resolve22 } from "path";
+import { dirname as dirname18, join as join23, resolve as resolve23 } from "path";
 import { z as z31 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -17706,9 +18278,9 @@ var ManagedToolStore = class {
   #entries = /* @__PURE__ */ new Map();
   #diagnostics = [];
   constructor(options) {
-    this.#workspace = resolve22(options.workspace);
-    this.#projectRoot = join22(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join22(resolve22(options.home), ".flavor-code", "tools");
+    this.#workspace = resolve23(options.workspace);
+    this.#projectRoot = join23(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join23(resolve23(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -17755,7 +18327,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join22(this.directory(input.scope), filename(input.name));
+    const path = join23(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record, void 0, 2)}
 `);
@@ -17780,7 +18352,7 @@ var ManagedToolStore = class {
     if (!parsed.success) return [];
     const matches = this.#matching(parsed.data.name).filter((entry2) => parsed.data.scope === void 0 || entry2.scope === parsed.data.scope);
     if (matches.length > 0) return matches.map((entry2) => entry2.path);
-    return [join22(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join23(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -17793,7 +18365,7 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join22(root, name);
+      const path = join23(root, name);
       try {
         const info = await lstat11(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
@@ -18712,7 +19284,7 @@ ${total}`;
 // src/memory/store.ts
 import { createHash as createHash16 } from "crypto";
 import { readFile as readFile20, rm as rm9 } from "fs/promises";
-import { resolve as resolve23, join as join23, relative as relative17, sep as sep17 } from "path";
+import { resolve as resolve24, join as join24, relative as relative17, sep as sep17 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -18814,10 +19386,10 @@ var MemoryStore = class {
   constructor(options) {
     if (!Number.isSafeInteger(options.maxEntries) || options.maxEntries < 1) throw new Error("maxEntries must be an integer of at least 1");
     if (!Number.isSafeInteger(options.maxEntryChars) || options.maxEntryChars < 1) throw new Error("maxEntryChars must be an integer of at least 1");
-    this.workspace = resolve23(options.workspace);
-    this.#memoryRoot = join23(this.workspace, ".flavor", "memory");
-    this.path = join23(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join23(this.#memoryRoot, "behavior.json");
+    this.workspace = resolve24(options.workspace);
+    this.#memoryRoot = join24(this.workspace, ".flavor", "memory");
+    this.path = join24(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join24(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -19040,7 +19612,7 @@ var MemoryStore = class {
   }
   #resolveContentPath(contentPath) {
     if (!/^tasks\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.md$/.test(contentPath)) throw new Error("Invalid memory content path");
-    const path = resolve23(this.#memoryRoot, ...contentPath.split("/"));
+    const path = resolve24(this.#memoryRoot, ...contentPath.split("/"));
     const rel = relative17(this.#memoryRoot, path);
     if (rel === ".." || rel.startsWith(`..${sep17}`)) throw new Error("Memory content path escapes the memory directory");
     return path;
@@ -19511,8 +20083,8 @@ function createExecutionEnvironment(workspace, config) {
 }
 
 // src/ide/client.ts
-import { readFile as readFile21, readdir as readdir9, stat as stat8 } from "fs/promises";
-import { basename as basename5, join as join24, relative as relative18, resolve as resolve24, sep as sep18 } from "path";
+import { readFile as readFile21, readdir as readdir9, stat as stat9 } from "fs/promises";
+import { basename as basename5, join as join25, relative as relative18, resolve as resolve25, sep as sep18 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -19523,8 +20095,8 @@ var FlavorIdeClient = class {
   #sessionId;
   #eventTail = Promise.resolve();
   constructor(options) {
-    this.#workspace = resolve24(options.workspace);
-    this.#home = resolve24(options.home);
+    this.#workspace = resolve25(options.workspace);
+    this.#home = resolve25(options.home);
     this.#environment = options.environment ?? process.env;
     this.#fetch = options.fetch ?? fetch;
   }
@@ -19608,7 +20180,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join24(this.#home, ".flavor-code", "ide");
+    const directory = join25(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir9(directory)).filter((name) => name.endsWith(".lock"));
@@ -19616,9 +20188,9 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join24(directory, name);
+      const path = join25(directory, name);
       try {
-        const [contents, info] = await Promise.all([readFile21(path, "utf8"), stat8(path)]);
+        const [contents, info] = await Promise.all([readFile21(path, "utf8"), stat9(path)]);
         const lock = parseLockfile(contents);
         return lock === void 0 ? void 0 : { lock, modified: info.mtimeMs };
       } catch {
@@ -19722,8 +20294,8 @@ function parsePort(value) {
   return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
 }
 function isWithin8(parent, child) {
-  const base = normalize(resolve24(parent));
-  const target = normalize(resolve24(child));
+  const base = normalize(resolve25(parent));
+  const target = normalize(resolve25(child));
   return target === base || target.startsWith(`${base}${sep18}`);
 }
 function normalize(path) {
@@ -19753,8 +20325,8 @@ var JobRegistry = class {
     const id = `job-${randomUUID17().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
-    const done = new Promise((resolve28) => {
-      settle = resolve28;
+    const done = new Promise((resolve29) => {
+      settle = resolve29;
     });
     const record = {
       id,
@@ -19877,8 +20449,8 @@ function snapshot2(job) {
 
 // src/terminal/service.ts
 import { randomUUID as randomUUID18 } from "crypto";
-import { createRequire as nodeCreateRequire } from "module";
-import { isAbsolute as isAbsolute11, relative as relative19, resolve as resolve25, sep as sep19 } from "path";
+import { createRequire as nodeCreateRequire2 } from "module";
+import { isAbsolute as isAbsolute11, relative as relative19, resolve as resolve26, sep as sep19 } from "path";
 var TerminalService = class {
   #root;
   #factory;
@@ -19886,7 +20458,7 @@ var TerminalService = class {
   #maxOutputChars;
   #sessions = /* @__PURE__ */ new Map();
   constructor(workspace, options = {}) {
-    this.#root = resolve25(workspace);
+    this.#root = resolve26(workspace);
     this.#factory = options.factory ?? defaultFactory;
     this.#jobs = options.jobs;
     this.#maxOutputChars = options.maxOutputChars ?? 2e5;
@@ -19991,7 +20563,7 @@ function snapshot3(record) {
 }
 function defaultFactory(shell, args, options) {
   try {
-    const pty = nodeCreateRequire(import.meta.url)("node-pty");
+    const pty = nodeCreateRequire2(import.meta.url)("node-pty");
     return pty.spawn(shell, args, { ...options, name: "xterm-256color" });
   } catch (error) {
     throw new Error(`Pseudo-terminal backend is unavailable: ${error instanceof Error ? error.message : String(error)}`);
@@ -20004,7 +20576,7 @@ function cleanEnvironment(environment) {
   return Object.fromEntries(Object.entries(environment).filter((entry2) => entry2[1] !== void 0));
 }
 function workspacePath(root, input) {
-  const path = resolve25(root, input);
+  const path = resolve26(root, input);
   const delta = relative19(root, path);
   if (delta === ".." || delta.startsWith(`..${sep19}`) || isAbsolute11(delta)) throw new Error("Terminal cwd is outside the workspace");
   return path;
@@ -20012,7 +20584,7 @@ function workspacePath(root, input) {
 
 // src/tools/terminal.ts
 import { z as z33 } from "zod";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 var Id = z33.string().regex(/^term-[a-f0-9-]+$/);
 var OpenInput = z33.object({ cwd: z33.string().optional(), shell: z33.string().optional(), args: z33.array(z33.string()).optional(), columns: z33.coerce.number().int().min(10).max(500).optional(), rows: z33.coerce.number().int().min(2).max(300).optional() });
 var OptionalBoolean = z33.union([z33.boolean(), z33.string().refine((value) => value === "true" || value === "false")]);
@@ -20026,8 +20598,8 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       name: "TerminalOpen",
       description: "Open a persistent interactive pseudo-terminal in the workspace",
       inputSchema: OpenInput,
-      paths: (input) => [resolve26(workspace, input.cwd ?? ".")],
-      permissions: (input) => ({ paths: [resolve26(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve26(workspace, input.cwd ?? ".") }),
+      paths: (input) => [resolve27(workspace, input.cwd ?? ".")],
+      permissions: (input) => ({ paths: [resolve27(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve27(workspace, input.cwd ?? ".") }),
       execute: async (input, _signal, context) => terminals.open({
         owner: owner(context),
         ...input.cwd === void 0 ? {} : { cwd: input.cwd },
@@ -20253,8 +20825,8 @@ var PalClient = class {
       let disconnectTimer;
       await Promise.race([
         this.request({ version: 1, type: "disconnect", requestId: randomUUID19() }).catch(() => void 0),
-        new Promise((resolve28) => {
-          disconnectTimer = setTimeout(resolve28, Math.min(this.requestTimeoutMs, 250));
+        new Promise((resolve29) => {
+          disconnectTimer = setTimeout(resolve29, Math.min(this.requestTimeoutMs, 250));
         })
       ]);
       if (disconnectTimer !== void 0) clearTimeout(disconnectTimer);
@@ -20300,7 +20872,7 @@ var PalClient = class {
     return presence;
   }
   openSocket() {
-    return new Promise((resolve28, reject) => {
+    return new Promise((resolve29, reject) => {
       let settled = false;
       const rejectConnection = (error) => {
         if (settled) return;
@@ -20323,7 +20895,7 @@ var PalClient = class {
         settled = true;
         if (this.connectingReject === rejectConnection) this.connectingReject = void 0;
         socket.off("error", onInitialError);
-        resolve28();
+        resolve29();
       };
       const onInitialError = (error) => {
         socket.off("connect", onConnect);
@@ -20354,12 +20926,12 @@ var PalClient = class {
     if (this.closed || socket === void 0 || socket.destroyed || !socket.writable) {
       return Promise.reject(new Error(this.closed ? "Pal client is closed" : "Pal client is not connected"));
     }
-    return new Promise((resolve28, reject) => {
+    return new Promise((resolve29, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(request.requestId);
         reject(new Error(`Pal request '${request.type}' timed out`));
       }, this.requestTimeoutMs);
-      this.pending.set(request.requestId, { resolve: resolve28, reject, timer });
+      this.pending.set(request.requestId, { resolve: resolve29, reject, timer });
       let frame;
       try {
         frame = encodeControlFrame(BrokerRequestSchema.parse(request));
@@ -20763,8 +21335,8 @@ var ApprovalBridge = class {
   }
 };
 async function createProductionRuntime(options) {
-  const workspace = resolve27(options.workspace ?? process.cwd());
-  const home = resolve27(options.home ?? homedir2());
+  const workspace = resolve28(options.workspace ?? process.cwd());
+  const home = resolve28(options.home ?? homedir2());
   const environment = options.environment ?? process.env;
   const ide = new FlavorIdeClient({ workspace, home, environment });
   const ideReady = ide.initialize();
@@ -20988,8 +21560,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join25(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join25(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join26(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join26(workspace, ".flavor", "plugins")],
     config,
     // Existing project plugins (including astgraph and superharness) use Node.js
     // built-ins. The Worker/vm sandbox deliberately blocks those imports, so it
@@ -21097,7 +21669,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join25(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join26(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -21208,8 +21780,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join25(home, ".flavor-code", "skills")],
-      projectRoots: [join25(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join26(home, ".flavor-code", "skills")],
+      projectRoots: [join26(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -21217,7 +21789,7 @@ async function createProductionRuntime(options) {
     skillsReady.catch(() => void 0);
     tools.push(createSkillTool(skills), createSkillResourceTool(skills));
     if (options.extraTools !== void 0) tools.push(...options.extraTools);
-    const flavor = await optionalText2(join25(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join26(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -21795,7 +22367,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join25(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join26(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -22155,6 +22727,22 @@ async function createProductionRuntime(options) {
         modelId: () => harness.subagentModelId,
         notify: (message2) => emitOutput({ type: "notice", message: message2 })
       }, focus, signal),
+      explain: (query, focus, signal, onText) => runExplain({
+        graph: new DesktopAstGraphService(workspace),
+        readFile: async (path) => {
+          const root = resolve28(workspace);
+          const abs = resolve28(root, path);
+          if (abs !== root && !abs.startsWith(root + sep20)) throw new Error(`path outside workspace: ${path}`);
+          return readFile22(abs, "utf8");
+        },
+        history: async (path, limit) => fileHistory(workspace, path, limit),
+        questions,
+        registry,
+        modelId: () => harness.subagentModelId,
+        language,
+        notify: (message2) => emitOutput({ type: "notice", message: message2 }),
+        ...onText === void 0 ? {} : { onText }
+      }, query, focus, signal),
       audit: async (toolFilter) => {
         try {
           const raw = await readFile22(auditLogger.path, "utf8");
@@ -22344,7 +22932,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join25(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join26(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -22367,8 +22955,12 @@ ${renderMemoryDocument(entries)}`;
           };
           registry.register(next.providerId, next.apiType === "anthropic" ? new AnthropicModelAdapter({
             ...adapterOptions,
+            ...providerConfig?.thinkingBudget === void 0 ? {} : { thinkingBudget: providerConfig.thinkingBudget },
             ...providerConfig?.claudeClient === true ? { headers: CLAUDE_CLIENT_HEADERS } : {}
-          }) : new OpenAIModelAdapter(adapterOptions));
+          }) : new OpenAIModelAdapter({
+            ...adapterOptions,
+            ...providerConfig?.thinkingEffort === void 0 ? {} : { thinkingEffort: providerConfig.thinkingEffort }
+          }));
           effectiveLlm = next;
           mainModel = `${next.providerId}:${next.defaultModel}`;
           childModel = `${next.providerId}:${next.cheapModel}`;
@@ -22387,7 +22979,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join25(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join26(home, ".flavor-code", "auth.json"));
         const tokens = await tokenStore.load();
         const hadCredentials = Object.keys(tokens).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -22663,8 +23255,8 @@ async function workspaceFingerprint(workspace) {
   let remaining = 5 * 1024 * 1024;
   for (const name of untracked.stdout.split("\0").filter(Boolean).sort()) {
     if (name === ".flavor/loops" || name.startsWith(".flavor/loops/")) continue;
-    const path = resolve27(workspace, name);
-    const relativePath = relative20(resolve27(workspace), path);
+    const path = resolve28(workspace, name);
+    const relativePath = relative20(resolve28(workspace), path);
     if (relativePath === ".." || relativePath.startsWith(`..${sep20}`)) continue;
     hash.update(name);
     if (remaining <= 0) continue;
@@ -22882,7 +23474,7 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
   const configured = { ...providers };
   if (configured.openai === void 0 && environment.OPENAI_API_KEY) configured.openai = { type: "openai", apiKey: environment.OPENAI_API_KEY };
   if (configured.anthropic === void 0 && environment.ANTHROPIC_API_KEY) configured.anthropic = { type: "anthropic", apiKey: environment.ANTHROPIC_API_KEY };
-  const oauthTokenStore = createFileTokenStore(join25(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join26(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -22954,8 +23546,12 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
       };
       const adapter = apiProtocol === "anthropic" ? new AnthropicModelAdapter({
         ...adapterOptions,
+        ...runtimeProvider.thinkingBudget === void 0 ? {} : { thinkingBudget: runtimeProvider.thinkingBudget },
         ...runtimeProvider.claudeClient === true ? { headers: CLAUDE_CLIENT_HEADERS } : {}
-      }) : new OpenAIModelAdapter(adapterOptions);
+      }) : new OpenAIModelAdapter({
+        ...adapterOptions,
+        ...runtimeProvider.thinkingEffort === void 0 ? {} : { thinkingEffort: runtimeProvider.thinkingEffort }
+      });
       const cacheProfile = resolveCacheProfile({ apiType: apiProtocol, baseURL: runtimeProvider.baseURL });
       if (apiProtocol === "openai" && isDashScopeBaseURL(runtimeProvider.baseURL)) {
         diagnostics.push(
@@ -23320,6 +23916,8 @@ export {
   executeShell,
   packageVersion,
   SkillRegistry,
+  charWidth,
+  thinkingWindow,
   createTranscriptState,
   transcriptReducer,
   WorkspaceCheckpointStore,