tesseract-agent 0.7.0 → 0.7.1

package/dist-bundle/cli.js

@@ -4475,14 +4475,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
+  let str2 = "";
   for (let i = 0; i < length; i++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
+    str2 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str;
+  return str2;
 }
-function esc(str) {
-  return JSON.stringify(str);
+function esc(str2) {
+  return JSON.stringify(str2);
 }
 function slugify(input) {
   return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -4526,8 +4526,8 @@ function numKeys(data) {
   }
   return keyCount;
 }
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str2) {
+  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -19467,6 +19467,12 @@ var init_ws_protocol = __esm({
       // co-viewers see the Mission card's live stage progress
       "agent:elicitation_complete",
       // M5 — co-viewers clear a resolved url-mode card
+      "agent:framework_event",
+      // full-visibility debug feed — co-viewers see the same framework events
+      "agent:sources",
+      // citation footnotes — co-viewers see the same sources under the reply
+      "agent:task",
+      // live subagent cards — co-viewers watch subagent progress too
       "chat:echoed",
       "chat:scheduled_fired"
       // cron — co-viewers see the synthetic "Scheduled" user turn
@@ -22871,6 +22877,72 @@ var init_kill_tree = __esm({
   }
 });
 
+// ../../packages/agent-core/dist/sources.js
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function extractSources(content) {
+  if (!Array.isArray(content))
+    return [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const block of content) {
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    if (b.type !== "text" || !Array.isArray(b.citations))
+      continue;
+    for (const raw of b.citations) {
+      if (!raw || typeof raw !== "object")
+        continue;
+      const c = raw;
+      let url2;
+      let title;
+      let kind;
+      switch (c.type) {
+        case "web_search_result_location":
+          url2 = str(c.url) || void 0;
+          title = str(c.title) || url2 || "Web result";
+          kind = "web";
+          break;
+        case "search_result_location": {
+          const source = str(c.source);
+          url2 = /^https?:\/\//.test(source) ? source : void 0;
+          title = str(c.title) || source || "Search result";
+          kind = "search";
+          break;
+        }
+        case "char_location":
+        case "page_location":
+        case "content_block_location":
+          title = str(c.document_title) || "Document";
+          kind = "document";
+          break;
+        default:
+          continue;
+      }
+      const key2 = (url2 || title).toLowerCase();
+      const snippet = str(c.cited_text).replace(/\s+/g, " ").trim().slice(0, SNIPPET_MAX);
+      const existing = byKey.get(key2);
+      if (existing) {
+        existing.count += 1;
+        if (!existing.snippet && snippet)
+          existing.snippet = snippet;
+      } else if (byKey.size < SOURCES_MAX) {
+        byKey.set(key2, { ...url2 ? { url: url2 } : {}, title, ...snippet ? { snippet } : {}, kind, count: 1 });
+      }
+    }
+  }
+  return [...byKey.values()];
+}
+var SNIPPET_MAX, SOURCES_MAX;
+var init_sources = __esm({
+  "../../packages/agent-core/dist/sources.js"() {
+    "use strict";
+    SNIPPET_MAX = 220;
+    SOURCES_MAX = 40;
+  }
+});
+
 // ../../packages/agent-core/dist/agent-manager.js
 import { query, createSdkMcpServer, startup } from "@anthropic-ai/claude-agent-sdk";
 import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile6 } from "node:fs/promises";
@@ -22990,8 +23062,176 @@ function extractHumanReadable(message) {
   }
   return parts.join("\n");
 }
