dodo-ai 0.1.0 → 0.1.4

package/dist/index.mjs

@@ -0,0 +1,3763 @@
+// src/index.tsx
+import fs5 from "fs";
+import path4 from "path";
+import process2 from "process";
+import { spawn } from "child_process";
+import net from "net";
+import { render } from "ink";
+
+// src/ui/app.tsx
+import path3 from "path";
+import { useEffect as useEffect11, useState as useState13, useCallback as useCallback10 } from "react";
+import { Box as Box20, useApp as useApp6 } from "ink";
+
+// src/hooks/useEngineConnection.ts
+import { useState as useState5, useCallback as useCallback6, useMemo as useMemo2 } from "react";
+
+// src/hooks/useConversation.ts
+import { useCallback, useState } from "react";
+
+// src/contexts/ConversationContext.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var ConversationContext = createContext(void 0);
+function ConversationProvider({ children }) {
+  const conversation = useConversationState();
+  return /* @__PURE__ */ jsx(ConversationContext.Provider, { value: conversation, children });
+}
+function useConversationContext() {
+  const context = useContext(ConversationContext);
+  if (!context) {
+    throw new Error("useConversationContext must be used within a ConversationProvider");
+  }
+  return context;
+}
+
+// src/hooks/useConversation.ts
+function isMetadataEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return a === b;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every((key) => a[key] === b[key]);
+}
+function useConversationState() {
+  const [turns, setTurns] = useState([]);
+  const pushTurn = useCallback((userMessage) => {
+    const id = `${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 6)}`;
+    setTurns((prev) => [...prev, {
+      id,
+      user: userMessage,
+      assistant: "",
+      done: false,
+      collapsed: false,
+      activities: [],
+      timelineSteps: [],
+      logLines: []
+    }]);
+  }, []);
+  const appendAssistantContent = useCallback((content, replace = false) => {
+    setTurns((prev) => {
+      if (prev.length === 0) return prev;
+      const lastIndex = prev.length - 1;
+      const last = prev[lastIndex];
+      const newAssistant = replace ? content : last.assistant + content;
+      if (last.assistant === newAssistant) return prev;
+      const updated = [...prev];
+      updated[lastIndex] = { ...last, assistant: newAssistant };
+      return updated;
+    });
+  }, []);
+  const markLastTurnDone = useCallback((summary) => {
+    setTurns((prev) => {
+      if (prev.length === 0) return prev;
+      const lastIndex = prev.length - 1;
+      const last = prev[lastIndex];
+      const updated = [...prev];
+      updated[lastIndex] = { ...last, done: true, summary: summary || last.summary };
+      return updated;
+    });
+  }, []);
+  const addActivity = useCallback((turnId, activity) => {
+    setTurns((prev) => {
+      if (prev.length === 0) return prev;
+      const lastIndex = prev.length - 1;
+      if (prev[lastIndex].id === turnId) {
+        const updated = [...prev];
+        const last = prev[lastIndex];
+        updated[lastIndex] = {
+          ...last,
+          activities: [...last.activities, activity]
+        };
+        return updated;
+      }
+      return prev.map((turn) => {
+        if (turn.id === turnId) {
+          return { ...turn, activities: [...turn.activities, activity] };
+        }
+        return turn;
+      });
+    });
+  }, []);
+  const updateActivity = useCallback(
+    (turnId, activityId, updates) => {
+      setTurns((prev) => {
+        if (prev.length === 0) return prev;
+        const lastIndex = prev.length - 1;
+        const updateTurnActivities = (turn) => {
+          const updatedActivities = turn.activities.map((activity) => {
+            if (activity.id === activityId) {
+              const hasChanges = Object.entries(updates).some(([key, value]) => {
+                if (key === "metadata") return !isMetadataEqual(activity.metadata, value);
+                return activity[key] !== value;
+              });
+              if (!hasChanges) return activity;
+              return { ...activity, ...updates };
+            }
+            return activity;
+          });
+          const activitiesChanged = updatedActivities.some((a, i) => a !== turn.activities[i]);
+          if (!activitiesChanged) return turn;
+          return { ...turn, activities: updatedActivities };
+        };
+        if (prev[lastIndex].id === turnId) {
+          const updated = [...prev];
+          updated[lastIndex] = updateTurnActivities(prev[lastIndex]);
+          return updated;
+        }
+        return prev.map((turn) => {
+          if (turn.id === turnId) {
+            return updateTurnActivities(turn);
+          }
+          return turn;
+        });
+      });
+    },
+    []
+  );
+  const toggleTurnCollapsed = useCallback((turnId) => {
+    setTurns((prev) => {
+      return prev.map((turn) => {
+        if (turn.id === turnId) {
+          return { ...turn, collapsed: !turn.collapsed };
+        }
+        return turn;
+      });
+    });
+  }, []);
+  const addTimelineStep = useCallback((turnId, step) => {
+    setTurns((prev) => {
+      if (prev.length === 0) return prev;
+      const lastIndex = prev.length - 1;
+      if (prev[lastIndex].id === turnId) {
+        const updated = [...prev];
+        const last = prev[lastIndex];
+        updated[lastIndex] = {
+          ...last,
+          timelineSteps: [...last.timelineSteps || [], step]
+        };
+        return updated;
+      }
+      return prev.map((turn) => {
+        if (turn.id === turnId) {
+          return { ...turn, timelineSteps: [...turn.timelineSteps || [], step] };
+        }
+        return turn;
+      });
+    });
+  }, []);
+  const updateTimelineStep = useCallback(
+    (turnId, stepId, updates) => {
+      setTurns((prev) => {
+        if (prev.length === 0) return prev;
+        const lastIndex = prev.length - 1;
+        const updateTurnSteps = (turn) => {
+          const updatedSteps = (turn.timelineSteps || []).map((step) => {
+            if (step.id === stepId) {
+              const hasChanges = Object.entries(updates).some(([key, value]) => {
+                if (key === "metadata") return !isMetadataEqual(step.metadata, value);
+                return step[key] !== value;
+              });
+              if (!hasChanges) return step;
+              return { ...step, ...updates };
+            }
+            return step;
+          });
+          const stepsChanged = updatedSteps.some((s, i) => s !== (turn.timelineSteps || [])[i]);
+          if (!stepsChanged) return turn;
+          return { ...turn, timelineSteps: updatedSteps };
+        };
+        if (prev[lastIndex].id === turnId) {
+          const updated = [...prev];
+          updated[lastIndex] = updateTurnSteps(prev[lastIndex]);
+          return updated;
+        }
+        return prev.map((turn) => {
+          if (turn.id === turnId) {
+            return updateTurnSteps(turn);
+          }
+          return turn;
+        });
+      });
+    },
+    []
+  );
+  const appendLogLine = useCallback((turnId, line) => {
+    setTurns((prev) => {
+      if (prev.length === 0) return prev;
+      const lastIndex = prev.length - 1;
+      if (prev[lastIndex].id === turnId) {
+        const updated = [...prev];
+        const last = prev[lastIndex];
+        updated[lastIndex] = {
+          ...last,
+          logLines: [...last.logLines || [], line]
+        };
+        return updated;
+      }
+      return prev.map((turn) => {
+        if (turn.id === turnId) {
+          return { ...turn, logLines: [...turn.logLines || [], line] };
+        }
+        return turn;
+      });
+    });
+  }, []);
+  const appendToolOutput = useCallback(
+    (turnId, invocationId, output, stream) => {
+      if (!output) return;
+      setTurns((prev) => {
+        if (prev.length === 0) return prev;
+        const lastIndex = prev.length - 1;
+        const updateTurnOutput = (turn) => {
+          const updatedSteps = (turn.timelineSteps || []).map((step) => {
+            if (step.id === invocationId) {
+              const currentMetadata = step.metadata || {};
+              const currentStream = currentMetadata[stream] || "";
+              return {
+                ...step,
+                metadata: {
+                  ...currentMetadata,
+                  [stream]: currentStream + output
+                }
+              };
+            }
+            return step;
+          });
+          return { ...turn, timelineSteps: updatedSteps };
+        };
+        if (prev[lastIndex].id === turnId) {
+          const updated = [...prev];
+          updated[lastIndex] = updateTurnOutput(prev[lastIndex]);
+          return updated;
+        }
+        return prev.map((turn) => {
+          if (turn.id === turnId) {
+            return updateTurnOutput(turn);
+          }
+          return turn;
+        });
+      });
+    },
+    []
+  );
+  const addContextEvent = useCallback((turnId, event) => {
+    const step = {
+      id: `ctx-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      toolName: "context",
+      label: event.description,
+      status: "done",
+      startedAt: /* @__PURE__ */ new Date(),
+      finishedAt: /* @__PURE__ */ new Date(),
+      type: "context_event",
+      contextEventType: event.kind,
+      metadata: {
+        before: event.before,
+        after: event.after
+      }
+    };
+    addTimelineStep(turnId, step);
+  }, [addTimelineStep]);
+  const getCurrentTurnId = useCallback(() => {
+    if (turns.length === 0) return null;
+    return turns[turns.length - 1].id;
+  }, [turns]);
+  const clearTurns = useCallback(() => {
+    setTurns([]);
+  }, []);
+  return {
+    turns,
+    pushTurn,
+    appendAssistantContent,
+    markLastTurnDone,
+    addActivity,
+    updateActivity,
+    toggleTurnCollapsed,
+    addTimelineStep,
+    updateTimelineStep,
+    appendLogLine,
+    appendToolOutput,
+    addContextEvent,
+    getCurrentTurnId,
+    clearTurns
+  };
+}
+function useConversation() {
+  return useConversationContext();
+}
+
+// src/utils/logger.ts
+import fs from "fs";
+import path from "path";
+var LOG_FILE = path.resolve(process.cwd(), "ui_debug.log");
+function safeStringify(obj, space = 2) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(obj, (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  }, space);
+}
+var STATE_LOG_FILE = path.resolve(process.cwd(), "ui_state.log");
+var lastStateLogTime = 0;
+var STATE_LOG_THROTTLE_MS = 1e3;
+var logQueue = [];
+var isProcessing = false;
+async function processQueue() {
+  if (isProcessing || logQueue.length === 0) return;
+  isProcessing = true;
+  while (logQueue.length > 0) {
+    const item = logQueue.shift();
+    if (item) {
+      try {
+        await fs.promises.appendFile(item.file, item.message);
+      } catch (e) {
+      }
+    }
+  }
+  isProcessing = false;
+}
+function queueLog(file, message) {
+  logQueue.push({ file, message });
+  void processQueue();
+}
+var logger = {
+  log: (message, data) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logMessage = `[${timestamp}] [INFO] ${message} ${data ? safeStringify(data, 0) : ""}
+`;
+    queueLog(LOG_FILE, logMessage);
+  },
+  error: (message, error) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let errorDetails = "";
+    if (error instanceof Error) {
+      errorDetails = safeStringify({
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      });
+    } else if (typeof error === "object" && error !== null) {
+      try {
+        errorDetails = safeStringify(error);
+        if (errorDetails === "{}") {
+          const props = Object.getOwnPropertyNames(error).reduce((acc, key) => {
+            acc[key] = error[key];
+            return acc;
+          }, {});
+          errorDetails = safeStringify(props);
+        }
+      } catch (e) {
+        errorDetails = String(error);
+      }
+    } else {
+      errorDetails = String(error);
+    }
+    const errorMessage = `[${timestamp}] [ERROR] ${message} ${errorDetails}
+`;
+    queueLog(LOG_FILE, errorMessage);
+  },
+  clear: () => {
+    try {
+      fs.writeFileSync(LOG_FILE, "");
+      fs.writeFileSync(STATE_LOG_FILE, "");
+    } catch (_) {
+    }
+  },
+  snapshot: (name, data) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const snapshotData = safeStringify(data, 2);
+    const logMessage = `
+[${timestamp}] [SNAPSHOT] === ${name} ===
+${snapshotData}
+=====================================
+`;
+    queueLog(LOG_FILE, logMessage);
+  },
+  state: (message, data, immediate = false) => {
+    const now = Date.now();
+    if (!immediate && now - lastStateLogTime < STATE_LOG_THROTTLE_MS) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logMessage = `[${timestamp}] [STATE] ${message} ${data ? safeStringify(data, 0) : ""}
+`;
+    queueLog(STATE_LOG_FILE, logMessage);
+    if (!immediate) {
+      lastStateLogTime = now;
+    }
+  }
+};
+
+// src/hooks/useEngineConnection.ts
+import { useApp as useApp2 } from "ink";
+
+// src/hooks/useSessionLifecycle.ts
+import { useState as useState2, useRef as useRef2, useEffect as useEffect2, useCallback as useCallback3 } from "react";
+
+// src/hooks/useEngineEvents.ts
+import { useCallback as useCallback2, useEffect, useRef } from "react";
+function useEngineEvents(client, callbacks) {
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const callbacksRef = useRef(callbacks);
+  useEffect(() => {
+    callbacksRef.current = callbacks;
+  });
+  const handleEvent = useCallback2(
+    (event) => {
+      if (!mountedRef.current) return;
+      const currentCallbacks = callbacksRef.current;
+      switch (event.type) {
+        case "status":
+          if (event.status === "session_ready" && event.session_id) {
+            if (currentCallbacks.onSessionReady) currentCallbacks.onSessionReady(event.session_id);
+          } else if (event.status === "engine_ready") {
+          } else if (event.status === "setup_complete") {
+            if (currentCallbacks.onSetupComplete) currentCallbacks.onSetupComplete();
+            const status = mapStatusToUiStatus(event.status);
+            if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange(status, event.detail ?? event.status);
+          } else {
+            const status = mapStatusToUiStatus(event.status);
+            if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange(status, event.detail ?? event.status);
+          }
+          break;
+        case "assistant_text":
+          if (currentCallbacks.onAssistantText) {
+            currentCallbacks.onAssistantText(
+              event.content,
+              false,
+              // Never replace, always append for assistant text
+              event.final ?? false
+            );
+          }
+          break;
+        case "tool_event":
+          if (currentCallbacks.onToolEvent) {
+            currentCallbacks.onToolEvent({
+              tool: event.tool,
+              phase: event.phase,
+              success: event.success,
+              details: event.details,
+              timestamp: /* @__PURE__ */ new Date()
+            });
+          }
+          break;
+        case "files_changed":
+          if (currentCallbacks.onFilesChanged) currentCallbacks.onFilesChanged(event.files);
+          break;
+        case "done":
+          if (currentCallbacks.onDone) currentCallbacks.onDone(event.summary, event.files_changed);
+          if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange("ready", event.summary ?? "Done");
+          break;
+        case "error":
+          if (currentCallbacks.onError) currentCallbacks.onError(event.message);
+          if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange("error", event.message);
+          break;
+        case "token_usage":
+          if (currentCallbacks.onTokenUsage) {
+            currentCallbacks.onTokenUsage({
+              prompt: event.prompt_tokens,
+              limit: event.limit,
+              total: event.total
+            });
+          }
+          break;
+        case "project_plan":
+          if (currentCallbacks.onProjectPlan) currentCallbacks.onProjectPlan(event.content, event.source);
+          break;
+        case "context":
+          if (currentCallbacks.onContext) {
+            currentCallbacks.onContext({
+              kind: event.kind,
+              description: event.description,
+              before: event.before,
+              after: event.after
+            });
+          }
+          break;
+        case "tool_output":
+          if (event.stream === "stdout" || event.stream === "stderr") {
+            if (currentCallbacks.onToolOutput) {
+              currentCallbacks.onToolOutput(
+                event.invocation_id,
+                event.tool,
+                event.output,
+                event.stream
+              );
+            }
+          }
+          break;
+        case "activity":
+          const activity = {
+            id: event.activity_id,
+            type: mapActivityType(event.activity_type),
+            tool: event.tool,
+            target: event.target,
+            metadata: event.metadata,
+            status: mapActivityStatus(event.status),
+            timestamp: /* @__PURE__ */ new Date(),
+            // Fallback if start_time not parsed
+            startTime: event.start_time ? new Date(event.start_time) : void 0,
+            endTime: event.end_time ? new Date(event.end_time) : void 0,
+            durationMs: event.duration_ms,
+            invocationId: event.invocation_id,
+            command: event.command,
+            codeChange: event.code_change ? {
+              file: event.code_change.file,
+              before: event.code_change.before,
+              after: event.code_change.after,
+              startLine: event.code_change.start_line,
+              endLine: event.code_change.end_line
+            } : void 0
+          };
+          if (currentCallbacks.onActivity) currentCallbacks.onActivity(activity);
+          break;
+        case "setup_required":
+          if (currentCallbacks.onSetupRequired) currentCallbacks.onSetupRequired();
+          break;
+        case "config_loaded":
+          if (currentCallbacks.onConfigLoaded) currentCallbacks.onConfigLoaded(event.config);
+          break;
+        case "config_reloaded":
+          if (currentCallbacks.onConfigReloaded) currentCallbacks.onConfigReloaded(event.provider, event.model_name);
+          break;
+        case "cancelled":
+          if (currentCallbacks.onCancelled) currentCallbacks.onCancelled(event.reason);
+          if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange("ready", event.reason || "Cancelled");
+          break;
+        case "session_history":
+          if (currentCallbacks.onSessionHistory) {
+            currentCallbacks.onSessionHistory(event.title, event.summary || "", event.messages || []);
+          }
+          break;
+        case "project_permission_required":
+          if (currentCallbacks.onProjectPermissionRequired) {
+            currentCallbacks.onProjectPermissionRequired(event.repo_root);
+          }
+          break;
+      }
+    },
+    []
+  );
+  const handleError = useCallback2(
+    (err) => {
+      if (!mountedRef.current) return;
+      const currentCallbacks = callbacksRef.current;
+      if (currentCallbacks.onError) currentCallbacks.onError(err.message);
+      if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange("error", err.message);
+    },
+    []
+  );
+  const handleClose = useCallback2(() => {
+    if (!mountedRef.current) return;
+    const currentCallbacks = callbacksRef.current;
+    if (currentCallbacks.onStatusChange) currentCallbacks.onStatusChange("disconnected", "Engine connection closed");
+  }, []);
+  useEffect(() => {
+    client.on("event", handleEvent);
+    client.on("error", handleError);
+    client.on("close", handleClose);
+    return () => {
+      client.off("event", handleEvent);
+      client.off("error", handleError);
+      client.off("close", handleClose);
+    };
+  }, [client, handleEvent, handleError, handleClose]);
+}
+function mapStatusToUiStatus(status) {
+  switch (status) {
+    case "engine_ready":
+      return "connecting";
+    case "thinking":
+      return "thinking";
+    case "step_start":
+      return "running_tools";
+    case "done":
+      return "ready";
+    case "retry":
+    case "budget_exceeded":
+      return "running_tools";
+    default:
+      return "ready";
+  }
+}
+function mapActivityType(type) {
+  switch (type) {
+    case "thinking":
+      return "thinking";
+    case "reasoning":
+      return "reasoning";
+    case "edit":
+      return "edit";
+    case "tool":
+      return "tool";
+    default:
+      return "tool";
+  }
+}
+function mapActivityStatus(status) {
+  switch (status) {
+    case "started":
+      return "active";
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    default:
+      return "active";
+  }
+}
+
+// src/utils/debugLogger.ts
+import fs2 from "fs";
+try {
+  fs2.appendFileSync("/tmp/dodo_debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] debugLogger.ts loaded, DODO_DEBUG=${process.env.DODO_DEBUG}
+`);
+} catch {
+}
+var DebugLogger = class {
+  constructor() {
+    this.logPath = "/tmp/dodo_debug.log";
+  }
+  /**
+   * Check if debug mode is enabled (checked dynamically each time)
+   */
+  isEnabled() {
+    return process.env.DODO_DEBUG === "true";
+  }
+  /**
+   * Write a structured log entry
+   */
+  async log(entry) {
+    if (!this.isEnabled()) return;
+    const fullEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...entry
+    };
+    try {
+      await fs2.promises.appendFile(this.logPath, JSON.stringify(fullEntry) + "\n");
+    } catch {
+    }
+  }
+  /**
+   * Log an event received from the backend
+   */
+  event(component, eventType, data) {
+    this.log({
+      category: "event",
+      component,
+      message: `Received event: ${eventType}`,
+      data
+    });
+  }
+  /**
+   * Log a command sent to the backend
+   */
+  command(component, cmdType, data) {
+    this.log({
+      category: "command",
+      component,
+      message: `Sent command: ${cmdType}`,
+      data
+    });
+  }
+  /**
+   * Log a state change
+   */
+  state(component, change, before, after) {
+    this.log({
+      category: "state",
+      component,
+      message: change,
+      data: { before, after }
+    });
+  }
+  /**
+   * Log component lifecycle events
+   */
+  lifecycle(component, phase, details) {
+    this.log({
+      category: "lifecycle",
+      component,
+      message: `${phase}${details ? `: ${details}` : ""}`
+    });
+  }
+  /**
+   * Log an error with context
+   */
+  error(component, error, context) {
+    this.log({
+      category: "error",
+      component,
+      message: error instanceof Error ? error.message : error,
+      data: {
+        ...error instanceof Error ? { stack: error.stack } : {},
+        ...context
+      }
+    });
+  }
+  /**
+   * Clear the debug log file
+   */
+  clear() {
+    try {
+      fs2.writeFileSync(this.logPath, "");
+    } catch {
+    }
+  }
+};
+var debugLog = new DebugLogger();
+
+// src/hooks/useSessionLifecycle.ts
+import { useApp } from "ink";
+function useSessionLifecycle(client, repoPath, requestedSessionId, engineExited, skipConnection = false) {
+  const { exit } = useApp();
+  const [sessionId, setSessionId] = useState2();
+  const [status, setStatus] = useState2(engineExited ? "disconnected" : "connecting");
+  const [infoMessage, setInfoMessage] = useState2("Connecting to engine...");
+  const [error, setError] = useState2();
+  const [tokenUsage, setTokenUsage] = useState2();
+  const [loadedConfig, setLoadedConfig] = useState2();
+  const [isSetupRequired, setIsSetupRequired] = useState2(false);
+  const [isProjectPermissionRequired, setIsProjectPermissionRequired] = useState2(false);
+  const [pendingRepoRoot, setPendingRepoRoot] = useState2(null);
+  const statusRef = useRef2(status);
+  useEffect2(() => {
+    statusRef.current = status;
+  }, [status]);
+  useEffect2(() => {
+    if (skipConnection) {
+      return;
+    }
+    if (engineExited) {
+      statusRef.current = "disconnected";
+      setStatus("disconnected");
+      setInfoMessage("Engine process exited");
+      return;
+    }
+    client.startSession({ repoRoot: repoPath, sessionId: requestedSessionId }).catch((err) => {
+      setError(err instanceof Error ? err.message : String(err));
+      statusRef.current = "error";
+      setStatus("error");
+    });
+  }, [client, repoPath, requestedSessionId, engineExited, skipConnection]);
+  useEffect2(() => {
+    if (engineExited) {
+      setInfoMessage(
+        `Engine exited${engineExited.code !== null ? ` (code ${engineExited.code})` : ""}`
+      );
+      const timer = setTimeout(() => {
+        process.stdout.write("\x1B[?1049l");
+        exit();
+      }, 500);
+      return () => clearTimeout(timer);
+    }
+  }, [engineExited, exit]);
+  useEngineEvents(client, {
+    onStatusChange: useCallback3((newStatus, message) => {
+      if (statusRef.current !== newStatus) {
+        statusRef.current = newStatus;
+        setStatus(newStatus);
+        setInfoMessage(message);
+      } else {
+        setInfoMessage((prevMsg) => prevMsg !== message ? message : prevMsg);
+      }
+    }, []),
+    onSessionReady: useCallback3((id) => {
+      setSessionId(id);
+      statusRef.current = "ready";
+      setStatus("ready");
+      setInfoMessage(`Session ready (${id.slice(0, 8)})`);
+      setError(void 0);
+      client.sendCommand({ type: "get_config" });
+    }, [client]),
+    onError: useCallback3((message) => {
+      setError(message);
+      statusRef.current = "error";
+      setStatus("error");
+    }, []),
+    onTokenUsage: useCallback3((usage) => {
+      setTokenUsage({
+        used: usage.prompt,
+        total: usage.limit,
+        percentage: usage.limit > 0 ? usage.prompt / usage.limit * 100 : 0,
+        sessionTotal: usage.total
+      });
+    }, []),
+    onSetupRequired: useCallback3(() => {
+      setIsSetupRequired(true);
+    }, []),
+    onProjectPermissionRequired: useCallback3((repoRoot) => {
+      setIsProjectPermissionRequired(true);
+      setPendingRepoRoot(repoRoot);
+    }, []),
+    onConfigLoaded: useCallback3((config) => {
+      setLoadedConfig(config);
+    }, []),
+    onConfigReloaded: useCallback3((provider, modelName) => {
+      statusRef.current = "ready";
+      setStatus("ready");
+      setInfoMessage(`Config reloaded: ${provider} (${modelName})`);
+      setLoadedConfig((prev) => prev ? {
+        ...prev,
+        llm_provider: provider,
+        model: modelName
+      } : { llm_provider: provider, model: modelName });
+      debugLog.event("useSessionLifecycle", "config_reloaded", { provider, modelName });
+    }, []),
+    onCancelled: useCallback3((reason) => {
+      logger.log(`[useSessionLifecycle] onCancelled received. reason=${reason}`);
+      statusRef.current = "ready";
+      setStatus("ready");
+      setInfoMessage(reason || "Task cancelled");
+    }, [])
+  });
+  const reloadSession = useCallback3(() => {
+    debugLog.command("useSessionLifecycle", "reloadSession", { sessionId });
+    if (!sessionId) {
+      debugLog.error("useSessionLifecycle", "No sessionId, cannot reload");
+      return;
+    }
+    debugLog.command("useSessionLifecycle", "reload_config", { sessionId });
+    client.sendCommand({
+      type: "reload_config",
+      session_id: sessionId
+    });
+    setInfoMessage("Configuration reloaded!");
+    statusRef.current = "ready";
+    setStatus("ready");
+    debugLog.state("useSessionLifecycle", "reloadSession completed", void 0, { status: "ready" });
+  }, [sessionId, client]);
+  return {
+    sessionId,
+    status,
+    statusRef,
+    infoMessage,
+    setInfoMessage,
+    setStatus,
+    error,
+    setError,
+    tokenUsage,
+    loadedConfig,
+    isSetupRequired,
+    setIsSetupRequired,
+    isProjectPermissionRequired,
+    setIsProjectPermissionRequired,
+    pendingRepoRoot,
+    reloadSession
+  };
+}
+
+// src/hooks/useResponseStream.ts
+import { useState as useState3, useCallback as useCallback4, useRef as useRef3, useEffect as useEffect3 } from "react";
+function useResponseStream(client, appendAssistantContent, markLastTurnDone) {
+  const [currentThought, setCurrentThought] = useState3("");
+  const bufferRef = useRef3("");
+  const timerRef = useRef3(null);
+  const lastUpdateRef = useRef3(0);
+  const THROTTLE_MS = 50;
+  const flushBuffer = useCallback4((final) => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    const textToFlush = bufferRef.current;
+    bufferRef.current = "";
+    lastUpdateRef.current = Date.now();
+    if (textToFlush) {
+      setCurrentThought((prev) => prev + textToFlush);
+      appendAssistantContent(textToFlush, false);
+    }
+    if (final) {
+      setCurrentThought("");
+      markLastTurnDone();
+    }
+  }, [appendAssistantContent, markLastTurnDone]);
+  useEffect3(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, []);
+  const handleAssistantText = useCallback4(
+    (content, replace, final) => {
+      if (replace) {
+        if (timerRef.current) clearTimeout(timerRef.current);
+        timerRef.current = null;
+        bufferRef.current = "";
+        lastUpdateRef.current = Date.now();
+        setCurrentThought(final ? "" : content);
+        appendAssistantContent(content, true);
+        if (final) markLastTurnDone();
+        return;
+      }
+      bufferRef.current += content;
+      const now = Date.now();
+      if (final || now - lastUpdateRef.current > THROTTLE_MS) {
+        flushBuffer(final);
+      } else if (!timerRef.current) {
+        timerRef.current = setTimeout(() => flushBuffer(false), THROTTLE_MS);
+      }
+    },
+    [flushBuffer, appendAssistantContent, markLastTurnDone]
+  );
+  useEngineEvents(client, {
+    onAssistantText: handleAssistantText
+  });
+  return {
+    currentThought,
+    setCurrentThought
+  };
+}
+
+// src/hooks/useToolActivities.ts
+import { useState as useState4, useRef as useRef4, useCallback as useCallback5, useEffect as useEffect4 } from "react";
+function useToolActivities(client, conversation) {
+  const [projectPlan, setProjectPlan] = useState4("");
+  const [showProjectPlan, setShowProjectPlan] = useState4(false);
+  const activeStepIdsRef = useRef4(/* @__PURE__ */ new Set());
+  const {
+    addActivity,
+    addTimelineStep,
+    updateTimelineStep,
+    getCurrentTurnId,
+    addContextEvent,
+    appendToolOutput
+  } = conversation;
+  const THROTTLE_MS = 50;
+  const activityBufferRef = useRef4([]);
+  const activityThrottleTimerRef = useRef4(null);
+  const lastActivityFlushRef = useRef4(0);
+  const flushActivityBuffer = useCallback5(() => {
+    if (activityThrottleTimerRef.current) {
+      clearTimeout(activityThrottleTimerRef.current);
+      activityThrottleTimerRef.current = null;
+    }
+    const currentTurnId = getCurrentTurnId();
+    if (!currentTurnId) {
+      activityBufferRef.current = [];
+      return;
+    }
+    activityBufferRef.current.forEach((activity) => {
+      addActivity(currentTurnId, activity);
+      if (activity.type === "tool" || activity.type === "reasoning") {
+        const stepId = activity.invocationId || activity.id;
+        if (activity.status === "active") {
+          if (!activeStepIdsRef.current.has(stepId)) {
+            addTimelineStep(currentTurnId, {
+              id: stepId,
+              toolName: activity.tool || "unknown",
+              label: activity.tool || "unknown",
+              status: "running",
+              startedAt: activity.timestamp,
+              type: "tool",
+              command: activity.command,
+              metadata: activity.metadata
+            });
+            activeStepIdsRef.current.add(stepId);
+          } else {
+            updateTimelineStep(currentTurnId, stepId, {
+              metadata: activity.metadata,
+              command: activity.command || void 0
+            });
+          }
+        } else {
+          updateTimelineStep(currentTurnId, stepId, {
+            status: activity.status === "completed" ? "done" : "failed",
+            finishedAt: activity.timestamp,
+            metadata: activity.metadata,
+            command: activity.command || void 0,
+            durationMs: activity.durationMs
+          });
+          activeStepIdsRef.current.delete(stepId);
+        }
+      }
+    });
+    activityBufferRef.current = [];
+    lastActivityFlushRef.current = Date.now();
+  }, [addActivity, addTimelineStep, updateTimelineStep, getCurrentTurnId]);
+  const outputBufferRef = useRef4(/* @__PURE__ */ new Map());
+  const throttleTimerRef = useRef4(null);
+  const lastFlushRef = useRef4(0);
+  const flushOutputBuffer = useCallback5(() => {
+    if (throttleTimerRef.current) {
+      clearTimeout(throttleTimerRef.current);
+      throttleTimerRef.current = null;
+    }
+    const turnId = getCurrentTurnId();
+    if (!turnId) return;
+    outputBufferRef.current.forEach((data, key) => {
+      const [invocationId] = key.split(":");
+      appendToolOutput(turnId, invocationId, data.output, data.stream);
+    });
+    outputBufferRef.current.clear();
+    lastFlushRef.current = Date.now();
+  }, [getCurrentTurnId, appendToolOutput]);
+  useEffect4(() => {
+    return () => {
+      if (throttleTimerRef.current) clearTimeout(throttleTimerRef.current);
+      if (activityThrottleTimerRef.current) clearTimeout(activityThrottleTimerRef.current);
+    };
+  }, []);
+  useEngineEvents(client, {
+    onActivity: useCallback5((activity) => {
+      activityBufferRef.current.push(activity);
+      const now = Date.now();
+      if (now - lastActivityFlushRef.current > THROTTLE_MS) {
+        flushActivityBuffer();
+      } else if (!activityThrottleTimerRef.current) {
+        activityThrottleTimerRef.current = setTimeout(flushActivityBuffer, THROTTLE_MS);
+      }
+    }, [flushActivityBuffer]),
+    onProjectPlan: useCallback5((content, source) => {
+      setProjectPlan(content);
+      if (content && !showProjectPlan) {
+        setShowProjectPlan(true);
+      }
+    }, [showProjectPlan]),
+    onContext: useCallback5((event) => {
+      const currentTurnId = getCurrentTurnId();
+      if (currentTurnId) {
+        addContextEvent(currentTurnId, event);
+      }
+    }, [getCurrentTurnId, addContextEvent]),
+    onToolOutput: useCallback5((invocationId, tool, output, stream) => {
+      const key = `${invocationId}:${stream}`;
+      const existing = outputBufferRef.current.get(key);
+      if (existing) {
+        existing.output += output;
+      } else {
+        outputBufferRef.current.set(key, { output, stream, tool });
+      }
+      const now = Date.now();
+      if (now - lastFlushRef.current > THROTTLE_MS) {
+        flushOutputBuffer();
+      } else if (!throttleTimerRef.current) {
+        throttleTimerRef.current = setTimeout(flushOutputBuffer, THROTTLE_MS);
+      }
+    }, [flushOutputBuffer])
+  });
+  return {
+    projectPlan,
+    showProjectPlan,
+    setShowProjectPlan,
+    activeStepIdsRef
+    // Exported if needed by parent, e.g. to clear on new turn
+  };
+}
+
+// src/hooks/useEngineConnection.ts
+function useEngineConnection(client, repoPath, requestedSessionId, engineExited, skipConnection = false) {
+  const { exit } = useApp2();
+  const [errorCount, setErrorCount] = useState5(0);
+  const {
+    turns,
+    pushTurn,
+    appendAssistantContent,
+    markLastTurnDone,
+    addActivity,
+    updateActivity,
+    toggleTurnCollapsed,
+    addTimelineStep,
+    updateTimelineStep,
+    getCurrentTurnId,
+    appendLogLine,
+    appendToolOutput,
+    addContextEvent,
+    clearTurns
+  } = useConversation();
+  const {
+    sessionId,
+    status,
+    statusRef,
+    infoMessage,
+    setInfoMessage,
+    setStatus,
+    error: lifecycleError,
+    setError: setLifecycleError,
+    tokenUsage,
+    loadedConfig,
+    isSetupRequired,
+    setIsSetupRequired,
+    isProjectPermissionRequired,
+    setIsProjectPermissionRequired,
+    pendingRepoRoot,
+    reloadSession
+  } = useSessionLifecycle(client, repoPath, requestedSessionId, engineExited, skipConnection);
+  const {
+    currentThought,
+    setCurrentThought
+  } = useResponseStream(client, appendAssistantContent, markLastTurnDone);
+  const {
+    projectPlan,
+    showProjectPlan,
+    activeStepIdsRef
+  } = useToolActivities(client, {
+    addActivity,
+    addTimelineStep,
+    updateTimelineStep,
+    getCurrentTurnId,
+    addContextEvent,
+    appendToolOutput
+  });
+  useEngineEvents(client, {
+    onSessionHistory: useCallback6((title, summary, _messages) => {
+      if (summary) {
+        const resumeTurnId = `resume-${Date.now()}`;
+        pushTurn(`Resumed: ${title}`);
+        const timer = setTimeout(() => {
+          markLastTurnDone(summary);
+        }, 100);
+        return () => clearTimeout(timer);
+      }
+    }, [pushTurn, markLastTurnDone])
+  });
+  const submitQuery = useCallback6((query) => {
+    if (!sessionId) return;
+    logger.state("User Query Submitted", { query, sessionId });
+    pushTurn(query);
+    activeStepIdsRef.current.clear();
+    setStatus("thinking");
+    setLifecycleError(void 0);
+    client.sendUserMessage(sessionId, query);
+  }, [sessionId, pushTurn, client, setStatus, setLifecycleError]);
+  const isRunning = status === "thinking" || status === "running_tools";
+  const cancelRequest = useCallback6(() => {
+    logger.log(`[useEngineConnection] cancelRequest called. sessionId=${sessionId}, status=${status}, isRunning=${isRunning}`);
+    if (!sessionId) {
+      logger.error("[useEngineConnection] No sessionId, cannot cancel");
+      return false;
+    }
+    if (!isRunning) {
+      logger.log("[useEngineConnection] Cancel skipped - not running");
+      return false;
+    }
+    logger.log("[useEngineConnection] Sending cancel_request");
+    client.sendCommand({
+      type: "cancel_request",
+      session_id: sessionId
+    });
+    setInfoMessage("Stopping...");
+    return true;
+  }, [sessionId, isRunning, status, client, setInfoMessage]);
+  const { currentTimelineSteps, currentLogLines, currentRunningStep } = useMemo2(() => {
+    const currentTurn = turns.length > 0 ? turns[turns.length - 1] : null;
+    const timelineSteps = currentTurn?.timelineSteps || [];
+    const logLines = currentTurn?.logLines || [];
+    const runningStep = timelineSteps.find((s) => s.status === "running");
+    return {
+      currentTimelineSteps: timelineSteps,
+      currentLogLines: logLines,
+      currentRunningStep: runningStep
+    };
+  }, [turns]);
+  return {
+    sessionId,
+    status,
+    infoMessage,
+    isRunning,
+    error: lifecycleError,
+    tokenUsage,
+    projectPlan,
+    showProjectPlan,
+    errorCount,
+    currentThought,
+    turns,
+    currentTimelineSteps,
+    currentRunningStepId: currentRunningStep?.id,
+    toggleTurnCollapsed,
+    submitQuery,
+    setInput: () => {
+    },
+    sendCommand: client.sendCommand.bind(client),
+    isSetupRequired,
+    setIsSetupRequired,
+    isProjectPermissionRequired,
+    setIsProjectPermissionRequired,
+    pendingRepoRoot,
+    loadedConfig,
+    reloadSession,
+    cancelRequest,
+    clearTurns
+  };
+}
+
+// src/components/layout/AppLayout.tsx
+import React7, { useRef as useRef7 } from "react";
+import { Box as Box15, Text as Text16, useApp as useApp3, useInput as useInput2 } from "ink";
+
+// src/components/layout/Header.tsx
+import { Box, Text } from "ink";
+import { createRequire } from "module";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../../package.json");
+var Header = () => {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx2(Box, { flexDirection: "row", alignItems: "center", children: /* @__PURE__ */ jsx2(Box, { paddingY: 1, marginRight: 4, children: /* @__PURE__ */ jsx2(Text, { color: "cyan", bold: true, children: `
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588      \u2588\u2588\u2588\u2588\u2588\u2588\u2588    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588      \u2588\u2588\u2588\u2588\u2588\u2588\u2588   
+\u2591\u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2588   \u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588 \u2591\u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2588   \u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588 
+ \u2591\u2588\u2588\u2588   \u2591\u2591\u2588\u2588\u2588 \u2588\u2588\u2588     \u2591\u2591\u2588\u2588\u2588 \u2591\u2588\u2588\u2588   \u2591\u2591\u2588\u2588\u2588 \u2588\u2588\u2588     \u2591\u2591\u2588\u2588\u2588
+ \u2591\u2588\u2588\u2588    \u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588      \u2591\u2588\u2588\u2588 \u2591\u2588\u2588\u2588    \u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588      \u2591\u2588\u2588\u2588
+ \u2591\u2588\u2588\u2588    \u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588      \u2591\u2588\u2588\u2588 \u2591\u2588\u2588\u2588    \u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588      \u2591\u2588\u2588\u2588
+ \u2591\u2588\u2588\u2588    \u2588\u2588\u2588 \u2591\u2591\u2588\u2588\u2588     \u2588\u2588\u2588  \u2591\u2588\u2588\u2588    \u2588\u2588\u2588 \u2591\u2591\u2588\u2588\u2588     \u2588\u2588\u2588 
+ \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588   \u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588   \u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591     
+\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591      \u2591\u2591\u2591\u2591\u2591\u2591\u2591    \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591      \u2591\u2591\u2591\u2591\u2591\u2591\u2591     v${pkg.version}
+ ` }) }) }),
+    /* @__PURE__ */ jsx2(Text, { color: "yellow", italic: true, children: "The Agentic AI Coding Assistant" })
+  ] });
+};
+
+// src/components/layout/Footer.tsx
+import { Box as Box4, Text as Text5 } from "ink";
+
+// src/components/common/Input.tsx
+import { useState as useState6, useEffect as useEffect6, useRef as useRef6 } from "react";
+import { Text as Text2, Box as Box2, useInput } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var Input = ({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "",
+  isDisabled = false,
+  onHistoryUp,
+  onHistoryDown
+}) => {
+  const [cursorPos, setCursorPos] = useState6(value.length);
+  useEffect6(() => {
+    if (cursorPos > value.length) {
+      setCursorPos(value.length);
+    }
+  }, [value, cursorPos]);
+  const stateRef = useRef6({ value, cursorPos, onChange, onSubmit, isDisabled, onHistoryUp, onHistoryDown });
+  stateRef.current = { value, cursorPos, onChange, onSubmit, isDisabled, onHistoryUp, onHistoryDown };
+  useInput((input, key) => {
+    const { value: value2, cursorPos: cursorPos2, onChange: onChange2, onSubmit: onSubmit2, isDisabled: isDisabled2, onHistoryUp: onHistoryUp2, onHistoryDown: onHistoryDown2 } = stateRef.current;
+    if (isDisabled2) return;
+    if (key.return) {
+      if (key.shift) {
+        const newValue = value2.slice(0, cursorPos2) + "\n" + value2.slice(cursorPos2);
+        onChange2(newValue);
+        setCursorPos((p) => p + 1);
+        return;
+      }
+      onSubmit2(value2);
+      return;
+    }
+    if (key.leftArrow) {
+      setCursorPos((p) => Math.max(0, p - 1));
+      return;
+    }
+    if (key.rightArrow) {
+      setCursorPos((p) => Math.min(value2.length, p + 1));
+      return;
+    }
+    if (key.upArrow) {
+      onHistoryUp2?.();
+      return;
+    }
+    if (key.downArrow) {
+      onHistoryDown2?.();
+      return;
+    }
+    if (key.backspace || key.delete || input === "\x7F" || input === "\b" || key.ctrl && input === "h") {
+      if (cursorPos2 > 0) {
+        const newValue = value2.slice(0, cursorPos2 - 1) + value2.slice(cursorPos2);
+        onChange2(newValue);
+        setCursorPos((p) => Math.max(0, p - 1));
+      }
+      return;
+    }
+    if (input === "\x1B[H" || input === "\x1BOH") {
+      setCursorPos(0);
+      return;
+    }
+    if (input === "\x1B[F" || input === "\x1BOF") {
+      setCursorPos(value2.length);
+      return;
+    }
+    if (input === "\x1B[3~" || key.ctrl && input === "d") {
+      if (cursorPos2 < value2.length) {
+        const newValue = value2.slice(0, cursorPos2) + value2.slice(cursorPos2 + 1);
+        onChange2(newValue);
+      }
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      if (input.includes("\n") || input.includes("\r")) {
+        const normalizedInput = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        const newValue = value2.slice(0, cursorPos2) + normalizedInput + value2.slice(cursorPos2);
+        onChange2(newValue);
+        setCursorPos((p) => p + normalizedInput.length);
+        return;
+      }
+      const charCode = input.charCodeAt(0);
+      if (input.length === 1 && (charCode >= 32 && charCode <= 126 || // Printable ASCII
+      charCode === 9 || // Tab
+      charCode > 127)) {
+        const newValue = value2.slice(0, cursorPos2) + input + value2.slice(cursorPos2);
+        onChange2(newValue);
+        setCursorPos((p) => p + 1);
+      }
+    }
+  }, { isActive: !isDisabled });
+  if (!value && placeholder) {
+    return /* @__PURE__ */ jsx3(Text2, { color: "gray", children: placeholder });
+  }
+  const lines = value.split("\n");
+  let currentPos = 0;
+  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: lines.map((line, lineIdx) => {
+    const isLastLine = lineIdx === lines.length - 1;
+    const lineStart = currentPos;
+    const lineEnd = lineStart + line.length;
+    const element = /* @__PURE__ */ jsx3(Text2, { children: cursorPos >= lineStart && cursorPos <= lineEnd ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx3(Text2, { color: "green", children: line.slice(0, cursorPos - lineStart) }),
+      /* @__PURE__ */ jsx3(Text2, { inverse: true, color: "green", children: value[cursorPos] === "\n" ? "\u21B5" : line[cursorPos - lineStart] || " " }),
+      /* @__PURE__ */ jsx3(Text2, { color: "green", children: line.slice(cursorPos - lineStart + 1) })
+    ] }) : /* @__PURE__ */ jsx3(Text2, { color: "green", children: line }) }, lineIdx);
+    currentPos = lineEnd + 1;
+    return element;
+  }) });
+};
+
+// src/components/common/StatusBadge.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+
+// src/components/common/Spinner.tsx
+import { Text as Text3 } from "ink";
+
+// src/contexts/AnimationContext.tsx
+import { createContext as createContext2, useContext as useContext3, useState as useState7, useEffect as useEffect7 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var AnimationContext = createContext2(void 0);
+var useAnimation = () => {
+  const context = useContext3(AnimationContext);
+  if (!context) {
+    throw new Error("useAnimation must be used within an AnimationProvider");
+  }
+  return context;
+};
+var AnimationProvider = ({ children, interval = 80 }) => {
+  const [frameIndex, setFrameIndex] = useState7(0);
+  useEffect7(() => {
+    const timer = setInterval(() => {
+      setFrameIndex((prev) => (prev + 1) % 1e3);
+    }, interval);
+    return () => clearInterval(timer);
+  }, [interval]);
+  return /* @__PURE__ */ jsx4(AnimationContext.Provider, { value: { frameIndex }, children });
+};
+
+// src/components/common/Spinner.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var SPINNER_FRAMES = {
+  dots: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"]
+};
+var Spinner = ({ type = "dots", color = "yellow" }) => {
+  const { frameIndex } = useAnimation();
+  const frames = SPINNER_FRAMES[type];
+  const frame = frames[frameIndex % frames.length];
+  return /* @__PURE__ */ jsx5(Text3, { color, children: frame });
+};
+
+// src/components/common/StatusBadge.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+var StatusBadge = ({ status, message }) => {
+  let color;
+  let label;
+  let showSpinner = false;
+  switch (status) {
+    case "pending":
+    case "booting":
+    case "connecting":
+      color = "gray";
+      label = status.toUpperCase();
+      break;
+    case "ready":
+      color = "green";
+      label = "READY";
+      break;
+    case "running":
+    case "thinking":
+    case "running_tools":
+      color = "yellow";
+      label = "RUNNING";
+      showSpinner = true;
+      break;
+    case "done":
+      color = "green";
+      label = "DONE";
+      break;
+    case "failed":
+    case "error":
+    case "disconnected":
+      color = "red";
+      label = status === "error" ? "ERROR" : status.toUpperCase();
+      break;
+    default:
+      color = "gray";
+      label = "UNKNOWN";
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    showSpinner && /* @__PURE__ */ jsx6(Box3, { marginRight: 1, children: /* @__PURE__ */ jsx6(Spinner, {}) }),
+    /* @__PURE__ */ jsx6(Text4, { color, bold: true, children: label }),
+    message && /* @__PURE__ */ jsxs3(Text4, { color: "gray", children: [
+      " ",
+      message
+    ] })
+  ] });
+};
+
+// src/contexts/SessionContext.tsx
+import { createContext as createContext3, useContext as useContext4 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var SessionContext = createContext3(void 0);
+function SessionProvider({
+  children,
+  value
+}) {
+  return /* @__PURE__ */ jsx7(SessionContext.Provider, { value, children });
+}
+function useSessionContext() {
+  const context = useContext4(SessionContext);
+  if (!context) {
+    throw new Error("useSessionContext must be used within a SessionProvider");
+  }
+  return context;
+}
+
+// src/components/layout/Footer.tsx
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+var Footer = ({
+  input,
+  onChange,
+  onSubmit,
+  onHistoryUp,
+  onHistoryDown,
+  repoLabel
+}) => {
+  const {
+    sessionId: sessionLabel,
+    status,
+    infoMessage,
+    isRunning,
+    tokenUsage,
+    errorCount,
+    currentThought,
+    loadedConfig
+  } = useSessionContext();
+  const canSubmit = !isRunning && status !== "connecting" && status !== "disconnected";
+  const modelLabel = loadedConfig?.model;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "round", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsx8(Box4, { children: /* @__PURE__ */ jsxs4(Text5, { color: "gray", children: [
+      "Tokens:",
+      " ",
+      tokenUsage ? /* @__PURE__ */ jsxs4(Text5, { color: tokenUsage.percentage > 80 ? "red" : tokenUsage.percentage > 50 ? "yellow" : "green", children: [
+        "Context: ",
+        tokenUsage.used,
+        " / ",
+        tokenUsage.total,
+        " (",
+        tokenUsage.percentage.toFixed(2),
+        "%)",
+        tokenUsage.sessionTotal !== void 0 && ` | Session: ${tokenUsage.sessionTotal}`
+      ] }) : "\u2014",
+      isRunning && /* @__PURE__ */ jsx8(Text5, { color: "yellow", children: " \u2502 ESC to stop" })
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box4, { children: currentThought ? /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 0, children: [
+      /* @__PURE__ */ jsx8(Box4, { children: /* @__PURE__ */ jsxs4(Text5, { color: "gray", dimColor: true, children: [
+        /* @__PURE__ */ jsx8(Spinner, {}),
+        " Thinking..."
+      ] }) }),
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx8(Text5, { color: "cyan", children: "> " }),
+        canSubmit ? /* @__PURE__ */ jsx8(
+          Input,
+          {
+            value: input,
+            onChange,
+            onSubmit,
+            placeholder: "Describe your task, or type /help...",
+            onHistoryUp,
+            onHistoryDown
+          }
+        ) : /* @__PURE__ */ jsxs4(Text5, { color: "gray", children: [
+          "Processing... ",
+          /* @__PURE__ */ jsx8(Text5, { color: "yellow", children: "(ESC to stop)" })
+        ] })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx8(Text5, { color: "cyan", children: "> " }),
+      canSubmit ? /* @__PURE__ */ jsx8(
+        Input,
+        {
+          value: input,
+          onChange,
+          onSubmit,
+          placeholder: "Describe your task, or type /help...",
+          onHistoryUp,
+          onHistoryDown
+        }
+      ) : /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx8(Text5, { color: "yellow", children: /* @__PURE__ */ jsx8(Spinner, {}) }),
+        /* @__PURE__ */ jsxs4(Text5, { color: "gray", children: [
+          " ",
+          isRunning ? "Processing... " : "Connecting to engine..."
+        ] }),
+        isRunning && /* @__PURE__ */ jsx8(Text5, { color: "yellow", children: "(ESC to stop)" })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxs4(Box4, { borderStyle: "single", borderTop: true, borderBottom: false, borderLeft: false, borderRight: false, borderColor: "gray", marginTop: 0, children: [
+      /* @__PURE__ */ jsx8(Box4, { flexGrow: 1, children: /* @__PURE__ */ jsxs4(Text5, { children: [
+        "Repo: ",
+        /* @__PURE__ */ jsx8(Text5, { color: "blue", children: repoLabel }),
+        " \u2502 Session: ",
+        /* @__PURE__ */ jsx8(Text5, { color: "magenta", children: sessionLabel }),
+        modelLabel && /* @__PURE__ */ jsxs4(Text5, { children: [
+          " \u2502 Model: ",
+          /* @__PURE__ */ jsx8(Text5, { color: "green", children: modelLabel })
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        errorCount !== void 0 && errorCount > 0 && /* @__PURE__ */ jsxs4(Text5, { color: "red", children: [
+          "Errors: ",
+          errorCount,
+          " \u2502 "
+        ] }),
+        /* @__PURE__ */ jsx8(StatusBadge, { status, message: infoMessage })
+      ] })
+    ] })
+  ] });
+};
+
+// src/components/conversation/Conversation.tsx
+import React6, { useMemo as useMemo3 } from "react";
+import { Box as Box14, Text as Text15 } from "ink";
+
+// src/config.ts
+var UI_CONFIG = {
+  // Layout settings
+  LAYOUT: {
+    STATUS_BAR_HEIGHT: 1
+  },
+  // Turn settings
+  TURN: {
+    HEADER_COLOR_USER: "gray",
+    HEADER_COLOR_ASSISTANT: "green",
+    SUMMARY_PREFIX: "\u{1F4DD} "
+  },
+  // Conversation display
+  CONVERSATION: {
+    // Tools to hide from timeline (internal/noisy tools)
+    HIDDEN_TOOLS: ["think"],
+    // Prefixes for compact conversation display
+    PREFIXES: {
+      USER: ">",
+      ASSISTANT: "$"
+    },
+    // Whether to show reasoning steps (think, internal reasoning)
+    SHOW_REASONING: false
+  },
+  // Tool Component Layouts (Height in lines)
+  TOOLS: {
+    COMMON: {
+      MARGIN_Y: 1
+      // Spacing between steps
+    },
+    RUN_CMD: {
+      HEADER_HEIGHT: 4,
+      // Header box (Border + Content + Padding + Margin)
+      BORDER_HEIGHT: 2,
+      // Top/Bottom borders
+      MARGIN_INNER: 1,
+      // Padding
+      FOOTER_HEIGHT: 4,
+      // Exit code box (Margin + Border + Padding + Content)
+      MAX_OUTPUT_LINES: 20
+    },
+    THINK: {
+      HEADER_HEIGHT: 1,
+      BORDER_HEIGHT: 2,
+      MARGIN_INNER: 1
+    },
+    READ_FILE: {
+      HEADER_HEIGHT: 4,
+      // Header box (Border + Content + Padding + Margin)
+      BORDER_HEIGHT: 2,
+      MARGIN_INNER: 1,
+      MAX_CONTENT_LINES: 30
+    },
+    RESPOND: {
+      HEADER_HEIGHT: 0,
+      BORDER_HEIGHT: 0,
+      MARGIN_INNER: 0
+    },
+    CONTEXT: {
+      HEIGHT: 1
+    }
+  }
+};
+
+// src/utils/flatten.ts
+function flattenTurn(turn, steps, currentRunningStepId) {
+  const items = [];
+  const { PREFIXES, HIDDEN_TOOLS, SHOW_REASONING } = UI_CONFIG.CONVERSATION;
+  items.push({
+    type: "user_message",
+    id: `turn-${turn.id}-user`,
+    prefix: PREFIXES.USER,
+    text: turn.user
+  });
+  if (turn.collapsed) {
+    if (turn.summary) {
+      items.push({
+        type: "text_chunk",
+        id: `turn-${turn.id}-summary`,
+        text: `\u{1F4DD} ${turn.summary}`,
+        color: "gray"
+      });
+    }
+    const activeCount = steps.filter((s) => s.status === "running").length;
+    const completedCount = steps.filter((s) => s.status === "done").length;
+    if (steps.length > 0) {
+      items.push({
+        type: "text_chunk",
+        id: `turn-${turn.id}-status`,
+        text: `${activeCount > 0 ? `\u23F3 ${activeCount} running \u2022 ` : ""}\u2705 ${completedCount} completed`,
+        color: "gray"
+      });
+    }
+  } else {
+    if (turn.assistant) {
+      items.push({
+        type: "assistant_message",
+        id: `turn-${turn.id}-assistant`,
+        prefix: PREFIXES.ASSISTANT,
+        text: turn.assistant
+      });
+    } else if (!turn.done) {
+      items.push({
+        type: "assistant_message",
+        id: `turn-${turn.id}-assistant-placeholder`,
+        prefix: PREFIXES.ASSISTANT,
+        text: "..."
+      });
+    }
+    const visibleSteps = steps.filter((step) => {
+      if (step.toolName && HIDDEN_TOOLS.includes(step.toolName)) return false;
+      const isReasoning = (!step.toolName || step.toolName === "") && step.metadata?.content;
+      const isThinking = step.toolName === "think" && step.metadata?.reasoning;
+      if (!SHOW_REASONING && (isReasoning || isThinking)) return false;
+      return true;
+    });
+    visibleSteps.forEach((step) => {
+      items.push({
+        type: "timeline_step",
+        id: `step-${step.id}`,
+        step,
+        turnId: turn.id
+      });
+      if (step.toolName === "edit") {
+        const matchingEdit = turn.activities?.find(
+          (a) => a.type === "edit" && a.codeChange && (a.invocationId === step.id || step.metadata?.path && a.codeChange.file === step.metadata.path)
+        );
+        if (matchingEdit?.codeChange) {
+          items.push({
+            type: "code_change",
+            id: `edit-inline-${matchingEdit.id}`,
+            codeChange: matchingEdit.codeChange
+          });
+        }
+      }
+    });
+    if (visibleSteps.length > 0) {
+      items.push({ type: "divider", id: `turn-${turn.id}-divider-steps` });
+    }
+    if (turn.summary) {
+      items.push({
+        type: "text_chunk",
+        id: `turn-${turn.id}-summary-footer`,
+        text: turn.summary,
+        color: "gray"
+      });
+    }
+  }
+  items.push({ type: "divider", id: `turn-${turn.id}-end-spacing` });
+  return items;
+}
+
+// src/components/timeline/TimelineItem.tsx
+import React5 from "react";
+import { Box as Box11, Text as Text12 } from "ink";
+
+// src/utils/toolConfig.ts
+var TOOL_CONFIGS = {
+  // Execution tools
+  run_cmd: {
+    icon: "",
+    label: (m) => {
+      const cmd = m.command || m.cmd || "";
+      if (cmd.length > 50) {
+        return `run: ${cmd.substring(0, 47)}...`;
+      }
+      return cmd ? `run: ${cmd}` : "Run command";
+    },
+    color: "cyan",
+    category: "execution"
+  },
+  run_tests: {
+    icon: "",
+    label: () => "Run tests",
+    color: "green",
+    category: "execution"
+  },
+  run_build: {
+    icon: "",
+    label: () => "Build",
+    color: "yellow",
+    category: "execution"
+  },
+  run_terminal_cmd: {
+    icon: "",
+    label: (m) => {
+      const cmd = m.command || "";
+      if (cmd.length > 50) {
+        return `run: ${cmd.substring(0, 47)}...`;
+      }
+      return cmd ? `run: ${cmd}` : "Run terminal command";
+    },
+    color: "cyan",
+    category: "execution"
+  },
+  // Editing tools
+  search_replace: {
+    icon: "",
+    label: (m) => {
+      const file = m.file || m.file_path || "";
+      return file ? `Edit ${file}` : "Edit file";
+    },
+    color: "blue",
+    category: "editing"
+  },
+  write: {
+    icon: "",
+    label: (m) => {
+      const file = m.file || m.file_path || "";
+      return file ? `Write ${file}` : "Write file";
+    },
+    color: "blue",
+    category: "editing"
+  },
+  write_file: {
+    icon: "",
+    label: (m) => {
+      const file = m.file || m.path || "";
+      return file ? `Write ${file}` : "Write file";
+    },
+    color: "blue",
+    category: "editing"
+  },
+  propose_diff: {
+    icon: "",
+    label: (m) => {
+      const file = m.file || m.file_path || "";
+      return file ? `Propose diff for ${file}` : "Propose diff";
+    },
+    color: "blue",
+    category: "editing"
+  },
+  // Search tools
+  codebase_search: {
+    icon: "",
+    label: (m) => {
+      const query = m.query || "";
+      if (query.length > 40) {
+        return `Search: ${query.substring(0, 37)}...`;
+      }
+      return query ? `Search: ${query}` : "Codebase search";
+    },
+    color: "magenta",
+    category: "search"
+  },
+  grep: {
+    icon: "",
+    label: (m) => {
+      const pattern = m.pattern || "";
+      if (pattern.length > 40) {
+        return `Grep: ${pattern.substring(0, 37)}...`;
+      }
+      return pattern ? `Grep: ${pattern}` : "Grep";
+    },
+    color: "magenta",
+    category: "search"
+  },
+  // Filesystem tools
+  read_file: {
+    icon: "",
+    label: (m) => {
+      const path5 = m.path || "";
+      return path5 ? `Read ${path5}` : "Read file";
+    },
+    color: "gray",
+    category: "filesystem"
+  },
+  read_span: {
+    icon: "",
+    label: (m) => {
+      const path5 = m.path || "";
+      const start = m.start_line || m.start;
+      const end = m.end_line || m.end;
+      if (path5 && start && end) {
+        return `Read ${path5}:${start}-${end}`;
+      }
+      return path5 ? `Read ${path5}` : "Read span";
+    },
+    color: "gray",
+    category: "filesystem"
+  },
+  delete_file: {
+    icon: "",
+    label: (m) => {
+      const path5 = m.path || "";
+      return path5 ? `Delete ${path5}` : "Delete file";
+    },
+    color: "red",
+    category: "filesystem"
+  },
+  list_files: {
+    icon: "",
+    label: (m) => {
+      const path5 = m.path || "";
+      return path5 ? `List ${path5}` : "List files";
+    },
+    color: "gray",
+    category: "filesystem"
+  },
+  // Meta tools
+  think: {
+    icon: "",
+    label: (m) => {
+      const summary = m.summary || "";
+      return summary || "Planning next action";
+    },
+    color: "dim",
+    category: "meta"
+  },
+  respond: {
+    icon: "",
+    label: () => "Final answer",
+    color: "green",
+    category: "meta"
+  },
+  plan: {
+    icon: "",
+    label: () => "Create execution plan",
+    color: "blue",
+    category: "meta"
+  },
+  revise_plan: {
+    icon: "",
+    label: () => "Revise plan",
+    color: "blue",
+    category: "meta"
+  }
+};
+function getToolConfig(toolName) {
+  if (!toolName || toolName === "") {
+    return {
+      icon: "",
+      label: () => "Reasoning",
+      color: "blue",
+      category: "reasoning"
+    };
+  }
+  return TOOL_CONFIGS[toolName] || {
+    icon: "",
+    label: () => toolName,
+    color: "gray",
+    category: "unknown"
+  };
+}
+
+// src/components/timeline/PlanContent.tsx
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var PlanContent = ({
+  content,
+  summary,
+  steps,
+  targetAreas,
+  risks
+}) => {
+  if (summary || steps) {
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+      summary && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx9(Text6, { color: "white", bold: true, children: "Plan Summary:" }),
+        /* @__PURE__ */ jsx9(Box5, { marginLeft: 1, marginTop: 0, children: /* @__PURE__ */ jsx9(Text6, { color: "white", children: summary }) })
+      ] }),
+      steps && steps.length > 0 && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Text6, { color: "white", bold: true, children: [
+          "Steps (",
+          steps.length,
+          "):"
+        ] }),
+        steps.map((step, index) => {
+          const stepId = step.id || `step - ${index + 1} `;
+          const description = step.description || "";
+          const targetFiles = step.target_files || [];
+          const status = step.status || "pending";
+          return /* @__PURE__ */ jsxs5(Box5, { marginLeft: 1, marginTop: 0, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs5(Box5, { flexDirection: "row", children: [
+              /* @__PURE__ */ jsxs5(Text6, { color: "cyan", bold: true, children: [
+                index + 1,
+                "."
+              ] }),
+              /* @__PURE__ */ jsx9(Box5, { marginLeft: 1, flexGrow: 1, children: /* @__PURE__ */ jsx9(Text6, { color: "white", children: description }) }),
+              status === "completed" && /* @__PURE__ */ jsx9(Text6, { color: "green", children: " \u2713" }),
+              status === "skipped" && /* @__PURE__ */ jsx9(Text6, { color: "gray", children: " \u2298" })
+            ] }),
+            targetFiles.length > 0 && /* @__PURE__ */ jsx9(Box5, { marginLeft: 2, marginTop: 0, children: /* @__PURE__ */ jsxs5(Text6, { color: "gray", dimColor: true, children: [
+              "Files: ",
+              targetFiles.join(", ")
+            ] }) })
+          ] }, stepId);
+        })
+      ] }),
+      targetAreas && targetAreas.length > 0 && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx9(Text6, { color: "white", bold: true, children: "Target Areas:" }),
+        /* @__PURE__ */ jsx9(Box5, { marginLeft: 1, marginTop: 0, children: /* @__PURE__ */ jsx9(Text6, { color: "gray", children: targetAreas.join(", ") }) })
+      ] }),
+      risks && risks.length > 0 && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx9(Text6, { color: "red", bold: true, children: "Risks:" }),
+        risks.map((risk, index) => /* @__PURE__ */ jsx9(Box5, { marginLeft: 1, marginTop: 0, children: /* @__PURE__ */ jsxs5(Text6, { color: "yellow", children: [
+          "\u26A0 ",
+          risk
+        ] }) }, index))
+      ] })
+    ] });
+  }
+  if (content) {
+    const lines = content.split("\n");
+    return /* @__PURE__ */ jsx9(Box5, { flexDirection: "column", marginTop: 1, children: lines.map((line, index) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return /* @__PURE__ */ jsx9(Box5, { height: 1 }, index);
+      }
+      if (trimmed.startsWith("\u2705")) {
+        return /* @__PURE__ */ jsx9(Text6, { color: "green", bold: true, children: trimmed }, index);
+      }
+      if (trimmed.startsWith("Plan Summary:") || trimmed.startsWith("Plan:")) {
+        return /* @__PURE__ */ jsx9(Box5, { marginTop: index > 0 ? 1 : 0, children: /* @__PURE__ */ jsx9(Text6, { color: "cyan", bold: true, children: trimmed }) }, index);
+      }
+      if (/^\s*\d+\.\s*\[/.test(trimmed)) {
+        const hasCheckmark = trimmed.includes("\u2713") || trimmed.includes("\u2705");
+        return /* @__PURE__ */ jsx9(Box5, { marginLeft: 1, children: /* @__PURE__ */ jsx9(Text6, { color: hasCheckmark ? "green" : "white", children: trimmed }) }, index);
+      }
+      if (/^\d+\./.test(trimmed)) {
+        return /* @__PURE__ */ jsx9(Box5, { marginLeft: 1, children: /* @__PURE__ */ jsx9(Text6, { color: "white", children: trimmed }) }, index);
+      }
+      if (trimmed.startsWith("You can now") || trimmed.startsWith("Use 'revise_plan'")) {
+        return /* @__PURE__ */ jsx9(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text6, { color: "gray", dimColor: true, children: trimmed }) }, index);
+      }
+      return /* @__PURE__ */ jsx9(Text6, { color: "white", children: trimmed }, index);
+    }) });
+  }
+  return null;
+};
+
+// src/components/timeline/ExecutionStep.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+
+// src/utils/formatting.ts
+function truncateOutput(content, maxLines) {
+  const lines = content.split("\n");
+  if (lines.length <= maxLines) {
+    return content;
+  }
+  return lines.slice(0, maxLines).join("\n") + `
+... (${lines.length - maxLines} lines hidden)`;
+}
+
+// src/components/timeline/ExecutionStep.tsx
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var ExecutionStep = ({ step }) => {
+  const stdout = step.metadata?.stdout;
+  const stderr = step.metadata?.stderr;
+  const exitCode = step.metadata?.exit_code;
+  const command = step.command || step.toolName;
+  const isSuccess = exitCode === 0 || exitCode === void 0 && step.status === "done";
+  const isError = exitCode !== void 0 && exitCode !== 0;
+  const isRunning = step.status === "running";
+  const borderColor = isError ? "red" : isSuccess ? "green" : isRunning ? "yellow" : "gray";
+  const headerColor = isError ? "red" : isSuccess ? "green" : isRunning ? "yellow" : "gray";
+  return /* @__PURE__ */ jsx10(Box6, { marginTop: 1, marginLeft: 1, flexDirection: "column", children: /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsx10(
+          Box6,
+          {
+            marginBottom: 1,
+            borderStyle: "single",
+            borderBottom: true,
+            borderLeft: false,
+            borderRight: false,
+            borderTop: false,
+            borderColor,
+            paddingBottom: 1,
+            children: /* @__PURE__ */ jsxs6(Text7, { color: headerColor, bold: true, children: [
+              "\u279C ",
+              command
+            ] })
+          }
+        ),
+        stdout && /* @__PURE__ */ jsx10(Box6, { marginBottom: stderr ? 1 : 0, flexDirection: "column", children: /* @__PURE__ */ jsx10(Text7, { color: isError ? "red" : "white", children: truncateOutput(stdout, 20) }) }),
+        stderr && /* @__PURE__ */ jsx10(Box6, { flexDirection: "column", marginTop: stdout ? 1 : 0, children: /* @__PURE__ */ jsx10(Text7, { color: "red", children: truncateOutput(stderr, 20) }) }),
+        !stdout && !stderr && isRunning && /* @__PURE__ */ jsx10(Box6, { children: /* @__PURE__ */ jsx10(Text7, { color: "gray", dimColor: true, children: "Running..." }) }),
+        !stdout && !stderr && !isRunning && /* @__PURE__ */ jsx10(Box6, { children: /* @__PURE__ */ jsx10(Text7, { color: "gray", dimColor: true, children: "(No output)" }) }),
+        exitCode !== void 0 && /* @__PURE__ */ jsx10(
+          Box6,
+          {
+            marginTop: 1,
+            borderStyle: "single",
+            borderBottom: false,
+            borderLeft: false,
+            borderRight: false,
+            borderTop: true,
+            borderColor,
+            paddingTop: 1,
+            children: /* @__PURE__ */ jsxs6(Text7, { color: isError ? "red" : "green", bold: true, children: [
+              "Exit code: ",
+              exitCode
+            ] })
+          }
+        )
+      ]
+    }
+  ) });
+};
+
+// src/components/timeline/ReasoningStep.tsx
+import { Box as Box7, Text as Text8 } from "ink";
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var ReasoningStep = ({ step }) => {
+  const isThinkTool = step.toolName === "think";
+  const reasoning = step.metadata?.reasoning;
+  const isReasoning = (!step.toolName || step.toolName === "") && step.metadata?.content;
+  const reasoningContent = step.metadata?.content;
+  if (isThinkTool && reasoning && step.status === "done") {
+    return /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, marginLeft: 1, marginBottom: 1, flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1, children: [
+      /* @__PURE__ */ jsx11(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text8, { color: "blue", bold: true, children: "Thinking Process:" }) }),
+      /* @__PURE__ */ jsx11(Text8, { color: "white", children: reasoning })
+    ] });
+  }
+  if (isReasoning && reasoningContent) {
+    return /* @__PURE__ */ jsx11(Box7, { marginTop: 1, marginLeft: 1, flexDirection: "column", children: /* @__PURE__ */ jsx11(Text8, { color: "blue", dimColor: true, children: reasoningContent }) });
+  }
+  return null;
+};
+
+// src/components/timeline/ContextStep.tsx
+import { Box as Box8, Text as Text9 } from "ink";
+import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+var ContextStep = ({ step }) => {
+  const contextBefore = step.metadata?.before;
+  const contextAfter = step.metadata?.after;
+  const contextSaved = contextBefore && contextAfter ? contextBefore - contextAfter : 0;
+  const contextPercent = contextBefore && contextSaved ? Math.round(contextSaved / contextBefore * 100) : 0;
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", alignItems: "center", children: [
+    /* @__PURE__ */ jsxs8(Text9, { color: "gray", children: [
+      "\u{1F9E0} ",
+      step.label
+    ] }),
+    contextSaved > 0 && /* @__PURE__ */ jsx12(Box8, { marginLeft: 1, children: /* @__PURE__ */ jsxs8(Text9, { color: "dim", dimColor: true, children: [
+      "(saved ",
+      contextSaved,
+      " tokens, ",
+      contextPercent,
+      "%)"
+    ] }) })
+  ] });
+};
+
+// src/components/timeline/RespondStep.tsx
+import { Box as Box9, Text as Text10 } from "ink";
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+var RespondStep = ({ step }) => {
+  const respondSummary = step.metadata?.summary;
+  const respondFiles = step.metadata?.files_changed;
+  if (step.status !== "done") return null;
+  return /* @__PURE__ */ jsxs9(Box9, { marginTop: 0, marginLeft: 2, flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs9(Box9, { children: [
+      /* @__PURE__ */ jsx13(Text10, { color: "green", children: "\u2714 " }),
+      /* @__PURE__ */ jsx13(Text10, { color: "white", children: respondSummary || "Task completed" })
+    ] }),
+    respondFiles && respondFiles.length > 0 && /* @__PURE__ */ jsx13(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsxs9(Text10, { color: "gray", dimColor: true, children: [
+      "Files: ",
+      respondFiles.join(", ")
+    ] }) })
+  ] });
+};
+
+// src/components/timeline/ReadFileStep.tsx
+import { Box as Box10, Text as Text11 } from "ink";
+import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+var ReadFileStep = ({ step }) => {
+  const { status, metadata } = step;
+  const isError = status === "failed" || metadata?.error;
+  const filePath = metadata?.path || metadata?.file_path || metadata?.params?.file_path || metadata?.params?.path || "Unknown file";
+  const fileName = filePath.split("/").pop() || filePath;
+  const statusIcon = isError ? "\u2717" : status === "running" ? "\u22EF" : "\u2713";
+  const statusColor = isError ? "red" : status === "running" ? "gray" : "green";
+  return /* @__PURE__ */ jsxs10(Box10, { children: [
+    /* @__PURE__ */ jsxs10(Text11, { color: statusColor, children: [
+      statusIcon,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx14(Text11, { color: "gray", children: "Reading " }),
+    /* @__PURE__ */ jsx14(Text11, { color: "cyan", children: fileName })
+  ] });
+};
+
+// src/components/timeline/TimelineItem.tsx
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+var TimelineItem = React5.memo(({ step, isActive = false }) => {
+  const config = getToolConfig(step.toolName);
+  let durationText = "";
+  if (step.durationMs !== void 0 && step.durationMs > 0) {
+    const seconds = (step.durationMs / 1e3).toFixed(2);
+    durationText = ` (${seconds}s)`;
+  }
+  const isPlanTool = step.toolName === "plan";
+  const planContent = step.metadata?.plan_content;
+  const planSummary = step.metadata?.plan_summary;
+  const planSteps = step.metadata?.plan_steps;
+  const planTargetAreas = step.metadata?.plan_target_areas;
+  const planRisks = step.metadata?.plan_risks;
+  const isExecutionTool = step.toolName === "run_cmd" || step.toolName === "run_tests" || step.toolName === "run_build";
+  const isThinkTool = step.toolName === "think";
+  const isReasoning = (!step.toolName || step.toolName === "") && step.metadata?.content;
+  const errorMessage = step.metadata?.error;
+  const errorResult = step.metadata?.error_result;
+  const isFailed = step.status === "failed";
+  const displayError = errorMessage || errorResult;
+  const isRespondTool = step.toolName === "respond";
+  const isReadFileTool = step.toolName === "read_file";
+  const isContextEvent = step.type === "context_event";
+  return /* @__PURE__ */ jsxs11(
+    Box11,
+    {
+      flexDirection: "column",
+      marginLeft: 1,
+      children: [
+        isContextEvent && /* @__PURE__ */ jsx15(ContextStep, { step }),
+        isReadFileTool && /* @__PURE__ */ jsx15(ReadFileStep, { step }),
+        !isContextEvent && !isReadFileTool && /* @__PURE__ */ jsxs11(Box11, { flexDirection: "row", alignItems: "center", justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs11(Box11, { flexDirection: "row", alignItems: "center", flexGrow: 1, children: [
+            /* @__PURE__ */ jsx15(Text12, { color: config.color, bold: true, children: config.icon }),
+            step.toolName && /* @__PURE__ */ jsx15(Box11, { marginLeft: 1, children: /* @__PURE__ */ jsxs11(Text12, { color: config.color, bold: true, children: [
+              "[",
+              step.toolName.toUpperCase(),
+              "]"
+            ] }) }),
+            /* @__PURE__ */ jsx15(Box11, { marginLeft: 1, flexGrow: 1, children: /* @__PURE__ */ jsx15(Text12, { children: step.label }) })
+          ] }),
+          /* @__PURE__ */ jsx15(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsx15(StatusBadge, { status: step.status }) })
+        ] }),
+        step.command && /* @__PURE__ */ jsx15(Box11, { marginTop: 0, marginLeft: 1, children: /* @__PURE__ */ jsxs11(Text12, { color: "dim", dimColor: true, children: [
+          "$ ",
+          step.command
+        ] }) }),
+        isPlanTool && step.status === "done" && (planContent || planSummary || planSteps) && /* @__PURE__ */ jsx15(Box11, { marginTop: 1, marginLeft: 1, flexDirection: "column", children: /* @__PURE__ */ jsx15(
+          PlanContent,
+          {
+            content: planContent,
+            summary: planSummary,
+            steps: planSteps,
+            targetAreas: planTargetAreas,
+            risks: planRisks
+          }
+        ) }),
+        isFailed && displayError && /* @__PURE__ */ jsxs11(Box11, { marginTop: 1, marginLeft: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx15(Text12, { color: "red", bold: true, children: "Error:" }),
+          /* @__PURE__ */ jsx15(Box11, { marginLeft: 1, children: /* @__PURE__ */ jsx15(Text12, { color: "red", children: displayError }) })
+        ] }),
+        isExecutionTool && /* @__PURE__ */ jsx15(ExecutionStep, { step }),
+        (isThinkTool || isReasoning) && /* @__PURE__ */ jsx15(ReasoningStep, { step }),
+        isRespondTool && /* @__PURE__ */ jsx15(RespondStep, { step })
+      ]
+    }
+  );
+}, (prevProps, nextProps) => {
+  return prevProps.step.id === nextProps.step.id && prevProps.step.label === nextProps.step.label && prevProps.step.status === nextProps.step.status && prevProps.step.metadata === nextProps.step.metadata && prevProps.step.finishedAt?.getTime() === nextProps.step.finishedAt?.getTime() && prevProps.isActive === nextProps.isActive;
+});
+
+// src/components/timeline/CodeDiff.tsx
+import { Box as Box12, Text as Text13 } from "ink";
+import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+var formatDiffLines = (text, prefix, color, maxLines = 10) => {
+  const lines = text.split("\n").slice(0, maxLines);
+  const hasMore = text.split("\n").length > maxLines;
+  const elements = lines.map((line, idx) => /* @__PURE__ */ jsx16(Box12, { children: /* @__PURE__ */ jsxs12(Text13, { color, children: [
+    prefix,
+    " ",
+    line || "(empty line)"
+  ] }) }, idx));
+  if (hasMore) {
+    elements.push(
+      /* @__PURE__ */ jsx16(Box12, { children: /* @__PURE__ */ jsx16(Text13, { color: "gray", children: "  ..." }) }, "more")
+    );
+  }
+  return elements;
+};
+var CodeDiff = ({ codeChange }) => {
+  const { file, before, after, startLine, endLine } = codeChange;
+  let location = file;
+  if (startLine && endLine) {
+    location += ` (L${startLine}-${endLine})`;
+  } else if (startLine) {
+    location += ` (L${startLine})`;
+  }
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginLeft: 2, marginTop: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsx16(Box12, { children: /* @__PURE__ */ jsxs12(Text13, { color: "magenta", children: [
+      "\u{1F4DD} ",
+      location
+    ] }) }),
+    before && /* @__PURE__ */ jsx16(Box12, { flexDirection: "column", marginLeft: 1, children: formatDiffLines(before, "-", "red", 5) }),
+    after && /* @__PURE__ */ jsx16(Box12, { flexDirection: "column", marginLeft: 1, children: formatDiffLines(after, "+", "green", 5) })
+  ] });
+};
+
+// src/components/common/FormattedText.tsx
+import { Box as Box13, Text as Text14 } from "ink";
+import { lexer } from "marked";
+import { jsx as jsx17, jsxs as jsxs13 } from "react/jsx-runtime";
+var RenderInline = ({ tokens }) => {
+  if (!tokens) return null;
+  return /* @__PURE__ */ jsx17(Text14, { children: tokens.map((token, i) => {
+    if (token.type === "text") {
+      if (token.tokens) {
+        return /* @__PURE__ */ jsx17(RenderInline, { tokens: token.tokens }, i);
+      }
+      return /* @__PURE__ */ jsx17(Text14, { children: token.text }, i);
+    }
+    if (token.type === "strong") {
+      return /* @__PURE__ */ jsx17(Text14, { bold: true, children: /* @__PURE__ */ jsx17(RenderInline, { tokens: token.tokens }) }, i);
+    }
+    if (token.type === "em") {
+      return /* @__PURE__ */ jsx17(Text14, { italic: true, children: /* @__PURE__ */ jsx17(RenderInline, { tokens: token.tokens }) }, i);
+    }
+    if (token.type === "codespan") {
+      return /* @__PURE__ */ jsx17(Text14, { color: "blue", backgroundColor: "black", children: token.text }, i);
+    }
+    if (token.type === "link") {
+      return /* @__PURE__ */ jsx17(Text14, { color: "blue", underline: true, children: token.text }, i);
+    }
+    return /* @__PURE__ */ jsx17(Text14, { children: token.raw }, i);
+  }) });
+};
+var FormattedText = ({ content }) => {
+  if (!content) return null;
+  const tokens = lexer(content);
+  return /* @__PURE__ */ jsx17(Box13, { flexDirection: "column", children: tokens.map((token, index) => {
+    if (token.type === "paragraph") {
+      return /* @__PURE__ */ jsx17(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsx17(RenderInline, { tokens: token.tokens }) }, index);
+    }
+    if (token.type === "code") {
+      return /* @__PURE__ */ jsx17(
+        Box13,
+        {
+          flexDirection: "column",
+          marginBottom: 1,
+          borderStyle: "round",
+          borderColor: "gray",
+          paddingX: 1,
+          children: /* @__PURE__ */ jsx17(Text14, { color: "yellow", children: token.text })
+        },
+        index
+      );
+    }
+    if (token.type === "list") {
+      return /* @__PURE__ */ jsx17(Box13, { flexDirection: "column", marginBottom: 1, children: token.items.map((item, i) => /* @__PURE__ */ jsxs13(Box13, { marginLeft: 1, children: [
+        /* @__PURE__ */ jsx17(Text14, { color: "green", children: "\u2022 " }),
+        /* @__PURE__ */ jsx17(RenderInline, { tokens: item.tokens })
+      ] }, i)) }, index);
+    }
+    if (token.type === "heading") {
+      return /* @__PURE__ */ jsx17(Box13, { marginBottom: 1, marginTop: 1, children: /* @__PURE__ */ jsx17(Text14, { bold: true, underline: true, children: token.text }) }, index);
+    }
+    if (token.type === "space") {
+      return null;
+    }
+    return /* @__PURE__ */ jsx17(Box13, { marginBottom: 1, children: token.text && /* @__PURE__ */ jsx17(Text14, { children: token.text }) }, index);
+  }) });
+};
+
+// src/components/conversation/Conversation.tsx
+import { jsx as jsx18, jsxs as jsxs14 } from "react/jsx-runtime";
+var Conversation = ({
+  isRunning,
+  timelineSteps = [],
+  currentRunningStepId
+}) => {
+  const { turns } = useConversation();
+  const turnCacheRef = React6.useRef(/* @__PURE__ */ new Map());
+  const items = useMemo3(() => {
+    const result = [];
+    turns.forEach((turn, index) => {
+      const isLastTurn = index === turns.length - 1;
+      let turnItems;
+      if (isLastTurn || !turnCacheRef.current.has(turn.id)) {
+        const steps = isLastTurn && timelineSteps.length > 0 ? timelineSteps : turn.timelineSteps;
+        turnItems = flattenTurn(turn, steps, currentRunningStepId);
+        if (turn.done && !isLastTurn) {
+          turnCacheRef.current.set(turn.id, turnItems);
+        }
+      } else {
+        turnItems = turnCacheRef.current.get(turn.id);
+      }
+      result.push(...turnItems);
+    });
+    return result;
+  }, [turns, timelineSteps, currentRunningStepId]);
+  if (turns.length === 0) {
+    return /* @__PURE__ */ jsx18(Box14, { flexDirection: "column", children: /* @__PURE__ */ jsx18(Text15, { color: "gray", children: "Describe a task below to get started." }) });
+  }
+  return /* @__PURE__ */ jsx18(Box14, { flexDirection: "column", children: items.map((item) => /* @__PURE__ */ jsx18(
+    RenderItemComponent,
+    {
+      item,
+      currentRunningStepId
+    },
+    item.id
+  )) });
+};
+var RenderItemComponent = React6.memo(({ item, currentRunningStepId }) => {
+  switch (item.type) {
+    case "user_message":
+      return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs14(Box14, { children: [
+          /* @__PURE__ */ jsxs14(Text15, { color: "gray", bold: true, children: [
+            item.prefix,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx18(Text15, { color: "gray", children: item.text.split("\n")[0] })
+        ] }),
+        item.text.split("\n").slice(1).map((line, i) => /* @__PURE__ */ jsx18(Box14, { marginLeft: item.prefix.length + 1, children: /* @__PURE__ */ jsx18(Text15, { color: "gray", children: line }) }, i))
+      ] });
+    case "label":
+      return /* @__PURE__ */ jsx18(Box14, { children: /* @__PURE__ */ jsx18(Text15, { color: item.color, bold: true, dimColor: item.dimColor, children: item.text }) });
+    case "text_chunk":
+      return /* @__PURE__ */ jsx18(Box14, { marginLeft: 1, children: item.dimColor ? /* @__PURE__ */ jsx18(Text15, { color: "gray", dimColor: true, children: item.text }) : /* @__PURE__ */ jsx18(FormattedText, { content: item.text }) });
+    case "divider":
+      return null;
+    case "timeline_step":
+      return /* @__PURE__ */ jsx18(
+        TimelineItem,
+        {
+          step: item.step,
+          isActive: item.step.id === currentRunningStepId || item.step.status === "running"
+        }
+      );
+    case "assistant_message":
+      return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs14(Box14, { children: [
+          /* @__PURE__ */ jsxs14(Text15, { color: "green", bold: true, children: [
+            item.prefix,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx18(FormattedText, { content: item.text.split("\n")[0] })
+        ] }),
+        item.text.split("\n").length > 1 && /* @__PURE__ */ jsx18(Box14, { flexDirection: "column", marginLeft: item.prefix.length + 1, children: /* @__PURE__ */ jsx18(FormattedText, { content: item.text.split("\n").slice(1).join("\n") }) })
+      ] });
+    case "code_change":
+      return /* @__PURE__ */ jsx18(Box14, { paddingX: 1, children: /* @__PURE__ */ jsx18(CodeDiff, { codeChange: item.codeChange }) });
+    default:
+      return null;
+  }
+});
+
+// src/components/layout/AppLayout.tsx
+import { jsx as jsx19, jsxs as jsxs15 } from "react/jsx-runtime";
+var AppLayout = React7.memo(({
+  terminalRows,
+  terminalColumns,
+  error,
+  showProjectPlan,
+  projectPlan,
+  currentTimelineSteps,
+  currentRunningStepId,
+  isRunning,
+  footerProps,
+  onCancelRequest,
+  helpModal,
+  onHelp
+}) => {
+  const { exit } = useApp3();
+  const handlerRef = useRef7({
+    exit,
+    isRunning,
+    onCancelRequest,
+    onHelp,
+    helpModal: !!helpModal
+  });
+  handlerRef.current = {
+    exit,
+    isRunning,
+    onCancelRequest,
+    onHelp,
+    helpModal: !!helpModal
+  };
+  useInput2((input, key) => {
+    const { exit: exit2, isRunning: isRunning2, onCancelRequest: onCancelRequest2, onHelp: onHelp2, helpModal: helpModal2 } = handlerRef.current;
+    if (key.ctrl && input === "c") {
+      exit2();
+      return;
+    }
+    if (key.escape) {
+      if (helpModal2) {
+        return;
+      }
+      if (onCancelRequest2) {
+        onCancelRequest2();
+      }
+      return;
+    }
+    if (input === "\x1BOP") {
+      onHelp2?.();
+      return;
+    }
+  }, { isActive: true });
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx19(Box15, { paddingX: 1, flexShrink: 0, children: /* @__PURE__ */ jsx19(Header, {}) }),
+    error && /* @__PURE__ */ jsx19(Box15, { paddingX: 1, children: /* @__PURE__ */ jsx19(Box15, { borderStyle: "round", borderColor: "red", paddingX: 1, children: /* @__PURE__ */ jsxs15(Text16, { color: "red", children: [
+      "Error: ",
+      error
+    ] }) }) }),
+    /* @__PURE__ */ jsx19(Box15, { flexGrow: 1, flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsx19(
+      Conversation,
+      {
+        isRunning,
+        timelineSteps: currentTimelineSteps,
+        currentRunningStepId
+      }
+    ) }),
+    helpModal && /* @__PURE__ */ jsx19(Box15, { position: "absolute", width: "100%", height: "100%", alignItems: "center", justifyContent: "center", children: helpModal }),
+    !helpModal && /* @__PURE__ */ jsx19(Box15, { flexShrink: 0, paddingX: 1, children: /* @__PURE__ */ jsx19(Footer, { ...footerProps }) })
+  ] });
+});
+
+// src/components/SetupWizard.tsx
+import React8, { useState as useState8 } from "react";
+import { Box as Box16, Text as Text17, useApp as useApp4, useInput as useInput3 } from "ink";
+import { jsx as jsx20, jsxs as jsxs16 } from "react/jsx-runtime";
+var PROVIDERS = ["openai", "anthropic", "kimi", "gemini", "deepseek", "groq", "lmstudio", "ollama", "glm", "minimax"];
+var UncontrolledInput = ({ placeholder, onSubmit }) => {
+  const [value, setValue] = useState8("");
+  return /* @__PURE__ */ jsx20(
+    Input,
+    {
+      value,
+      onChange: setValue,
+      onSubmit,
+      placeholder
+    }
+  );
+};
+var PROVIDER_MODELS = {
+  "openai": ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"],
+  "anthropic": ["claude-3-5-sonnet-20240620", "claude-3-opus-20240229", "claude-3-sonnet-20240229", "claude-3-haiku-20240307"],
+  "kimi": ["kimi-k2-250711"]
+};
+var SetupWizard = ({ sendCommand, onComplete, isUpdate = false, initialConfig }) => {
+  const { exit } = useApp4();
+  const [step, setStep] = useState8("intro");
+  const [isReady, setIsReady] = useState8(false);
+  const [config, setConfig] = useState8({
+    llm_provider: "openai",
+    api_key: "",
+    model: "gpt-4o",
+    auto_index: true,
+    embedding_key: ""
+  });
+  React8.useEffect(() => {
+    if (initialConfig) {
+      setConfig((prev) => ({
+        ...prev,
+        llm_provider: initialConfig.llm_provider || prev.llm_provider,
+        api_key: initialConfig.api_key || prev.api_key,
+        model: initialConfig.model || prev.model,
+        auto_index: initialConfig.auto_index === "true"
+      }));
+    }
+  }, [initialConfig]);
+  const [selectedProviderIndex, setSelectedProviderIndex] = useState8(0);
+  const [selectedModelIndex, setSelectedModelIndex] = useState8(0);
+  const lastStepChangeRef = React8.useRef(Date.now());
+  React8.useEffect(() => {
+    debugLog.lifecycle("SetupWizard", "mount", `isUpdate=${isUpdate}`);
+    const timer = setTimeout(() => setIsReady(true), 1e3);
+    return () => {
+      debugLog.lifecycle("SetupWizard", "unmount");
+      clearTimeout(timer);
+    };
+  }, [isUpdate]);
+  useInput3((input, key) => {
+    debugLog.event("SetupWizard", "keypress", { step, input, key });
+    if (!isReady) return;
+    if (Date.now() - lastStepChangeRef.current < 500) {
+      return;
+    }
+    if (key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (step === "intro" && key.return) {
+      setStep("provider");
+      lastStepChangeRef.current = Date.now();
+      return;
+    }
+    if (step === "provider") {
+      if (key.upArrow) {
+        setSelectedProviderIndex((prev) => Math.max(0, prev - 1));
+      }
+      if (key.downArrow) {
+        setSelectedProviderIndex((prev) => Math.min(PROVIDERS.length - 1, prev + 1));
+      }
+      if (key.return) {
+        const provider = PROVIDERS[selectedProviderIndex];
+        setConfig((prev) => ({ ...prev, llm_provider: provider, model: PROVIDER_MODELS[provider][0] }));
+        setSelectedModelIndex(0);
+        setStep("model");
+        lastStepChangeRef.current = Date.now();
+      }
+      return;
+    }
+    if (step === "model") {
+      const models = PROVIDER_MODELS[config.llm_provider] || [];
+      if (key.upArrow) {
+        setSelectedModelIndex((prev) => Math.max(0, prev - 1));
+      }
+      if (key.downArrow) {
+        setSelectedModelIndex((prev) => Math.min(models.length - 1, prev + 1));
+      }
+      if (key.return) {
+        setConfig((prev) => ({ ...prev, model: models[selectedModelIndex] }));
+        setStep("api_key");
+        lastStepChangeRef.current = Date.now();
+      }
+      return;
+    }
+    if (step === "auto_index") {
+      if (input === "y" || input === "Y" || key.return) {
+        setConfig((prev) => ({ ...prev, auto_index: true }));
+        setStep("summary");
+        lastStepChangeRef.current = Date.now();
+        return;
+      }
+      if (input === "n" || input === "N") {
+        setConfig((prev) => ({ ...prev, auto_index: false }));
+        setStep("summary");
+        lastStepChangeRef.current = Date.now();
+        return;
+      }
+    }
+    if (step === "summary") {
+      if (key.return) {
+        handleSave();
+        lastStepChangeRef.current = Date.now();
+        return;
+      }
+      if (key.escape || key.backspace || key.delete) {
+        setStep("intro");
+        return;
+      }
+    }
+    if (step === "complete" && key.return) {
+      debugLog.lifecycle("SetupWizard", "update", "onComplete triggered");
+      onComplete();
+    }
+  }, { isActive: true });
+  const handleSave = () => {
+    setStep("saving");
+    const payload = {
+      ...config,
+      auto_index: config.auto_index ? "true" : "false"
+    };
+    sendCommand("save_config", payload);
+    setTimeout(() => {
+      setStep("complete");
+    }, 1e3);
+  };
+  if (step === "intro") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan", children: [
+      /* @__PURE__ */ jsx20(Text17, { bold: true, color: "cyan", children: isUpdate ? "Update Configuration" : "Welcome to Dodo! \u{1F9A4}" }),
+      /* @__PURE__ */ jsx20(Text17, { children: isUpdate ? "Let's update your Dodo agent settings." : "It looks like this is your first time running Dodo." }),
+      !isUpdate && /* @__PURE__ */ jsx20(Text17, { children: "Let's get you set up in a few seconds." }),
+      isUpdate && /* @__PURE__ */ jsx20(Box16, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx20(Text17, { color: "gray", children: "You are currently re-configuring the agent." }) }),
+      /* @__PURE__ */ jsx20(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text17, { color: "green", children: "Press Enter to start..." }) })
+    ] });
+  }
+  if (step === "provider") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "blue", children: [
+      /* @__PURE__ */ jsx20(Text17, { bold: true, children: "Select your LLM Provider:" }),
+      PROVIDERS.map((p, i) => /* @__PURE__ */ jsxs16(Text17, { color: i === selectedProviderIndex ? "green" : "white", children: [
+        i === selectedProviderIndex ? "> " : "  ",
+        " ",
+        p
+      ] }, p)),
+      /* @__PURE__ */ jsx20(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text17, { color: "gray", children: "Use Up/Down arrows, Enter to select" }) })
+    ] });
+  }
+  if (step === "model") {
+    const models = PROVIDER_MODELS[config.llm_provider] || [];
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "blue", children: [
+      /* @__PURE__ */ jsxs16(Text17, { bold: true, children: [
+        "Select Default Model for ",
+        config.llm_provider,
+        ":"
+      ] }),
+      models.map((m, i) => /* @__PURE__ */ jsxs16(Text17, { color: i === selectedModelIndex ? "green" : "white", children: [
+        i === selectedModelIndex ? "> " : "  ",
+        " ",
+        m
+      ] }, m)),
+      /* @__PURE__ */ jsx20(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text17, { color: "gray", children: "Use Up/Down arrows, Enter to select" }) })
+    ] });
+  }
+  if (step === "api_key") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "blue", children: [
+      /* @__PURE__ */ jsxs16(Text17, { bold: true, children: [
+        "Enter your API Key for ",
+        config.llm_provider,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsx20(
+        UncontrolledInput,
+        {
+          placeholder: "sk-...",
+          onSubmit: (val) => {
+            if (!val.trim()) return;
+            setConfig((prev) => ({ ...prev, api_key: val }));
+            if (config.llm_provider === "openai") {
+              setStep("auto_index");
+            } else {
+              setStep("embedding_key");
+            }
+          }
+        },
+        step
+      )
+    ] });
+  }
+  if (step === "embedding_key") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "blue", children: [
+      /* @__PURE__ */ jsx20(Text17, { bold: true, children: "Optional: Enter OpenAI API Key for Embeddings" }),
+      /* @__PURE__ */ jsx20(Text17, { color: "gray", children: "Semantic search requires OpenAI embeddings. Press Enter to skip." }),
+      /* @__PURE__ */ jsx20(
+        UncontrolledInput,
+        {
+          placeholder: "sk-... (optional)",
+          onSubmit: (val) => {
+            setConfig((prev) => ({ ...prev, embedding_key: val.trim() }));
+            setStep("auto_index");
+          }
+        },
+        step
+      )
+    ] });
+  }
+  if (step === "auto_index") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "blue", children: [
+      /* @__PURE__ */ jsx20(Text17, { bold: true, children: "Enable Auto-Indexing for new projects? (Y/n)" }),
+      /* @__PURE__ */ jsx20(Text17, { color: "gray", children: "This allows Dodo to understand your codebase using semantic search." })
+    ] });
+  }
+  if (step === "summary") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "yellow", children: [
+      /* @__PURE__ */ jsx20(Text17, { bold: true, color: "yellow", children: "Configuration Summary" }),
+      /* @__PURE__ */ jsxs16(Box16, { marginY: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs16(Text17, { children: [
+          "Provider:   ",
+          /* @__PURE__ */ jsx20(Text17, { bold: true, color: "white", children: config.llm_provider })
+        ] }),
+        /* @__PURE__ */ jsxs16(Text17, { children: [
+          "Model:      ",
+          /* @__PURE__ */ jsx20(Text17, { bold: true, color: "white", children: config.model })
+        ] }),
+        /* @__PURE__ */ jsxs16(Text17, { children: [
+          "API Key:    ",
+          /* @__PURE__ */ jsx20(Text17, { bold: true, color: "white", children: config.api_key ? "********" + config.api_key.slice(-4) : "(Not set)" })
+        ] }),
+        config.llm_provider !== "openai" && /* @__PURE__ */ jsxs16(Text17, { children: [
+          "Embed Key:  ",
+          /* @__PURE__ */ jsx20(Text17, { bold: true, color: "white", children: config.embedding_key ? "********" + config.embedding_key.slice(-4) : "(Not set - no semantic search)" })
+        ] }),
+        /* @__PURE__ */ jsxs16(Text17, { children: [
+          "Auto-Index: ",
+          /* @__PURE__ */ jsx20(Text17, { bold: true, color: "white", children: config.auto_index ? "Yes" : "No" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs16(Text17, { children: [
+        "Press ",
+        /* @__PURE__ */ jsx20(Text17, { bold: true, color: "green", children: "Enter" }),
+        " to Save, or ",
+        /* @__PURE__ */ jsx20(Text17, { bold: true, color: "red", children: "Esc" }),
+        " to Restart"
+      ] })
+    ] });
+  }
+  if (step === "saving") {
+    return /* @__PURE__ */ jsx20(Box16, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx20(Text17, { color: "yellow", children: "Saving configuration..." }) });
+  }
+  if (step === "complete") {
+    return /* @__PURE__ */ jsxs16(Box16, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "green", children: [
+      /* @__PURE__ */ jsx20(Text17, { bold: true, color: "green", children: "Setup Complete! \u{1F389}" }),
+      /* @__PURE__ */ jsx20(Text17, { children: "Configuration saved successfully." }),
+      /* @__PURE__ */ jsx20(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text17, { color: "gray", children: "Press Enter to return..." }) })
+    ] });
+  }
+  return null;
+};
+
+// src/components/ProjectPermissionPrompt.tsx
+import { useState as useState9, useEffect as useEffect8 } from "react";
+import { Box as Box17, Text as Text18, useInput as useInput4 } from "ink";
+import { jsx as jsx21, jsxs as jsxs17 } from "react/jsx-runtime";
+var ProjectPermissionPrompt = ({
+  repoRoot,
+  onResponse
+}) => {
+  const [isReady, setIsReady] = useState9(false);
+  useEffect8(() => {
+    debugLog.lifecycle("ProjectPermissionPrompt", "mount", `repo=${repoRoot}`);
+    const timer = setTimeout(() => setIsReady(true), 500);
+    return () => {
+      debugLog.lifecycle("ProjectPermissionPrompt", "unmount");
+      clearTimeout(timer);
+    };
+  }, [repoRoot]);
+  useInput4((input, key) => {
+    if (!isReady) return;
+    if (input === "y" || input === "Y" || key.return) {
+      debugLog.command("ProjectPermissionPrompt", "response", { enabled: true });
+      onResponse(true);
+    } else if (input === "n" || input === "N") {
+      debugLog.command("ProjectPermissionPrompt", "response", { enabled: false });
+      onResponse(false);
+    }
+  });
+  const projectName = repoRoot.split("/").pop() || repoRoot;
+  return /* @__PURE__ */ jsxs17(Box17, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan", children: [
+    /* @__PURE__ */ jsx21(Text18, { bold: true, color: "cyan", children: "Project Indexing Setup \u{1F4CA}" }),
+    /* @__PURE__ */ jsxs17(Box17, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx21(Text18, { children: "Would you like to enable semantic indexing for " }),
+      /* @__PURE__ */ jsx21(Text18, { bold: true, color: "white", children: projectName }),
+      /* @__PURE__ */ jsx21(Text18, { children: "?" })
+    ] }),
+    /* @__PURE__ */ jsxs17(Box17, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx21(Text18, { color: "gray", children: "This allows Dodo to understand your codebase deeply for:" }),
+      /* @__PURE__ */ jsx21(Text18, { color: "gray", children: "  \u2022 Semantic code search" }),
+      /* @__PURE__ */ jsx21(Text18, { color: "gray", children: "  \u2022 Context-aware suggestions" }),
+      /* @__PURE__ */ jsx21(Text18, { color: "gray", children: "  \u2022 Better code understanding" })
+    ] }),
+    /* @__PURE__ */ jsxs17(Box17, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx21(Text18, { color: "gray", children: "You can add custom rules in " }),
+      /* @__PURE__ */ jsx21(Text18, { color: "yellow", children: ".dodo/rules" })
+    ] }),
+    /* @__PURE__ */ jsxs17(Box17, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx21(Text18, { color: "green", bold: true, children: "(Y)" }),
+      /* @__PURE__ */ jsx21(Text18, { children: "es / " }),
+      /* @__PURE__ */ jsx21(Text18, { color: "red", bold: true, children: "(N)" }),
+      /* @__PURE__ */ jsx21(Text18, { children: "o" })
+    ] })
+  ] });
+};
+
+// src/components/SessionPicker.tsx
+import { useState as useState10, useEffect as useEffect9 } from "react";
+import { Box as Box18, Text as Text19, useApp as useApp5, useInput as useInput5 } from "ink";
+import fs3 from "fs";
+import path2 from "path";
+import os from "os";
+import crypto from "crypto";
+import { jsx as jsx22, jsxs as jsxs18 } from "react/jsx-runtime";
+var formatDate = (date) => {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  const days = Math.floor(diff / (1e3 * 60 * 60 * 24));
+  if (days === 0) {
+    return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+  } else if (days === 1) {
+    return "Yesterday";
+  } else {
+    return date.toLocaleDateString();
+  }
+};
+var SessionPicker = ({ repoPath, onSelect }) => {
+  const [sessions, setSessions] = useState10([]);
+  const [selectedIndex, setSelectedIndex] = useState10(0);
+  const [loading, setLoading] = useState10(true);
+  useEffect9(() => {
+    const loadSessions = async () => {
+      try {
+        const hash = crypto.createHash("sha256").update(path2.resolve(repoPath)).digest("hex").substring(0, 12);
+        const sessionDir = path2.join(os.homedir(), ".dodo", "sessions", hash);
+        if (!fs3.existsSync(sessionDir)) {
+          setSessions([]);
+          return;
+        }
+        const files = fs3.readdirSync(sessionDir);
+        const loadedSessions = [];
+        for (const file of files) {
+          if (!file.endsWith(".json")) continue;
+          try {
+            const content = fs3.readFileSync(path2.join(sessionDir, file), "utf-8");
+            const data = JSON.parse(content);
+            loadedSessions.push({
+              id: data.id,
+              title: data.title || "Untitled Session",
+              updatedAt: new Date(data.updated_at),
+              summary: data.summary
+            });
+          } catch (e) {
+          }
+        }
+        loadedSessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+        setSessions(loadedSessions);
+        if (loadedSessions.length === 0) {
+          onSelect(void 0);
+          return;
+        }
+      } catch (err) {
+      } finally {
+        setLoading(false);
+      }
+    };
+    loadSessions();
+  }, [repoPath, onSelect]);
+  const options = [
+    { id: "new", title: "+ Start New Session", updatedAt: /* @__PURE__ */ new Date(), summary: "" },
+    ...sessions
+  ];
+  const { exit } = useApp5();
+  useInput5((input, key) => {
+    if (loading) return;
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(options.length - 1, prev + 1));
+    }
+    if (key.return) {
+      if (options[selectedIndex]) {
+        const selected = options[selectedIndex];
+        onSelect(selected.id === "new" ? void 0 : selected.id);
+      }
+    }
+    if (input === "q" || key.ctrl && input === "c") {
+      exit();
+    }
+  }, { isActive: !loading });
+  if (loading) {
+    return /* @__PURE__ */ jsx22(Box18, { padding: 1, children: /* @__PURE__ */ jsx22(Text19, { children: "Loading sessions..." }) });
+  }
+  return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "blue", children: [
+    /* @__PURE__ */ jsx22(Box18, { marginBottom: 1, children: /* @__PURE__ */ jsx22(Text19, { bold: true, color: "cyan", children: "Select a Session" }) }),
+    options.map((option, index) => {
+      const isSelected = index === selectedIndex;
+      return /* @__PURE__ */ jsxs18(Box18, { flexDirection: "column", marginBottom: 0, children: [
+        /* @__PURE__ */ jsxs18(Box18, { children: [
+          /* @__PURE__ */ jsx22(Text19, { color: isSelected ? "green" : void 0, children: isSelected ? "> " : "  " }),
+          /* @__PURE__ */ jsx22(Text19, { bold: isSelected, color: isSelected ? "white" : "gray", children: option.title }),
+          /* @__PURE__ */ jsx22(Box18, { marginLeft: 2, children: option.id !== "new" && /* @__PURE__ */ jsxs18(Text19, { color: "gray", children: [
+            "(",
+            formatDate(option.updatedAt),
+            ")"
+          ] }) })
+        ] }),
+        isSelected && option.summary && /* @__PURE__ */ jsx22(Box18, { marginLeft: 2, marginBottom: 1, children: /* @__PURE__ */ jsxs18(Text19, { color: "gray", italic: true, children: [
+          "\u2514\u2500 ",
+          option.summary.length > 80 ? option.summary.substring(0, 80) + "..." : option.summary
+        ] }) })
+      ] }, option.id);
+    }),
+    /* @__PURE__ */ jsxs18(Box18, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx22(Text19, { color: "gray", children: "Use UP/DOWN to navigate, ENTER to select" }),
+      /* @__PURE__ */ jsx22(Text19, { color: "gray", children: "Press 'q' or 'Ctrl+C' to quit" })
+    ] })
+  ] });
+};
+
+// src/components/modal/HelpModal.tsx
+import { Box as Box19, Text as Text20, useInput as useInput6 } from "ink";
+import { jsx as jsx23, jsxs as jsxs19 } from "react/jsx-runtime";
+var SECTIONS = [
+  {
+    title: "System Commands",
+    items: [
+      { command: "/help", description: "Show this help menu" },
+      { command: "/exit", description: "Exit the application" },
+      { command: "/clear", description: "Clear conversation history" },
+      { command: "/stop", description: "Stop current running task" }
+    ]
+  },
+  {
+    title: "Agent Capabilities",
+    items: [
+      { command: "Run Tests", description: "Agent can run project tests" },
+      { command: "Edit Files", description: "Agent can search & edit code" },
+      { command: "Search", description: "Agent can search codebase" }
+    ]
+  },
+  {
+    title: "Keyboard Shortcuts",
+    items: [
+      { command: "Esc", description: "Close modal / cancel task" },
+      { command: "Ctrl+C", description: "Force exit application" },
+      { command: "\u2191 / \u2193", description: "Navigate history" },
+      { command: "F1", description: "Toggle Help" }
+    ]
+  }
+];
+var HelpModal = ({ onClose }) => {
+  useInput6((_input, key) => {
+    if (key.escape) {
+      onClose();
+    }
+  }, { isActive: true });
+  return /* @__PURE__ */ jsxs19(
+    Box19,
+    {
+      borderStyle: "double",
+      borderColor: "cyan",
+      paddingX: 2,
+      paddingY: 1,
+      flexDirection: "column",
+      alignSelf: "center",
+      children: [
+        /* @__PURE__ */ jsx23(Box19, { marginBottom: 1, justifyContent: "center", children: /* @__PURE__ */ jsx23(Text20, { bold: true, color: "cyan", children: "Dodo Help & Commands" }) }),
+        SECTIONS.map((section, idx) => /* @__PURE__ */ jsxs19(Box19, { flexDirection: "column", marginBottom: idx === SECTIONS.length - 1 ? 0 : 1, children: [
+          /* @__PURE__ */ jsx23(Text20, { bold: true, underline: true, color: "white", children: section.title }),
+          section.items.map((item) => /* @__PURE__ */ jsxs19(Box19, { marginLeft: 2, children: [
+            /* @__PURE__ */ jsx23(Box19, { width: 15, children: /* @__PURE__ */ jsx23(Text20, { color: "green", children: item.command }) }),
+            /* @__PURE__ */ jsx23(Text20, { children: item.description })
+          ] }, item.command))
+        ] }, section.title)),
+        /* @__PURE__ */ jsx23(Box19, { marginTop: 1, justifyContent: "center", borderStyle: "single", borderTop: false, borderLeft: false, borderRight: false, borderBottom: true, borderColor: "gray" }),
+        /* @__PURE__ */ jsx23(Box19, { marginTop: 1, justifyContent: "center", children: /* @__PURE__ */ jsxs19(Text20, { color: "gray", children: [
+          "Press ",
+          /* @__PURE__ */ jsx23(Text20, { bold: true, color: "white", children: "ESC" }),
+          " to close"
+        ] }) })
+      ]
+    }
+  );
+};
+
+// src/hooks/useHistory.ts
+import { useState as useState11, useCallback as useCallback8 } from "react";
+function useHistory() {
+  const [history, setHistory] = useState11([]);
+  const [historyIndex, setHistoryIndex] = useState11(-1);
+  const addToHistory = useCallback8((command) => {
+    setHistory((prev) => {
+      const last = prev[prev.length - 1];
+      if (last !== command) {
+        return [...prev, command];
+      }
+      return prev;
+    });
+    setHistoryIndex(-1);
+  }, []);
+  const resetHistoryIndex = useCallback8(() => setHistoryIndex(-1), []);
+  const navigateHistory = useCallback8(
+    (direction) => {
+      let newIndex = 0;
+      let returnValue = void 0;
+      setHistoryIndex((prev) => {
+        newIndex = prev;
+        if (direction === "up") {
+          newIndex = Math.min(prev + 1, history.length - 1);
+        } else {
+          newIndex = Math.max(prev - 1, -1);
+        }
+        return newIndex;
+      });
+    },
+    [history]
+  );
+  const navigate = useCallback8((direction, currentHistoryIndex, currentHistory) => {
+    let newIndex = currentHistoryIndex;
+    if (direction === "up") {
+      newIndex = Math.min(currentHistoryIndex + 1, currentHistory.length - 1);
+    } else {
+      newIndex = Math.max(currentHistoryIndex - 1, -1);
+    }
+    let newValue = void 0;
+    if (newIndex >= 0 && newIndex < currentHistory.length) {
+      newValue = currentHistory[currentHistory.length - 1 - newIndex];
+    }
+    return { index: newIndex, value: newValue };
+  }, []);
+  return {
+    history,
+    historyIndex,
+    addToHistory,
+    navigateHistory: (direction) => {
+      const res = navigate(direction, historyIndex, history);
+      setHistoryIndex(res.index);
+      return res;
+    },
+    resetHistoryIndex
+  };
+}
+
+// src/hooks/useTerminal.ts
+import { useState as useState12, useEffect as useEffect10 } from "react";
+
+// src/utils/ansi.ts
+var ANSI = {
+  // Screen / Buffer
+  ALTERNATE_BUFFER_ENTER: "\x1B[?1049h",
+  ALTERNATE_BUFFER_EXIT: "\x1B[?1049l",
+  CLEAR_SCREEN: "\x1B[2J",
+  CURSOR_HOME: "\x1B[H",
+  // Mouse Tracking
+  MOUSE_TRACKING_ENABLE: "\x1B[?1002h\x1B[?1006h",
+  MOUSE_TRACKING_DISABLE: "\x1B[?1006l\x1B[?1002l",
+  // Bracketed Paste
+  BRACKETED_PASTE_ENABLE: "\x1B[?2004h",
+  BRACKETED_PASTE_DISABLE: "\x1B[?2004l"
+};
+
+// src/hooks/useTerminal.ts
+function useTerminal(options = {}) {
+  const { enableAlternateBuffer = true, defaultRows = 24 } = options;
+  const [terminalRows, setTerminalRows] = useState12(() => {
+    return process.stdout?.rows || defaultRows;
+  });
+  const [terminalColumns, setTerminalColumns] = useState12(() => {
+    return process.stdout?.columns || 80;
+  });
+  useEffect10(() => {
+    const updateDimensions = () => {
+      if (process.stdout?.rows) {
+        setTerminalRows(process.stdout.rows);
+      }
+      if (process.stdout?.columns) {
+        setTerminalColumns(process.stdout.columns);
+      }
+    };
+    process.stdout?.on("resize", updateDimensions);
+    updateDimensions();
+    return () => {
+      process.stdout?.off("resize", updateDimensions);
+    };
+  }, []);
+  useEffect10(() => {
+    if (!enableAlternateBuffer || !process.stdout?.write) return;
+    process.stdout.write(ANSI.ALTERNATE_BUFFER_ENTER);
+    process.stdout.write(ANSI.BRACKETED_PASTE_ENABLE);
+    process.stdout.write(ANSI.CLEAR_SCREEN + ANSI.CURSOR_HOME);
+    return () => {
+      process.stdout.write(ANSI.BRACKETED_PASTE_DISABLE);
+      process.stdout.write(ANSI.ALTERNATE_BUFFER_EXIT);
+    };
+  }, [enableAlternateBuffer]);
+  return { terminalRows, terminalColumns };
+}
+
+// src/hooks/useCommandProcessor.ts
+import { useCallback as useCallback9 } from "react";
+
+// src/utils/diagnostics.ts
+import fs4 from "fs";
+function generateDiagnostics(params) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    session: {
+      id: params.sessionId,
+      status: params.status,
+      isRunning: params.isRunning
+    },
+    config: params.loadedConfig,
+    environment: {
+      LLM_PROVIDER: process.env.LLM_PROVIDER,
+      DODO_DEBUG: process.env.DODO_DEBUG,
+      NODE_ENV: process.env.NODE_ENV
+    },
+    componentStates: {
+      isSetupRequired: params.isSetupRequired,
+      isUpdateMode: params.isUpdateMode
+    }
+  };
+}
+function writeDiagnostics(diagnostics) {
+  const filePath = "/tmp/dodo_diagnostics.json";
+  try {
+    fs4.writeFileSync(filePath, JSON.stringify(diagnostics, null, 2));
+    return filePath;
+  } catch (error) {
+    return `Error writing diagnostics: ${error}`;
+  }
+}
+
+// src/hooks/useCommandProcessor.ts
+function useCommandProcessor(ctx) {
+  const processCommand = useCallback9((input) => {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) return false;
+    if (trimmed === "/help") {
+      ctx.setActiveModal("help");
+      ctx.setInput("");
+      return true;
+    }
+    if (trimmed === "/exit" || trimmed === "/quit") {
+      process.stdout.write("\x1B[?1049l");
+      process.exit(0);
+      return true;
+    }
+    if (trimmed === "/clear") {
+      ctx.clearTurns();
+      ctx.setInput("");
+      return true;
+    }
+    if (trimmed === "/debug") {
+      const diagnostics = generateDiagnostics({
+        sessionId: ctx.sessionId,
+        status: ctx.status,
+        isRunning: ctx.isRunning,
+        loadedConfig: ctx.loadedConfig,
+        isSetupRequired: ctx.isSetupRequired,
+        isUpdateMode: ctx.isUpdateMode
+      });
+      const filePath = writeDiagnostics(diagnostics);
+      debugLog.command("App", "/debug", { outputPath: filePath });
+      ctx.setInput("");
+      return true;
+    }
+    if (trimmed === "/stop") {
+      if (ctx.isRunning) {
+        ctx.cancelRequest();
+        debugLog.command("App", "/stop", { sessionId: ctx.sessionId });
+      }
+      ctx.setInput("");
+      return true;
+    }
+    if (trimmed === "/configure") {
+      ctx.setIsUpdateMode(true);
+      ctx.setIsSetupRequired(true);
+      ctx.sendCommand({ type: "get_config" });
+      ctx.setInput("");
+      return true;
+    }
+    return false;
+    return false;
+  }, [ctx]);
+  return { processCommand };
+}
+
+// src/ui/app.tsx
+import { jsx as jsx24 } from "react/jsx-runtime";
+debugLog.lifecycle("App", "mount", "module loaded");
+var App = ({
+  client,
+  repoPath,
+  requestedSessionId,
+  engineCommand,
+  engineExited
+}) => {
+  const [input, setInput] = useState13("");
+  const [activeModal, setActiveModal] = useState13("none");
+  const [targetSessionId, setTargetSessionId] = useState13(requestedSessionId);
+  const [isSessionSelected, setIsSessionSelected] = useState13(!!requestedSessionId);
+  useEffect11(() => {
+    if (isSessionSelected && process.stdout?.write) {
+      process.stdout.write("\x1B[2J\x1B[H");
+    }
+  }, [isSessionSelected]);
+  const { history, historyIndex, addToHistory, navigateHistory, resetHistoryIndex } = useHistory();
+  const { terminalRows, terminalColumns } = useTerminal({ enableAlternateBuffer: false });
+  const {
+    sessionId,
+    status,
+    infoMessage,
+    isRunning,
+    error,
+    tokenUsage,
+    projectPlan,
+    showProjectPlan,
+    errorCount,
+    currentThought,
+    turns,
+    currentTimelineSteps,
+    currentRunningStepId,
+    toggleTurnCollapsed,
+    submitQuery,
+    sendCommand,
+    isSetupRequired,
+    setIsSetupRequired,
+    isProjectPermissionRequired,
+    setIsProjectPermissionRequired,
+    pendingRepoRoot,
+    reloadSession,
+    loadedConfig,
+    cancelRequest,
+    clearTurns
+  } = useEngineConnection(client, repoPath, targetSessionId, engineExited, !isSessionSelected);
+  const canSubmit = Boolean(sessionId) && !isRunning && status !== "connecting" && status !== "disconnected";
+  const { exit } = useApp6();
+  const [isUpdateMode, setIsUpdateMode] = useState13(false);
+  useEffect11(() => {
+    if (!isSetupRequired) {
+      setIsUpdateMode(false);
+    }
+  }, [isSetupRequired]);
+  const { processCommand } = useCommandProcessor({
+    sessionId,
+    status,
+    isRunning,
+    loadedConfig,
+    isSetupRequired,
+    isUpdateMode,
+    clearTurns,
+    cancelRequest,
+    sendCommand,
+    setIsSetupRequired,
+    setIsUpdateMode,
+    setActiveModal,
+    setInput
+  });
+  const handleSubmit = useCallback10(async () => {
+    if (!canSubmit) return;
+    const trimmed = input.trim();
+    if (!trimmed) return;
+    const handled = processCommand(trimmed);
+    if (handled) return;
+    addToHistory(trimmed);
+    await submitQuery(trimmed);
+    setInput("");
+  }, [canSubmit, input, submitQuery, addToHistory, processCommand]);
+  const navigate = (dir) => {
+    const res = navigateHistory(dir);
+    if (res.index === -1) {
+      setInput("");
+    } else if (res.value !== void 0) {
+      setInput(res.value);
+    }
+  };
+  if (!isSessionSelected) {
+    return /* @__PURE__ */ jsx24(AnimationProvider, { children: /* @__PURE__ */ jsx24(Box20, { flexDirection: "column", height: terminalRows, width: "100%", justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsx24(
+      SessionPicker,
+      {
+        repoPath,
+        onSelect: (id) => {
+          setTargetSessionId(id);
+          setIsSessionSelected(true);
+        }
+      }
+    ) }) });
+  }
+  if (isProjectPermissionRequired && sessionId) {
+    return /* @__PURE__ */ jsx24(AnimationProvider, { children: /* @__PURE__ */ jsx24(Box20, { flexDirection: "column", height: terminalRows, width: "100%", justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsx24(
+      ProjectPermissionPrompt,
+      {
+        repoRoot: pendingRepoRoot || repoPath,
+        onResponse: (enabled) => {
+          process.stdout.write("\x1B[2J\x1B[H");
+          sendCommand({
+            type: "project_permission",
+            session_id: sessionId,
+            indexing_enabled: enabled
+          });
+          setIsProjectPermissionRequired(false);
+        }
+      }
+    ) }) });
+  }
+  if (isSetupRequired) {
+    return /* @__PURE__ */ jsx24(AnimationProvider, { children: /* @__PURE__ */ jsx24(Box20, { flexDirection: "column", height: terminalRows, width: "100%", justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsx24(
+      SetupWizard,
+      {
+        isUpdate: isUpdateMode,
+        initialConfig: loadedConfig,
+        sendCommand: (type, payload) => {
+          if (type === "save_config") {
+            sendCommand({
+              type: "save_config",
+              config: payload
+            });
+          }
+        },
+        onComplete: () => {
+          debugLog.lifecycle("App", "update", "SetupWizard onComplete");
+          setIsSetupRequired(false);
+          setIsUpdateMode(false);
+          debugLog.command("App", "reloadSession", { sessionId });
+          reloadSession();
+        }
+      }
+    ) }) });
+  }
+  return /* @__PURE__ */ jsx24(AnimationProvider, { children: /* @__PURE__ */ jsx24(SessionProvider, { value: {
+    sessionId,
+    status,
+    infoMessage,
+    isRunning,
+    error,
+    tokenUsage,
+    errorCount,
+    currentThought,
+    loadedConfig,
+    isSetupRequired
+  }, children: /* @__PURE__ */ jsx24(
+    AppLayout,
+    {
+      terminalRows,
+      terminalColumns,
+      error,
+      showProjectPlan,
+      projectPlan,
+      currentTimelineSteps,
+      currentRunningStepId,
+      isRunning,
+      footerProps: {
+        input,
+        onChange: (val) => {
+          setInput(val);
+          resetHistoryIndex();
+        },
+        onSubmit: handleSubmit,
+        repoLabel: repoPath ? process.cwd() === repoPath ? path3.basename(repoPath) : repoPath : "No Repo",
+        // Pass history handlers to Footer
+        onHistoryUp: () => navigate("up"),
+        onHistoryDown: () => navigate("down")
+      },
+      onCancelRequest: cancelRequest,
+      helpModal: activeModal === "help" ? /* @__PURE__ */ jsx24(HelpModal, { onClose: () => setActiveModal("none") }) : void 0,
+      onHelp: () => setActiveModal("help")
+    }
+  ) }) });
+};
+var app_default = App;
+
+// src/engineClient.ts
+import { EventEmitter } from "events";
+import readline from "readline";
+
+// src/protocol.ts
+var serializeCommand = (command) => {
+  return JSON.stringify(command);
+};
+
+// src/engineClient.ts
+var EngineClient = class extends EventEmitter {
+  constructor(stdin, stdout) {
+    super();
+    this.stdin = stdin;
+    this.closed = false;
+    debugLog.state("EngineClient", "initialized");
+    this.rl = readline.createInterface({ input: stdout });
+    this.rl.on("line", (line) => {
+      if (!line.trim() || this.closed) {
+        return;
+      }
+      debugLog.log({ category: "traffic", component: "EngineClient", message: "IN", data: { line } });
+      try {
+        const evt = JSON.parse(line);
+        this.handleEvent(evt);
+        this.emit("event", evt);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(`Failed to parse engine event: ${String(err)}`);
+        debugLog.error("EngineClient", "ParseError", error);
+        this.emit("error", error);
+      }
+    });
+    this.rl.on("close", () => {
+      this.closed = true;
+      debugLog.state("EngineClient", "closed");
+      if (this.pendingSession) {
+        const err = new Error("Engine closed before session became ready");
+        this.pendingSession.reject(err);
+        this.pendingSession = void 0;
+      }
+      this.emit("close");
+    });
+  }
+  /**
+   * Logs a user-facing issue or error.
+   */
+  logIssue(message) {
+    debugLog.error("EngineClient", "Issue", new Error(message));
+  }
+  /**
+   * Closes the client and the underlying readline interface.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.rl) {
+      this.rl.close();
+      this.rl = void 0;
+    }
+  }
+  /**
+   * Starts a new session with the engine.
+   * Resolves when the session is ready.
+   */
+  async startSession(opts) {
+    if (this.pendingSession) {
+      throw new Error("Session already starting");
+    }
+    if (!opts.sessionId) {
+      this.currentSessionId = void 0;
+    }
+    const command = {
+      type: "start_session",
+      session_id: opts.sessionId,
+      repo_root: opts.repoRoot,
+      meta: {}
+    };
+    debugLog.command("EngineClient", "start_session", command);
+    const sessionId = await new Promise((resolve, reject) => {
+      this.pendingSession = { resolve, reject };
+      this.sendCommand(command).catch((err) => {
+        this.pendingSession = void 0;
+        reject(err);
+      });
+    });
+    this.currentSessionId = sessionId;
+    return sessionId;
+  }
+  /**
+   * Sends a user message to the engine.
+   */
+  sendUserMessage(sessionId, message) {
+    const command = {
+      type: "user_message",
+      session_id: sessionId,
+      message
+    };
+    debugLog.command("EngineClient", "user_message", { sessionId });
+    void this.sendCommand(command);
+  }
+  /**
+   * Returns the current session ID, if any.
+   */
+  getSessionId() {
+    return this.currentSessionId;
+  }
+  /**
+   * Low-level method to send a command object.
+   */
+  async sendCommand(command) {
+    if (this.closed) {
+      throw new Error("Engine client is closed");
+    }
+    const payload = serializeCommand(command);
+    debugLog.log({ category: "traffic", component: "EngineClient", message: "OUT", data: { payload } });
+    await new Promise((resolve, reject) => {
+      this.stdin.write(payload + "\n", (err) => {
+        if (err) {
+          debugLog.error("EngineClient", "WriteError", err);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  handleEvent(event) {
+    if (event.type === "status") {
+      this.handleStatusEvent(event);
+    }
+  }
+  handleStatusEvent(event) {
+    if (event.status === "session_ready" && event.session_id) {
+      if (this.pendingSession) {
+        debugLog.state("EngineClient", "session_ready", { sessionId: event.session_id });
+        this.pendingSession.resolve(event.session_id);
+        this.pendingSession = void 0;
+      }
+    }
+  }
+};
+
+// src/components/common/ErrorBoundary.tsx
+import { Component } from "react";
+import { Box as Box21, Text as Text21 } from "ink";
+import { jsx as jsx25, jsxs as jsxs20 } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = {
+      hasError: false,
+      error: null
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    logger.error("Uncaught error in UI:", {
+      message: error.message,
+      stack: error.stack,
+      componentStack: errorInfo.componentStack
+    });
+  }
+  render() {
+    if (this.state.hasError) {
+      return /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", padding: 1, borderColor: "red", borderStyle: "round", children: [
+        /* @__PURE__ */ jsx25(Text21, { color: "red", bold: true, children: "Something went wrong." }),
+        /* @__PURE__ */ jsx25(Text21, { color: "red", children: this.state.error?.message }),
+        /* @__PURE__ */ jsx25(Text21, { color: "gray", children: "Check ui_debug.log for details." })
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+// src/index.tsx
+import { jsx as jsx26 } from "react/jsx-runtime";
+async function main() {
+  const parseArgs = (argv) => {
+    const result = {};
+    for (let i = 2; i < argv.length; i++) {
+      const arg = argv[i];
+      if (!arg.startsWith("--")) {
+        continue;
+      }
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (!next || next.startsWith("--")) {
+        result[key] = true;
+      } else {
+        result[key] = next;
+        i++;
+      }
+    }
+    return result;
+  };
+  const args = parseArgs(process2.argv);
+  const repoPath = path4.resolve(
+    typeof args.repo === "string" ? args.repo : process2.cwd()
+  );
+  const engineCwd = path4.resolve(
+    typeof args["engine-cwd"] === "string" ? args["engine-cwd"] : path4.resolve(process2.cwd(), "..")
+  );
+  const enginePath = typeof args.engine === "string" ? args.engine : void 0;
+  const engineAddr = typeof args["engine-addr"] === "string" ? args["engine-addr"] : void 0;
+  const requestedSessionId = typeof args["session-id"] === "string" ? args["session-id"] : void 0;
+  const logFile = typeof args["log-file"] === "string" ? args["log-file"] : void 0;
+  if (logFile) {
+    logger.log(`Logging started. Repository: ${repoPath}`);
+  }
+  if (!fs5.existsSync(repoPath)) {
+    console.error("\n\u274C Error: Repository path does not exist");
+    console.error(`   Path: ${repoPath}
+`);
+    console.error("Usage:");
+    console.error("  npm run dev -- --repo <path-to-your-repo> --engine <path-to-dodo-binary> [--log-file <path>]\n");
+    console.error("Example:");
+    console.error("  npm run dev -- --repo ../../dodo_tasks/my-project --engine ../repl --log-file debug.log\n");
+    process2.exit(1);
+  }
+  const repoStat = fs5.statSync(repoPath);
+  if (!repoStat.isDirectory()) {
+    console.error("\n\u274C Error: Repository path is not a directory");
+    console.error(`   Path: ${repoPath}
+`);
+    console.error("Please provide a valid directory path.\n");
+    process2.exit(1);
+  }
+  let client;
+  let childProcess;
+  let engineExited;
+  if (engineAddr) {
+    try {
+      fs5.writeFileSync("e2e_debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] Index.tsx starting. EngineAddr: ${engineAddr}
+`);
+    } catch (_) {
+    }
+    const [host, portStr] = engineAddr.split(":");
+    const port = parseInt(portStr, 10);
+    const socket = net.createConnection({ host, port });
+    socket.on("connect", () => {
+      try {
+        fs5.appendFileSync("e2e_debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] Socket connected to ${host}:${port}!
+`);
+      } catch (_) {
+      }
+    });
+    socket.on("error", (err) => {
+      try {
+        fs5.appendFileSync("e2e_debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] Socket error: ${err.message}
+`);
+      } catch (_) {
+      }
+    });
+    socket.on("close", () => {
+      try {
+        fs5.appendFileSync("e2e_debug.log", `[${(/* @__PURE__ */ new Date()).toISOString()}] Socket closed.
+`);
+      } catch (_) {
+      }
+    });
+    client = new EngineClient(socket, socket);
+  } else {
+    const resolveEngineCommand = () => {
+      const baseArgs = ["engine", "--stdio", "--repo", repoPath];
+      if (enginePath) {
+        const resolvedEnginePath = path4.resolve(enginePath);
+        if (!fs5.existsSync(resolvedEnginePath)) {
+          console.error("\n\u274C Error: Engine binary not found");
+          console.error(`   Path: ${resolvedEnginePath}
+`);
+          console.error("Please build the engine first:");
+          console.error("  cd <dodo-repo> && go build -o dodo ./cmd/repl\n");
+          process2.exit(1);
+        }
+        return { command: resolvedEnginePath, args: baseArgs, cwd: path4.dirname(resolvedEnginePath) };
+      }
+      const envEnginePath = process2.env.DODO_ENGINE_PATH;
+      if (envEnginePath && fs5.existsSync(envEnginePath)) {
+        return { command: envEnginePath, args: baseArgs, cwd: path4.dirname(envEnginePath) };
+      }
+      const homeDir = process2.env.HOME || process2.env.USERPROFILE || "";
+      const searchPaths = [
+        path4.join(homeDir, ".local", "bin", "dodo"),
+        path4.join(homeDir, "bin", "dodo"),
+        "/usr/local/bin/dodo",
+        path4.join(engineCwd, "dodo")
+      ];
+      for (const candidate of searchPaths) {
+        if (fs5.existsSync(candidate)) {
+          return { command: candidate, args: baseArgs, cwd: path4.dirname(candidate) };
+        }
+      }
+      const dodoDir = process2.env.DODO_DIR || engineCwd;
+      if (fs5.existsSync(path4.join(dodoDir, "cmd", "repl"))) {
+        return { command: "go", args: ["run", "./cmd/repl", ...baseArgs], cwd: dodoDir };
+      }
+      console.error("\n\u274C Error: Could not find dodo engine");
+      console.error("Options:");
+      console.error("  1. Set DODO_ENGINE_PATH=/path/to/dodo binary");
+      console.error("  2. Set DODO_DIR=/path/to/dodo/source (for go run)");
+      console.error("  3. Install dodo to ~/.local/bin/dodo\n");
+      process2.exit(1);
+    };
+    const { command, args: engineArgs, cwd: engineWorkDir } = resolveEngineCommand();
+    try {
+      fs5.appendFileSync("/tmp/dodo_ui_debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Spawning engine: ${command} ${engineArgs.join(" ")} (cwd: ${engineWorkDir})
+`);
+    } catch (_) {
+    }
+    childProcess = spawn(command, engineArgs, {
+      cwd: engineWorkDir,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    childProcess.on("error", (err) => {
+      try {
+        fs5.appendFileSync("/tmp/dodo_ui_debug.log", `${(/* @__PURE__ */ new Date()).toISOString()} Engine spawn error: ${err.message}
+`);
+      } catch (_) {
+      }
+    });
+    if (!childProcess.stdin || !childProcess.stdout) {
+      console.error("Failed to spawn engine: stdin/stdout missing");
+      process2.exit(1);
+    }
+    childProcess.on("exit", (code, signal) => {
+      engineExited = { code, signal };
+    });
+    if (childProcess.stderr) {
+      childProcess.stderr.on("data", (data) => {
+        const line = data.toString();
+        try {
+          fs5.appendFileSync("/tmp/dodo_backend_stderr.log", line);
+        } catch (_) {
+        }
+        logger.log(`[BACKEND] ${line.trim()}`);
+      });
+    }
+    client = new EngineClient(childProcess.stdin, childProcess.stdout);
+  }
+  const displayCommand = childProcess ? "Local Engine" : `Remote Engine (${engineAddr})`;
+  const inkApp = render(
+    /* @__PURE__ */ jsx26(ErrorBoundary, { children: /* @__PURE__ */ jsx26(ConversationProvider, { children: /* @__PURE__ */ jsx26(
+      app_default,
+      {
+        client,
+        repoPath,
+        requestedSessionId,
+        engineCommand: displayCommand
+      }
+    ) }) }),
+    {
+      stdin: process2.stdin,
+      patchConsole: true
+    }
+  );
+  const cleanup = (code = 0) => {
+    process2.stdout.write("\x1B[?1049l");
+    try {
+      client.close();
+      if (childProcess && !childProcess.killed) {
+        childProcess.kill("SIGINT");
+      }
+      inkApp.unmount();
+    } catch (err) {
+    } finally {
+      setTimeout(() => {
+        process2.exit(code);
+      }, 100);
+    }
+  };
+  if (childProcess) {
+    childProcess.on("exit", (code, signal) => {
+      cleanup(code ?? (signal ? 1 : 0));
+    });
+  }
+  process2.on("SIGINT", () => cleanup(0));
+  process2.on("SIGTERM", () => cleanup(0));
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process2.exit(1);
+});