govon 1.2.2 → 1.4.0

package/dist/index.js

@@ -0,0 +1,1496 @@
+// src/index.tsx
+import { render } from "ink";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { createRequire } from "node:module";
+
+// src/App.tsx
+import React5, { useReducer as useReducer2, useCallback as useCallback5, useMemo as useMemo2 } from "react";
+import { Box as Box9, Text as Text10, Static, useApp, useInput as useInput2, useStdout } from "ink";
+
+// src/client.ts
+import { EventSourceParserStream } from "eventsource-parser/stream";
+
+// src/config.ts
+function parsePosInt(envVal, defaultVal, maxVal = 86400) {
+  const parsed = parseInt(envVal ?? String(defaultVal), 10);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > maxVal) {
+    return defaultVal;
+  }
+  return parsed;
+}
+function getBaseUrl() {
+  const raw = (process.env.GOVON_RUNTIME_URL ?? "http://127.0.0.1:8000").replace(/\/+$/, "");
+  try {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error(`GOVON_RUNTIME_URL must use http or https scheme, got: ${parsed.protocol}`);
+    }
+    if (parsed.hostname !== "127.0.0.1" && parsed.hostname !== "localhost" && parsed.protocol === "http:") {
+      process.stderr.write(
+        "[warn] GOVON_RUNTIME_URL uses http:// for a non-localhost host. Use https:// to protect query content in transit.\n"
+      );
+    }
+    return raw;
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("GOVON_RUNTIME_URL")) throw err;
+    throw new Error(`GOVON_RUNTIME_URL is not a valid URL: ${raw}`);
+  }
+}
+var TIMEOUTS = {
+  connect: 1e4,
+  read: 3e5,
+  /** Blocking /v2/agent/run and /v3/agent/run request timeout. */
+  run: 12e4,
+  /** Default timeout for simple requests (health, approve, cancel). */
+  default: 3e4,
+  coldStart: parsePosInt(process.env.GOVON_COLD_START_TIMEOUT, 600) * 1e3,
+  coldStartInterval: parsePosInt(process.env.GOVON_COLD_START_INTERVAL, 5) * 1e3
+};
+var THEME_COLORS = {
+  primary: "#2D5A3D",
+  accent: "#F5E6C8",
+  muted: "#7A8B7E",
+  error: "#D32F2F",
+  warning: "#FFA000",
+  success: "#388E3C",
+  info: "#1976D2",
+  dimmed: "#666666"
+};
+var SPINNER = {
+  fps: 30,
+  verbChangeInterval: 90,
+  // frames (~3 seconds at 30fps)
+  chars: ["\xB7", "\u273B", "\u273D", "\u2736", "\u2733", "\u2722"]
+};
+
+// src/client.ts
+function makeSignal(ms) {
+  return AbortSignal.timeout(ms);
+}
+var GovOnClient = class _GovOnClient {
+  _baseUrl;
+  /** Cold-start polling timeout in ms (from config). */
+  static _COLD_START_TIMEOUT_MS = TIMEOUTS.coldStart;
+  /** Cold-start polling interval in ms (from config). */
+  static _COLD_START_INTERVAL_MS = TIMEOUTS.coldStartInterval;
+  /**
+   * @param baseUrl - Daemon base URL (e.g. "http://127.0.0.1:8000").
+   *                  Trailing slash is stripped automatically.
+   */
+  constructor(baseUrl = getBaseUrl()) {
+    this._baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * GET /health — check daemon status.
+   *
+   * @returns Health response from the server.
+   * @throws Error when daemon is unreachable.
+   */
+  async health() {
+    return this._get("/health", TIMEOUTS.default);
+  }
+  /**
+   * Poll GET /health until the server responds with HTTP 200.
+   *
+   * Handles cold-start / sleeping remote servers (e.g. HF Space) by
+   * printing Korean status messages to stderr and waiting patiently.
+   *
+   * @returns true when server is ready, false on timeout.
+   */
+  async waitForReady() {
+    const url = `${this._baseUrl}/health`;
+    const deadline = Date.now() + _GovOnClient._COLD_START_TIMEOUT_MS;
+    const intervalMs = _GovOnClient._COLD_START_INTERVAL_MS;
+    let lastStatus = "";
+    let attempt = 0;
+    while (Date.now() < deadline) {
+      let newStatus;
+      try {
+        const signal = makeSignal(1e4);
+        const resp = await fetch(url, { signal });
+        if (resp.status === 200) {
+          if (attempt > 0) {
+            process.stderr.write("\r\u2726 \uC11C\uBC84 \uC900\uBE44 \uC644\uB8CC.                              \n");
+          }
+          return true;
+        }
+        if (resp.status === 503) {
+          newStatus = "\u229B \uC11C\uBC84 \uC2DC\uC791 \uC911\u2026 (503 \uC751\uB2F5 \uB300\uAE30)";
+        } else {
+          newStatus = `\u229B \uC11C\uBC84 \uC751\uB2F5 \uB300\uAE30 \uC911\u2026 (HTTP ${resp.status})`;
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("fetch failed") || msg.includes("connect")) {
+          newStatus = "\u229B \uC11C\uBC84\uC5D0 \uC5F0\uACB0 \uC911\u2026 (sleeping \uC0C1\uD0DC\uC5D0\uC11C \uAE68\uC5B4\uB098\uB294 \uC911)";
+        } else if (msg.includes("TimeoutError") || msg.includes("timed out") || msg.includes("abort")) {
+          newStatus = "\u229B \uC11C\uBC84 \uC751\uB2F5 \uB300\uAE30 \uC911\u2026 (\uBE4C\uB4DC \uB610\uB294 \uBAA8\uB378 \uB85C\uB529 \uC911)";
+        } else {
+          newStatus = "\u229B \uC11C\uBC84\uC5D0 \uC5F0\uACB0 \uC911\u2026 (sleeping \uC0C1\uD0DC\uC5D0\uC11C \uAE68\uC5B4\uB098\uB294 \uC911)";
+        }
+      }
+      const elapsed = Math.round((Date.now() - (deadline - _GovOnClient._COLD_START_TIMEOUT_MS)) / 1e3);
+      if (newStatus !== lastStatus || attempt % 6 === 0) {
+        process.stderr.write(`\r\u23F3 ${newStatus} (${elapsed}s)`);
+        lastStatus = newStatus;
+      }
+      attempt += 1;
+      await sleep(intervalMs);
+    }
+    process.stderr.write("\r\u2718 \uC11C\uBC84 \uC5F0\uACB0 \uC2DC\uAC04 \uCD08\uACFC.                            \n");
+    return false;
+  }
+  /**
+   * POST /v3/agent/stream — v3 ReAct fine-grained SSE streaming.
+   *
+   * @param query         - User input query.
+   * @param sessionId     - Session ID to resume an existing session.
+   * @param maxIterations - Maximum ReAct loop iterations.
+   * @param signal        - Optional external AbortSignal; composed with the internal timeout.
+   * @yields Parsed SSE event objects. Use the `type` key to distinguish them.
+   */
+  async *streamV3(query2, sessionId, maxIterations, signal) {
+    const body = { query: query2 };
+    if (sessionId !== void 0) body["session_id"] = sessionId;
+    if (maxIterations !== void 0) body["max_iterations"] = maxIterations;
+    const url = `${this._baseUrl}/v3/agent/stream`;
+    yield* this._sseStream(url, body, "stream_v3", signal);
+  }
+  /**
+   * POST /v2/agent/stream — per-node SSE streaming.
+   *
+   * @param query     - User input query.
+   * @param sessionId - Session ID to resume an existing session.
+   * @param signal    - Optional external AbortSignal; composed with the internal timeout.
+   * @yields Parsed SSE event objects. Contains at least `node` and `status` keys.
+   */
+  async *stream(query2, sessionId, signal) {
+    const body = { query: query2 };
+    if (sessionId !== void 0) body["session_id"] = sessionId;
+    const url = `${this._baseUrl}/v2/agent/stream`;
+    yield* this._sseStream(url, body, "stream", signal);
+  }
+  /**
+   * POST /v2/agent/run — blocking agent execution.
+   *
+   * @param query     - User input query.
+   * @param sessionId - Session ID to resume an existing session.
+   * @param signal    - Optional external AbortSignal; composed with the internal timeout.
+   * @returns Server response including thread_id, status, etc.
+   */
+  async run(query2, sessionId, signal) {
+    const body = { query: query2 };
+    if (sessionId !== void 0) body["session_id"] = sessionId;
+    return this._post("/v2/agent/run", body, TIMEOUTS.run, signal);
+  }
+  /**
+   * POST /v3/agent/run — v3 ReAct blocking execution.
+   *
+   * @param query         - User input query.
+   * @param sessionId     - Session ID to resume an existing session.
+   * @param maxIterations - Maximum ReAct loop iterations.
+   * @param signal        - Optional external AbortSignal; composed with the internal timeout.
+   * @returns Server response including metadata.
+   */
+  async runV3(query2, sessionId, maxIterations, signal) {
+    const body = { query: query2 };
+    if (sessionId !== void 0) body["session_id"] = sessionId;
+    if (maxIterations !== void 0) body["max_iterations"] = maxIterations;
+    return this._post("/v3/agent/run", body, TIMEOUTS.run, signal);
+  }
+  /**
+   * POST /v2/agent/approve — approve or reject a pending tool call.
+   *
+   * Note: uses QUERY PARAMETERS (thread_id, approved), not request body.
+   *
+   * @param threadId - Graph thread ID to approve or reject.
+   * @param approved - true to approve, false to reject.
+   * @returns Server response.
+   */
+  async approve(threadId, approved) {
+    const params = new URLSearchParams({
+      thread_id: threadId,
+      approved: String(approved).toLowerCase()
+    });
+    return this._postParams("/v2/agent/approve", params, TIMEOUTS.default);
+  }
+  /**
+   * POST /v2/agent/cancel — cancel a running session.
+   *
+   * Note: uses QUERY PARAMETER (thread_id), not request body.
+   *
+   * @param threadId - Graph thread ID to cancel.
+   * @returns Server response.
+   */
+  async cancel(threadId) {
+    const params = new URLSearchParams({ thread_id: threadId });
+    return this._postParams("/v2/agent/cancel", params, TIMEOUTS.default);
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------------
+  /** Shared SSE streaming implementation used by stream() and streamV3(). */
+  async *_sseStream(url, body, label, externalSignal) {
+    const timeoutSignal = AbortSignal.timeout(TIMEOUTS.read);
+    const signal = externalSignal ? AbortSignal.any([externalSignal, timeoutSignal]) : timeoutSignal;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("fetch failed") || msg.includes("connect")) {
+        throw new Error(`daemon is not running. (${this._baseUrl})`);
+      }
+      throw err;
+    }
+    if (!response.ok) {
+      throw new Error(`[${label}] HTTP ${response.status}: ${url}`);
+    }
+    if (!response.body) {
+      throw new Error(`[${label}] Response body is null: ${url}`);
+    }
+    const sseStream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
+    for await (const event of sseStream) {
+      if (event.data) {
+        try {
+          yield JSON.parse(event.data);
+        } catch {
+          process.stderr.write(`[${label}] SSE JSON parse failed: len=${event.data.length}
+`);
+        }
+      }
+    }
+  }
+  /** GET helper with connection-error normalisation. */
+  async _get(path, timeoutMs) {
+    const url = `${this._baseUrl}${path}`;
+    let response;
+    try {
+      response = await fetch(url, { signal: makeSignal(timeoutMs) });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("fetch failed") || msg.includes("connect")) {
+        throw new Error(`daemon is not running. (${this._baseUrl})`);
+      }
+      throw err;
+    }
+    if (!response.ok) {
+      throw new Error(`[http_client] HTTP ${response.status}: ${url}`);
+    }
+    return response.json();
+  }
+  /** POST with JSON body helper. */
+  async _post(path, body, timeoutMs, externalSignal) {
+    const url = `${this._baseUrl}${path}`;
+    const timeoutSignal = makeSignal(timeoutMs);
+    const signal = externalSignal ? AbortSignal.any([externalSignal, timeoutSignal]) : timeoutSignal;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("fetch failed") || msg.includes("connect")) {
+        throw new Error(`daemon is not running. (${this._baseUrl})`);
+      }
+      throw err;
+    }
+    if (!response.ok) {
+      throw new Error(`[http_client] HTTP ${response.status}: ${url}`);
+    }
+    return response.json();
+  }
+  /** POST with query-parameter helper (used by /approve and /cancel). */
+  async _postParams(path, params, timeoutMs) {
+    const url = `${this._baseUrl}${path}?${params.toString()}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        signal: makeSignal(timeoutMs)
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ECONNREFUSED") || msg.includes("ENOTFOUND") || msg.includes("fetch failed") || msg.includes("connect")) {
+        throw new Error(`daemon is not running. (${this._baseUrl})`);
+      }
+      throw err;
+    }
+    if (!response.ok) {
+      throw new Error(`[http_client] HTTP ${response.status}: ${url}`);
+    }
+    return response.json();
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/hooks/useDaemon.ts
+import { useState, useEffect, useRef } from "react";
+function useDaemon(client) {
+  const [state, setState] = useState({
+    ready: false,
+    waiting: true,
+    error: null
+  });
+  const controllerRef = useRef(new AbortController());
+  useEffect(() => {
+    let mounted = true;
+    async function check() {
+      try {
+        await client.health();
+        if (mounted) setState({ ready: true, waiting: false, error: null });
+      } catch {
+        if (mounted) setState((s) => ({ ...s, waiting: true }));
+        try {
+          const ok = await client.waitForReady();
+          if (mounted) {
+            setState({
+              ready: ok,
+              waiting: false,
+              error: ok ? null : "Server connection timed out"
+            });
+          }
+        } catch (err) {
+          if (mounted) {
+            setState({
+              ready: false,
+              waiting: false,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+        }
+      }
+    }
+    check();
+    return () => {
+      mounted = false;
+      controllerRef.current.abort();
+    };
+  }, [client]);
+  return state;
+}
+
+// src/hooks/useSSE.ts
+import { useCallback, useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/types.ts
+var NODE_STATUS_MESSAGES = {
+  session_load: "\uC138\uC158 \uB85C\uB4DC \uC911\u2026",
+  agent: "\uC5D0\uC774\uC804\uD2B8 \uCD94\uB860 \uC911\u2026",
+  approval_wait: "\uC2B9\uC778 \uB300\uAE30 \uC911\u2026",
+  tools: "\uB3C4\uAD6C \uC2E4\uD589 \uC911\u2026",
+  persist: "\uC800\uC7A5 \uC911\u2026"
+};
+var TASK_TYPE_LABELS = {
+  draft_response: "\uB2F5\uBCC0 \uCD08\uC548 \uC791\uC131",
+  revise_response: "\uB2F5\uBCC0 \uC218\uC815",
+  lookup_stats: "\uD1B5\uACC4 \uC870\uD68C",
+  issue_detection: "\uC774\uC288 \uD0D0\uC9C0",
+  stats_query: "\uD1B5\uACC4 \uC870\uD68C",
+  keyword_analysis: "\uD0A4\uC6CC\uB4DC \uBD84\uC11D",
+  demographics_query: "\uC778\uAD6C\uD1B5\uACC4 \uC870\uD68C",
+  default: "\uC77C\uBC18 \uC791\uC5C5"
+};
+var TASK_TYPE_STYLES = {
+  draft_response: "cyan",
+  revise_response: "blue",
+  lookup_stats: "magenta",
+  issue_detection: "yellow",
+  stats_query: "magenta",
+  keyword_analysis: "yellow",
+  demographics_query: "blueBright",
+  default: "cyan"
+};
+var TOOL_DISPLAY_NAMES = {
+  stats_lookup: "\uBBFC\uC6D0 \uD1B5\uACC4",
+  keyword_analyzer: "\uD0A4\uC6CC\uB4DC \uBD84\uC11D",
+  demographics_lookup: "\uC778\uAD6C\uD1B5\uACC4"
+};
+
+// src/hooks/useSSE.ts
+function useSSE({ client, dispatch, sessionId }) {
+  const abortRef = useRef2(null);
+  const mountedRef = useRef2(true);
+  useEffect2(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeDispatch = useCallback(
+    (action) => {
+      if (mountedRef.current) dispatch(action);
+    },
+    [dispatch]
+  );
+  const cancel = useCallback(() => {
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+    }
+  }, []);
+  const submit = useCallback(
+    async (query2) => {
+      cancel();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const isCurrentRun = () => abortRef.current === controller;
+      const assistantMsgId = crypto.randomUUID();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const sid = sessionId ?? void 0;
+      safeDispatch({ type: "SET_LOADING", payload: true });
+      safeDispatch({ type: "SET_ERROR", payload: null });
+      safeDispatch({
+        type: "START_ASSISTANT_MESSAGE",
+        payload: { id: assistantMsgId, timestamp }
+      });
+      const { success: v3Success, contentDispatched: v3ContentDispatched } = await _tryV3(
+        client,
+        query2,
+        sid,
+        assistantMsgId,
+        controller,
+        safeDispatch
+      );
+      if (v3Success) {
+        safeDispatch({ type: "SET_API_VERSION", payload: "v3" });
+        safeDispatch({ type: "SET_LOADING", payload: false });
+        if (isCurrentRun()) abortRef.current = null;
+        return;
+      }
+      if (controller.signal.aborted) {
+        safeDispatch({ type: "SET_LOADING", payload: false });
+        if (isCurrentRun()) abortRef.current = null;
+        return;
+      }
+      if (v3ContentDispatched) {
+        safeDispatch({
+          type: "SET_ERROR",
+          payload: "Streaming interrupted after partial response \u2014 please retry."
+        });
+        safeDispatch({ type: "SET_LOADING", payload: false });
+        if (isCurrentRun()) abortRef.current = null;
+        return;
+      }
+      const v2Success = await _tryV2(
+        client,
+        query2,
+        sid,
+        assistantMsgId,
+        controller,
+        safeDispatch
+      );
+      if (v2Success) {
+        safeDispatch({ type: "SET_API_VERSION", payload: "v2" });
+        safeDispatch({ type: "SET_LOADING", payload: false });
+        if (isCurrentRun()) abortRef.current = null;
+        return;
+      }
+      if (controller.signal.aborted) {
+        safeDispatch({ type: "SET_LOADING", payload: false });
+        if (isCurrentRun()) abortRef.current = null;
+        return;
+      }
+      await _tryBlocking(client, query2, sid, assistantMsgId, controller, safeDispatch);
+      safeDispatch({ type: "SET_LOADING", payload: false });
+      if (isCurrentRun()) abortRef.current = null;
+    },
+    [client, safeDispatch, sessionId, cancel]
+  );
+  return { submit, cancel };
+}
+async function _tryV3(client, query2, sessionId, assistantMsgId, controller, dispatch) {
+  let contentDispatched = false;
+  try {
+    for await (const raw of client.streamV3(query2, sessionId, void 0, controller.signal)) {
+      if (controller.signal.aborted) return { success: false, contentDispatched };
+      const event = raw;
+      switch (event.type) {
+        case "thinking_start":
+          dispatch({
+            type: "START_THINKING_STEP",
+            payload: { iteration: event.iteration }
+          });
+          break;
+        case "thinking_delta":
+          contentDispatched = true;
+          dispatch({
+            type: "APPEND_STREAMING_THINKING",
+            payload: event.content
+          });
+          break;
+        case "thinking_end":
+          dispatch({
+            type: "END_THINKING_STEP",
+            payload: { iteration: event.iteration, tool_calls: event.tool_calls }
+          });
+          break;
+        case "tool_start":
+          dispatch({
+            type: "MARK_TOOL_START",
+            payload: { tool: event.tool }
+          });
+          break;
+        case "tool_end":
+          dispatch({
+            type: "MARK_TOOL_END",
+            payload: { tool: event.tool, success: event.success }
+          });
+          break;
+        case "response_delta":
+          contentDispatched = true;
+          dispatch({
+            type: "APPEND_STREAMING_CONTENT",
+            payload: event.content
+          });
+          break;
+        case "run_complete":
+          dispatch({
+            type: "FINALIZE_ASSISTANT_MESSAGE",
+            payload: {
+              messageId: assistantMsgId,
+              content: event.text,
+              evidence: event.evidence_items,
+              metadata: event.metadata,
+              sessionId: event.session_id,
+              threadId: event.thread_id
+            }
+          });
+          return { success: true, contentDispatched };
+        case "error":
+          dispatch({ type: "SET_ERROR", payload: event.error });
+          return { success: false, contentDispatched: true };
+        default:
+          break;
+      }
+    }
+    return { success: false, contentDispatched };
+  } catch (_err) {
+    return { success: false, contentDispatched };
+  }
+}
+async function _tryV2(client, query2, sessionId, assistantMsgId, controller, dispatch) {
+  try {
+    for await (const raw of client.stream(query2, sessionId, controller.signal)) {
+      if (controller.signal.aborted) return false;
+      const event = raw;
+      const { node, status } = event;
+      const statusMsg = NODE_STATUS_MESSAGES[node];
+      if (statusMsg !== void 0) {
+        dispatch({ type: "SET_STATUS_LABEL", payload: statusMsg });
+      }
+      if (node === "agent" && status === "completed") {
+        if (event.planned_tools && event.planned_tools.length > 0) {
+          dispatch({
+            type: "SET_STATUS_LABEL",
+            payload: `\uB3C4\uAD6C \uC2E4\uD589 \uC608\uC815: ${event.planned_tools.join(", ")}`
+          });
+        }
+        if (event.final_text !== void 0) {
+          dispatch({
+            type: "FINALIZE_ASSISTANT_MESSAGE",
+            payload: {
+              messageId: assistantMsgId,
+              content: event.final_text,
+              evidence: event.evidence_items ?? [],
+              metadata: {},
+              sessionId: event.session_id ?? "",
+              threadId: event.thread_id ?? ""
+            }
+          });
+          return true;
+        }
+      }
+      if (node === "tools" && status === "completed") {
+        dispatch({ type: "SET_STATUS_LABEL", payload: "\uB3C4\uAD6C \uC2E4\uD589 \uC644\uB8CC" });
+      }
+      if (node === "approval_wait" && status === "awaiting_approval") {
+        if (event.approval_request !== void 0) {
+          dispatch({
+            type: "SET_PENDING_APPROVAL",
+            payload: event.approval_request
+          });
+        }
+      }
+      if (node === "persist" && status === "completed") {
+        if (event.final_text !== void 0) {
+          dispatch({
+            type: "FINALIZE_ASSISTANT_MESSAGE",
+            payload: {
+              messageId: assistantMsgId,
+              content: event.final_text,
+              evidence: event.evidence_items ?? [],
+              metadata: {},
+              sessionId: event.session_id ?? "",
+              threadId: event.thread_id ?? ""
+            }
+          });
+          return true;
+        }
+      }
+      if (node === "error") {
+        dispatch({
+          type: "SET_ERROR",
+          payload: event.error ?? "Unknown error from v2 stream"
+        });
+        return false;
+      }
+    }
+    return false;
+  } catch (_err) {
+    return false;
+  }
+}
+async function _tryBlocking(client, query2, sessionId, assistantMsgId, controller, dispatch) {
+  if (controller.signal.aborted) return;
+  try {
+    const result = await client.run(query2, sessionId, controller.signal);
+    if (controller.signal.aborted) return;
+    dispatch({
+      type: "FINALIZE_ASSISTANT_MESSAGE",
+      payload: {
+        messageId: assistantMsgId,
+        content: result.text,
+        evidence: result.evidence_items ?? [],
+        metadata: result.metadata ?? {},
+        sessionId: result.session_id,
+        threadId: result.thread_id ?? ""
+      }
+    });
+    dispatch({ type: "SET_API_VERSION", payload: "v2" });
+  } catch (err) {
+    if (controller.signal.aborted) return;
+    const msg = err instanceof Error ? err.message : String(err);
+    dispatch({ type: "SET_ERROR", payload: msg });
+  }
+}
+
+// src/hooks/useHistory.ts
+import { useReducer, useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3 } from "react";
+import { writeFile } from "node:fs/promises";
+import { readFileSync, mkdirSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+var HISTORY_DIR = join(homedir(), ".govon");
+var HISTORY_FILE = join(HISTORY_DIR, "history");
+var MAX_ENTRIES = 500;
+var MAX_ENTRY_BYTES = 4096;
+var DEBOUNCE_MS = 300;
+function historyReducer(state, action) {
+  switch (action.type) {
+    case "PUSH": {
+      const trimmed = action.entry.trim();
+      if (!trimmed) return state;
+      if (Buffer.byteLength(trimmed, "utf8") > MAX_ENTRY_BYTES) return state;
+      const next = state.entries[state.entries.length - 1] === trimmed ? state.entries : [...state.entries, trimmed];
+      return { entries: next.slice(-MAX_ENTRIES), cursor: -1 };
+    }
+    case "NAVIGATE": {
+      const { entries, cursor } = state;
+      if (entries.length === 0) return state;
+      if (action.direction === "up") {
+        const next = cursor === -1 ? entries.length - 1 : Math.max(0, cursor - 1);
+        return { ...state, cursor: next };
+      }
+      if (cursor === -1) return state;
+      if (cursor + 1 >= entries.length) {
+        return { ...state, cursor: -1 };
+      }
+      return { ...state, cursor: cursor + 1 };
+    }
+    case "RESET_CURSOR":
+      return { ...state, cursor: -1 };
+    default:
+      return state;
+  }
+}
+function loadInitialEntries() {
+  try {
+    const raw = readFileSync(HISTORY_FILE, "utf-8");
+    return raw.split("\n").filter(Boolean).slice(-MAX_ENTRIES);
+  } catch {
+    return [];
+  }
+}
+async function persistEntries(entries) {
+  try {
+    mkdirSync(HISTORY_DIR, { recursive: true });
+    try {
+      const stat = lstatSync(HISTORY_FILE);
+      if (!stat.isFile()) return;
+    } catch {
+    }
+    await writeFile(HISTORY_FILE, entries.join("\n") + "\n", "utf-8");
+  } catch {
+  }
+}
+function useHistory() {
+  const [state, dispatch] = useReducer(historyReducer, void 0, () => ({
+    entries: loadInitialEntries(),
+    cursor: -1
+  }));
+  const { entries, cursor } = state;
+  const debounceTimerRef = useRef3(null);
+  const writeInProgressRef = useRef3(false);
+  const pendingWriteRef = useRef3(false);
+  const latestEntriesRef = useRef3(entries);
+  latestEntriesRef.current = entries;
+  useEffect3(() => {
+    if (debounceTimerRef.current !== null) {
+      clearTimeout(debounceTimerRef.current);
+    }
+    debounceTimerRef.current = setTimeout(() => {
+      debounceTimerRef.current = null;
+      if (writeInProgressRef.current) {
+        pendingWriteRef.current = true;
+        return;
+      }
+      writeInProgressRef.current = true;
+      persistEntries(latestEntriesRef.current).finally(() => {
+        writeInProgressRef.current = false;
+        if (pendingWriteRef.current) {
+          pendingWriteRef.current = false;
+          writeInProgressRef.current = true;
+          void persistEntries(latestEntriesRef.current).finally(() => {
+            writeInProgressRef.current = false;
+          });
+        }
+      });
+    }, DEBOUNCE_MS);
+    return () => {
+      if (debounceTimerRef.current !== null) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+    };
+  }, [entries]);
+  const push = useCallback2((entry) => {
+    dispatch({ type: "PUSH", entry });
+  }, []);
+  const navigate = useCallback2(
+    (direction) => {
+      if (entries.length === 0) return void 0;
+      const prevCursor = cursor;
+      if (direction === "down") {
+        if (prevCursor === -1) return void 0;
+        if (prevCursor + 1 >= entries.length) {
+          dispatch({ type: "NAVIGATE", direction: "down" });
+          return "";
+        }
+      }
+      dispatch({ type: "NAVIGATE", direction });
+      if (direction === "up") {
+        const next = prevCursor === -1 ? entries.length - 1 : Math.max(0, prevCursor - 1);
+        return entries[next];
+      } else {
+        return entries[prevCursor + 1];
+      }
+    },
+    [entries, cursor]
+  );
+  const resetCursor = useCallback2(() => {
+    dispatch({ type: "RESET_CURSOR" });
+  }, []);
+  return { entries, push, navigate, resetCursor, cursor };
+}
+
+// src/components/Banner.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var LOGO_ART = [
+  "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  " \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D ",
+  " \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2557",
+  " \u2588\u2588\u2551 \u255A\u2550\u2588\u2588\u2551",
+  " \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  "  \u255A\u2550\u2550\u2550\u2550\u2550\u255D "
+];
+function Banner({ version }) {
+  const baseUrl = getBaseUrl();
+  let modeLabel;
+  try {
+    const url = new URL(baseUrl);
+    const isLocal = url.hostname === "127.0.0.1" || url.hostname === "localhost";
+    modeLabel = isLocal ? "\uB85C\uCEEC \uBAA8\uB4DC" : `\uC6D0\uACA9: ${url.hostname}`;
+  } catch {
+    modeLabel = "\uB85C\uCEEC \uBAA8\uB4DC";
+  }
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: THEME_COLORS.primary,
+      paddingX: 2,
+      paddingY: 1,
+      flexDirection: "row",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginRight: 3, children: [
+          LOGO_ART.map((line, i) => /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.accent, children: line }, i)),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsxs(Text, { bold: true, color: THEME_COLORS.accent, children: [
+            "GovOn v",
+            version
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.muted, children: modeLabel })
+        ] }),
+        /* @__PURE__ */ jsx(
+          Box,
+          {
+            borderStyle: "single",
+            borderLeft: true,
+            borderRight: false,
+            borderTop: false,
+            borderBottom: false,
+            borderColor: THEME_COLORS.primary,
+            marginRight: 3
+          }
+        ),
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: THEME_COLORS.accent, children: "\uC2DC\uC791 \uAC00\uC774\uB4DC" }),
+          /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.muted, children: "\uC9C8\uBB38\uC744 \uC785\uB825\uD558\uBA74 AI \uC5D0\uC774\uC804\uD2B8\uAC00 \uBD84\uC11D\uD558\uACE0 \uB3C4\uAD6C\uB97C \uC0AC\uC6A9\uD569\uB2C8\uB2E4" }),
+          /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.muted, children: "/help \uB85C \uBA85\uB839\uC5B4 \uBAA9\uB85D \uD655\uC778" }),
+          /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.muted, children: "/exit \uB610\uB294 Ctrl+D \uB85C \uC885\uB8CC" }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.muted, children: "\uC2B9\uC778 \uD544\uC694 \uB3C4\uAD6C\uB294 \uC2E4\uD589 \uC804 \uD655\uC778\uC744 \uC694\uCCAD\uD569\uB2C8\uB2E4" }),
+          /* @__PURE__ */ jsx(Text, { color: THEME_COLORS.muted, children: "Esc \uB85C \uC9C4\uD589 \uC911\uC778 \uC791\uC5C5 \uCDE8\uC18C" })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/InputBar.tsx
+import { useState as useState2, useCallback as useCallback3, useEffect as useEffect4 } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import TextInput from "ink-text-input";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function InputBar({ onSubmit, disabled = false }) {
+  const [value, setValue] = useState2("");
+  useEffect4(() => {
+    if (disabled) setValue("");
+  }, [disabled]);
+  const handleChange = useCallback3(
+    (next) => {
+      if (!disabled) setValue(next);
+    },
+    [disabled]
+  );
+  const handleSubmit = useCallback3(
+    (val) => {
+      const trimmed = val.trim();
+      if (!trimmed || disabled) return;
+      onSubmit(trimmed);
+      setValue("");
+    },
+    [onSubmit, disabled]
+  );
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: disabled ? "gray" : "green", children: "\u276F " }),
+    /* @__PURE__ */ jsx2(
+      TextInput,
+      {
+        value,
+        onChange: handleChange,
+        onSubmit: handleSubmit,
+        placeholder: disabled ? "\uCC98\uB9AC \uC911\u2026" : "\uC9C8\uBB38\uC744 \uC785\uB825\uD558\uC138\uC694"
+      }
+    )
+  ] });
+}
+
+// src/components/Spinner.tsx
+import { useState as useState3, useEffect as useEffect5, useRef as useRef4 } from "react";
+import { Text as Text3 } from "ink";
+
+// src/data/spinnerVerbs.ts
+var SPINNER_VERBS = [
+  // 사자성어 (Four-character idioms)
+  "\uC628\uACE0\uC9C0\uC2E0 (\u6EAB\u6545\u77E5\u65B0)",
+  "\uC720\uBE44\uBB34\uD658 (\u6709\u5099\u7121\u60A3)",
+  "\uC77C\uC11D\uC774\uC870 (\u4E00\u77F3\u4E8C\u9CE5)",
+  "\uB300\uAE30\uB9CC\uC131 (\u5927\u5668\u6669\u6210)",
+  "\uC790\uAC15\uBD88\uC2DD (\u81EA\u5F37\u4E0D\u606F)",
+  "\uD615\uC124\uC9C0\uACF5 (\u87A2\u96EA\u4E4B\u529F)",
+  "\uC6B0\uACF5\uC774\uC0B0 (\u611A\u516C\u79FB\u5C71)",
+  "\uB9C8\uBD80\uC704\uCE68 (\u78E8\u65A7\u7232\u91DD)",
+  "\uACAC\uC778\uBD88\uBC1C (\u5805\u5FCD\u4E0D\u62D4)",
+  "\uAE08\uC0C1\uCCA8\uD654 (\u9326\u4E0A\u6DFB\u82B1)",
+  "\uC120\uACAC\uC9C0\uBA85 (\u5148\u898B\u4E4B\u660E)",
+  "\uD0C0\uC0B0\uC9C0\uC11D (\u4ED6\u5C71\u4E4B\u77F3)",
+  "\uD654\uB8E1\uC810\uC815 (\u756B\u9F8D\u9EDE\u775B)",
+  "\uC0AC\uD544\uADC0\uC815 (\u4E8B\u5FC5\u6B78\u6B63)",
+  "\uC804\uD654\uC704\uBCF5 (\u8F49\u798D\u7232\u798F)",
+  "\uACE0\uC9C4\uAC10\uB798 (\u82E6\u76E1\u7518\u4F86)",
+  "\uBD88\uCCA0\uC8FC\uC57C (\u4E0D\u64A4\u665D\u591C)",
+  "\uC808\uCC28\uD0C1\uB9C8 (\u5207\u78CB\u7422\u78E8)",
+  "\uC2EC\uC0AC\uC219\uACE0 (\u6DF1\u601D\u719F\u8003)",
+  "\uCC9C\uC7AC\uC77C\uC6B0 (\u5343\u8F09\u4E00\u9047)",
+  "\uC774\uC2EC\uC804\uC2EC (\u4EE5\u5FC3\u50B3\u5FC3)",
+  "\uBC31\uBB38\uBD88\uC5EC\uC77C\uACAC (\u767E\u805E\u4E0D\u5982\u4E00\u898B)",
+  "\uAC01\uACE8\uB09C\uB9DD (\u523B\u9AA8\u96E3\u5FD8)",
+  "\uACB0\uCD08\uBCF4\uC740 (\u7D50\u8349\u5831\u6069)",
+  "\uAC1C\uACFC\uCC9C\uC120 (\u6539\u904E\u9077\u5584)",
+  // 속담 (Proverbs)
+  "\uCC9C \uB9AC \uAE38\uB3C4 \uD55C \uAC78\uC74C\uBD80\uD130",
+  "\uAD6C\uC2AC\uC774 \uC11C \uB9D0\uC774\uB77C\uB3C4 \uAFF0\uC5B4\uC57C \uBCF4\uBC30",
+  "\uB3CC\uB2E4\uB9AC\uB3C4 \uB450\uB4E4\uACA8 \uBCF4\uACE0 \uAC74\uB108\uB77C",
+  "\uB73B\uC774 \uC788\uB294 \uACF3\uC5D0 \uAE38\uC774 \uC788\uB2E4",
+  "\uACF5\uB4E0 \uD0D1\uC774 \uBB34\uB108\uC9C0\uB7B4",
+  "\uD2F0\uB04C \uBAA8\uC544 \uD0DC\uC0B0",
+  "\uD558\uB298\uC740 \uC2A4\uC2A4\uB85C \uB3D5\uB294 \uC790\uB97C \uB3D5\uB294\uB2E4",
+  "\uC2E4\uD328\uB294 \uC131\uACF5\uC758 \uC5B4\uBA38\uB2C8",
+  "\uC138 \uC0B4 \uBC84\uB987 \uC5EC\uB4E0\uAE4C\uC9C0 \uAC04\uB2E4",
+  "\uBE48 \uC218\uB808\uAC00 \uC694\uB780\uD558\uB2E4",
+  "\uB4F1\uC794 \uBC11\uC774 \uC5B4\uB461\uB2E4",
+  "\uD638\uB791\uC774\uB3C4 \uC81C \uB9D0 \uD558\uBA74 \uC628\uB2E4",
+  "\uC6D0\uC22D\uC774\uB3C4 \uB098\uBB34\uC5D0\uC11C \uB5A8\uC5B4\uC9C4\uB2E4",
+  "\uC18C \uC783\uACE0 \uC678\uC591\uAC04 \uACE0\uCE5C\uB2E4",
+  "\uAC00\uB294 \uB9D0\uC774 \uACE0\uC640\uC57C \uC624\uB294 \uB9D0\uC774 \uACF1\uB2E4",
+  // 재미있는 상식 (Fun facts)
+  "\uAFC0\uBC8C\uC740 \uD55C \uC21F\uAC08\uC758 \uAFC0\uC744 \uC704\uD574 \uD3C9\uC0DD \uB09C\uB2E4",
+  "\uBB38\uC5B4\uC758 \uC2EC\uC7A5\uC740 \uC138 \uAC1C\uB2E4",
+  "\uBC14\uB098\uB098\uB294 \uC2DD\uBB3C\uD559\uC801\uC73C\uB85C \uC7A5\uACFC(berry)\uC774\uB2E4",
+  "\uC9C0\uAD6C\uC5D0\uC11C \uAC00\uC7A5 \uC624\uB798\uB41C \uB098\uBB34\uB294 5000\uC0B4\uC774 \uB118\uB294\uB2E4",
+  "\uC778\uAC04\uC758 \uB1CC\uB294 60%\uAC00 \uC9C0\uBC29\uC774\uB2E4",
+  "\uD574\uD30C\uB9AC\uB294 \uB1CC\uAC00 \uC5C6\uB2E4",
+  "\uB099\uD0C0\uC758 \uD639\uC5D0\uB294 \uBB3C\uC774 \uC544\uB2C8\uB77C \uC9C0\uBC29\uC774 \uC788\uB2E4"
+];
+
+// src/components/Spinner.tsx
+import { jsxs as jsxs3 } from "react/jsx-runtime";
+function formatElapsed(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return `${m}m ${String(s).padStart(2, "0")}s`;
+}
+function formatTokens(count) {
+  if (count >= 1e3) return `${(count / 1e3).toFixed(1)}k`;
+  return String(count);
+}
+function randomVerb() {
+  return SPINNER_VERBS[Math.floor(Math.random() * SPINNER_VERBS.length)];
+}
+function Spinner({ tokens = 0 }) {
+  const [frame, setFrame] = useState3(0);
+  const [verb, setVerb] = useState3(randomVerb);
+  const tickRef = useRef4(0);
+  const startTime = useRef4(Date.now());
+  useEffect5(() => {
+    const interval = setInterval(() => {
+      setFrame((f) => f + 1);
+      tickRef.current += 1;
+      if (tickRef.current % SPINNER.verbChangeInterval === 0) {
+        setVerb(randomVerb());
+      }
+    }, 1e3 / SPINNER.fps);
+    return () => clearInterval(interval);
+  }, []);
+  const char = SPINNER.chars[frame % SPINNER.chars.length];
+  const elapsed = Math.floor((Date.now() - startTime.current) / 1e3);
+  const elapsedStr = formatElapsed(elapsed);
+  const suffix = tokens > 0 ? ` (${elapsedStr} \xB7 \u2193 ${formatTokens(tokens)} tokens)` : ` (${elapsedStr})`;
+  return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    char,
+    " ",
+    verb,
+    "\u2026",
+    suffix
+  ] });
+}
+
+// src/components/ThinkingBlock.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { jsx as jsx3, jsxs as jsxs4 } from "react/jsx-runtime";
+function ThinkingBlock({ content, streaming = false }) {
+  if (!content) return null;
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs4(Text4, { color: THEME_COLORS.muted, dimColor: true, children: [
+      "\u{1F4AD} ",
+      streaming ? "\uC0AC\uACE0 \uC911\u2026" : "\uC0AC\uACE0 \uC644\uB8CC"
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx3(Text4, { color: THEME_COLORS.dimmed, dimColor: true, wrap: "wrap", children: content }) })
+  ] });
+}
+
+// src/components/MarkdownView.tsx
+import { useMemo } from "react";
+import { Box as Box4, Text as Text5 } from "ink";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { jsx as jsx4, jsxs as jsxs5 } from "react/jsx-runtime";
+marked.use(
+  markedTerminal({
+    reflowText: true,
+    width: process.stdout.columns || 80,
+    showSectionPrefix: false
+  })
+);
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function MarkdownView({ content, streaming = false }) {
+  const rendered = useMemo(() => {
+    if (!content) return "";
+    try {
+      const result = marked.parse(stripAnsi(content));
+      return typeof result === "string" ? result.trimEnd() : "";
+    } catch {
+      return content;
+    }
+  }, [content]);
+  if (!rendered) return null;
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text5, { wrap: "wrap", children: rendered }),
+    streaming && /* @__PURE__ */ jsx4(Text5, { dimColor: true, children: "\u258D" })
+  ] });
+}
+
+// src/components/MessageBubble.tsx
+import { Box as Box7, Text as Text8 } from "ink";
+
+// src/components/ToolPanel.tsx
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
+function ToolPanel({ tools }) {
+  if (tools.length === 0) return null;
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginLeft: 2, children: tools.map((tool, i) => {
+    const displayName = TOOL_DISPLAY_NAMES[tool.tool] ?? tool.tool;
+    if (tool.pending) {
+      return /* @__PURE__ */ jsxs6(Text6, { color: THEME_COLORS.warning, children: [
+        "\u250C\u2500 \u2699 ",
+        tool.tool,
+        " (",
+        displayName,
+        ") \uC2E4\uD589 \uC911\u2026"
+      ] }, i);
+    }
+    const statusColor = tool.success !== false ? THEME_COLORS.success : THEME_COLORS.error;
+    const statusIcon = tool.success !== false ? "\u2726" : "\u2718";
+    const statusText = tool.success !== false ? "\uC644\uB8CC" : "\uC2E4\uD328";
+    return /* @__PURE__ */ jsxs6(Text6, { color: statusColor, children: [
+      "\u2514\u2500 ",
+      statusIcon,
+      " ",
+      tool.tool,
+      " (",
+      displayName,
+      ") ",
+      statusText
+    ] }, i);
+  }) });
+}
+
+// src/components/MetadataBar.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx6, jsxs as jsxs7 } from "react/jsx-runtime";
+function MetadataBar({ metadata }) {
+  const parts = [];
+  if (metadata.total_iterations !== void 0) {
+    parts.push(`${metadata.total_iterations} iterations`);
+  }
+  if (metadata.total_tool_calls !== void 0) {
+    parts.push(`${metadata.total_tool_calls} tools`);
+  }
+  if (metadata.total_latency_ms !== void 0) {
+    parts.push(`${Math.round(metadata.total_latency_ms).toLocaleString()}ms`);
+  }
+  if (parts.length === 0) return null;
+  return /* @__PURE__ */ jsx6(Box6, { marginLeft: 2, marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: THEME_COLORS.muted, dimColor: true, children: [
+    "\u2500 ",
+    parts.join(" \xB7 ")
+  ] }) });
+}
+
+// src/components/MessageBubble.tsx
+import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
+function MessageBubble({ message }) {
+  if (message.role === "user") {
+    return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "row", marginTop: 1, children: [
+      /* @__PURE__ */ jsx7(Text8, { bold: true, color: "green", children: "\u276F " }),
+      /* @__PURE__ */ jsx7(Text8, { wrap: "wrap", children: message.content })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx7(Text8, { bold: true, color: THEME_COLORS.primary, children: "GovOn" }),
+    message.thinking && message.thinking.length > 0 && /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: message.thinking.map((step, i) => /* @__PURE__ */ jsx7(
+      ThinkingBlock,
+      {
+        content: step.content,
+        streaming: false
+      },
+      i
+    )) }),
+    message.tools && message.tools.length > 0 && /* @__PURE__ */ jsx7(ToolPanel, { tools: message.tools }),
+    message.error ? /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsxs8(Text8, { color: THEME_COLORS.error, children: [
+      "\uC624\uB958: ",
+      message.error
+    ] }) }) : /* @__PURE__ */ jsx7(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx7(MarkdownView, { content: message.content, streaming: false }) }),
+    message.metadata && /* @__PURE__ */ jsx7(MetadataBar, { metadata: message.metadata })
+  ] });
+}
+
+// src/components/ApprovalPrompt.tsx
+import { useCallback as useCallback4, useRef as useRef5 } from "react";
+import { Box as Box8, Text as Text9, useInput } from "ink";
+import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
+var MAX_DESCRIPTION_LENGTH = 1e3;
+function ApprovalPrompt({ request, onApprove }) {
+  const safeDescription = request.description?.slice(0, MAX_DESCRIPTION_LENGTH);
+  const decidedRef = useRef5(false);
+  useInput(
+    useCallback4(
+      (input) => {
+        if (decidedRef.current) return;
+        const key = input.toLowerCase();
+        if (key === "y") {
+          decidedRef.current = true;
+          onApprove(true);
+        } else if (key === "n") {
+          decidedRef.current = true;
+          onApprove(false);
+        }
+      },
+      [onApprove]
+    )
+  );
+  const taskLabel = TASK_TYPE_LABELS[request.task_type] ?? TASK_TYPE_LABELS["default"];
+  const taskColor = TASK_TYPE_STYLES[request.task_type] ?? TASK_TYPE_STYLES["default"];
+  return /* @__PURE__ */ jsxs9(
+    Box8,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: THEME_COLORS.warning,
+      paddingX: 2,
+      paddingY: 1,
+      marginTop: 1,
+      children: [
+        /* @__PURE__ */ jsxs9(Box8, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsx8(Text9, { bold: true, color: THEME_COLORS.warning, children: "\u26A0 \uC2B9\uC778 \uC694\uCCAD  " }),
+          /* @__PURE__ */ jsxs9(Text9, { color: taskColor, children: [
+            "[",
+            taskLabel,
+            "]"
+          ] })
+        ] }),
+        safeDescription && /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text9, { wrap: "wrap", children: safeDescription }) }),
+        request.planned_tools && request.planned_tools.length > 0 && /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx8(Text9, { color: THEME_COLORS.muted, children: "\uC2E4\uD589 \uC608\uC815 \uB3C4\uAD6C:" }),
+          request.planned_tools.map((tool, i) => /* @__PURE__ */ jsx8(Text9, { color: THEME_COLORS.muted, children: `  \u2022 ${tool}` }, i))
+        ] }),
+        /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
+          "\uC2B9\uC778\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? ",
+          /* @__PURE__ */ jsx8(Text9, { color: "green", children: "y" }),
+          " / ",
+          /* @__PURE__ */ jsx8(Text9, { color: "red", children: "n" })
+        ] }) })
+      ]
+    }
+  );
+}
+
+// src/App.tsx
+import { jsx as jsx9, jsxs as jsxs10 } from "react/jsx-runtime";
+var BANNER_ITEM = { _banner: true };
+var initialState = {
+  messages: [],
+  isLoading: false,
+  streamingContent: "",
+  streamingThinking: "",
+  pendingThinking: [],
+  activeTools: [],
+  sessionId: null,
+  threadId: null,
+  pendingApproval: null,
+  statusLabel: null,
+  error: null,
+  theme: "dark",
+  apiBase: getBaseUrl(),
+  apiVersion: "v3"
+};
+function reducer(state, action) {
+  switch (action.type) {
+    case "SET_LOADING":
+      return { ...state, isLoading: action.payload };
+    case "ADD_USER_MESSAGE": {
+      const msg = {
+        ...action.payload,
+        role: "user",
+        content: action.payload.content
+      };
+      return { ...state, messages: [...state.messages, msg] };
+    }
+    case "START_ASSISTANT_MESSAGE": {
+      const msg = {
+        id: action.payload.id,
+        role: "assistant",
+        content: "",
+        timestamp: action.payload.timestamp,
+        streaming: true
+      };
+      return {
+        ...state,
+        messages: [...state.messages, msg],
+        streamingContent: "",
+        streamingThinking: "",
+        pendingThinking: [],
+        activeTools: []
+      };
+    }
+    case "APPEND_STREAMING_CONTENT":
+      return {
+        ...state,
+        streamingContent: state.streamingContent + action.payload
+      };
+    case "APPEND_STREAMING_THINKING":
+      return {
+        ...state,
+        streamingThinking: state.streamingThinking + action.payload
+      };
+    case "START_THINKING_STEP": {
+      const { iteration } = action.payload;
+      const already = state.pendingThinking.some((s) => s.iteration === iteration);
+      if (already) return state;
+      return {
+        ...state,
+        pendingThinking: [
+          ...state.pendingThinking,
+          { iteration, content: "" }
+        ],
+        streamingThinking: ""
+      };
+    }
+    case "END_THINKING_STEP": {
+      const { iteration, tool_calls } = action.payload;
+      const updated = state.pendingThinking.map(
+        (step) => step.iteration === iteration ? { ...step, content: step.content + state.streamingThinking, tool_calls } : step
+      );
+      return {
+        ...state,
+        pendingThinking: updated,
+        streamingThinking: ""
+      };
+    }
+    case "MARK_TOOL_START":
+      return {
+        ...state,
+        activeTools: [
+          ...state.activeTools,
+          { tool: action.payload.tool, pending: true }
+        ]
+      };
+    case "MARK_TOOL_END": {
+      const { tool, success } = action.payload;
+      const idx = state.activeTools.findIndex((t) => t.tool === tool && t.pending);
+      if (idx === -1) return state;
+      const updated = [...state.activeTools];
+      updated[idx] = { ...updated[idx], pending: false, success };
+      return { ...state, activeTools: updated };
+    }
+    case "FINALIZE_ASSISTANT_MESSAGE": {
+      const {
+        messageId,
+        content,
+        evidence,
+        metadata,
+        sessionId,
+        threadId
+      } = action.payload;
+      const messages = state.messages.map(
+        (msg) => msg.id === messageId ? {
+          ...msg,
+          content,
+          streaming: false,
+          thinking: state.pendingThinking,
+          tools: state.activeTools,
+          evidence,
+          metadata
+        } : msg
+      );
+      return {
+        ...state,
+        messages,
+        streamingContent: "",
+        streamingThinking: "",
+        pendingThinking: [],
+        activeTools: [],
+        sessionId,
+        threadId,
+        isLoading: false,
+        statusLabel: null,
+        error: null
+      };
+    }
+    case "SET_PENDING_APPROVAL":
+      return { ...state, pendingApproval: action.payload };
+    case "SET_STATUS_LABEL":
+      return { ...state, statusLabel: action.payload };
+    case "SET_ERROR":
+      return { ...state, error: action.payload, isLoading: false };
+    case "SET_THEME":
+      return { ...state, theme: action.payload };
+    case "SET_API_BASE":
+      return { ...state, apiBase: action.payload };
+    case "SET_API_VERSION":
+      return { ...state, apiVersion: action.payload };
+    case "RESET_SESSION":
+      return { ...initialState, apiBase: state.apiBase, theme: state.theme };
+    default:
+      return state;
+  }
+}
+function App({ version, initialQuery }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [state, dispatch] = useReducer2(reducer, initialState);
+  const client = useMemo2(() => new GovOnClient(state.apiBase), [state.apiBase]);
+  const daemon = useDaemon(client);
+  const { submit, cancel } = useSSE({
+    client,
+    dispatch,
+    sessionId: state.sessionId
+  });
+  const { push: pushHistory } = useHistory();
+  const handleSubmit = useCallback5(
+    (query2) => {
+      if (state.isLoading) return;
+      const userMsgId = crypto.randomUUID();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      dispatch({
+        type: "ADD_USER_MESSAGE",
+        payload: { id: userMsgId, content: query2, timestamp }
+      });
+      pushHistory(query2);
+      submit(query2);
+    },
+    [state.isLoading, dispatch, pushHistory, submit]
+  );
+  const handleApproval = useCallback5(
+    async (approved) => {
+      if (!state.threadId || !state.pendingApproval) return;
+      dispatch({ type: "SET_PENDING_APPROVAL", payload: null });
+      try {
+        const result = await client.approve(state.threadId, approved);
+        if (approved && result.text) {
+          const streamingMsg = state.messages.find((m) => m.streaming);
+          if (streamingMsg) {
+            dispatch({
+              type: "FINALIZE_ASSISTANT_MESSAGE",
+              payload: {
+                messageId: streamingMsg.id,
+                content: result.text,
+                evidence: result.evidence_items ?? [],
+                metadata: {},
+                sessionId: result.session_id,
+                threadId: result.thread_id
+              }
+            });
+          }
+        }
+        dispatch({ type: "SET_LOADING", payload: false });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        dispatch({ type: "SET_ERROR", payload: msg });
+        dispatch({ type: "SET_LOADING", payload: false });
+      }
+    },
+    [client, state.threadId, state.pendingApproval, state.messages, dispatch]
+  );
+  const initialSubmittedRef = React5.useRef(false);
+  React5.useEffect(() => {
+    if (daemon.ready && initialQuery && !initialSubmittedRef.current) {
+      initialSubmittedRef.current = true;
+      handleSubmit(initialQuery);
+    }
+  }, [daemon.ready, initialQuery, handleSubmit]);
+  useInput2((input, key) => {
+    if (key.ctrl && input === "d") exit();
+    if (key.ctrl && input === "c") exit();
+    if (key.escape && state.isLoading) cancel();
+  });
+  if (daemon.waiting) {
+    return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Banner, { version }),
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text10, { color: THEME_COLORS.muted, children: "\uC11C\uBC84 \uC5F0\uACB0 \uC911\u2026" }) })
+    ] });
+  }
+  if (daemon.error) {
+    return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Banner, { version }),
+      /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text10, { color: THEME_COLORS.error, children: [
+        "\uC11C\uBC84 \uC624\uB958: ",
+        daemon.error
+      ] }) })
+    ] });
+  }
+  const completedMessages = state.messages.filter((m) => !m.streaming);
+  const staticItems = useMemo2(
+    () => [BANNER_ITEM, ...completedMessages],
+    [completedMessages]
+  );
+  const cols = stdout?.columns ?? 80;
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(Static, { items: staticItems, children: (item) => {
+      if ("_banner" in item && item._banner) {
+        return /* @__PURE__ */ jsx9(Banner, { version }, "__banner__");
+      }
+      const msg = item;
+      return /* @__PURE__ */ jsx9(MessageBubble, { message: msg }, msg.id);
+    } }),
+    state.isLoading && /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", marginTop: 1, children: [
+      state.streamingThinking.length > 0 && /* @__PURE__ */ jsx9(ThinkingBlock, { content: state.streamingThinking, streaming: true }),
+      state.activeTools.length > 0 && /* @__PURE__ */ jsx9(ToolPanel, { tools: state.activeTools }),
+      state.streamingContent.length > 0 ? /* @__PURE__ */ jsx9(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsx9(MarkdownView, { content: state.streamingContent, streaming: true }) }) : /* @__PURE__ */ jsx9(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsx9(Spinner, {}) }),
+      state.statusLabel && /* @__PURE__ */ jsx9(Box9, { marginLeft: 2, children: /* @__PURE__ */ jsx9(Text10, { color: THEME_COLORS.muted, dimColor: true, children: state.statusLabel }) })
+    ] }),
+    state.error && !state.isLoading && /* @__PURE__ */ jsx9(Box9, { marginTop: 1, marginLeft: 2, children: /* @__PURE__ */ jsxs10(Text10, { color: THEME_COLORS.error, children: [
+      "\uC624\uB958: ",
+      state.error
+    ] }) }),
+    state.pendingApproval && /* @__PURE__ */ jsx9(
+      ApprovalPrompt,
+      {
+        request: state.pendingApproval,
+        onApprove: handleApproval
+      }
+    ),
+    /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text10, { color: THEME_COLORS.muted, dimColor: true, children: "\u2500".repeat(Math.max(1, cols - 1)) }) }),
+    !state.pendingApproval && /* @__PURE__ */ jsx9(InputBar, { onSubmit: handleSubmit, disabled: state.isLoading }),
+    /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text10, { dimColor: true, color: THEME_COLORS.dimmed, children: "esc \uCDE8\uC18C \xB7 Ctrl+D \uC885\uB8CC \xB7 /help \uB3C4\uC6C0\uB9D0" }) })
+  ] });
+}
+
+// src/index.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var argv = yargs(hideBin(process.argv)).scriptName("govon").usage("$0 [query]", "GovOn agentic TUI for civil complaint assistance").positional("query", {
+  type: "string",
+  describe: "Initial query to submit immediately"
+}).option("version", {
+  alias: "v",
+  type: "boolean",
+  describe: "Show version"
+}).help().parseSync();
+if (argv.version) {
+  process.stdout.write(pkg.version + "\n");
+  process.exit(0);
+}
+var query = argv._[0];
+render(/* @__PURE__ */ jsx10(App, { version: pkg.version, initialQuery: query }));