-function systemHeader(type, subtype) {
-  return `_${subtype ? `${type}/${subtype}` : type}_`;
+function traceFrame(message) {
+  const type = message.type || "unknown";
+  if (type === "stream_event") {
+    const ev = message.event ?? {};
+    const et = ev.type ?? "?";
+    if (et === "content_block_delta" || et === "ping")
+      return;
+    const cb = ev.content_block ? ` ${ev.content_block.type ?? ""}${ev.content_block.name ? `:${ev.content_block.name}` : ""}` : "";
+    log(`frame stream_event/${et}${cb}`);
+    return;
+  }
+  const sub = typeof message.subtype === "string" ? `/${message.subtype}` : "";
+  const parent = message.parent_tool_use_id ? " (subagent)" : "";
+  log(`frame ${type}${sub}${parent}`);
+}
+function rawFramePreview(message, limit = 2e3) {
+  let s;
+  try {
+    s = JSON.stringify(message, null, 2);
+  } catch {
+    s = String(message);
+  }
+  return s.length > limit ? `${s.slice(0, limit)}
+\u2026 (${s.length} bytes total)` : s;
+}
+function humanizeName(name) {
+  const s = name.replace(/[_-]+/g, " ").trim();
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function salientFields(m, max = 8) {
+  const SKIP = /* @__PURE__ */ new Set(["type", "subtype", "uuid", "session_id", "parent_tool_use_id", "request_id"]);
+  const out = [];
+  for (const [k, v] of Object.entries(m)) {
+    if (SKIP.has(k))
+      continue;
+    if (v === null || v === void 0)
+      continue;
+    let val;
+    if (typeof v === "string")
+      val = v.length > 200 ? `${v.slice(0, 200)}\u2026` : v;
+    else if (typeof v === "number" || typeof v === "boolean")
+      val = String(v);
+    else if (Array.isArray(v))
+      val = `[${v.length}]`;
+    else
+      continue;
+    out.push({ label: humanizeName(k), value: val });
+    if (out.length >= max)
+      break;
+  }
+  return out;
+}
+function describeSystemSubtype(subtype, m) {
+  if (subtype === "thinking_tokens") {
+    const est = Number(m.estimated_tokens ?? 0);
+    const delta = Number(m.estimated_tokens_delta ?? 0);
+    return {
+      category: "thinking",
+      name: subtype,
+      title: `Thinking \u2014 ~${est.toLocaleString("en-US")} tokens`,
+      ...delta ? { fields: [{ label: "this step", value: `+${delta.toLocaleString("en-US")}` }] } : {},
+      updateKey: "thinking_tokens"
+      // one self-updating card per turn, not one per tick
+    };
+  }
+  const category = SYSTEM_EVENT_CATEGORY[subtype];
+  if (category) {
+    const updateKey = category === "hook" ? `hook:${String(m.hook_name ?? m.hook_event_name ?? subtype)}` : category === "task" ? `task:${String(m.task_id ?? subtype)}` : category === "telemetry" ? `sys:${subtype}` : void 0;
+    return { category, name: subtype, title: humanizeName(subtype), fields: salientFields(m), ...updateKey ? { updateKey } : {} };
+  }
+  const text3 = extractHumanReadable(m);
+  return { category: "unknown", name: subtype, title: `system/${subtype}`, ...text3 ? { detail: text3 } : {}, raw: rawFramePreview(m) };
+}
+function sstr(v) {
+  return typeof v === "string" ? v : "";
+}
+function prettifyModel(id) {
+  if (!id)
+    return "the model";
+  const known = {
+    "claude-opus-4-8": "Opus 4.8",
+    "claude-sonnet-4-6": "Sonnet 4.6",
+    "claude-haiku-4-5-20251001": "Haiku 4.5",
+    "claude-fable-5": "Fable 5",
+    "claude-sonnet-5": "Sonnet 5"
+  };
+  return known[id] ?? id.replace(/^claude-/, "").replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function buildNotice(subtype, m) {
+  switch (subtype) {
+    case "notification": {
+      const text3 = sstr(m.text) || "Notification";
+      const priority = ["low", "medium", "high", "immediate"].includes(sstr(m.priority)) ? m.priority : "medium";
+      const level = priority === "immediate" ? "error" : priority === "high" ? "warning" : priority === "low" ? "info" : "notice";
+      return { category: "notification", level, priority, title: text3, toast: true, inline: true, ...typeof m.timeout_ms === "number" ? { timeoutMs: m.timeout_ms } : {} };
+    }
+    case "informational": {
+      const content = sstr(m.content).trim();
+      if (!content)
+        return null;
+      const level = ["info", "notice", "suggestion", "warning"].includes(sstr(m.level)) ? m.level : "info";
+      const nl = content.indexOf("\n");
+      const firstLine = nl >= 0 ? content.slice(0, nl) : content;
+      const remainder = nl >= 0 ? content.slice(nl + 1).trim() : "";
+      const truncated = firstLine.length > 160;
+      const title = truncated ? `${firstLine.slice(0, 159).trimEnd()}\u2026` : firstLine;
+      const body = truncated ? content : remainder;
+      return { category: "info", level, title, ...body ? { body } : {}, ...sstr(m.tool_use_id) ? { toolUseId: sstr(m.tool_use_id) } : {}, inline: true, toast: level === "warning" };
+    }
+    case "plugin_install": {
+      const status2 = sstr(m.status);
+      if (status2 !== "installed" && status2 !== "failed" && status2 !== "completed")
+        return null;
+      const name = sstr(m.name) || "plugin";
+      const failed = status2 === "failed";
+      return { category: "plugin", level: failed ? "error" : "success", title: failed ? `Plugin \u201C${name}\u201D failed to install` : `Installed plugin \u201C${name}\u201D`, ...failed && sstr(m.error) ? { body: sstr(m.error) } : {}, toast: true, inline: true };
+    }
+    case "memory_recall": {
+      const memories = Array.isArray(m.memories) ? m.memories : [];
+      if (!memories.length)
+        return null;
+      const names = memories.map((x) => sstr(x.path).split(/[/\\]/).pop() || sstr(x.path)).filter(Boolean);
+      return { category: "memory", level: "info", title: `Recalled ${memories.length} ${memories.length === 1 ? "memory" : "memories"}`, ...names.length ? { body: names.join(" \xB7 ") } : {}, toast: false, inline: true };
+    }
+    case "permission_denied": {
+      const tool9 = sstr(m.tool_name) || "a tool";
+      const reason = sstr(m.decision_reason) || sstr(m.message);
+      return { category: "permission", level: "warning", title: `Blocked: ${tool9}`, ...reason ? { body: reason } : {}, ...sstr(m.tool_use_id) ? { toolUseId: sstr(m.tool_use_id) } : {}, toast: true, inline: true };
+    }
+    case "model_refusal_fallback": {
+      const orig = sstr(m.original_model);
+      const fb = sstr(m.fallback_model);
+      const cat = sstr(m.api_refusal_category);
+      const expl = sstr(m.api_refusal_explanation) || sstr(m.content);
+      const oL = prettifyModel(orig);
+      const fL = prettifyModel(fb);
+      const reverted = sstr(m.direction) === "revert";
+      return {
+        category: "model",
+        level: "warning",
+        priority: "high",
+        title: reverted ? `${oL} declined this request${cat ? ` (${cat})` : ""} \u2014 retried on ${fL}` : `${oL} declined this request${cat ? ` (${cat})` : ""} \u2014 now on ${fL}`,
+        ...expl ? { body: expl } : {},
+        ...!reverted && fb ? { setModel: fb } : {},
+        toast: true,
+        inline: true,
+        actions: reverted ? [{ id: "pick", label: "Choose model\u2026", kind: "pick_model" }] : [
+          ...orig ? [{ id: "back", label: `Switch back to ${oL}`, style: "primary", kind: "switch_model", data: { model: orig } }] : [],
+          { id: "stay", label: `Stay on ${fL}`, kind: "dismiss" },
+          { id: "pick", label: "Choose model\u2026", kind: "pick_model" }
+        ]
+      };
+    }
+    case "model_refusal_no_fallback": {
+      const orig = sstr(m.original_model);
+      const cat = sstr(m.api_refusal_category);
+      const expl = sstr(m.api_refusal_explanation) || sstr(m.content);
+      return {
+        category: "model",
+        level: "error",
+        title: `${prettifyModel(orig)} declined this request${cat ? ` (${cat})` : ""}`,
+        ...expl ? { body: expl } : {},
+        toast: true,
+        inline: true,
+        actions: [{ id: "pick", label: "Try another model\u2026", style: "primary", kind: "pick_model" }]
+      };
+    }
+    default:
+      return null;
+  }
 }
 function parseTodos(rawInput) {
   try {
@@ -23200,7 +23440,7 @@ MOBILE (${fw}):
     return "";
   }
 }
-var cachedClaudeExe, cachedNodeExe, HUMAN_READABLE_FIELDS, TOOL_RESULT_CAP, MAX_RESULT_IMAGES, MAX_IMAGE_BASE64, PERMISSION_MODES, EDIT_PREVIEW_CAP, AsyncMessagePump, IDLE_REAP_MS, MODERATE_IDLE_MS, STEER_COALESCE_MS, STOP_HARD_KILL_AFTER_MS, AgentManager;
+var cachedClaudeExe, cachedNodeExe, HUMAN_READABLE_FIELDS, THINKING_THROTTLE_MS, SYSTEM_EVENT_CATEGORY, TOOL_RESULT_CAP, MAX_RESULT_IMAGES, MAX_IMAGE_BASE64, PERMISSION_MODES, EDIT_PREVIEW_CAP, AsyncMessagePump, IDLE_REAP_MS, MODERATE_IDLE_MS, STEER_COALESCE_MS, STOP_HARD_KILL_AFTER_MS, AgentManager;
 var init_agent_manager = __esm({
   "../../packages/agent-core/dist/agent-manager.js"() {
     "use strict";
@@ -23222,7 +23462,17 @@ var init_agent_manager = __esm({
     init_session_usage();
     init_kill_tree();
     init_log();
+    init_sources();
     HUMAN_READABLE_FIELDS = ["message", "text", "content", "summary", "description", "output", "stdout", "error", "reason", "name"];
+    THINKING_THROTTLE_MS = 2e3;
+    SYSTEM_EVENT_CATEGORY = {
+      hook_started: "hook",
+      hook_progress: "hook",
+      thinking_tokens: "thinking"
+      // task_* / files_persisted / worker_shutting_down are handled explicitly now;
+      // get_context_usage / get_session_cost / background_tasks are outbound control-requests
+      // we never receive — both dropped from here rather than kept as dead entries.
+    };
     TOOL_RESULT_CAP = 16e3;
     MAX_RESULT_IMAGES = 4;
     MAX_IMAGE_BASE64 = 15e5;
@@ -23315,6 +23565,9 @@ var init_agent_manager = __esm({
       /** M5 H6 — parked MCP elicitation prompts, resolved when the client replies via
        *  chat:elicitation (→ respondToElicitation) or denied on abort. */
       pendingElicitations = /* @__PURE__ */ new Map();
+      /** request_user_dialog prompts (model-fallback / usage-consent), resolved when the
+       *  client replies via chat:user_dialog (→ respondToUserDialog) or cancelled on abort. */
+      pendingUserDialogs = /* @__PURE__ */ new Map();
       /** Skill-driven interactive UI requests (ask_form / present_choices), resolved when
        *  the client replies via chat:ui_response (→ respondToUiRequest) or the owning
        *  session is torn down (→ cancelled). Keyed by requestId; `sessionId` lets a
@@ -23622,6 +23875,159 @@ ${full.slice(-8e3)}`;
           entry.resolve({ behavior: "deny", message: decision.message || "Denied by user.", ...decision.interrupt ? { interrupt: true } : {} });
         }
       }
+      /** AskUserQuestion: park a promise, raise the multiple-choice question card
+       *  (agent:permission_request, toolName='AskUserQuestion'), and resolve it from the
+       *  client's chat:permission reply — which lands in respondToPermission carrying
+       *  `updatedInput.answers`. Deliberately reuses pendingPermissions + the
+       *  PermissionResult shape so the existing answer round-trip (client card →
+       *  respondToPermission) is unchanged; the PreToolUse hook maps the resolved
+       *  PermissionResult into hookSpecificOutput. Driven from a PreToolUse hook rather
+       *  than canUseTool because hooks fire in EVERY permission mode — bypassPermissions
+       *  (the app default) shadows canUseTool but never hooks. Mirrors canUseTool's
+       *  abort/cleanup handling so an interrupted turn never leaks a parked card. */
+      raiseQuestion(live, input, toolUseId, signal, agentId) {
+        return new Promise((resolve10) => {
+          const requestId = randomUUID2();
+          const onAbort = () => {
+            if (this.pendingPermissions.delete(requestId))
+              resolve10({ behavior: "deny", message: "Interrupted.", interrupt: true });
+          };
+          const cleanup2 = () => signal.removeEventListener("abort", onAbort);
+          if (signal.aborted) {
+            resolve10({ behavior: "deny", message: "Interrupted.", interrupt: true });
+            return;
+          }
+          signal.addEventListener("abort", onAbort, { once: true });
+          this.pendingPermissions.set(requestId, { resolve: resolve10, cleanup: cleanup2, origin: live.origin });
+          const willEvaluate = !!this.cheapLlm && Array.isArray(input.questions) && input.questions.length > 0;
+          const evt = {
+            type: "agent:permission_request",
+            sessionId: live.sessionId,
+            requestId,
+            toolName: "AskUserQuestion",
+            input,
+            ...toolUseId ? { toolUseId } : {},
+            ...agentId ? { agentId } : {},
+            ...willEvaluate ? { recommendationsPending: true } : {}
+          };
+          if (!live.sessionId && live.clientRequestId)
+            this.send({ ...evt, clientRequestId: live.clientRequestId }, live.origin);
+          else
+            this.send(evt, live.origin);
+          if (willEvaluate)
+            void this.evaluateOptions(live, requestId, input);
+        });
+      }
+      /** Compile a compact context summary for the option-recommendation LLM: the project,
+       *  the user's current request, and what the assistant just said (why it's asking). */
+      compileQuestionContext(live) {
+        const parts = [];
+        if (live.cwd)
+          parts.push(`Project directory: ${live.cwd}`);
+        if (live.lastPrompt)
+          parts.push(`The user's current request:
+${live.lastPrompt.slice(0, 1400)}`);
+        if (Array.isArray(live.lastAssistantContent)) {
+          const text3 = live.lastAssistantContent.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
+          if (text3)
+            parts.push(`What the assistant just said (leading to this question):
+${text3.slice(0, 1600)}`);
+        }
+        return parts.join("\n\n") || "No additional context available beyond the question itself.";
+      }
+      /** Rate every option of an AskUserQuestion for the user's situation via the cheap LLM
+       *  (structured JSON, 5 levels), then emit agent:option_recommendations. Best-effort:
+       *  any failure (no model, bad JSON, card already answered) simply yields no badges. */
+      async evaluateOptions(live, requestId, input) {
+        const llm = this.cheapLlm;
+        if (!llm)
+          return;
+        const questions = Array.isArray(input.questions) ? input.questions : [];
+        if (!questions.length)
+          return;
+        try {
+          const qText = questions.map((q, qi) => {
+            const opts = Array.isArray(q.options) ? q.options : [];
+            const lines = opts.map((o) => `  - "${String(o.label)}"${o.description ? `: ${String(o.description)}` : ""}`).join("\n");
+            return `Question ${qi}: ${String(q.question)}
+Options:
+${lines}`;
+          }).join("\n\n");
+          const system = `You advise a user who is answering multiple-choice questions posed by a coding agent mid-task. For EVERY option of EVERY question, rate how advisable it is FOR THIS USER'S SPECIFIC SITUATION, using exactly one of these five levels: "highly_recommended", "recommended", "neutral", "caution", "discouraged". Be decisive and honest \u2014 most questions have one or two clearly better choices; do not rate everything neutral. Ground each rating in the provided context. Respond with ONLY a JSON object, no prose: {"recommendations":[{"questionIndex":<int>,"optionLabel":"<verbatim label>","level":"<level>","reason":"<max 12 words>"}]}. Include every option.`;
+          const prompt = `## Context
+${this.compileQuestionContext(live)}
+
+## Questions and options
+${qText}`;
+          const out = await llm({ system, prompt, maxTokens: 1400 });
+          if (!out)
+            return;
+          const parsed = JSON.parse(out.slice(out.indexOf("{"), out.lastIndexOf("}") + 1));
+          const LEVELS = /* @__PURE__ */ new Set(["highly_recommended", "recommended", "neutral", "caution", "discouraged"]);
+          const clean = (Array.isArray(parsed.recommendations) ? parsed.recommendations : []).map((r) => r).filter((r) => r && typeof r.optionLabel === "string" && typeof r.questionIndex === "number" && typeof r.level === "string" && LEVELS.has(r.level)).map((r) => ({ questionIndex: r.questionIndex, optionLabel: r.optionLabel, level: r.level, reason: typeof r.reason === "string" ? r.reason.slice(0, 140) : "" }));
+          if (!clean.length || !this.pendingPermissions.has(requestId))
+            return;
+          const evt = { type: "agent:option_recommendations", sessionId: live.sessionId, requestId, recommendations: clean };
+          if (!live.sessionId && live.clientRequestId)
+            this.send({ ...evt, clientRequestId: live.clientRequestId }, live.origin);
+          else
+            this.send(evt, live.origin);
+        } catch (err) {
+          log("option recommendation eval failed:", err instanceof Error ? err.message : String(err));
+        }
+      }
+      /** request_user_dialog: park a promise, raise the dialog card
+       *  (agent:user_dialog_request), and resolve it from the client's chat:user_dialog
+       *  reply (→ respondToUserDialog). Mirrors onElicitation: the CLI parks the flow until
+       *  we answer; an unanswered/aborted dialog resolves 'cancelled' so the CLI applies the
+       *  dialog's default behavior (e.g. the classic refusal message) rather than hanging. */
+      raiseUserDialog(live, request, signal) {
+        return new Promise((resolve10) => {
+          const requestId = randomUUID2();
+          log("user_dialog raised:", request.dialogKind, "requestId=" + requestId, "payloadKeys=" + Object.keys(request.payload ?? {}).join(","));
+          const onAbort = () => {
+            if (this.pendingUserDialogs.delete(requestId)) {
+              log("user_dialog aborted (cancelled):", request.dialogKind, requestId);
+              resolve10({ behavior: "cancelled" });
+            }
+          };
+          const cleanup2 = () => signal.removeEventListener("abort", onAbort);
+          if (signal.aborted) {
+            log("user_dialog pre-aborted (cancelled):", request.dialogKind);
+            resolve10({ behavior: "cancelled" });
+            return;
+          }
+          signal.addEventListener("abort", onAbort, { once: true });
+          this.pendingUserDialogs.set(requestId, { resolve: resolve10, cleanup: cleanup2, origin: live.origin });
+          const evt = {
+            type: "agent:user_dialog_request",
+            sessionId: live.sessionId,
+            requestId,
+            dialogKind: request.dialogKind,
+            payload: request.payload ?? {},
+            ...request.toolUseID ? { toolUseId: request.toolUseID } : {}
+          };
+          if (!live.sessionId && live.clientRequestId)
+            this.send({ ...evt, clientRequestId: live.clientRequestId }, live.origin);
+          else
+            this.send(evt, live.origin);
+        });
+      }
+      /** Resolve a parked request_user_dialog (client replied via chat:user_dialog).
+       *  Driver-only, same origin guard as respondToPermission. */
+      respondToUserDialog(requestId, decision, callerOrigin) {
+        const entry = this.pendingUserDialogs.get(requestId);
+        if (!entry) {
+          log("user_dialog response for unknown/expired requestId:", requestId);
+          return;
+        }
+        if (entry.origin && callerOrigin && entry.origin !== callerOrigin)
+          return;
+        this.pendingUserDialogs.delete(requestId);
+        entry.cleanup();
+        log("user_dialog answered:", requestId, decision.behavior === "completed" ? `result=${JSON.stringify(decision.result)}` : "cancelled");
+        entry.resolve(decision.behavior === "completed" ? { behavior: "completed", result: decision.result } : { behavior: "cancelled" });
+      }
       /** M5 H6 — resolve a parked MCP elicitation (client replied via chat:elicitation).
        *  Driver-only, same origin guard as respondToPermission. */
       respondToElicitation(requestId, decision, callerOrigin) {
@@ -24306,6 +24712,10 @@ CRITICAL RULES:
             // resolve it when the client replies via chat:permission (respondToPermission),
             // or deny on abort so an interrupted turn never leaks a pending decision.
             canUseTool: (toolName, input, opts) => new Promise((resolve10) => {
+              if (toolName === "AskUserQuestion") {
+                resolve10({ behavior: "allow" });
+                return;
+              }
               const requestId = randomUUID2();
               const onAbort = () => {
                 if (this.pendingPermissions.delete(requestId)) {
@@ -24374,12 +24784,38 @@ CRITICAL RULES:
               else
                 this.send(evt, live.origin);
             }),
+            // request_user_dialog — blocking model-fallback / usage-consent dialogs the CLI
+            // asks the host to render. Without this the flow degrades to no-dialog (a model
+            // refusal ends the turn with the classic error). We declare the kinds we render
+            // (supportedDialogKinds); the CLI fails closed and never emits an undeclared kind.
+            onUserDialog: (request, opts) => this.raiseUserDialog(live, request, opts.signal),
+            supportedDialogKinds: ["refusal_fallback_prompt", "fable_overage_consent_prompt"],
             // Capture file edits for the client's "Review changes" (see pendingEdits
             // above). Bash-driven writes aren't visible here — only the editing tools.
             // Subagent tool calls (agent_id set) are skipped: their tool blocks aren't
             // in the visible stream, so an emitted edit would convert the wrong card.
             hooks: {
               PreToolUse: [{
+                // AskUserQuestion is an INTERACTIVE tool with no server-side executor: its
+                // "result" IS the user's selection. If it isn't surfaced and answered, the
+                // tool_use dangles and the whole turn stalls (no result ever arrives).
+                // canUseTool can't carry it: in bypassPermissions (the app default) the SDK
+                // auto-approves every tool BEFORE canUseTool runs — it even logs
+                // CLAUDE_SDK_CAN_USE_TOOL_SHADOWED — so the question card never shows. A
+                // PreToolUse hook fires in EVERY permission mode and can return updatedInput,
+                // so we raise the card here and bake the chosen answers back into the input.
+                matcher: "AskUserQuestion",
+                hooks: [async (input, _toolUseId, opts) => {
+                  if (input.hook_event_name !== "PreToolUse" || input.tool_name !== "AskUserQuestion")
+                    return {};
+                  const original = input.tool_input ?? {};
+                  const decision = await this.raiseQuestion(live, original, input.tool_use_id, opts.signal, input.agent_id);
+                  if (decision.behavior === "allow") {
+                    return { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...original, ...decision.updatedInput ?? {} } } };
+                  }
+                  return { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: decision.message || "The user dismissed the question without answering." } };
+                }]
+              }, {
                 matcher: "Edit|Write|MultiEdit|NotebookEdit",
                 hooks: [async (input) => {
                   if (input.hook_event_name === "PreToolUse" && !input.agent_id) {
@@ -24458,10 +24894,14 @@ CRITICAL RULES:
 
 ${params.appendSystemPrompt}` : "") },
             includePartialMessages: true,
-            // Opt into AskUserQuestion option previews. Without a previewFormat the
-            // SDK omits the preview-field guidance from the tool prompt, so the
-            // model never emits previews; our card renders them as markdown.
-            toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
+            // Emit a predicted follow-up prompt after each turn (git/context-aware) — rendered
+            // as a clickable suggestion chip. Off by default in the SDK, so opt in here.
+            promptSuggestions: true,
+            // Opt into AskUserQuestion option previews as self-contained HTML fragments —
+            // the card renders them as live, sandboxed mockups (an actual styled button,
+            // not its source). Without a previewFormat the SDK omits the preview guidance
+            // and the model never emits previews.
+            toolConfig: { askUserQuestion: { previewFormat: "html" } },
             // M7 — structured output: constrain the final result to a JSON Schema.
             ...params.jsonSchema ? { outputFormat: { type: "json_schema", schema: params.jsonSchema } } : {},
             // Customize panel: inline-key parity surfaces. These keep the SDK
@@ -24529,6 +24969,36 @@ ${params.appendSystemPrompt}` : "") },
             log("send callback threw (ignored):", err instanceof Error ? err.message : String(err));
           }
         };
+        const sendEvent = (spec) => {
+          emit({ type: "agent:framework_event", sessionId: live.sessionId, ...spec });
+        };
+        const flushPendingThinking = () => {
+          if (live.pendingThinking) {
+            sendEvent(live.pendingThinking);
+            live.pendingThinking = void 0;
+            live.lastThinkingEmitAt = Date.now();
+          }
+        };
+        const emitNotice = (spec) => {
+          flushPendingThinking();
+          emit({ type: "agent:notice", sessionId: live.sessionId, noticeId: randomUUID2(), ...spec });
+        };
+        const emitEvent = (spec, parentId) => {
+          const payload = { ...spec, ...parentId ? { parentToolUseId: parentId } : {} };
+          if (spec.updateKey === "thinking_tokens") {
+            const now2 = Date.now();
+            if (now2 - (live.lastThinkingEmitAt ?? 0) >= THINKING_THROTTLE_MS) {
+              live.lastThinkingEmitAt = now2;
+              live.pendingThinking = void 0;
+              sendEvent(payload);
+            } else {
+              live.pendingThinking = payload;
+            }
+            return;
+          }
+          flushPendingThinking();
+          sendEvent(payload);
+        };
         const refreshSessionUsage = (sessionId) => {
           void getSessionUsage(live.engineEnv).then((usage) => {
             if (usage && (usage.session || usage.weekly)) {
@@ -24544,6 +25014,7 @@ ${params.appendSystemPrompt}` : "") },
               live.trace = { turnId: crypto.randomUUID(), startedAt: Date.now(), frames: [] };
             if (live.trace.frames.length < 2e3)
               live.trace.frames.push(message);
+            traceFrame(message);
             if (!live.sessionId && "session_id" in message && message.session_id) {
               const sid2 = message.session_id;
               live.sessionId = sid2;
@@ -24566,6 +25037,7 @@ ${params.appendSystemPrompt}` : "") },
                 if (event.type === "content_block_start") {
                   const cbt = event.content_block?.type;
                   if ((cbt === "tool_use" || cbt === "server_tool_use") && event.content_block?.name) {
+                    flushPendingThinking();
                     const isServerTool = cbt === "server_tool_use";
                     const id = event.content_block.id ?? "";
                     blockAcc.set(key2, { name: event.content_block.name, input: "", isServerTool, id });
@@ -24659,6 +25131,7 @@ ${params.appendSystemPrompt}` : "") },
                 break;
               }
               case "result": {
+                flushPendingThinking();
                 const r = message;
                 const turnSid = r.session_id || sid;
                 this.narrator.endTurn(turnSid);
@@ -24695,6 +25168,9 @@ ${params.appendSystemPrompt}` : "") },
                       }
                     }
                   }
+                  const sources = extractSources(live.lastAssistantContent);
+                  if (sources.length > 0)
+                    emit({ type: "agent:sources", sessionId: turnSid, messageId: turnMessageId, sources });
                   const usage = r.usage;
                   const continuable = r.stop_reason === "max_tokens";
                   emit({
@@ -24742,14 +25218,14 @@ ${params.appendSystemPrompt}` : "") },
               }
               case "auth_status": {
                 const m = message;
-                const lines = [systemHeader("auth_status")];
-                if (m.isAuthenticating)
-                  lines.push("Authenticating\u2026");
-                if (m.error)
-                  lines.push(`Error: ${m.error}`);
-                if (m.output?.length)
-                  lines.push(m.output.join("\n"));
-                emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: lines.join("\n\n") });
+                emitEvent({
+                  category: "auth",
+                  name: "auth_status",
+                  title: m.error ? "Authentication error" : m.isAuthenticating ? "Authenticating\u2026" : "Auth status",
+                  ...m.error ? { fields: [{ label: "Error", value: m.error }] } : {},
+                  ...m.output?.length ? { detail: m.output.join("\n") } : {},
+                  updateKey: "auth_status"
+                });
                 break;
               }
               case "rate_limit_event": {
@@ -24765,46 +25241,121 @@ ${params.appendSystemPrompt}` : "") },
                     const attempt = m.attempt ?? "?";
                     const max = m.max_retries ?? "?";
                     const errStatus = m.error_status ? ` (HTTP ${m.error_status})` : "";
-                    emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: `${systemHeader("system", "api_retry")}
-
-Retrying API call (${attempt}/${max})${errStatus}\u2026` });
+                    emitEvent({
+                      category: "retry",
+                      name: "api_retry",
+                      title: `Retrying API call (${attempt}/${max})${errStatus}`,
+                      ...m.error_status ? { fields: [{ label: "HTTP", value: String(m.error_status) }] } : {}
+                    });
                     break;
                   }
+                  // Subagent (Task tool) lifecycle → one live card per task_id (agent:task).
                   case "task_started": {
-                    const desc = m.description || "subagent task";
-                    const taskId = typeof m.task_id === "string" ? m.task_id : void 0;
-                    if (taskId)
-                      live.taskIds.add(taskId);
-                    emit({ type: "agent:tool_use", sessionId: sid, toolName: "Task", summary: `**Task**: ${desc}`, ...taskId ? { taskId } : {} });
+                    const taskId = sstr(m.task_id);
+                    if (!taskId)
+                      break;
+                    live.taskIds.add(taskId);
+                    emit({
+                      type: "agent:task",
+                      sessionId: sid,
+                      taskId,
+                      phase: "started",
+                      status: "running",
+                      ...sstr(m.tool_use_id) ? { toolUseId: sstr(m.tool_use_id) } : {},
+                      ...parentToolUseId ? { parentToolUseId } : {},
+                      description: sstr(m.description) || "subagent task",
+                      ...sstr(m.subagent_type) ? { subagentType: sstr(m.subagent_type) } : {},
+                      ...sstr(m.workflow_name) ? { workflowName: sstr(m.workflow_name) } : {}
+                    });
+                    break;
+                  }
+                  case "task_progress": {
+                    const taskId = sstr(m.task_id);
+                    if (!taskId)
+                      break;
+                    const u = m.usage;
+                    emit({
+                      type: "agent:task",
+                      sessionId: sid,
+                      taskId,
+                      phase: "progress",
+                      status: "running",
+                      ...sstr(m.description) ? { description: sstr(m.description) } : {},
+                      ...sstr(m.subagent_type) ? { subagentType: sstr(m.subagent_type) } : {},
+                      ...sstr(m.last_tool_name) ? { lastToolName: sstr(m.last_tool_name) } : {},
+                      ...sstr(m.summary) ? { summary: sstr(m.summary) } : {},
+                      ...u ? { usage: { totalTokens: u.total_tokens ?? 0, toolUses: u.tool_uses ?? 0, durationMs: u.duration_ms ?? 0 } } : {}
+                    });
+                    break;
+                  }
+                  case "task_updated": {
+                    const taskId = sstr(m.task_id);
+                    if (!taskId)
+                      break;
+                    const patch = m.patch && typeof m.patch === "object" ? m.patch : {};
+                    const status2 = ["pending", "running", "completed", "failed", "killed", "paused"].includes(sstr(patch.status)) ? patch.status : void 0;
+                    emit({
+                      type: "agent:task",
+                      sessionId: sid,
+                      taskId,
+                      phase: "updated",
+                      ...status2 ? { status: status2 } : {},
+                      ...sstr(patch.description) ? { description: sstr(patch.description) } : {},
+                      ...sstr(patch.error) ? { error: sstr(patch.error) } : {}
+                    });
+                    if (status2 === "completed" || status2 === "failed" || status2 === "killed")
+                      live.taskIds.delete(taskId);
                     break;
                   }
                   case "task_notification": {
-                    const status2 = m.status || "completed";
-                    const summary = m.summary || "";
-                    const body = summary ? `**${status2}** \u2014 ${summary}` : `**${status2}**`;
-                    emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: `${systemHeader("system", "task_notification")}
-
-${body}` });
+                    const taskId = sstr(m.task_id);
+                    if (!taskId)
+                      break;
+                    const status2 = ["completed", "failed", "stopped"].includes(sstr(m.status)) ? m.status : "completed";
+                    const u = m.usage;
+                    emit({
+                      type: "agent:task",
+                      sessionId: sid,
+                      taskId,
+                      phase: "done",
+                      status: status2,
+                      ...sstr(m.summary) ? { summary: sstr(m.summary) } : {},
+                      ...u ? { usage: { totalTokens: u.total_tokens ?? 0, toolUses: u.tool_uses ?? 0, durationMs: u.duration_ms ?? 0 } } : {}
+                    });
+                    live.taskIds.delete(taskId);
                     break;
                   }
+                  // Slash-command output is user-requested content — a visible inline notice
+                  // (NOT the geek-only debug feed).
                   case "local_command_output": {
-                    const content = m.content || "";
-                    if (content.trim()) {
-                      emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: `${systemHeader("system", "local_command_output")}
-
-${content}` });
+                    const content = sstr(m.content).trim();
+                    if (content)
+                      emitNotice({ category: "info", level: "info", title: "Command output", body: content, inline: true, toast: false });
+                    break;
+                  }
+                  // The session worker is stopping — surface it so an abrupt halt is explained.
+                  case "worker_shutting_down": {
+                    emitNotice({ category: "info", level: "warning", title: "Session worker is restarting", ...sstr(m.reason) ? { body: sstr(m.reason) } : {}, toast: true, inline: true });
+                    break;
+                  }
+                  // File persistence — only surface FAILURES (successes stay quiet in the log).
+                  case "files_persisted": {
+                    const failed = Array.isArray(m.failed) ? m.failed : [];
+                    if (failed.length) {
+                      emitNotice({ category: "info", level: "warning", title: `${failed.length} file${failed.length === 1 ? "" : "s"} failed to save`, body: failed.map((f) => `${sstr(f.filename)}: ${sstr(f.error)}`).join("\n"), toast: true, inline: true });
                     }
                     break;
                   }
                   case "hook_response": {
-                    const stdout = m.stdout || "";
-                    const stderr = m.stderr || "";
-                    const out = stdout || stderr;
-                    if (out.trim()) {
-                      const hookName = m.hook_name || "hook";
-                      emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: `${systemHeader("system", `hook_response/${hookName}`)}
-
-${out}` });
+                    const hookName = sstr(m.hook_name) || "hook";
+                    const out = (sstr(m.stderr) || sstr(m.stdout) || sstr(m.output)).trim();
+                    const exit = typeof m.exit_code === "number" ? m.exit_code : void 0;
+                    const failed = sstr(m.outcome) === "error" || exit !== void 0 && exit !== 0;
+                    if (failed) {
+                      const body = [sstr(m.hook_event) ? `Event: ${sstr(m.hook_event)}` : "", exit !== void 0 ? `Exit ${exit}` : "", out].filter(Boolean).join("\n").slice(0, 800);
+                      emitNotice({ category: "hook", level: "warning", title: `Hook failed: ${hookName}`, ...body ? { body } : {}, toast: true, inline: true });
+                    } else if (out) {
+                      emitEvent({ category: "hook", name: "hook_response", title: `Hook response \u2014 ${hookName}`, detail: out, updateKey: `hook:${hookName}` });
                     }
                     break;
                   }
@@ -24839,9 +25390,7 @@ ${out}` });
                   // M4 H11 — compaction boundary: clear the "compacting" indicator + a notice.
                   case "compact_boundary": {
                     emit({ type: "agent:session_state", sessionId: sid, state: "running" });
-                    emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: `${systemHeader("system", "compact_boundary")}
-
-Compacted earlier context.` });
+                    emitEvent({ category: "lifecycle", name: "compact_boundary", title: "Compacted earlier context", fields: salientFields(m) });
                     break;
                   }
                   // M4 H11 — authoritative idle/running/requires_action. Never drains
@@ -24856,20 +25405,37 @@ Compacted earlier context.` });
                     emit({ type: "agent:elicitation_complete", sessionId: sid, serverName: m.mcp_server_name ?? "", elicitationId: m.elicitation_id ?? "" });
                     break;
                   }
-                  // Low-value subtypes — don't render. Log so we notice if their semantics change.
-                  case "hook_started":
-                  case "hook_progress":
-                  case "task_progress":
-                  case "files_persisted":
+                  // Slash-command set changed (plugin loaded, .claude/commands edited) — push
+                  // the fresh list so the command palette updates without a restart.
+                  case "commands_changed": {
+                    const commands = (Array.isArray(m.commands) ? m.commands : []).flatMap((c) => {
+                      if (!c || typeof c !== "object")
+                        return [];
+                      const o = c;
+                      if (typeof o.name !== "string")
+                        return [];
+                      return [{ name: o.name, description: typeof o.description === "string" ? o.description : "", ...typeof o.hint === "string" ? { hint: o.hint } : {} }];
+                    });
+                    this.send({ type: "commands:list", commands }, live.origin);
                     break;
+                  }
+                  // Subtypes that earn a real user-facing notice (toast + inline card + native
+                  // when unfocused) rather than the raw debug feed: model-fallback, blocked
+                  // tools, plugin installs, leveled info, memory recall.
+                  case "notification":
+                  case "informational":
+                  case "plugin_install":
+                  case "memory_recall":
+                  case "permission_denied":
+                  case "model_refusal_fallback":
+                  case "model_refusal_no_fallback": {
+                    const notice = buildNotice(subtype, m);
+                    if (notice)
+                      emitNotice(notice);
+                    break;
+                  }
                   default: {
-                    const text3 = extractHumanReadable(m);
-                    const header = systemHeader("system", subtype);
-                    const body = text3 ? `${header}
-
-${text3}` : header;
-                    emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: body });
-                    log("best-effort surfaced unknown system subtype:", subtype ?? "?");
+                    emitEvent(describeSystemSubtype(subtype ?? "unknown", m), parentToolUseId);
                     break;
                   }
                 }
