@codemap-ai/cli 0.1.0

package/dist/chat-terminal-DFFYQ6AF.js

@@ -0,0 +1,1743 @@
+import{createRequire as __cmr}from"node:module";import{fileURLToPath as __f2p}from"node:url";import{dirname as __dn}from"node:path";var require=__cmr(import.meta.url);var __filename=__f2p(import.meta.url);var __dirname=__dn(__filename);
+import {
+  fetchResourceContext
+} from "./chunk-WNJNT3FC.js";
+import {
+  executeCommand,
+  getCachedContext,
+  getCommandList,
+  loadOrSynthesizeAll,
+  loadThreadIntoUI,
+  runShell,
+  warmupFileSearch
+} from "./chunk-KWYP3ADN.js";
+import {
+  buildLocalIndex,
+  getMastraCurrentModelId,
+  getMastraThreadId,
+  getMastraThreadTokenUsage,
+  readWorkspacePath,
+  refreshLocalFile,
+  removeLocalFile,
+  resetHarnessSingleton,
+  resolveGatewayModel,
+  runMultiPhaseWithMastra,
+  runWithMastraHarness,
+  switchMastraThread,
+  tryGetCurrentWorkspaceInfo,
+  warmupHarness
+} from "./chunk-FFFJKKKM.js";
+import {
+  C_ERROR,
+  C_SUCCESS,
+  RESET
+} from "./chunk-YRXVMFXS.js";
+import "./chunk-AXGGL47C.js";
+
+// src/cli-agent/chat/ui/chat-terminal.ts
+import path2 from "path";
+
+// src/cli-agent/chat/harness/cli-runtime.ts
+async function runSingleAgentRuntime(input) {
+  return runWithMastraHarness(input);
+}
+async function runMultiPhaseAgentRuntime(input) {
+  return runMultiPhaseWithMastra(input);
+}
+
+// src/cli-agent/core/mention-context.ts
+import path from "path";
+import { readFile, stat } from "fs/promises";
+var MAX_FILE_CHARS = 24e3;
+var MAX_TOTAL_CHARS = 6e4;
+var MAX_MENTIONED_FILES = 8;
+async function hydrateMentionContext(message) {
+  const mentions = extractFileMentions(message).slice(0, MAX_MENTIONED_FILES);
+  if (mentions.length === 0) {
+    return { content: message, files: [], warnings: [] };
+  }
+  const workspacePath = await readWorkspacePath();
+  const files = [];
+  const warnings = [];
+  const blocks = [];
+  let totalChars = 0;
+  for (const mentionPath of mentions) {
+    const safePath = normalizeMentionPath(mentionPath);
+    if (!safePath) {
+      warnings.push(`Skipped unsafe file mention: ${mentionPath}`);
+      continue;
+    }
+    const absolutePath = path.join(workspacePath, safePath);
+    try {
+      const fileStat = await stat(absolutePath);
+      if (!fileStat.isFile()) {
+        warnings.push(`Mention is not a file: ${safePath}`);
+        continue;
+      }
+      const raw = await readFile(absolutePath, "utf8");
+      const remaining = MAX_TOTAL_CHARS - totalChars;
+      if (remaining <= 0) {
+        warnings.push(
+          "Skipped remaining file mentions because context is full."
+        );
+        break;
+      }
+      const limit = Math.min(MAX_FILE_CHARS, remaining);
+      const content = raw.length > limit ? raw.slice(0, limit) : raw;
+      totalChars += content.length;
+      files.push(safePath);
+      blocks.push(formatFileBlock(safePath, content, raw.length > limit));
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        continue;
+      }
+      const message2 = error instanceof Error ? error.message : String(error);
+      warnings.push(`Could not read ${safePath}: ${message2}`);
+    }
+  }
+  if (blocks.length === 0) {
+    return { content: message, files, warnings };
+  }
+  return {
+    content: `${message}
+
+${formatContextBlock(blocks)}`,
+    files,
+    warnings
+  };
+}
+function extractFileMentions(message) {
+  const matches = message.matchAll(/@([^\s`"'<>]+)/g);
+  const seen = /* @__PURE__ */ new Set();
+  const mentions = [];
+  for (const match of matches) {
+    const mention = stripTrailingPunctuation(match[1] ?? "");
+    if (!mention || seen.has(mention) || !looksLikeFilePath(mention)) continue;
+    seen.add(mention);
+    mentions.push(mention);
+  }
+  return mentions;
+}
+function looksLikeFilePath(input) {
+  if (input.includes("/")) return true;
+  if (input.startsWith(".")) return true;
+  if (/\.[a-zA-Z0-9]{1,10}$/.test(input)) return true;
+  return false;
+}
+function normalizeMentionPath(input) {
+  const normalized = path.posix.normalize(input.replace(/\\/g, "/"));
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.startsWith("/")) {
+    return null;
+  }
+  return normalized;
+}
+function stripTrailingPunctuation(input) {
+  return input.replace(/[.,;:!?]+$/, "");
+}
+function formatContextBlock(blocks) {
+  return `<mentioned_files>
+${blocks.join("\n\n")}
+</mentioned_files>`;
+}
+function formatFileBlock(filePath, content, truncated) {
+  const suffix = truncated ? "\n\n[truncated]" : "";
+  return `<file path="${escapeAttribute(filePath)}">
+${content}${suffix}
+</file>`;
+}
+function escapeAttribute(input) {
+  return input.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+
+// src/cli-agent/core/task-classifier.ts
+var CLASSIFIER_SYSTEM = `You are a task router for a coding assistant. Analyze the user message and respond with ONLY a JSON object.
+
+Output format:
+{"phase":"single"|"multi","taskType":"feature"|"bugfix"|"debugging"|"review"|"refactor"|"research"|"general","effort":"low"|"medium"|"high","reason":"<one line>"}
+
+Rules:
+- phase "multi": ONLY for large features spanning multiple modules, major architectural refactors, or when user explicitly says "make a plan" / "plan first". Requires genuine multi-step planning before coding.
+- phase "single": everything else \u2014 including simple file edits, bug fixes, test changes, adding a function, renaming things, one-file changes, quick fixes, explaining code, Q&A, and ALL lookup/search/find/explain tasks. Default to "single" unless the task is clearly large/complex.
+- CRITICAL: phase "multi" is NEVER correct for lookup, search, find, explain, or read-only tasks. If the task does not produce code changes, it is always "single".
+- effort "high": complex multi-file debugging, architectural decisions, security/auth/payment changes, multi-phase tasks, user says "carefully"/"thoroughly"/"deep dive", investigating intermittent/hard-to-reproduce issues
+- effort "medium": standard coding tasks \u2014 add a feature, fix a bug, write tests, refactor a module
+- effort "low": rename, one-liner fix, explaining code, lookup/search tasks, Q&A
+
+Examples:
+- "fix the bug in auth.ts" \u2192 single, bugfix, medium
+- "add a unit test for parseDate" \u2192 single, feature, low
+- "implement pagination for the project list" \u2192 single, feature, medium
+- "rename variable X to Y in file Z" \u2192 single, refactor, low
+- "s\u1EEDa 1 d\xF2ng trong file X" / "delete line X" \u2192 single, bugfix, low
+- "debug t\u1EA1i sao auth redirect b\u1ECB l\u1ED7i" \u2192 single, debugging, high
+- "fix the race condition in the payment flow" \u2192 single, bugfix, high
+- "investigate why the import worker crashes intermittently" \u2192 single, debugging, high
+- "explain how this function works" \u2192 single, review, low
+- "t\xECm \u0111o\u1EA1n code render X" / "find where X is rendered" \u2192 single, review, low
+- "how does X work" / "ch\u1ED7 n\xE0o x\u1EED l\xFD X" \u2192 single, research, low
+- "implement full OAuth2 system across auth/web/api modules" \u2192 multi, feature, high
+- "refactor the entire database layer" \u2192 multi, refactor, high
+- "make a plan for adding notifications" \u2192 multi, feature, high
+
+Respond with ONLY the JSON.`;
+var FALLBACK = {
+  phase: "single",
+  taskType: "general",
+  effort: "medium",
+  reason: "classification failed"
+};
+var CONFIRMATION_SYNONYMS = /* @__PURE__ */ new Set([
+  "ok",
+  "okay",
+  "yes",
+  "y",
+  "go",
+  "proceed",
+  "sure",
+  "do it",
+  "implement",
+  "\u1EEB",
+  "\u1EEBm",
+  "\u0111\u1ED3ng \xFD",
+  "\u0111\u01B0\u1EE3c",
+  "l\xE0m \u0111i",
+  "l\xE0m lu\xF4n",
+  "ti\u1EBFp t\u1EE5c",
+  "ok lu\xF4n",
+  "okie",
+  "yep",
+  "yup",
+  "oke"
+]);
+var CONFIRMATION_RESULT = {
+  phase: "single",
+  taskType: "general",
+  effort: "medium",
+  reason: "confirmation \u2014 continuing coding task"
+};
+async function classifyTask(message, provider, model, signal) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 8e3);
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    if (signal?.aborted) return FALLBACK;
+    if (CONFIRMATION_SYNONYMS.has(message.trim().toLowerCase())) {
+      return CONFIRMATION_RESULT;
+    }
+    let raw = "";
+    for await (const chunk of provider.stream({
+      model,
+      system: CLASSIFIER_SYSTEM,
+      messages: [{ role: "user", content: message }],
+      maxTokens: 120,
+      signal: controller.signal
+    })) {
+      if (chunk.text) raw += chunk.text;
+    }
+    return parseClassification(raw);
+  } catch {
+    return FALLBACK;
+  } finally {
+    clearTimeout(timeout);
+    signal?.removeEventListener("abort", abort);
+  }
+}
+function parseClassification(raw) {
+  const json = raw.replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
+  const parsed = JSON.parse(json);
+  if (!isPhase(parsed.phase)) return FALLBACK;
+  if (!isTaskType(parsed.taskType)) return FALLBACK;
+  const readOnlyTaskType = parsed.taskType === "research" || parsed.taskType === "review";
+  const phase = parsed.phase === "multi" && readOnlyTaskType ? "single" : parsed.phase;
+  return {
+    phase,
+    taskType: parsed.taskType,
+    effort: isEffort(parsed.effort) ? parsed.effort : "low",
+    reason: typeof parsed.reason === "string" ? parsed.reason : ""
+  };
+}
+function isPhase(value) {
+  return value === "single" || value === "multi";
+}
+function isTaskType(value) {
+  return value === "feature" || value === "bugfix" || value === "debugging" || value === "review" || value === "refactor" || value === "research" || value === "general";
+}
+function isEffort(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+
+// src/cli-agent/core/debug-logger.ts
+import { appendFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+function findGitRoot() {
+  let dir = process.cwd();
+  while (true) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+var LOG_DIR = join(findGitRoot(), ".codemap", "debug-logs");
+function ensureDir() {
+  if (!existsSync(LOG_DIR)) {
+    mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+function createDebugLogger() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const logFile = join(LOG_DIR, `chat-${timestamp}.jsonl`);
+  let requestIdx = 0;
+  ensureDir();
+  function write(entry) {
+    appendFileSync(
+      logFile,
+      JSON.stringify(sanitizeForLog({ ...entry, ts: (/* @__PURE__ */ new Date()).toISOString() })) + "\n"
+    );
+  }
+  return {
+    logFile,
+    logStreamRequest(info) {
+      write({ type: "stream_request", req: requestIdx++, ...info });
+    },
+    logChunk(chunkIdx, info) {
+      write({ type: "chunk", req: requestIdx - 1, chunkIdx, ...info });
+    },
+    logToolStart(name, args, id) {
+      write({ type: "tool_start", name, id, args: args.slice(0, 500) });
+    },
+    logToolResult(name, result) {
+      write({ type: "tool_result", name, result: result.slice(0, 500) });
+    },
+    logToolFallback(reason) {
+      write({ type: "tool_fallback", reason });
+    },
+    logError(err) {
+      const entry = {
+        type: "error",
+        message: err instanceof Error ? err.message : String(err)
+      };
+      if (err instanceof Error && err.stack) {
+        entry.stack = err.stack.split("\n").slice(0, 5).join("\n");
+      }
+      if (err instanceof Error && "cause" in err && err.cause) {
+        entry.cause = String(err.cause);
+      }
+      write(entry);
+    },
+    logSummary(info) {
+      write({ type: "summary", ...info });
+    },
+    logDebugInfo(info) {
+      write({ type: "debug_info", ...info });
+    }
+  };
+}
+function sanitizeForLog(value, depth = 0) {
+  if (value == null) return value;
+  if (typeof value === "string") {
+    return value.length > 1e3 ? `${value.slice(0, 1e3)}\u2026[truncated ${value.length}]` : value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) {
+    if (depth >= 4) return `[array ${value.length}]`;
+    return value.slice(0, 50).map((item) => sanitizeForLog(item, depth + 1));
+  }
+  if (typeof value === "object") {
+    if (depth >= 4) return "[object]";
+    const out = {};
+    for (const [key, item] of Object.entries(value).slice(0, 80)) {
+      out[key] = sanitizeForLog(item, depth + 1);
+    }
+    return out;
+  }
+  return String(value);
+}
+
+// src/cli-agent/chat/ui/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  anyListeners = /* @__PURE__ */ new Set();
+  refreshScheduled = false;
+  on(type, listener) {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(listener);
+    return () => set.delete(listener);
+  }
+  onAny(listener) {
+    this.anyListeners.add(listener);
+    return () => this.anyListeners.delete(listener);
+  }
+  emit(event) {
+    const set = this.listeners.get(event.type);
+    if (set) {
+      for (const fn of set) fn(event);
+    }
+    for (const fn of this.anyListeners) fn(event);
+  }
+  /**
+   * Schedule a single screen:refresh on the next microtask.
+   * Multiple calls in the same tick coalesce into one refresh.
+   */
+  scheduleRefresh() {
+    if (this.refreshScheduled) return;
+    this.refreshScheduled = true;
+    queueMicrotask(() => {
+      this.refreshScheduled = false;
+      this.emit({ type: "screen:refresh" });
+    });
+  }
+  removeAll() {
+    this.listeners.clear();
+    this.anyListeners.clear();
+  }
+};
+
+// src/cli-agent/chat/ui/store.ts
+function createInitialState(opts) {
+  return {
+    screen: "main",
+    messages: [],
+    taskList: [],
+    taskListVisible: true,
+    task: {
+      phase: "idle",
+      toolsCalled: 0
+    },
+    sessionTokens: 0,
+    streaming: {
+      active: false,
+      content: "",
+      entryIndex: -1
+    },
+    input: {
+      busy: false,
+      history: [],
+      lastUserText: null
+    },
+    subprocess: {
+      active: false,
+      command: "",
+      logLines: []
+    },
+    config: {
+      model: opts.model,
+      debug: opts.debug ?? false,
+      availableModels: opts.availableModels ?? []
+    },
+    chatMode: "auto",
+    workspaceState: {
+      indexStatus: "unknown",
+      isIndexStale: false,
+      hasLocalChanges: false,
+      changedFilesCount: 0,
+      authMode: "local",
+      includeDiff: false
+    },
+    contextState: {
+      files: [],
+      symbols: [],
+      searches: [],
+      diffs: [],
+      toolCalls: [],
+      assumptions: []
+    },
+    synthRunning: false,
+    planMode: false,
+    planReview: { active: false, selection: 0, reviseMode: false },
+    askQuestion: null,
+    debug: opts.debug ?? false,
+    debugLogFile: null
+  };
+}
+var Store = class {
+  state;
+  dirty = false;
+  bus;
+  constructor(initialState, bus) {
+    this.state = initialState;
+    this.bus = bus;
+  }
+  getState() {
+    return this.state;
+  }
+  /**
+   * Merge a partial state update. Schedules a single screen:refresh
+   * on the next microtask, coalescing multiple dispatches in the same tick.
+   */
+  dispatch(partial) {
+    if (typeof partial === "function") {
+      partial = partial(this.state);
+    }
+    this.state = deepMerge(this.state, partial);
+    if (!this.dirty) {
+      this.dirty = true;
+      queueMicrotask(() => {
+        this.dirty = false;
+        this.bus.emit({ type: "screen:refresh" });
+      });
+    }
+  }
+  /** Immediate dispatch — used for streaming tokens that need instant redraw. */
+  dispatchImmediate(partial) {
+    this.state = deepMerge(this.state, partial);
+    this.bus.emit({ type: "screen:refresh" });
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (srcVal !== null && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal !== null && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+      result[key] = deepMerge(tgtVal, srcVal);
+    } else if (srcVal !== void 0) {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+
+// src/cli-agent/chat/ui/tool-call-messages.ts
+function normalizeToolDisplayName(toolName) {
+  return toolName.includes("__") ? toolName.slice(toolName.indexOf("__") + 2) : toolName;
+}
+function parseJsonObject(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function stringField(obj, keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function summarizeToolArgs(toolName, args) {
+  const displayName = normalizeToolDisplayName(toolName);
+  const parsed = parseJsonObject(args);
+  if (!parsed) return `Call ${displayName}`;
+  const direct = stringField(parsed, [
+    "activeForm",
+    "content",
+    "path",
+    "query",
+    "q",
+    "url",
+    "command",
+    "title",
+    "question",
+    "id"
+  ]);
+  if (direct) return direct;
+  const patterns = parsed.pattern;
+  if (Array.isArray(patterns) && patterns.length > 0) {
+    return patterns.map(String).join(", ");
+  }
+  return `Call ${displayName}`;
+}
+function summarizeToolResult(resultText) {
+  const errorPrefix = "[ERROR] ";
+  const isError = resultText.startsWith(errorPrefix);
+  const body = isError ? resultText.slice(errorPrefix.length) : resultText;
+  const parsed = parseJsonObject(body);
+  if (!parsed) return resultText;
+  const content = stringField(parsed, ["content", "message", "summary"]);
+  if (!content) return resultText;
+  return isError ? `${errorPrefix}${content}` : content;
+}
+function withToolCallSummary(messages, toolName, args, toolCallId) {
+  const displayName = normalizeToolDisplayName(toolName);
+  const next = [...messages];
+  for (let i = next.length - 1; i >= 0; i -= 1) {
+    const msg = next[i];
+    if (!msg) continue;
+    if (msg.role === "user") break;
+    if (msg.role === "tool_call" && msg.name === displayName && (!toolCallId || msg.toolCallId === toolCallId)) {
+      return next;
+    }
+  }
+  const childLine = summarizeToolArgs(toolName, args);
+  const toolCallMsg = {
+    role: "tool_call",
+    name: displayName,
+    toolCallId,
+    content: childLine,
+    timestamp: Date.now()
+  };
+  next.push(toolCallMsg);
+  return next;
+}
+function markToolDone(messages, toolName, resultText, toolCallId) {
+  const success = !resultText.startsWith("[ERROR] ");
+  const marker = success ? ` ${C_SUCCESS}\u2713${RESET}` : ` ${C_ERROR}\u2717${RESET}`;
+  const displayName = normalizeToolDisplayName(toolName);
+  const summarizedResult = summarizeToolResult(resultText);
+  const next = [...messages];
+  let toolCallIndex = -1;
+  for (const mode of ["id", "name"]) {
+    if (toolCallIndex >= 0) break;
+    if (mode === "id" && !toolCallId) continue;
+    for (let i = next.length - 1; i >= 0; i -= 1) {
+      const msg = next[i];
+      if (!msg) continue;
+      if (msg.role === "user") break;
+      if (msg.role === "tool_call" && (mode === "id" && msg.toolCallId === toolCallId || mode === "name" && msg.name === displayName)) {
+        toolCallIndex = i;
+        break;
+      }
+    }
+  }
+  if (toolCallIndex >= 0) {
+    const resultName = displayName || next[toolCallIndex]?.name || displayName;
+    const toolResult = {
+      name: resultName,
+      content: summarizedResult,
+      fullContent: resultText,
+      success
+    };
+    const existingResults = next[toolCallIndex].toolResults ?? [];
+    next[toolCallIndex] = {
+      ...next[toolCallIndex],
+      toolResults: [...existingResults, toolResult],
+      content: next[toolCallIndex].content + marker,
+      expandedContent: resultText
+    };
+    return next;
+  }
+  return next;
+}
+function setToolCallPreview(messages, preview) {
+  const next = [...messages];
+  for (let i = next.length - 1; i >= 0; i -= 1) {
+    const msg = next[i];
+    if (!msg) continue;
+    if (msg.role === "user") break;
+    if (msg.role === "tool_call") {
+      next[i] = { ...msg, previewContent: preview };
+      return next;
+    }
+  }
+  return next;
+}
+function markLastPendingToolCallCanceled(messages) {
+  const next = [...messages];
+  for (let i = next.length - 1; i >= 0; i -= 1) {
+    const msg = next[i];
+    if (!msg) continue;
+    if (msg.role === "user") break;
+    if (msg.role !== "tool_call" || (msg.toolResults?.length ?? 0) > 0) {
+      continue;
+    }
+    const name = msg.name ?? "tool";
+    const content = "[ERROR] Canceled by user.";
+    next[i] = {
+      ...msg,
+      content: msg.content.endsWith(" \u2713") || msg.content.endsWith(" \u2717") ? msg.content : `${msg.content} \u2717`,
+      toolResults: [
+        ...msg.toolResults ?? [],
+        {
+          name,
+          content,
+          fullContent: content,
+          success: false
+        }
+      ],
+      expandedContent: content
+    };
+    return next;
+  }
+  return next;
+}
+function isTaskTool(toolName) {
+  const normalized = toolName.toLowerCase();
+  return normalized.includes("task_write") || normalized.includes("task_update") || normalized.includes("task_complete") || normalized.includes("task_check");
+}
+function syncTaskListFromTool(store, toolName, argsJson, resultJson) {
+  if (!isTaskTool(toolName)) return;
+  const args = parseJsonObject(argsJson);
+  if (!args) return;
+  const result = parseJsonObject(resultJson);
+  const resultTasks = extractTasksFromResult(result);
+  const normalized = toolName.toLowerCase();
+  if (normalized.includes("task_write")) {
+    handleTaskWrite(store, args, resultTasks);
+  } else if (normalized.includes("task_update")) {
+    handleTaskUpdate(store, args, resultTasks);
+  } else if (normalized.includes("task_complete")) {
+    handleTaskComplete(store, args, resultTasks);
+  } else if (normalized.includes("task_check")) {
+    handleTaskCheck(store, resultTasks);
+  }
+}
+function extractTasksFromResult(result) {
+  if (!result) return null;
+  const structured = result.structuredContent && typeof result.structuredContent === "object" && !Array.isArray(result.structuredContent) ? result.structuredContent : null;
+  if (structured) {
+    const data = structured.data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const tasks = data.tasks;
+      if (Array.isArray(tasks)) {
+        const filtered = tasks.filter(
+          (t) => typeof t === "object" && t !== null && typeof t.id === "string"
+        );
+        if (filtered.length > 0) return filtered;
+      }
+    }
+  }
+  const topLevelTasks = result.tasks;
+  if (Array.isArray(topLevelTasks)) {
+    const filtered = topLevelTasks.filter(
+      (t) => typeof t === "object" && t !== null && typeof t.id === "string"
+    );
+    if (filtered.length > 0) return filtered;
+  }
+  return null;
+}
+function handleTaskWrite(store, args, resultTasks) {
+  const inputTasks = extractInputTasks(args);
+  if (!inputTasks && !resultTasks) return;
+  const incomingTasks = resultTasks ?? inputTasks;
+  if (incomingTasks && incomingTasks.length === 0) {
+    store.dispatch({ taskList: [], taskListVisible: false });
+    return;
+  }
+  store.dispatch((prev) => {
+    const prevById = new Map(prev.taskList.map((t) => [t.id, t]));
+    const source = resultTasks ?? inputTasks ?? [];
+    const next = [];
+    for (const t of source) {
+      if (!t.id) continue;
+      const prev2 = prevById.get(t.id);
+      next.push({
+        id: t.id,
+        content: t.content ?? prev2?.content ?? "",
+        status: t.status ?? prev2?.status ?? "pending",
+        activeForm: t.activeForm ?? prev2?.activeForm ?? ""
+      });
+    }
+    return { taskList: next, taskListVisible: true };
+  });
+}
+function handleTaskUpdate(store, args, resultTasks) {
+  if (resultTasks && resultTasks.length > 0) {
+    store.dispatch({ taskList: resultTasks });
+    return;
+  }
+  const id = typeof args.id === "string" ? args.id : null;
+  if (!id) return;
+  const content = typeof args.content === "string" ? args.content : void 0;
+  const status = typeof args.status === "string" ? args.status : void 0;
+  const activeForm = typeof args.activeForm === "string" ? args.activeForm : void 0;
+  store.dispatch((prev) => ({
+    taskList: prev.taskList.map(
+      (t) => t.id === id ? {
+        ...t,
+        ...content !== void 0 && { content },
+        ...status !== void 0 && { status },
+        ...activeForm !== void 0 && { activeForm }
+      } : t
+    )
+  }));
+}
+function handleTaskComplete(store, args, resultTasks) {
+  if (resultTasks && resultTasks.length > 0) {
+    store.dispatch({ taskList: resultTasks });
+    return;
+  }
+  const id = typeof args.id === "string" ? args.id : null;
+  if (!id) return;
+  store.dispatch((prev) => ({
+    taskList: prev.taskList.map(
+      (t) => t.id === id ? { ...t, status: "completed" } : t
+    )
+  }));
+}
+function handleTaskCheck(store, resultTasks) {
+  if (!resultTasks) return;
+  store.dispatch({ taskList: resultTasks });
+}
+function extractInputTasks(args) {
+  const tasks = args.tasks;
+  if (Array.isArray(tasks)) {
+    return tasks.filter(
+      (t) => typeof t === "object" && t !== null
+    );
+  }
+  return null;
+}
+
+// src/cli-agent/chat/ui/chat-terminal.ts
+function isStrongModel(model) {
+  return /\b(strong|opus|sonnet|gpt-5|gpt-4|o3|o4|deepseek-r1|qwen3-coder)\b/i.test(
+    model
+  );
+}
+function createAbortError() {
+  const err = new Error("Task canceled.");
+  err.name = "AbortError";
+  return err;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+function extractCloudCommitFromGetProject(result) {
+  const structured = result?.structuredContent;
+  if (!structured || typeof structured !== "object") return void 0;
+  const data = structured;
+  const commitSha = data.data?.projectContext?.latestImport?.commitSha ?? data.data?.health?.latestImport?.commitSha ?? data.projectContext?.latestImport?.commitSha ?? data.health?.latestImport?.commitSha;
+  return typeof commitSha === "string" && commitSha.trim() ? commitSha.trim() : void 0;
+}
+var CODEMAP_AGENT_IDENTITY = [
+  "## CodeMap Identity",
+  "",
+  "You are CodeMap, the AI-powered code intelligence and coding agent CLI.",
+  "Mastra and mastracode are internal runtime implementation details, not the product identity.",
+  "Never identify yourself as Mastra Code, Mastra, Claude Code, Codex, or another host/runtime.",
+  "If asked what AI coding tool you are, answer that you are CodeMap.",
+  "Help the user read, understand, modify, and verify code in the current workspace."
+].join("\n");
+function buildSessionContext(modelId) {
+  return modelId ? `## Session Info
+
+You are running as model: **${modelId}**` : null;
+}
+function buildCurrentTaskContent(content) {
+  return [
+    "## Current Task",
+    "",
+    "<task>",
+    content,
+    "</task>",
+    "",
+    "Work only on this task. Use repository tools only when they are needed for this task; if the user already named exact files or symbols, inspect those directly."
+  ].join("\n");
+}
+function buildCodeMapAgentInstructions(resourceContext, projectContext, modelId) {
+  const parts = [CODEMAP_AGENT_IDENTITY];
+  const sessionContext = buildSessionContext(modelId);
+  if (sessionContext) parts.push(sessionContext);
+  if (projectContext?.rules) parts.push(projectContext.rules);
+  if (projectContext?.conventions) parts.push(projectContext.conventions);
+  if (projectContext?.skills) parts.push(projectContext.skills);
+  if (resourceContext) parts.push(resourceContext);
+  return parts.join("\n\n---\n\n");
+}
+async function abortable(promise, signal) {
+  if (signal.aborted) throw createAbortError();
+  let cleanup;
+  const abortPromise = new Promise((_, reject) => {
+    const onAbort = () => reject(createAbortError());
+    cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return Promise.race([
+    promise.then(
+      (value) => {
+        cleanup?.();
+        return value;
+      },
+      (err) => {
+        cleanup?.();
+        throw err;
+      }
+    ),
+    abortPromise
+  ]);
+}
+var ChatTerminal = class {
+  // Public so App and InputArea can access
+  bus;
+  store;
+  _planReviewResolve = null;
+  _askQuestionResolve = null;
+  _taskAbort = null;
+  _taskSeq = 0;
+  _activeTaskId = 0;
+  logger = null;
+  options;
+  // Session-level caches — fetched once on first turn, reused for the entire session.
+  _resourceContext = void 0;
+  // undefined = not yet fetched
+  _projectContext = void 0;
+  constructor(options) {
+    this.options = options;
+    this.bus = new EventBus();
+    const debug = process.env.CODEMAP_DEBUG_AGENT_TOOLS === "1";
+    this.store = new Store(
+      createInitialState({
+        model: options.model,
+        availableModels: options.availableModels,
+        debug
+      }),
+      this.bus
+    );
+    if (debug) this.logger = createDebugLogger();
+  }
+  async refreshWorkspaceCommits() {
+    try {
+      const info = await tryGetCurrentWorkspaceInfo();
+      if (info) {
+        const current = this.store.getState().workspace;
+        this.store.dispatch({
+          workspace: {
+            repoName: info.repoName,
+            branch: info.branch,
+            localCommit: info.commitSha,
+            cloudCommit: current?.cloudCommit
+          }
+        });
+      }
+    } catch {
+    }
+    try {
+      const result = await this.options.toolClient.callTool("get_project", {
+        verbose: false
+      });
+      const cloudCommit = extractCloudCommitFromGetProject(result);
+      if (!cloudCommit) return;
+      const current = this.store.getState().workspace;
+      if (!current) return;
+      this.store.dispatch({
+        workspace: {
+          repoName: current.repoName,
+          branch: current.branch,
+          localCommit: current.localCommit,
+          cloudCommit
+        }
+      });
+    } catch {
+    }
+  }
+  // ─── Public API for components ───────────────────────────
+  /** Cancel the running task and reset to idle. Late async results are ignored by task id. */
+  cancelTask() {
+    const state = this.store.getState();
+    if (!state.input.busy) return null;
+    const canceledPrompt = state.input.lastUserText;
+    const msgs = state.messages;
+    const lastUserIdx = msgs.reduce(
+      (acc, m, i) => m.role === "user" ? i : acc,
+      -1
+    );
+    const hasMessagesAfterLastUser = lastUserIdx >= 0 && msgs.slice(lastUserIdx + 1).length > 0;
+    const hasStreamingContent = Boolean(state.streaming.content.trim());
+    const shouldRollback = !hasMessagesAfterLastUser && !hasStreamingContent;
+    this._taskAbort?.abort();
+    this._taskAbort = null;
+    this._activeTaskId = 0;
+    this._planReviewResolve?.("cancel");
+    this._planReviewResolve = null;
+    this._askQuestionResolve?.("(skipped)");
+    this._askQuestionResolve = null;
+    const nextMessages = shouldRollback ? lastUserIdx >= 0 ? msgs.slice(0, lastUserIdx) : msgs : markLastPendingToolCallCanceled(msgs);
+    this.store.dispatch({
+      messages: nextMessages,
+      input: { ...state.input, busy: false },
+      task: { phase: "idle", toolsCalled: 0 },
+      planReview: { active: false, selection: 0 },
+      askQuestion: null,
+      streaming: { active: false, content: "", entryIndex: -1 }
+    });
+    return shouldRollback ? canceledPrompt : null;
+  }
+  /** Called by the multi-phase loop: pause and wait for user plan review. */
+  waitForPlanReview() {
+    return new Promise((resolve) => {
+      this._planReviewResolve = resolve;
+      this.store.dispatch({
+        planReview: { active: true, selection: 0, reviseMode: false }
+      });
+      this.bus.scheduleRefresh();
+    });
+  }
+  /** Called by the UI when user makes a plan review decision. */
+  resolvePlanReview(action) {
+    this._planReviewResolve?.(action);
+    this._planReviewResolve = null;
+    this.store.dispatch({
+      planReview: { active: false, selection: 0, reviseMode: false }
+    });
+    this.bus.scheduleRefresh();
+  }
+  /** Called by the multi-phase/single loop: pause and wait for user to answer ask_user question. */
+  waitForAskQuestion(questionId, question, options, selectionMode) {
+    return new Promise((resolve) => {
+      this._askQuestionResolve = resolve;
+      this.store.dispatch({
+        askQuestion: {
+          active: true,
+          questionId,
+          question,
+          options,
+          selection: 0,
+          selectionMode: selectionMode ?? (options?.length ? "single_select" : void 0),
+          selected: []
+        }
+      });
+      this.bus.scheduleRefresh();
+    });
+  }
+  /** Called by the UI when user answers the ask_user question. */
+  resolveAskQuestion(answer) {
+    this._askQuestionResolve?.(answer);
+    this._askQuestionResolve = null;
+    this.store.dispatch({ askQuestion: null });
+    this.bus.scheduleRefresh();
+  }
+  // ─── Start ───────────────────────────────────────────────
+  async start() {
+    if (!this.options.apiToken && this.options.mcpConfig) {
+      const { showLoginScreen } = await import("./login-screen-2DJBDM47.js");
+      const result = await showLoginScreen(this.options.mcpConfig);
+      if (result === "exit") return;
+    }
+    warmupFileSearch().catch(() => {
+    }).finally(() => this.bus.scheduleRefresh());
+    await this.refreshWorkspaceCommits();
+    const startupModel = this.store.getState().config.model;
+    const mastraTools = await this.options.toolClient.getMastraTools().catch(() => void 0);
+    warmupHarness({
+      toolClient: this.options.toolClient,
+      baseUrl: this.options.provider.baseUrl,
+      apiKey: this.options.provider.apiKey,
+      modelId: startupModel,
+      availableModels: this.store.getState().config.availableModels.map((m) => m.id),
+      onDebug: void 0,
+      extraServerConfigs: this.options.toolClient.getExtraServerConfigs(),
+      mastraTools
+    }).catch(() => {
+    });
+    this.store.dispatch({ synthRunning: true });
+    this.bus.scheduleRefresh();
+    loadOrSynthesizeAll(this.options.provider, this.store.getState().config.model).catch(() => {
+    }).finally(() => {
+      this.store.dispatch({ synthRunning: false });
+      this.bus.scheduleRefresh();
+    });
+    const { startPiTuiApp } = await import("./pi-tui-app-GVZ3AN42.js");
+    await startPiTuiApp(this);
+  }
+  // ─── Session management ───────────────────────────────────
+  persistSession() {
+  }
+  startNewSession() {
+    this.store.dispatch((prev) => ({
+      messages: [],
+      sessionTokens: 0,
+      input: { ...prev.input, history: [] }
+    }));
+    resetHarnessSingleton().catch(() => {
+    });
+  }
+  async loadThreadById(threadId) {
+    try {
+      await switchMastraThread(threadId);
+      await loadThreadIntoUI(
+        threadId,
+        (msgs) => this.store.dispatch({ messages: msgs }),
+        (msg) => this.appendMessage(msg)
+      );
+      const threadUsage = await getMastraThreadTokenUsage().catch(() => null);
+      this.store.dispatch({
+        sessionTokens: threadUsage?.totalTokens ?? 0
+      });
+    } catch (err) {
+      this.appendMessage({
+        role: "system",
+        content: `Failed to load thread: ${err}`
+      });
+    }
+  }
+  // ─── Submit ──────────────────────────────────────────────
+  async handleSubmit(text) {
+    await this.handleSubmitWithContent(text);
+  }
+  async handleSubmitWithContent(text, forceMultiPhase = false, imageFiles) {
+    const state = this.store.getState();
+    if (state.input.busy) return;
+    if (/^\/plan(\s|$)/i.test(text)) {
+      const taskText = text.replace(/^\/plan\s*/i, "").trim();
+      if (taskText) {
+        await this.handleSubmitWithContent(taskText, true);
+      } else {
+        const current = this.store.getState().planMode;
+        this.store.dispatch({ planMode: !current });
+        this.appendMessage({
+          role: "system",
+          content: !current ? "Plan mode ON \u2014 all messages will go through planner \u2192 coder \u2192 reviewer.\nType /plan again to exit." : "Plan mode OFF \u2014 back to normal routing."
+        });
+      }
+      return;
+    }
+    if (text.startsWith("/")) {
+      if (text === "/help") {
+        this.store.dispatch({ screen: "help" });
+        return;
+      }
+      const handled = executeCommand(text, this.buildCommandContext());
+      if (!handled) {
+        this.appendMessage({
+          role: "system",
+          content: "Unknown command. Type /help for available commands."
+        });
+      }
+      return;
+    }
+    if (text.startsWith("!")) {
+      await this.handleShellSubmit(text);
+      return;
+    }
+    this.store.dispatch({
+      input: { ...state.input, busy: true, lastUserText: text }
+    });
+    this.appendMessage({ role: "user", content: text });
+    this.store.dispatch({
+      task: {
+        phase: "thinking",
+        startTime: Date.now(),
+        toolsCalled: 0,
+        model: this.store.getState().config.model,
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+      }
+    });
+    const taskAbort = new AbortController();
+    const taskId = this.beginTask(taskAbort);
+    let streamingContent = "";
+    let hasStreamingEntry = false;
+    const toolArgsById = /* @__PURE__ */ new Map();
+    const dirtyLocalIndexPaths = /* @__PURE__ */ new Set();
+    let fullIndexRefreshTimer = null;
+    const extractEditedPath = (toolName, argsText) => {
+      if (![
+        "write_file",
+        "string_replace_lsp",
+        "ast_smart_edit",
+        "delete_file"
+      ].includes(toolName))
+        return null;
+      try {
+        const args = JSON.parse(argsText);
+        return typeof args.path === "string" && args.path.trim() ? args.path.trim() : null;
+      } catch {
+        return null;
+      }
+    };
+    const scheduleFullLocalIndexRefresh = () => {
+      if (fullIndexRefreshTimer) clearTimeout(fullIndexRefreshTimer);
+      fullIndexRefreshTimer = setTimeout(() => {
+        fullIndexRefreshTimer = null;
+        void buildLocalIndex().catch((error) => {
+          this.logger?.logDebugInfo({
+            event: "local_index_refresh_failed",
+            error: String(error)
+          });
+        });
+      }, 3e3);
+    };
+    const resetStreaming = () => {
+      streamingContent = "";
+      hasStreamingEntry = false;
+      this.store.dispatch({
+        streaming: { active: false, content: "", entryIndex: -1 }
+      });
+    };
+    const sharedCallbacks = {
+      onStreamReset: () => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        streamingContent = "";
+        this.store.dispatch({
+          streaming: { active: false, content: "", entryIndex: -1 }
+        });
+        this.bus.scheduleRefresh();
+      },
+      onToken: (token) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        const s = this.store.getState();
+        if (!s.task || s.task.phase === "idle") return;
+        streamingContent += token;
+        if (!hasStreamingEntry) {
+          hasStreamingEntry = true;
+          const entryIndex = this.appendMessage({
+            role: "assistant",
+            content: streamingContent
+          });
+          this.store.dispatch({
+            streaming: { active: true, content: streamingContent, entryIndex }
+          });
+        } else {
+          this.updateLastAssistantMessage(streamingContent);
+          this.store.dispatch((prev) => ({
+            streaming: {
+              ...prev.streaming,
+              active: true,
+              content: streamingContent
+            }
+          }));
+        }
+        this.store.dispatch({
+          task: {
+            ...s.task,
+            phase: "streaming",
+            toolName: void 0,
+            toolArgs: void 0
+          }
+        });
+        this.bus.scheduleRefresh();
+      },
+      onModel: (model) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.store.dispatch({ task: { ...this.store.getState().task, model } });
+      },
+      onUsage: (usage) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.store.dispatch((prev) => ({ task: { ...prev.task, usage } }));
+      },
+      onToolStart: (name, args, id, preview) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.logger?.logToolStart(name, args, id);
+        if (id) toolArgsById.set(id, { name, args });
+        streamingContent = "";
+        this.store.dispatch({
+          streaming: { active: false, content: "", entryIndex: -1 }
+        });
+        const s = this.store.getState();
+        this.store.dispatch({
+          task: {
+            ...s.task,
+            phase: "tool",
+            toolName: name,
+            toolArgs: args,
+            toolsCalled: s.task.toolsCalled + 1
+          }
+        });
+        this.store.dispatch((prev) => {
+          const newMsgs = withToolCallSummary(prev.messages, name, args, id);
+          return {
+            messages: preview ? setToolCallPreview(newMsgs, preview) : newMsgs
+          };
+        });
+        this.bus.scheduleRefresh();
+      },
+      onToolResult: (name, resultText, id) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.logger?.logToolResult(name, resultText);
+        resetStreaming();
+        this.store.dispatch({
+          task: {
+            ...this.store.getState().task,
+            phase: "executing",
+            toolName: void 0,
+            toolArgs: void 0
+          }
+        });
+        this.store.dispatch((prev) => {
+          const newMsgs = markToolDone(prev.messages, name, resultText, id);
+          return { messages: newMsgs };
+        });
+        const toolMeta = id ? toolArgsById.get(id) : void 0;
+        const rawName = toolMeta?.name ?? name;
+        const rawArgs = toolMeta?.args ?? "{}";
+        if (id) toolArgsById.delete(id);
+        syncTaskListFromTool(this.store, rawName, rawArgs, resultText);
+        const editedPath = extractEditedPath(rawName, rawArgs);
+        if (editedPath) {
+          const relativePath = path2.isAbsolute(editedPath) ? path2.relative(process.cwd(), editedPath) : editedPath;
+          if (!relativePath.startsWith("..")) {
+            dirtyLocalIndexPaths.add(relativePath);
+            const isDelete = rawName === "delete_file";
+            const refresh = isDelete ? removeLocalFile(relativePath).then((removed) => removed) : refreshLocalFile(relativePath).then((updated) => updated);
+            void refresh.then((changed) => {
+              if (changed) scheduleFullLocalIndexRefresh();
+            }).catch((error) => {
+              this.logger?.logDebugInfo({
+                event: isDelete ? "local_file_remove_failed" : "local_file_refresh_failed",
+                filePath: relativePath,
+                error: String(error)
+              });
+            });
+          }
+        }
+        this.bus.scheduleRefresh();
+      },
+      onOMObservation: (tokensObserved, observationTokens) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.appendMessage({
+          role: "system",
+          content: `\u{1F9E0} Memory: observed ${tokensObserved.toLocaleString()} tokens \u2192 distilled to ${observationTokens.toLocaleString()} observation tokens`
+        });
+        this.bus.scheduleRefresh();
+      },
+      onOMReflection: (compressedTokens) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.appendMessage({
+          role: "system",
+          content: `\u{1F9E0} Memory: reflected & compressed ${compressedTokens.toLocaleString()} tokens`
+        });
+        this.bus.scheduleRefresh();
+      },
+      onDebug: (info) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        if (!this.store.getState().debug) return;
+        if (info.event === "stream_request") {
+          this.logger?.logStreamRequest({
+            model: String(info.model ?? ""),
+            messageCount: Number(info.messageCount ?? 0),
+            toolCount: Number(info.toolCount ?? 0),
+            hasSystem: Boolean(info.hasSystem),
+            toolsCalled: this.store.getState().task.toolsCalled
+          });
+        } else if (info.event === "tool_fallback") {
+          this.logger?.logToolFallback(String(info.reason ?? ""));
+        } else {
+          this.logger?.logDebugInfo(info);
+        }
+      },
+      onAskQuestion: (questionId, question, options, respond, selectionMode) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.waitForAskQuestion(questionId, question, options, selectionMode).then((answer) => {
+          respond(answer);
+        }).catch(() => {
+          respond("(skipped)");
+        });
+      }
+    };
+    try {
+      const mentionContext = await hydrateMentionContext(text);
+      if (!this.isActiveTask(taskId, taskAbort)) return;
+      for (const warning of mentionContext.warnings) {
+        this.appendMessage({ role: "system", content: `\u26A0 ${warning}` });
+      }
+      const currentModel = this.store.getState().config.model;
+      let classification = {
+        phase: "single",
+        taskType: "general",
+        reason: "",
+        effort: "medium"
+      };
+      const planMode = this.store.getState().planMode;
+      if (!forceMultiPhase && !planMode) {
+        this.store.dispatch({
+          task: {
+            ...this.store.getState().task,
+            phase: "classifying",
+            model: currentModel
+          }
+        });
+        this.bus.scheduleRefresh();
+        classification = await classifyTask(
+          text,
+          this.options.provider,
+          currentModel,
+          taskAbort.signal
+        );
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        this.store.dispatch({
+          task: { ...this.store.getState().task, phase: "thinking", effort: classification.effort }
+        });
+        this.bus.scheduleRefresh();
+      }
+      const useMultiPhase = forceMultiPhase || planMode || classification.phase === "multi";
+      if (useMultiPhase) {
+        this.store.dispatch({
+          task: { ...this.store.getState().task, effort: "high" }
+        });
+      } else {
+        this.store.dispatch({
+          task: { ...this.store.getState().task, effort: classification.effort }
+        });
+      }
+      const [sessionResourceCtx, sessionProjectCtx] = await Promise.all([
+        this.getSessionResourceContext(taskAbort.signal),
+        this.getSessionProjectContext()
+      ]);
+      const resolvedAgentModel = getMastraCurrentModelId() ?? resolveGatewayModel(
+        this.store.getState().config.model,
+        this.store.getState().config.availableModels.map((m) => m.id)
+      );
+      const agentInstructions = buildCodeMapAgentInstructions(
+        sessionResourceCtx,
+        sessionProjectCtx,
+        resolvedAgentModel
+      );
+      const handlePlanReady = (_plan) => {
+        if (!this.isActiveTask(taskId, taskAbort)) return;
+        resetStreaming();
+      };
+      const result = useMultiPhase ? await runMultiPhaseAgentRuntime({
+        provider: this.options.provider,
+        availableModels: this.store.getState().config.availableModels.map((m) => m.id),
+        model: this.store.getState().config.model,
+        agentInstructions,
+        userMessage: {
+          role: "user",
+          content: buildCurrentTaskContent(mentionContext.content)
+        },
+        toolClient: this.options.toolClient,
+        signal: taskAbort.signal,
+        effort: "high",
+        onPhaseStart: (phase, model) => {
+          if (!this.isActiveTask(taskId, taskAbort)) return;
+          resetStreaming();
+          this.store.dispatch({
+            task: { ...this.store.getState().task, phase, model, effort: "high" }
+          });
+          this.bus.scheduleRefresh();
+        },
+        onPlanReady: handlePlanReady,
+        onPlanWait: () => this.waitForPlanReview(),
+        imageFiles,
+        ...sharedCallbacks
+      }) : await runSingleAgentRuntime({
+        provider: this.options.provider,
+        model: this.store.getState().config.model,
+        availableModels: this.store.getState().config.availableModels.map((m) => m.id),
+        agentInstructions,
+        userMessage: {
+          role: "user",
+          content: buildCurrentTaskContent(mentionContext.content)
+        },
+        toolClient: this.options.toolClient,
+        signal: taskAbort.signal,
+        onPlanReady: handlePlanReady,
+        onPlanWait: () => this.waitForPlanReview(),
+        imageFiles,
+        effort: classification.effort,
+        ...sharedCallbacks
+      });
+      if (!this.isActiveTask(taskId, taskAbort)) return;
+      const s = this.store.getState();
+      this.store.dispatch({
+        task: {
+          ...s.task,
+          phase: "done",
+          toolName: void 0,
+          toolArgs: void 0,
+          endTime: Date.now()
+        }
+      });
+      if (useMultiPhase && planMode && !forceMultiPhase) {
+        this.store.dispatch({ planMode: false });
+      }
+      if (this.logger) {
+        const toolCallsList = result.messages.filter((m) => m.role === "assistant" && m.toolCalls).flatMap((m) => m.toolCalls ?? []).map((tc) => tc.function.name);
+        this.logger.logSummary({
+          totalChunks: 0,
+          textChunks: 0,
+          toolCallChunks: toolCallsList.length,
+          finalToolCalls: toolCallsList,
+          model: this.store.getState().config.model
+        });
+      }
+      if (result.unsupportedToolCalling) {
+        const cs = this.store.getState().config;
+        this.appendMessage({
+          role: "system",
+          content: `\u26A0 Model "${cs.model}" does not support tool calling \u2014 the coder generated text instead of using tools.
+Check your coder profile in config and switch to a tool-capable model.`
+        });
+      }
+      if (useMultiPhase && !result.usedTools && !result.unsupportedToolCalling) {
+        this.appendMessage({
+          role: "system",
+          content: `\u26A0 Execute phase completed without any tool calls \u2014 the model may not be routing to a tool-capable backend.
+Check your coder profile configuration or start a new session with /new.`
+        });
+      }
+      if (hasStreamingEntry && result.text) {
+        this.updateLastAssistantMessage(result.text || "(no response)");
+      } else if (!hasStreamingEntry) {
+        this.appendMessage({
+          role: "assistant",
+          content: result.text || "(no response)"
+        });
+      }
+      resetStreaming();
+      this.bus.scheduleRefresh();
+      const mastraUsage = await getMastraThreadTokenUsage().catch(() => null);
+      this.store.dispatch({
+        sessionTokens: mastraUsage?.totalTokens ?? 0
+      });
+      this.bus.scheduleRefresh();
+    } catch (err) {
+      if (isAbortError(err) || taskAbort.signal.aborted) return;
+      this.store.dispatch({ task: { phase: "idle", toolsCalled: 0 } });
+      this.logger?.logError(err);
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const isContextFull = errMsg.includes("context window") || errMsg.includes("context length") || errMsg.includes("maximum context") || errMsg.includes("token limit") || errMsg.includes("too long") || errMsg.includes("exceeds") || errMsg.includes("input is too long") || errMsg.includes("prompt is too long");
+      const isModelBroken = errMsg.includes("zero-length") || errMsg.includes("empty document") || errMsg.includes("429");
+      const isImageUnsupported = errMsg.includes("image input") || errMsg.includes("support image");
+      const cs = this.store.getState().config;
+      if (isContextFull) {
+        this.appendMessage({
+          role: "system",
+          content: "Context window full. Start a new session with /new to free context."
+        });
+      } else if (isModelBroken && cs.availableModels.length > 1) {
+        const strong = cs.availableModels.filter(
+          (m) => m.id !== cs.model && isStrongModel(m.id)
+        );
+        const newModel = strong[0] ?? cs.availableModels.find((m) => m.id !== cs.model) ?? null;
+        if (newModel) {
+          this.store.dispatch({ config: { ...cs, model: newModel.id } });
+          this.appendMessage({
+            role: "system",
+            content: `Model "${cs.model}" failed. Auto-switched to "${newModel}". Resend your message to retry.`
+          });
+        } else {
+          this.appendMessage({
+            role: "system",
+            content: `Model "${cs.model}" failed and no alternative found.`
+          });
+        }
+      } else if (isImageUnsupported) {
+        this.appendMessage({
+          role: "system",
+          content: imageFiles?.length ? `Model "${cs.model}" does not support image input. Switch to a vision-capable model with /model, or resend without images.` : `Model "${cs.model}" does not support image input.`
+        });
+      } else {
+        this.appendMessage({ role: "system", content: `Error: ${errMsg}` });
+      }
+    }
+    if (this.isActiveTask(taskId, taskAbort)) {
+      this.finishTask(taskId);
+    }
+  }
+  async handleShellSubmit(text) {
+    const command = text.slice(1).trim();
+    if (!command) {
+      this.appendMessage({
+        role: "system",
+        content: "Usage: !<shell command>"
+      });
+      return;
+    }
+    this.store.dispatch((prev) => ({ input: { ...prev.input, busy: true } }));
+    this.appendMessage({ role: "user", content: text });
+    this.store.dispatch({
+      task: {
+        phase: "tool",
+        startTime: Date.now(),
+        toolsCalled: 1,
+        toolName: "bash",
+        toolArgs: command,
+        model: this.store.getState().config.model,
+        usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+      }
+    });
+    const taskAbort = new AbortController();
+    const taskId = this.beginTask(taskAbort);
+    this.appendMessage({ role: "tool_call", name: "bash", content: command });
+    try {
+      const result = await abortable(runShell(command), taskAbort.signal);
+      if (!this.isActiveTask(taskId, taskAbort)) return;
+      const content = result || "(no output)";
+      this.store.dispatch((prev) => ({
+        messages: markToolDone(prev.messages, "bash", content)
+      }));
+      this.store.dispatch({
+        task: {
+          ...this.store.getState().task,
+          phase: "done",
+          toolName: void 0,
+          toolArgs: void 0,
+          endTime: Date.now()
+        }
+      });
+    } catch (err) {
+      if (isAbortError(err) || taskAbort.signal.aborted) return;
+      const message = err instanceof Error ? err.message : String(err);
+      this.store.dispatch((prev) => ({
+        messages: markToolDone(prev.messages, "bash", `[ERROR] ${message}`)
+      }));
+      this.appendMessage({
+        role: "system",
+        content: `Shell command failed: ${message}`
+      });
+      this.store.dispatch({ task: { phase: "idle", toolsCalled: 0 } });
+    } finally {
+      if (this.isActiveTask(taskId, taskAbort)) {
+        this.finishTask(taskId);
+      }
+      this.bus.scheduleRefresh();
+    }
+  }
+  // ─── Session context cache ────────────────────────────────
+  async getSessionResourceContext(signal) {
+    if (this._resourceContext !== void 0) return this._resourceContext;
+    try {
+      this._resourceContext = await fetchResourceContext(
+        this.options.toolClient
+      );
+    } catch {
+      this._resourceContext = null;
+    }
+    return this._resourceContext;
+  }
+  async getSessionProjectContext() {
+    if (this._projectContext !== void 0) return this._projectContext;
+    try {
+      this._projectContext = await getCachedContext();
+    } catch {
+      this._projectContext = { conventions: null, rules: null, skills: null };
+    }
+    return this._projectContext ?? { conventions: null, rules: null, skills: null };
+  }
+  // ─── Message helpers ──────────────────────────────────────
+  appendMessage(msg) {
+    let index = -1;
+    this.store.dispatch((prev) => {
+      index = prev.messages.length;
+      return {
+        messages: [...prev.messages, { timestamp: Date.now(), ...msg }]
+      };
+    });
+    return index;
+  }
+  updateLastAssistantMessage(content) {
+    this.store.dispatch((prev) => {
+      const msgs = [...prev.messages];
+      for (let i = msgs.length - 1; i >= 0; i--) {
+        if (msgs[i].role === "assistant") {
+          msgs[i] = { ...msgs[i], content };
+          break;
+        }
+      }
+      return { messages: msgs };
+    });
+  }
+  beginTask(controller) {
+    const taskId = ++this._taskSeq;
+    this._activeTaskId = taskId;
+    this._taskAbort = controller;
+    return taskId;
+  }
+  finishTask(taskId) {
+    if (this._activeTaskId !== taskId) return;
+    this._activeTaskId = 0;
+    this._taskAbort = null;
+    this.store.dispatch((prev) => ({ input: { ...prev.input, busy: false } }));
+  }
+  isActiveTask(taskId, controller) {
+    return this._activeTaskId === taskId && this._taskAbort === controller && !controller.signal.aborted;
+  }
+  // ─── Command context ──────────────────────────────────────
+  buildCommandContext() {
+    const s = this.store.getState();
+    return {
+      currentModel: s.config.model,
+      provider: this.options.provider,
+      availableModels: s.config.availableModels.map((m) => m.id),
+      toolClient: this.options.toolClient,
+      getMessages: () => this.store.getState().messages,
+      appendMessage: (msg) => {
+        this.store.dispatch((prev) => ({
+          messages: [
+            ...prev.messages,
+            { timestamp: Date.now(), ...msg }
+          ]
+        }));
+        this.bus.scheduleRefresh();
+      },
+      setMessages: (updater) => {
+        if (typeof updater === "function") {
+          this.store.dispatch((prev) => ({ messages: updater(prev.messages) }));
+        } else {
+          this.store.dispatch({ messages: updater });
+        }
+      },
+      setInputHistory: (updater) => {
+        if (typeof updater === "function") {
+          this.store.dispatch((prev) => ({
+            input: { ...prev.input, history: updater(prev.input.history) }
+          }));
+        } else {
+          this.store.dispatch((prev) => ({
+            input: { ...prev.input, history: updater }
+          }));
+        }
+      },
+      setCurrentModel: (m) => {
+        this.store.dispatch((prev) => ({
+          config: { ...prev.config, model: m }
+        }));
+      },
+      setBusy: (b) => {
+        this.store.dispatch((prev) => ({ input: { ...prev.input, busy: b } }));
+      },
+      debug: s.debug,
+      setDebug: (d) => {
+        this.store.dispatch((prev) => ({
+          debug: d,
+          config: { ...prev.config, debug: d }
+        }));
+        if (d && !this.logger) this.logger = createDebugLogger();
+        if (!d) this.logger = null;
+      },
+      debugLogFile: this.logger?.logFile ?? null,
+      lastUserText: s.input.lastUserText,
+      persistSession: () => {
+      },
+      getSessionTokens: () => this.store.getState().sessionTokens,
+      resend: () => {
+        const cs = this.store.getState();
+        if (cs.input.lastUserText && !cs.input.busy)
+          this.handleSubmit(cs.input.lastUserText);
+      },
+      exit: () => {
+        process.stdout.write("\x1B[?1000l\x1B[?1006l");
+        process.exit(0);
+      },
+      newSession: () => this.startNewSession(),
+      reinitHarness: async () => {
+        await resetHarnessSingleton();
+        await warmupHarness({
+          toolClient: this.options.toolClient,
+          baseUrl: this.options.provider.baseUrl,
+          apiKey: this.options.provider.apiKey,
+          modelId: this.store.getState().config.model,
+          availableModels: this.store.getState().config.availableModels.map((m) => m.id),
+          onDebug: void 0,
+          extraServerConfigs: this.options.toolClient.getExtraServerConfigs()
+        });
+      },
+      getMastraThreadId: () => getMastraThreadId(),
+      loadThreadById: (id) => this.loadThreadById(id),
+      startSubprocess: (command) => {
+        this.store.dispatch({
+          subprocess: { active: true, command, logLines: [] }
+        });
+      },
+      logSubprocess: (line) => {
+        this.store.dispatch((prev) => ({
+          subprocess: {
+            ...prev.subprocess,
+            logLines: [...prev.subprocess.logLines, line]
+          }
+        }));
+      },
+      endSubprocess: () => {
+        this.store.dispatch({
+          subprocess: { active: false, command: "", logLines: [] }
+        });
+      },
+      refreshWorkspaceCommits: () => this.refreshWorkspaceCommits(),
+      getCommandList
+    };
+  }
+};
+export {
+  ChatTerminal,
+  buildCodeMapAgentInstructions,
+  buildCurrentTaskContent
+};