@@ -24924,24 +25490,40 @@ ${text3}` : header;
                 }
                 break;
               }
-              case "tool_progress":
-              case "prompt_suggestion":
+              // A still-running tool's elapsed time → update its card's badge in place. Only
+              // once it's been a few seconds (fast tools finish before the badge matters).
+              case "tool_progress": {
+                const tp = message;
+                const elapsed = Math.round(Number(tp.elapsed_time_seconds ?? 0));
+                if (tp.tool_use_id && elapsed >= 3)
+                  emit({ type: "agent:tool_use", sessionId: sid, toolName: "_progress_", summary: "", toolUseId: tp.tool_use_id, elapsedSeconds: elapsed, ...parentToolUseId ? { parentToolUseId } : {} });
+                break;
+              }
+              // A predicted follow-up prompt → a clickable chip under the reply.
+              case "prompt_suggestion": {
+                const s = sstr(message.suggestion).trim();
+                if (s)
+                  emit({ type: "agent:suggestion", sessionId: sid, suggestion: s });
                 break;
+              }
               default: {
                 const m = message;
                 const text3 = extractHumanReadable(m);
-                const header = systemHeader(m.type || "unknown");
-                const body = text3 ? `${header}
-
-${text3}` : header;
-                emit({ type: "agent:tool_use", sessionId: sid, toolName: "_notice_", summary: body });
-                log("best-effort surfaced unknown SDK message type:", m.type || "?");
+                emitEvent({
+                  category: "unknown",
+                  name: m.type || "unknown",
+                  title: m.type || "unknown frame",
+                  ...text3 ? { detail: text3 } : {},
+                  raw: rawFramePreview(m)
+                }, parentToolUseId);
+                log("unknown SDK message type surfaced with raw data:", m.type || "?");
                 break;
               }
             }
           }
         } catch (err) {
           const sid = live.sessionId;
+          live.pendingThinking = void 0;
           if (live.interrupted || live.abort.signal.aborted) {
             live.interrupted = false;
             this.clearStopWatchdog(live);
@@ -27132,26 +27714,26 @@ var require_build = __commonJS({
             throw new Error(`Unknown type of encoding '${enc}'`);
         }
       }
-      static FromString(str, enc = "utf8") {
-        if (!str) {
+      static FromString(str2, enc = "utf8") {
+        if (!str2) {
           return new ArrayBuffer(0);
         }
         switch (enc.toLowerCase()) {
           case "utf8":
-            return this.FromUtf8String(str);
+            return this.FromUtf8String(str2);
           case "binary":
-            return this.FromBinary(str);
+            return this.FromBinary(str2);
           case "hex":
-            return this.FromHex(str);
+            return this.FromHex(str2);
           case "base64":
-            return this.FromBase64(str);
+            return this.FromBase64(str2);
           case "base64url":
-            return this.FromBase64Url(str);
+            return this.FromBase64Url(str2);
           case "utf16le":
-            return Utf16Converter.fromString(str, true);
+            return Utf16Converter.fromString(str2, true);
           case "utf16":
           case "utf16be":
-            return Utf16Converter.fromString(str);
+            return Utf16Converter.fromString(str2);
           default:
             throw new Error(`Unknown type of encoding '${enc}'`);
         }
@@ -27354,11 +27936,11 @@ var require_utils = __commonJS({
     function bufferToHexCodes(inputBuffer, inputOffset = 0, inputLength = inputBuffer.byteLength - inputOffset, insertSpace = false) {
       let result = "";
       for (const item of new Uint8Array(inputBuffer, inputOffset, inputLength)) {
-        const str = item.toString(16).toUpperCase();
-        if (str.length === 1) {
+        const str2 = item.toString(16).toUpperCase();
+        if (str2.length === 1) {
           result += "0";
         }
-        result += str;
+        result += str2;
         if (insertSpace) {
           result += " ";
         }
@@ -27525,17 +28107,17 @@ var require_utils = __commonJS({
       return true;
     }
     function padNumber(inputNumber, fullLength) {
-      const str = inputNumber.toString(10);
-      if (fullLength < str.length) {
+      const str2 = inputNumber.toString(10);
+      if (fullLength < str2.length) {
         return "";
       }
-      const dif = fullLength - str.length;
+      const dif = fullLength - str2.length;
       const padding = new Array(dif);
       for (let i = 0; i < dif; i++) {
         padding[i] = "0";
       }
       const paddingString = padding.join("");
-      return paddingString.concat(str);
+      return paddingString.concat(str2);
     }
     var base64Template = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
     var base64UrlTemplate = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=";
@@ -27647,12 +28229,12 @@ var require_utils = __commonJS({
       }
       return resultString;
     }
-    function stringToArrayBuffer(str) {
-      const stringLength = str.length;
+    function stringToArrayBuffer(str2) {
+      const stringLength = str2.length;
       const resultBuffer = new ArrayBuffer(stringLength);
       const resultView = new Uint8Array(resultBuffer);
       for (let i = 0; i < stringLength; i++) {
-        resultView[i] = str.charCodeAt(i);
+        resultView[i] = str2.charCodeAt(i);
       }
       return resultBuffer;
     }
@@ -30090,11 +30672,11 @@ ${values.join("\n")}` : `${blockName} :`;
         this.fromString(String.fromCharCode.apply(null, pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer)));
       }
       toBuffer() {
-        const str = this.toString();
-        const buffer = new ArrayBuffer(str.length);
+        const str2 = this.toString();
+        const buffer = new ArrayBuffer(str2.length);
         const view = new Uint8Array(buffer);
-        for (let i = 0; i < str.length; i++)
-          view[i] = str.charCodeAt(i);
+        for (let i = 0; i < str2.length; i++)
+          view[i] = str2.charCodeAt(i);
         return buffer;
       }
       fromDate(inputDate) {
@@ -45761,6 +46343,7 @@ async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntim
     stopTask: (sessionId, taskId, callerOrigin) => manager2.stopTask(sessionId, taskId, callerOrigin),
     respondToElicitation: (requestId, decision, callerOrigin) => manager2.respondToElicitation(requestId, decision, callerOrigin),
     respondToUiRequest: (requestId, response, callerOrigin) => manager2.respondToUiRequest(requestId, response, callerOrigin),
+    respondToUserDialog: (requestId, decision, callerOrigin) => manager2.respondToUserDialog(requestId, decision, callerOrigin),
     mcpServerStatus: (sessionId) => manager2.mcpServerStatus(sessionId),
     reconnectMcpServer: (sessionId, name) => manager2.reconnectMcpServer(sessionId, name),
     toggleMcpServer: (sessionId, name, enabled) => manager2.toggleMcpServer(sessionId, name, enabled),
@@ -53507,18 +54090,18 @@ var unifyPaths = (paths_) => {
   return paths.map(normalizePathToUnix);
 };
 var toUnix = (string4) => {
-  let str = string4.replace(BACK_SLASH_RE, SLASH);
+  let str2 = string4.replace(BACK_SLASH_RE, SLASH);
   let prepend = false;
-  if (str.startsWith(SLASH_SLASH)) {
+  if (str2.startsWith(SLASH_SLASH)) {
     prepend = true;
   }
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  while (str2.match(DOUBLE_SLASH_RE)) {
+    str2 = str2.replace(DOUBLE_SLASH_RE, SLASH);
   }
   if (prepend) {
-    str = SLASH + str;
+    str2 = SLASH + str2;
   }
-  return str;
+  return str2;
 };
 var normalizePathToUnix = (path5) => toUnix(sysPath2.normalize(toUnix(path5)));
 var normalizeIgnored = (cwd = "") => (path5) => {
@@ -56069,6 +56652,9 @@ async function handleInboundAgent(msg, driverClientId) {
     case "chat:ui_response":
       b.respondToUiRequest?.(msg.requestId, msg.response, origin);
       break;
+    case "chat:user_dialog":
+      b.respondToUserDialog?.(msg.requestId, { behavior: msg.behavior, result: msg.result }, origin);
+      break;
     case "agent:mcp_reconnect":
       void b.reconnectMcpServer?.(msg.sessionId, msg.name);
       break;
@@ -56836,6 +57422,9 @@ async function startLocalServer(opts) {
         case "chat:ui_response":
           b.respondToUiRequest?.(msg.requestId, msg.response, loopbackOrigin);
           break;
+        case "chat:user_dialog":
+          b.respondToUserDialog?.(msg.requestId, { behavior: msg.behavior, result: msg.result }, loopbackOrigin);
+          break;
         case "agent:mcp_reconnect":
           void b.reconnectMcpServer?.(msg.sessionId, msg.name);
           break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tesseract-agent",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",